Skip to content

The easy-to-use open source Business Intelligence and Embedded Analytics tool that lets everyone work with data :bar_chart:

UI for model-less actions (#83662)

Alexander Polyankin0ed6ca6929fe
diff --git a/.clj-kondo/config/modules/config.edn b/.clj-kondo/config/modules/config.edn
index 5e8c0273cd9..48f5dd47a30 100644
--- a/.clj-kondo/config/modules/config.edn
+++ b/.clj-kondo/config/modules/config.edn
@@ -112,6 +112,7 @@
public-sharing
queries
query-processor
+ remote-sync
search
settings
users
@@ -141,6 +142,7 @@
collections
events
lib.schema
+ models
permissions
public-sharing
util}
diff --git a/e2e/support/helpers/e2e-data-app-helpers.ts b/e2e/support/helpers/e2e-data-app-helpers.ts
index bdf768bdcc9..b516f582733 100644
--- a/e2e/support/helpers/e2e-data-app-helpers.ts
+++ b/e2e/support/helpers/e2e-data-app-helpers.ts
@@ -223,7 +223,7 @@ export function setDataAppCollectionAccess(
});
}
-/** Creates a collection the non-admin groups hold `access` to. */
+/** Creates a data actions folder the non-admin groups hold `access` to. */
export function createDataAppCollection({
name,
access,
@@ -232,7 +232,10 @@ export function createDataAppCollection({
access: CollectionPermission;
}) {
return cy
- .request<Collection>("POST", "/api/collection", { name })
+ .request<Collection>("POST", "/api/collection", {
+ name,
+ namespace: "data-actions",
+ })
.then(({ body: collection }) => {
setDataAppCollectionAccess(collection.id, access);
return cy.wrap(collection, { log: false });
diff --git a/e2e/test-host-app/data-apps/sync-resources-actions.cy.spec.ts b/e2e/test-host-app/data-apps/sync-resources-actions.cy.spec.ts
index 0dd93ddfcaa..c2df6a01352 100644
--- a/e2e/test-host-app/data-apps/sync-resources-actions.cy.spec.ts
+++ b/e2e/test-host-app/data-apps/sync-resources-actions.cy.spec.ts
@@ -334,21 +334,22 @@ describe(
it("refuses to sync when a copy was moved out of the app collection", () => {
syncOneAction().then(({ copiedAction }) => {
- cy.request("POST", "/api/collection", { name: "Elsewhere" }).then(
- ({ body: collection }) => {
- cy.request("PUT", `/api/action/${copiedAction.id}`, {
- collection_id: collection.id,
- });
-
- syncExpectingRefusal(
- `Action ${copiedAction.id} is the copy of action`,
- );
- // Refusing is only worth anything if the copy is left alone.
- cy.request(`/api/action/${copiedAction.id}`)
- .its("body.collection_id")
- .should("eq", collection.id);
- },
- );
+ cy.request("POST", "/api/collection", {
+ name: "Elsewhere",
+ namespace: "data-actions",
+ }).then(({ body: collection }) => {
+ cy.request("PUT", `/api/action/${copiedAction.id}`, {
+ collection_id: collection.id,
+ });
+
+ syncExpectingRefusal(
+ `Action ${copiedAction.id} is the copy of action`,
+ );
+ // Refusing is only worth anything if the copy is left alone.
+ cy.request(`/api/action/${copiedAction.id}`)
+ .its("body.collection_id")
+ .should("eq", collection.id);
+ });
});
});
});
diff --git a/e2e/test/scenarios/admin/admin-reproductions.cy.spec.js b/e2e/test/scenarios/admin/admin-reproductions.cy.spec.js
index 1adc24409f5..deb00823794 100644
--- a/e2e/test/scenarios/admin/admin-reproductions.cy.spec.js
+++ b/e2e/test/scenarios/admin/admin-reproductions.cy.spec.js
@@ -19,19 +19,19 @@ describe("issue 26470", { tags: "@external" }, () => {
cy.visit(`/admin/databases/${WRITABLE_DB_ID}`);
- cy.findByTestId("database-model-features-section")
+ cy.findByTestId("database-model-persistence-section")
.findByLabelText("Model persistence")
.should("not.be.checked")
.click({ force: true });
cy.wait("@persist").its("response.statusCode").should("eq", 204);
- cy.findByTestId("database-model-features-section")
+ cy.findByTestId("database-model-persistence-section")
.findByLabelText("Model persistence")
.should("be.checked")
.click({ force: true });
cy.wait("@unpersist").its("response.statusCode").should("eq", 204);
- cy.findByTestId("database-model-features-section")
+ cy.findByTestId("database-model-persistence-section")
.findByLabelText("Model persistence")
.should("not.be.checked");
});
diff --git a/e2e/test/scenarios/admin/database-routing/database-routing-admin.cy.spec.ts b/e2e/test/scenarios/admin/database-routing/database-routing-admin.cy.spec.ts
index c031e3e1540..078b211c8a6 100644
--- a/e2e/test/scenarios/admin/database-routing/database-routing-admin.cy.spec.ts
+++ b/e2e/test/scenarios/admin/database-routing/database-routing-admin.cy.spec.ts
@@ -39,8 +39,8 @@ describe("admin > database > database routing", () => {
it("should be able to configure db routing and manage destination databases", () => {
// setup
visitDatabaseAdminPage(WRITABLE_DB_ID);
- cy.log("disable model actions");
- cy.findByLabelText("Model actions").click({ force: true });
+ cy.log("disable data actions");
+ cy.findByLabelText("Data actions").click({ force: true });
// enabling
cy.log("should be able to turn the feature on");
@@ -211,8 +211,8 @@ describe("admin > database > database routing", () => {
it("should not leak destinations databases in the application", () => {
cy.log("setup db routing via API");
cy.visit(`/admin/databases/${WRITABLE_DB_ID}`);
- cy.log("disable model actions");
- cy.findByLabelText("Model actions").click({ force: true });
+ cy.log("disable data actions");
+ cy.findByLabelText("Data actions").click({ force: true });
configureDbRoutingViaAPI({
router_database_id: WRITABLE_DB_ID,
user_attribute: "role",
@@ -289,13 +289,13 @@ describe("admin > database > database routing", () => {
setupModelPersistence();
visitDatabaseAdminPage(WRITABLE_DB_ID);
- cy.log("should be disabled if model actions is enabled");
- cy.findByLabelText("Model actions").should("be.checked");
+ cy.log("should be disabled if data actions is enabled");
+ cy.findByLabelText("Data actions").should("be.checked");
assertDbRoutingDisabled(
- "Database routing can't be enabled if model actions are enabled.",
+ "Database routing can't be enabled if data actions are enabled.",
);
- cy.findByLabelText("Model actions").parent("label").click();
+ cy.findByLabelText("Data actions").parent("label").click();
assertDbRoutingNotDisabled();
@@ -308,7 +308,7 @@ describe("admin > database > database routing", () => {
assertDbRoutingDisabled(
"Database routing can't be enabled if model persistence is enabled.",
);
- cy.findAllByTestId("database-model-features-section")
+ cy.findAllByTestId("database-model-persistence-section")
.findByLabelText("Model persistence")
.should("be.checked")
.parent("label")
@@ -317,7 +317,7 @@ describe("admin > database > database routing", () => {
cy.log("should be disabled if table editing is enabled");
// Table editing must be the only active conflict here: the routing
- // section shows a single message, and model actions, model persistence,
+ // section shows a single message, and data actions, model persistence,
// and uploads all take precedence over table editing.
tableEditingSection()
.findByLabelText("Editable tables")
@@ -450,11 +450,11 @@ describe("admin > database > database routing", () => {
describe("feature compatibility", () => {
beforeEach(() => {
- // disable model actions since it is enabled by default for this db
+ // disable data actions since it is enabled by default for this db
disableModelActionsViaApi(WRITABLE_DB_ID);
});
- it("should not be possible to enable model persistence, model actions, table editing, or uploads when database routing is enabled", () => {
+ it("should not be possible to enable model persistence, data actions, table editing, or uploads when database routing is enabled", () => {
cy.log("setup");
enableGlobalModelPersistence();
configureDbRoutingViaAPI({
@@ -467,7 +467,7 @@ describe("admin > database > database routing", () => {
cy.log(
"should not be possible to enable model persistence when database routing is enabled",
);
- modelsSection().within(() => {
+ modelPersistenceSection().within(() => {
cy.findByLabelText("Model persistence").should("be.disabled");
cy.findByText(
"Model persistence can't be enabled when database routing is enabled.",
@@ -477,12 +477,12 @@ describe("admin > database > database routing", () => {
});
cy.log(
- "should not be possible to enable model actions when database routing is enabled",
+ "should not be possible to enable data actions when database routing is enabled",
);
- modelsSection().within(() => {
- cy.findByLabelText("Model actions").should("be.disabled");
+ dataActionsSection().within(() => {
+ cy.findByLabelText("Data actions").should("be.disabled");
cy.findByText(
- "Model actions can't be enabled when database routing is enabled.",
+ "Data actions can't be enabled when database routing is enabled.",
)
.scrollIntoView()
.should("be.visible");
@@ -575,8 +575,12 @@ function visitDatabaseAdminPage(databaseId: DatabaseId) {
cy.visit(`/admin/databases/${databaseId}`);
}
-function modelsSection() {
- return cy.findByTestId("database-model-features-section");
+function modelPersistenceSection() {
+ return cy.findByTestId("database-model-persistence-section");
+}
+
+function dataActionsSection() {
+ return cy.findByTestId("database-data-actions-section");
}
function disableModelActionsViaApi(databaseId: DatabaseId) {
diff --git a/e2e/test/scenarios/admin/databases.cy.spec.js b/e2e/test/scenarios/admin/databases.cy.spec.js
index 222874c12a2..301b7dd801e 100644
--- a/e2e/test/scenarios/admin/databases.cy.spec.js
+++ b/e2e/test/scenarios/admin/databases.cy.spec.js
@@ -34,7 +34,7 @@ describe(
expect(body.settings["database-enable-actions"]).to.eq(true);
});
- cy.findByLabelText("Model actions").should("be.checked");
+ cy.findByLabelText("Data actions").should("be.checked");
});
});
},
diff --git a/e2e/test/scenarios/admin/databases/database-writable-connection.cy.spec.ts b/e2e/test/scenarios/admin/databases/database-writable-connection.cy.spec.ts
index 3859c6cadb4..1d15ecf0e20 100644
--- a/e2e/test/scenarios/admin/databases/database-writable-connection.cy.spec.ts
+++ b/e2e/test/scenarios/admin/databases/database-writable-connection.cy.spec.ts
@@ -124,8 +124,8 @@ describe("scenarios > admin > databases > writable connection", () => {
it("should be able to use model actions with a writable connection", () => {
visitDatabase(WRITABLE_DB_ID);
- cy.log("Model actions should be enabled for this db");
- cy.findByLabelText("Model actions").should("be.checked");
+ cy.log("Data actions should be enabled for this db");
+ cy.findByLabelText("Data actions").should("be.checked");
createModelWithAction().then((action) => {
updateMainConnection(READ_ONLY_USER);
diff --git a/e2e/test/scenarios/admin/tenants.cy.spec.ts b/e2e/test/scenarios/admin/tenants.cy.spec.ts
index 829047a6468..f42ec34ea40 100644
--- a/e2e/test/scenarios/admin/tenants.cy.spec.ts
+++ b/e2e/test/scenarios/admin/tenants.cy.spec.ts
@@ -616,7 +616,7 @@ describe("Tenants - management", () => {
cy.visit(`/admin/databases/${WRITABLE_DB_ID}`);
- cy.findByRole("switch", { name: /model actions/i }).click({ force: true });
+ cy.findByRole("switch", { name: /data actions/i }).click({ force: true });
cy.findByRole("switch", { name: /database routing/i }).click({
force: true,
});
diff --git a/enterprise/backend/src/metabase_enterprise/remote_sync/core.clj b/enterprise/backend/src/metabase_enterprise/remote_sync/core.clj
index e36518ea0a4..3b9c00a0ba4 100644
--- a/enterprise/backend/src/metabase_enterprise/remote_sync/core.clj
+++ b/enterprise/backend/src/metabase_enterprise/remote_sync/core.clj
@@ -234,7 +234,9 @@
top-level-ancestor-id
(get top-levels))]
(cond
- (= :library-synced (get-in (spec/spec-for-model-key (keyword "model" model)) [:eligibility :type]))
+ (let [spec (spec/spec-for-model-key (keyword "model" model))]
+ (or (= :library-synced (get-in spec [:eligibility :type]))
+ (spec/library-content? spec instance)))
(if library
{:type :collection
:collection (remedy-collection library)}
diff --git a/enterprise/backend/src/metabase_enterprise/remote_sync/db.clj b/enterprise/backend/src/metabase_enterprise/remote_sync/db.clj
index a47aef1ce2e..aff3b05a831 100644
--- a/enterprise/backend/src/metabase_enterprise/remote_sync/db.clj
+++ b/enterprise/backend/src/metabase_enterprise/remote_sync/db.clj
@@ -13,18 +13,19 @@
(def ^:private ConditionKey
"The column keys used in the `:conditions` / `:cascade-filter` / `:removal-conditions` of a remote-sync model
spec (see `metabase-enterprise.remote-sync.spec`)."
- [:enum :exploration_id :built_in_type :active :entity_id :collection_id :archived :archived_at :draft])
+ [:enum :exploration_id :built_in_type :active :entity_id :collection_id :model_id :archived :archived_at :draft])
(def ^:private Conditions
"A map of column to value (possibly nil) or Toucan 2 operator-vector value, or nil for none."
[:maybe [:map-of ConditionKey [:maybe [:or :string :int :boolean :keyword sequential?]]]])
(def ^:private RemovalOpts
- "The `:scope-key`, `:synced-collection-ids`, `:entity-ids`, and `:removal-conditions` describing which rows an
- import removes (see [[removal-exprs]])."
+ "The `:scope-key`, `:synced-collection-ids`, `:unscoped-conditions`, `:entity-ids`, and `:removal-conditions`
+ describing which rows an import removes (see [[removal-exprs]])."
[:map {:closed true}
[:scope-key [:maybe :keyword]]
[:synced-collection-ids [:maybe [:or [:set ::lib.schema.id/collection] [:sequential ::lib.schema.id/collection]]]]
+ [:unscoped-conditions Conditions]
[:entity-ids [:maybe [:or [:set :string] [:sequential :string]]]]
[:removal-conditions Conditions]])
@@ -90,16 +91,30 @@
(vector? v) [:in k v]
:else [:= k v])))
+(defn- scope-expr
+ "The `:where` fragment keeping the rows in `synced-collection-ids` or matching `unscoped-conditions`, or nil when
+ neither is given."
+ [scope-key synced-collection-ids unscoped-conditions]
+ (let [scoped (when (seq synced-collection-ids)
+ [:in scope-key synced-collection-ids])
+ unscoped (when (seq unscoped-conditions)
+ (into [:and] (removal-condition-exprs unscoped-conditions)))]
+ (if (and scoped unscoped)
+ [:or scoped unscoped]
+ (or scoped unscoped))))
+
(defn- removal-exprs
"The `:where` fragments (see [[removal-condition-exprs]]) selecting the `model-key` rows an import removes:
- scoped to `synced-collection-ids` (when `scope-key` is given), excluding `entity-ids`, and matching
- `removal-conditions`. Returns nil for a scoped model with no synced collections (removes nothing)."
- [{:keys [scope-key synced-collection-ids entity-ids removal-conditions]}]
- (when-not (and scope-key (empty? synced-collection-ids))
- (cond-> []
- scope-key (conj [:in scope-key synced-collection-ids])
- (seq entity-ids) (conj [:not-in :entity_id entity-ids])
- :always (into (removal-condition-exprs removal-conditions)))))
+ scoped to `synced-collection-ids` or `unscoped-conditions` (when `scope-key` is given), excluding `entity-ids`,
+ and matching `removal-conditions`. Returns nil for a scoped model with neither (removes nothing)."
+ [{:keys [scope-key synced-collection-ids unscoped-conditions entity-ids removal-conditions]}]
+ (let [scope (when scope-key
+ (scope-expr scope-key synced-collection-ids unscoped-conditions))]
+ (when-not (and scope-key (nil? scope))
+ (cond-> []
+ scope (conj scope)
+ (seq entity-ids) (conj [:not-in :entity_id entity-ids])
+ :always (into (removal-condition-exprs removal-conditions))))))
(mu/defn delete-removed-instances!
"Deletes the `model-key` rows an import removes (see [[removal-exprs]]); a no-op for a scoped model with no
@@ -424,6 +439,27 @@
[library-type :- :string]
(t2/select-one :model/Collection :type library-type))
+(mu/defn collections-with-names-in-namespace
+ "The `:id` and `:name` of the Collections of `namespace-name`."
+ [namespace-name :- :string]
+ (t2/select [:model/Collection :id :name] :namespace namespace-name))
+
+(mu/defn action-model-ids
+ "The model Card id, or nil, of each existing Action with `action-ids`, keyed by Action id."
+ [action-ids :- [:sequential ms/PositiveInt]]
+ (t2/select-pk->fn :model_id [:model/Action :id :model_id] :id [:in action-ids]))
+
+(mu/defn actions-without-model-in
+ "The `:id`, `:name`, and `:collection_id` of the Actions without a model outside of any Collection or in the
+ Collections with `collection-ids`."
+ [collection-ids :- [:sequential ::lib.schema.id/collection]]
+ (t2/select [:model/Action :id :name :collection_id]
+ {:where [:and
+ [:= :model_id nil]
+ (if (seq collection-ids)
+ [:or [:= :collection_id nil] [:in :collection_id collection-ids]]
+ [:= :collection_id nil])]}))
+
(mu/defn snippet-collections
"The `:id` and `:name` of the Collections of the snippets namespace."
[]
@@ -439,6 +475,11 @@
[namespace-name :- :string]
(t2/select [:model/Collection :id :entity_id] :namespace namespace-name))
+(mu/defn collection-namespace :- [:maybe [:or :keyword :string]]
+ "The namespace of the Collection with `collection-id`, or nil."
+ [collection-id :- ::lib.schema.id/collection]
+ (t2/select-one-fn :namespace [:model/Collection :namespace] :id collection-id))
+
(mu/defn collection-ids-in-namespace
"The IDs of the Collections of `namespace-name`."
[namespace-name :- :string]
diff --git a/enterprise/backend/src/metabase_enterprise/remote_sync/events.clj b/enterprise/backend/src/metabase_enterprise/remote_sync/events.clj
index 9a3af02159d..28928149361 100644
--- a/enterprise/backend/src/metabase_enterprise/remote_sync/events.clj
+++ b/enterprise/backend/src/metabase_enterprise/remote_sync/events.clj
@@ -37,12 +37,24 @@
:status "create"
:status_changed_at timestamp}))
+(defn- data-action-collections
+ "The `:id` and `:name` of the data actions Collections."
+ []
+ (remote-sync.db/collections-with-names-in-namespace (name collections/data-actions-ns)))
+
+(defn- library-actions
+ "The Actions without a model in the data actions root or a data actions Collection."
+ [data-action-collection-ids]
+ (remote-sync.db/actions-without-model-in (vec data-action-collection-ids)))
+
(defn enable-library-tracking!
- "Mark all existing snippets, snippets-namespace collections, and glossary entries as 'create' for initial sync."
+ "Mark all existing snippets, data actions, their namespaces' collections, and glossary entries as 'create' for
+ initial sync."
[]
- (let [timestamp (t/offset-date-time)
+ (let [timestamp (t/offset-date-time)
+ data-action-collections (data-action-collections)
rows (concat
- (for [coll (remote-sync.db/snippet-collections)]
+ (for [coll (concat (remote-sync.db/snippet-collections) data-action-collections)]
{:model_type "Collection"
:model_id (:id coll)
:model_name (:name coll)
@@ -55,6 +67,13 @@
:model_collection_id (:collection_id snippet)
:status "create"
:status_changed_at timestamp})
+ (for [action (library-actions (map :id data-action-collections))]
+ {:model_type "Action"
+ :model_id (:id action)
+ :model_name (:name action)
+ :model_collection_id (:collection_id action)
+ :status "create"
+ :status_changed_at timestamp})
(glossary-tracking-rows (remote-sync.db/glossary-entries) timestamp))]
(when (seq rows)
(remote-sync.db/insert-rsos! rows))))
@@ -106,13 +125,17 @@
(count rows)))
(defn disable-library-tracking!
- "Remove all snippet, snippets-namespace collection, and glossary tracking entries."
+ "Remove all snippet, data action, their namespaces' collection, and glossary tracking entries."
[]
- (let [snippet-coll-ids (remote-sync.db/snippet-collection-ids)]
+ (let [data-action-coll-ids (into #{} (map :id) (data-action-collections))
+ coll-ids (into (remote-sync.db/snippet-collection-ids) data-action-coll-ids)
+ action-ids (into #{} (map :id) (library-actions data-action-coll-ids))]
(remote-sync.db/delete-rsos-of-type! "NativeQuerySnippet")
(remote-sync.db/delete-rsos-of-type! "Glossary")
- (when (seq snippet-coll-ids)
- (remote-sync.db/delete-rsos-of-models! "Collection" snippet-coll-ids))))
+ (when (seq coll-ids)
+ (remote-sync.db/delete-rsos-of-models! "Collection" coll-ids))
+ (when (seq action-ids)
+ (remote-sync.db/delete-rsos-of-models! "Action" action-ids))))
;;; ----------------------------------------- Helper Functions ---------------------------------------------------------
diff --git a/enterprise/backend/src/metabase_enterprise/remote_sync/models/remote_sync_object.clj b/enterprise/backend/src/metabase_enterprise/remote_sync/models/remote_sync_object.clj
index c1f6ad9765d..97f8014b87a 100644
--- a/enterprise/backend/src/metabase_enterprise/remote_sync/models/remote_sync_object.clj
+++ b/enterprise/backend/src/metabase_enterprise/remote_sync/models/remote_sync_object.clj
@@ -33,6 +33,17 @@
[]
(remote-sync.db/dirty-rsos (spec/excluded-model-types)))
+(defn- with-action-card-ids
+ "`objects` with the `:card_id` of the model each existing Action belongs to, nil for an Action without a model."
+ [objects]
+ (let [action-ids (into [] (comp (filter #(= "action" (:model %))) (map :id)) objects)
+ card-ids (when (seq action-ids)
+ (remote-sync.db/action-model-ids action-ids))]
+ (mapv (fn [{:keys [id model] :as object}]
+ (cond-> object
+ (and (= "action" model) (contains? card-ids id)) (assoc :card_id (get card-ids id))))
+ objects)))
+
(defn dirty-objects
"Gets all models in any collection that are dirty with their sync status.
Returns a sequence of model maps that have changed since the last remote sync,
@@ -51,4 +62,4 @@
:model_table_name :table_name
:status :sync_status})
(update :model u/lower-case-en)))
- (into [])))
+ with-action-card-ids))
diff --git a/enterprise/backend/src/metabase_enterprise/remote_sync/schema.clj b/enterprise/backend/src/metabase_enterprise/remote_sync/schema.clj
index 4c51caef1b5..dd6ba33abe2 100644
--- a/enterprise/backend/src/metabase_enterprise/remote_sync/schema.clj
+++ b/enterprise/backend/src/metabase_enterprise/remote_sync/schema.clj
@@ -86,7 +86,8 @@
[:query_type {:optional true} [:maybe :string]]
[:description {:optional true} [:maybe :string]]
[:table_id {:optional true} [:maybe pos-int?]]
- [:table_name {:optional true} [:maybe :string]]])
+ [:table_name {:optional true} [:maybe :string]]
+ [:card_id {:optional true} [:maybe pos-int?]]])
;;; ------------------------------------------- API Response Schemas -------------------------------------------
diff --git a/enterprise/backend/src/metabase_enterprise/remote_sync/spec.clj b/enterprise/backend/src/metabase_enterprise/remote_sync/spec.clj
index 5352eba7778..ec21393f8ae 100644
--- a/enterprise/backend/src/metabase_enterprise/remote_sync/spec.clj
+++ b/enterprise/backend/src/metabase_enterprise/remote_sync/spec.clj
@@ -107,8 +107,10 @@
:delete-after [:model/Collection] ; has collection_id FK
:events {:prefix :event/action
:types [:create :update :delete]}
- :eligibility {:type :collection
- :collection :remote-synced}
+ ;; actions without a model are Library content: synced with it from the data actions root and namespace
+ :eligibility {:type :collection
+ :collection :remote-synced
+ :library-synced-conditions {:model_id nil}}
:archived-key :archived
:tracking {:select-fields [:name :collection_id]
:field-mappings {:model_name :name
@@ -520,7 +522,7 @@
under one category, so name them rather than the category."
[setting-kw]
(case setting-kw
- :library-synced "Library content (snippets, glossary)"
+ :library-synced "Library content (snippets, data actions, glossary)"
(setting->category setting-kw)))
(defn- setting->namespace
@@ -628,8 +630,9 @@
`import-namespace-collections` is a set of namespace strings found in the import.
`import-ns-collection-entity-ids` is a map of namespace string -> set of entity_ids from the import."
[import-namespace-collections import-ns-collection-entity-ids]
- (let [ns-configs [{:ns-name "transforms" :setting-kw :remote-sync-transforms :category "Transforms"}
- {:ns-name "snippets" :setting-kw :library-synced :category "Snippets"}]]
+ (let [ns-configs [{:ns-name "transforms" :setting-kw :remote-sync-transforms :category "Transforms"}
+ {:ns-name "snippets" :setting-kw :library-synced :category "Snippets"}
+ {:ns-name "data-actions" :setting-kw :library-synced :category "Snippets"}]]
(into []
(for [{:keys [ns-name setting-kw category]} ns-configs
:when (contains? import-namespace-collections ns-name)
@@ -653,6 +656,13 @@
:message (format "Import contains %s but local instance has unsynced %s namespace collections"
category category)}))))
+(defn- library-synced-root-conditions
+ "The conditions selecting `spec`'s Library content outside of any Collection, when the Library is synced."
+ [spec]
+ (when-let [conditions (get-in spec [:eligibility :library-synced-conditions])]
+ (when (rs-settings/library-is-remote-synced?)
+ (assoc conditions :collection_id nil))))
+
(defn removal-opts
"The `metabase-enterprise.remote-sync.db` removal-opts (`:scope-key`, `:synced-collection-ids`, `:entity-ids`,
`:removal-conditions`) for removing the entity-id `spec`'s rows not in the import, scoped to
@@ -660,6 +670,7 @@
[spec synced-collection-ids entity-ids]
{:scope-key (get-in spec [:removal :scope-key])
:synced-collection-ids synced-collection-ids
+ :unscoped-conditions (library-synced-root-conditions spec)
:entity-ids entity-ids
:removal-conditions (removal-conditions spec)})
@@ -702,6 +713,17 @@
[object]
(= (keyword (:namespace object)) :snippets))
+(defn data-actions-namespace-collection?
+ "Check if this is a data-actions-namespace collection."
+ [object]
+ (= (keyword (:namespace object)) collections/data-actions-ns))
+
+(defn library-namespace-collection?
+ "Check if this is a collection of a namespace synced with the Library: snippets or data actions."
+ [object]
+ (or (snippets-namespace-collection? object)
+ (data-actions-namespace-collection? object)))
+
(defn library-collection?
"Check if this is the Library collection."
[collection]
@@ -715,14 +737,14 @@
(and (rs-settings/remote-sync-transforms)
(transforms-namespace-collection? collection))
(and (rs-settings/library-is-remote-synced?)
- (snippets-namespace-collection? collection))))
+ (library-namespace-collection? collection))))
(defn all-syncable-collection-ids
"Returns a vector of all collection IDs that are eligible for remote sync.
This includes:
- Collections with is_remote_synced=true
- Transforms-namespace collections (when remote-sync-transforms setting is enabled)
- - Snippets-namespace collections (when Library is remote-synced)
+ - Snippets- and data-actions-namespace collections (when Library is remote-synced)
Used by import cleanup to determine which collections to scope deletions to."
[]
@@ -732,7 +754,9 @@
(when (rs-settings/remote-sync-transforms)
(remote-sync.db/collection-ids-in-namespace (name collections/transforms-ns)))
(when (rs-settings/library-is-remote-synced?)
- (remote-sync.db/collection-ids-in-namespace "snippets"))]))
+ (remote-sync.db/collection-ids-in-namespace "snippets"))
+ (when (rs-settings/library-is-remote-synced?)
+ (remote-sync.db/collection-ids-in-namespace (name collections/data-actions-ns)))]))
(def ^:private max-conflict-names
"Cap on how many entity names a collection deletion conflict carries, so the payload stays bounded when
@@ -758,7 +782,8 @@
:when (and (not (get-in spec [:removal :all-on-setting-disable]))
(not= :model/Collection model-key)
(or (seq synced-collection-ids)
- (nil? (get-in spec [:removal :scope-key]))))
+ (nil? (get-in spec [:removal :scope-key]))
+ (library-synced-root-conditions spec)))
:let [model-type (:model-type spec)
imported-ids (get by-entity-id model-type #{})
;; Same base restriction remove-unsynced! deletes by, plus an anti-join keeping only the
@@ -806,30 +831,49 @@
(and (object-matches-conditions? (:conditions spec) object)
(check-eligibility-by-type spec object))))
+(defn library-synced-object?
+ "Whether `object` matches the spec's `:library-synced-conditions`, which make it Library content."
+ [spec object]
+ (when-let [conditions (get-in spec [:eligibility :library-synced-conditions])]
+ (object-matches-conditions? conditions object)))
+
+(defn library-content?
+ "Whether `object` matches the spec's `:library-synced-conditions` and is in the data actions root or namespace,
+ which makes it Library content."
+ [spec {collection-id :collection_id :as object}]
+ (boolean
+ (and (library-synced-object? spec object)
+ (or (nil? collection-id)
+ (= collections/data-actions-ns
+ (some-> (remote-sync.db/collection-namespace collection-id) keyword))))))
+
(defmethod check-eligibility-by-type :collection
- [{:keys [eligibility]} object]
+ [{:keys [eligibility] :as spec} object]
(let [collection-type (:collection eligibility)
collection-id (:collection_id object)]
- (case collection-type
- :remote-synced
- (collections/remote-synced-collection? collection-id)
+ (if (library-synced-object? spec object)
+ (and (rs-settings/library-is-remote-synced?)
+ (library-content? spec object))
+ (case collection-type
+ :remote-synced
+ (collections/remote-synced-collection? collection-id)
- :transforms-namespace
- (and (rs-settings/remote-sync-transforms)
- (transforms-namespace-collection? object))
+ :transforms-namespace
+ (and (rs-settings/remote-sync-transforms)
+ (transforms-namespace-collection? object))
- :snippets-namespace
- (and (rs-settings/library-is-remote-synced?)
- (snippets-namespace-collection? object))
+ :snippets-namespace
+ (and (rs-settings/library-is-remote-synced?)
+ (snippets-namespace-collection? object))
- :any
- (or (collections/remote-synced-collection? (or collection-id object))
- (and (rs-settings/remote-sync-transforms)
- (transforms-namespace-collection? object))
- (and (rs-settings/library-is-remote-synced?)
- (snippets-namespace-collection? object)))
+ :any
+ (or (collections/remote-synced-collection? (or collection-id object))
+ (and (rs-settings/remote-sync-transforms)
+ (transforms-namespace-collection? object))
+ (and (rs-settings/library-is-remote-synced?)
+ (library-namespace-collection? object)))
- false)))
+ false))))
(defmethod check-eligibility-by-type :published-table
[_ {:keys [is_published collection_id]}]
@@ -1206,8 +1250,19 @@
{:arglists '([spec])}
(fn [spec] (get-in spec [:eligibility :type])))
+(defn- library-synced-root-export-roots
+ "The `[model-type id]` export roots of `spec`'s unarchived Library content outside of any Collection, when the
+ Library is synced; that in data actions Collections is exported with them."
+ [{:keys [model-key model-type archived-key eligibility]}]
+ (when-let [conditions (:library-synced-conditions eligibility)]
+ (when (rs-settings/library-is-remote-synced?)
+ (into #{}
+ (map (fn [id] [model-type id]))
+ (remote-sync.db/ids-where model-key (cond-> (assoc conditions :collection_id nil)
+ archived-key (assoc archived-key false)))))))
+
(defmethod query-export-roots :collection
- [{:keys [export-scope]}]
+ [{:keys [export-scope] :as spec}]
(case (or export-scope :derived)
:root-collections
;; Excludes archived collections - their files are handled by the removal logic
@@ -1217,9 +1272,12 @@
(when (rs-settings/remote-sync-transforms)
(collection-keys (remote-sync.db/unarchived-root-collection-ids-in-namespace (name collections/transforms-ns))))
(when (rs-settings/library-is-remote-synced?)
- (collection-keys (remote-sync.db/unarchived-root-collection-ids-in-namespace "snippets")))))
+ (collection-keys (remote-sync.db/unarchived-root-collection-ids-in-namespace "snippets")))
+ (when (rs-settings/library-is-remote-synced?)
+ (collection-keys (remote-sync.db/unarchived-root-collection-ids-in-namespace
+ (name collections/data-actions-ns))))))
:derived
- nil))
+ (library-synced-root-export-roots spec)))
(defmethod query-export-roots :setting
[{:keys [export-scope model-key model-type] :as spec}]
diff --git a/enterprise/backend/test/metabase_enterprise/remote_sync/api_test.clj b/enterprise/backend/test/metabase_enterprise/remote_sync/api_test.clj
index c1765d23ee3..0af73182109 100644
--- a/enterprise/backend/test/metabase_enterprise/remote_sync/api_test.clj
+++ b/enterprise/backend/test/metabase_enterprise/remote_sync/api_test.clj
@@ -2438,23 +2438,6 @@
(is (= tasks-before (t2/count :model/RemoteSyncTask))
"no NEW RemoteSyncTask row should be created when the guard fires")))))))
-(deftest moving-an-action-out-from-under-a-synced-dashboard-test
- (testing "an action a synced dashboard uses cannot move out of the synced collections"
- (mt/with-temporary-setting-values [remote-sync-type :read-write]
- (mt/with-actions-test-data-and-actions-enabled
- (mt/with-temp [:model/Collection {synced-id :id} {:name "Synced" :is_remote_synced true :location "/"}
- :model/Collection {plain-id :id} {:name "Plain" :location "/"}
- :model/Action {action-id :id} {:type :query :name "No model" :model_id nil
- :collection_id synced-id}
- :model/QueryAction _ {:action_id action-id
- :dataset_query (mt/native-query {:query "select 1"})}
- :model/Dashboard {dashboard-id :id} {:collection_id synced-id}
- :model/DashboardCard _ {:dashboard_id dashboard-id :action_id action-id}]
- (is (= "Used by remote synced content."
- (:message (mt/user-http-request :crowberto :put 400 (str "action/" action-id)
- {:collection_id plain-id}))))
- (is (= synced-id (t2/select-one-fn :collection_id :model/Action :id action-id))))))))
-
(deftest archiving-a-synced-model-with-actions-test
(testing "a model in a synced collection can be archived although it has actions, which are archived with it"
(mt/with-temporary-setting-values [remote-sync-type :read-write]
diff --git a/enterprise/backend/test/metabase_enterprise/remote_sync/glossary_test.clj b/enterprise/backend/test/metabase_enterprise/remote_sync/glossary_test.clj
index 1f52c747398..23ebdbd4f19 100644
--- a/enterprise/backend/test/metabase_enterprise/remote_sync/glossary_test.clj
+++ b/enterprise/backend/test/metabase_enterprise/remote_sync/glossary_test.clj
@@ -165,7 +165,7 @@
(let [[conflict :as conflicts] (spec/check-feature-conflicts #{"Glossary"} #{})]
(is (= 1 (count conflicts)))
(is (=? {:type :snippets-conflict :category "Snippets"} conflict))
- (is (str/includes? (:message conflict) "Library content (snippets, glossary)"))))
+ (is (str/includes? (:message conflict) "Library content (snippets, data actions, glossary)"))))
(testing "import! surfaces the conflict"
(mt/with-model-cleanup [:model/RemoteSyncTask]
(let [task-id (t2/insert-returning-pk! :model/RemoteSyncTask {:sync_task_type "import"
diff --git a/enterprise/backend/test/metabase_enterprise/remote_sync/models/remote_sync_object_test.clj b/enterprise/backend/test/metabase_enterprise/remote_sync/models/remote_sync_object_test.clj
index 2eb700ed3a0..065ff3f0b3a 100644
--- a/enterprise/backend/test/metabase_enterprise/remote_sync/models/remote_sync_object_test.clj
+++ b/enterprise/backend/test/metabase_enterprise/remote_sync/models/remote_sync_object_test.clj
@@ -538,3 +538,21 @@
models (set (map :model dirty-items))]
(is (= 8 (count dirty-items)))
(is (= #{"collection" "card" "dashboard" "document" "nativequerysnippet" "table" "field" "segment"} models)))))))
+
+(deftest dirty-objects-action-card-ids-test
+ (testing "dirty actions carry their model card, nil without a model, and no card id once deleted"
+ (mt/with-temp
+ [:model/Card model {:type :model :dataset_query (mt/native-query {:query "SELECT 1"})}
+ :model/Action with-model {:type :implicit :name "With model" :model_id (:id model)}
+ :model/Action data-action {:type :query :name "Data action"}
+ :model/RemoteSyncObject _ {:model_type "Action" :model_id (:id with-model) :model_name "With model"
+ :status "create" :status_changed_at (java.time.OffsetDateTime/now)}
+ :model/RemoteSyncObject _ {:model_type "Action" :model_id (:id data-action) :model_name "Data action"
+ :status "create" :status_changed_at (java.time.OffsetDateTime/now)}
+ :model/RemoteSyncObject _ {:model_type "Action" :model_id Integer/MAX_VALUE :model_name "Deleted"
+ :status "delete" :status_changed_at (java.time.OffsetDateTime/now)}]
+ (let [by-name (into {} (map (juxt :name identity)) (rs-object/dirty-objects))]
+ (is (= (:id model) (:card_id (by-name "With model"))))
+ (is (=? {:card_id nil} (by-name "Data action")))
+ (is (contains? (by-name "Data action") :card_id))
+ (is (not (contains? (by-name "Deleted") :card_id)))))))
diff --git a/enterprise/backend/test/metabase_enterprise/remote_sync/spec_test.clj b/enterprise/backend/test/metabase_enterprise/remote_sync/spec_test.clj
index 1755a30b0ee..c08c0942b92 100644
--- a/enterprise/backend/test/metabase_enterprise/remote_sync/spec_test.clj
+++ b/enterprise/backend/test/metabase_enterprise/remote_sync/spec_test.clj
@@ -7,6 +7,7 @@
[metabase-enterprise.remote-sync.spec :as spec]
[metabase-enterprise.transforms-python.core :as transforms-python]
[metabase.collections.test-utils :as collections.tu]
+ [metabase.models.interface :as mi]
[metabase.test :as mt]
[toucan2.core :as t2]))
@@ -368,6 +369,58 @@
:model_collection_id synced-coll :status "synced"}]
(spec/sync-all-entities! (t/offset-date-time) {:by-entity-id {"Action" #{eid}}}))))))))
+(defn- do-with-data-actions!
+ "Runs `f` with `{:folder :root-action :folder-action :app-action}`: actions without a model in the data actions root,
+ a data actions folder, and a data app collection."
+ [f]
+ (mt/with-temp [:model/Collection {folder :id} {:name "Billing" :namespace "data-actions" :location "/"}
+ :model/Collection {app-coll :id} {:name "App" :namespace "data-apps" :location "/"}
+ :model/Action {root-action :id} {:type :query :name "At root"}
+ :model/Action {folder-action :id} {:type :query :name "In folder" :collection_id folder}
+ :model/Action {app-action :id} {:type :query :name "App copy" :collection_id app-coll}]
+ (f {:folder folder :root-action root-action :folder-action folder-action :app-action app-action})))
+
+(deftest data-action-eligibility-follows-library-test
+ (testing "actions without a model are synced with the Library from the data actions root and namespace"
+ (do-with-data-actions!
+ (fn [{:keys [root-action folder-action app-action]}]
+ (let [action-spec (spec/spec-for-model-key :model/Action)
+ eligible? #(spec/check-eligibility action-spec (t2/select-one :model/Action :id %))]
+ (collections.tu/with-library-synced
+ (is (true? (eligible? root-action)))
+ (is (true? (eligible? folder-action)))
+ (is (false? (eligible? app-action))))
+ (collections.tu/with-library-not-synced
+ (is (false? (eligible? root-action)))
+ (is (false? (eligible? folder-action)))))))))
+
+(deftest data-action-export-and-removal-test
+ (testing "with the Library synced, root data actions are export roots and absent ones are removed on pull"
+ (do-with-data-actions!
+ (fn [{:keys [folder root-action app-action]}]
+ (collections.tu/with-library-synced
+ (let [action-spec (spec/spec-for-model-key :model/Action)]
+ (is (contains? (set (spec/query-export-roots action-spec)) ["Action" root-action]))
+ (is (contains? (set (spec/query-export-roots (spec/spec-for-model-key :model/Collection)))
+ ["Collection" folder]))
+ (remote-sync.db/delete-removed-instances!
+ :model/Action
+ (spec/removal-opts action-spec [] #{}))
+ (is (not (t2/exists? :model/Action :id root-action)))
+ (is (t2/exists? :model/Action :id app-action))))))))
+
+(deftest data-action-read-only-test
+ (testing "data actions synced with the Library cannot be changed while remote sync is read-only"
+ (do-with-data-actions!
+ (fn [{:keys [root-action app-action]}]
+ (collections.tu/with-library-synced
+ (mt/with-current-user (mt/user->id :crowberto)
+ (mt/with-temporary-setting-values [remote-sync-url "https://github.com/test/repo.git" remote-sync-type :read-only]
+ (is (false? (mi/can-write? (t2/select-one :model/Action :id root-action))))
+ (is (true? (mi/can-write? (t2/select-one :model/Action :id app-action)))))
+ (mt/with-temporary-setting-values [remote-sync-type :read-write]
+ (is (true? (mi/can-write? (t2/select-one :model/Action :id root-action)))))))))))
+
;;; -------------------------------------------- Editability Checking Tests ----------------------------------------
(deftest model-editable?-unknown-model-test
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/library/LibraryPage/components/ActionCell.tsx b/enterprise/frontend/src/metabase-enterprise/data-studio/library/LibraryPage/components/ActionCell.tsx
index ab09292b91e..c8325cc2399 100644
--- a/enterprise/frontend/src/metabase-enterprise/data-studio/library/LibraryPage/components/ActionCell.tsx
+++ b/enterprise/frontend/src/metabase-enterprise/data-studio/library/LibraryPage/components/ActionCell.tsx
@@ -6,6 +6,7 @@ import {
isTableData,
} from "metabase/data-studio/common/utils";
import { PLUGIN_LIBRARY } from "metabase/plugins";
+import { RootDataActionsMenu } from "metabase-enterprise/data-studio/library/actions/components/RootDataActionsMenu";
import { TableMoreMenu } from "metabase-enterprise/data-studio/library/tables/components/TableHeader/TableMoreMenu";
import type { CollectionId } from "metabase-types/api";
@@ -55,6 +56,16 @@ export function ActionCell({ treeItem, refreshSection }: ActionCellProps) {
return <CollectionRowMenu collection={data} />;
}
+ const isDataActionCollection = data.namespace === "data-actions";
+
+ if (isDataActionCollection && data.id === "root") {
+ return <RootDataActionsMenu />;
+ }
+
+ if (isDataActionCollection) {
+ return <CollectionRowMenu collection={data} />;
+ }
+
const isLibraryCollection =
PLUGIN_LIBRARY.isLibrarySubCollectionType(data.type) &&
!data.is_library_root;
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/library/LibraryPage/components/CreateMenu.tsx b/enterprise/frontend/src/metabase-enterprise/data-studio/library/LibraryPage/components/CreateMenu.tsx
index 5329b9b2eb3..60cbe12e715 100644
--- a/enterprise/frontend/src/metabase-enterprise/data-studio/library/LibraryPage/components/CreateMenu.tsx
+++ b/enterprise/frontend/src/metabase-enterprise/data-studio/library/LibraryPage/components/CreateMenu.tsx
@@ -13,6 +13,8 @@ import { setOpenModalWithProps } from "metabase/redux/ui";
import { useNavigate } from "metabase/router";
import { Button, FixedSizeIcon, Icon, Menu } from "metabase/ui";
import * as Urls from "metabase/urls";
+import { useActionDatabases } from "metabase-enterprise/data-studio/library/actions/hooks/use-action-databases";
+import { canCreateActions } from "metabase-enterprise/data-studio/library/actions/utils";
import { getIsRemoteSyncReadOnly } from "metabase-enterprise/remote_sync/selectors";
import type { CollectionId, CollectionNamespace } from "metabase-types/api";
@@ -45,6 +47,8 @@ export const CreateMenu = ({
const hasNativeWrite = useSelector(canUserCreateNativeQueries);
const hasDataAccess = useSelector(canUserCreateQueries);
const remoteSyncReadOnly = useSelector(getIsRemoteSyncReadOnly);
+ const { databases: actionDatabases } = useActionDatabases();
+ const canCreateDataActions = canCreateActions(actionDatabases);
if (remoteSyncReadOnly) {
return null;
@@ -63,7 +67,8 @@ export const CreateMenu = ({
const canCreateCollection =
canCreateLibraryCollection ||
- (hasNativeWrite && PLUGIN_SNIPPET_FOLDERS.isEnabled);
+ (hasNativeWrite && PLUGIN_SNIPPET_FOLDERS.isEnabled) ||
+ canCreateDataActions;
const collectionNamespaces: CollectionNamespace[] = [];
@@ -75,6 +80,10 @@ export const CreateMenu = ({
collectionNamespaces.push("snippets");
}
+ if (canCreateDataActions) {
+ collectionNamespaces.push("data-actions");
+ }
+
const initialCollectionId =
(dataCollectionId && canWriteToDataCollection && dataCollectionId) ||
(metricCollectionId && canWriteToMetricCollection && metricCollectionId) ||
@@ -122,6 +131,16 @@ export const CreateMenu = ({
{t`Snippet`}
</Menu.Item>
),
+ canCreateDataActions && (
+ <Menu.Item
+ key="data-action"
+ component={ForwardRefLink}
+ to={Urls.newDataStudioAction()}
+ leftSection={<FixedSizeIcon name="bolt" />}
+ >
+ {t`Action`}
+ </Menu.Item>
+ ),
canCreateCollection && (
<Menu.Item
key="collection"
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/library/LibraryPage/components/CreateMenu.unit.spec.tsx b/enterprise/frontend/src/metabase-enterprise/data-studio/library/LibraryPage/components/CreateMenu.unit.spec.tsx
index 180e6f92558..df369ff8ce4 100644
--- a/enterprise/frontend/src/metabase-enterprise/data-studio/library/LibraryPage/components/CreateMenu.unit.spec.tsx
+++ b/enterprise/frontend/src/metabase-enterprise/data-studio/library/LibraryPage/components/CreateMenu.unit.spec.tsx
@@ -1,11 +1,13 @@
import userEvent from "@testing-library/user-event";
import { setupEnterprisePlugins } from "__support__/enterprise";
+import { setupDatabasesEndpoints } from "__support__/server-mocks";
import { mockSettings } from "__support__/settings";
import { createMockState } from "__support__/state/state";
import { renderWithProviders, screen } from "__support__/ui";
-import type { EnterpriseSettings } from "metabase-types/api";
+import type { Database, EnterpriseSettings } from "metabase-types/api";
import {
+ createMockDatabase,
createMockTokenFeatures,
createMockUser,
} from "metabase-types/api/mocks";
@@ -20,6 +22,7 @@ interface SetupOptions {
canWriteToMetricCollection?: boolean;
canWriteToDashboardCollection?: boolean;
remoteSyncType?: EnterpriseSettings["remote-sync-type"];
+ databases?: Database[];
}
const fullPermissionsUser: Partial<User> = {
@@ -37,7 +40,9 @@ const setup = ({
canWriteToMetricCollection = true,
canWriteToDashboardCollection = false,
remoteSyncType,
+ databases = [],
}: SetupOptions = {}) => {
+ setupDatabasesEndpoints(databases);
const onNewDashboardClick = jest.fn();
const state = createMockState({
settings: mockSettings({
@@ -236,4 +241,41 @@ describe("CreateMenu", () => {
screen.queryByRole("button", { name: /New/ }),
).not.toBeInTheDocument();
});
+
+ it("renders the action option with native write on an actions-enabled database", async () => {
+ setup({
+ user: fullPermissionsUser,
+ databases: [
+ createMockDatabase({
+ native_permissions: "write",
+ settings: { "database-enable-actions": true },
+ }),
+ ],
+ });
+
+ await userEvent.click(screen.getByRole("button", { name: /New/ }));
+
+ expect(
+ await screen.findByRole("menuitem", { name: /Action/ }),
+ ).toBeInTheDocument();
+ });
+
+ it("does not render the action option without an actions-enabled database", async () => {
+ setup({
+ user: fullPermissionsUser,
+ databases: [
+ createMockDatabase({
+ native_permissions: "write",
+ settings: { "database-enable-actions": false },
+ }),
+ ],
+ });
+
+ await userEvent.click(screen.getByRole("button", { name: /New/ }));
+
+ expect(await screen.findByText("Snippet")).toBeInTheDocument();
+ expect(
+ screen.queryByRole("menuitem", { name: /Action/ }),
+ ).not.toBeInTheDocument();
+ });
});
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/library/LibraryPage/components/LibraryBulkActions.tsx b/enterprise/frontend/src/metabase-enterprise/data-studio/library/LibraryPage/components/LibraryBulkActions.tsx
index 4929fb661f6..6aa5d3c5b9d 100644
--- a/enterprise/frontend/src/metabase-enterprise/data-studio/library/LibraryPage/components/LibraryBulkActions.tsx
+++ b/enterprise/frontend/src/metabase-enterprise/data-studio/library/LibraryPage/components/LibraryBulkActions.tsx
@@ -229,7 +229,7 @@ function LibraryMoveModal({
[movingCollectionIds],
);
- if (section === "snippets") {
+ if (section === "snippets" || section === "actions") {
return (
<CollectionPickerModal
title={t`Move to…`}
@@ -238,7 +238,7 @@ function LibraryMoveModal({
onMove(destination.id === "root" ? null : destination.id)
}
onClose={onClose}
- namespaces={["snippets"]}
+ namespaces={[section === "snippets" ? "snippets" : "data-actions"]}
isDisabledItem={isDisabledItem}
options={{
hasPersonalCollections: false,
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/library/LibraryPage/hooks/library-bulk-selection.utils.ts b/enterprise/frontend/src/metabase-enterprise/data-studio/library/LibraryPage/hooks/library-bulk-selection.utils.ts
index bc060093092..3f36a4ac007 100644
--- a/enterprise/frontend/src/metabase-enterprise/data-studio/library/LibraryPage/hooks/library-bulk-selection.utils.ts
+++ b/enterprise/frontend/src/metabase-enterprise/data-studio/library/LibraryPage/hooks/library-bulk-selection.utils.ts
@@ -13,13 +13,19 @@ import type {
DatabaseId,
} from "metabase-types/api";
-export type LibrarySection = "data" | "metrics" | "dashboards" | "snippets";
+export type LibrarySection =
+ | "data"
+ | "metrics"
+ | "dashboards"
+ | "snippets"
+ | "actions";
export type SelectableModel =
| "table"
| "metric"
| "dashboard"
| "snippet"
+ | "action"
| "collection";
export type SelectedItem = {
@@ -39,13 +45,14 @@ const isCollectionRow = (
const isLeafRow = (
item: TreeItem,
): item is TreeItem & {
- model: "table" | "metric" | "dashboard" | "snippet";
+ model: "table" | "metric" | "dashboard" | "snippet" | "action";
data: CollectionItem;
} =>
item.model === "table" ||
item.model === "metric" ||
item.model === "dashboard" ||
- item.model === "snippet";
+ item.model === "snippet" ||
+ item.model === "action";
const keyOf = (item: TreeItem): string => item.id;
@@ -66,11 +73,17 @@ export function getItemSection(item: TreeItem): LibrarySection | null {
if (item.model === "snippet") {
return "snippets";
}
+ if (item.model === "action") {
+ return "actions";
+ }
if (isCollectionRow(item)) {
const { data } = item;
if (data.namespace === "snippets") {
return "snippets";
}
+ if (data.namespace === "data-actions") {
+ return "actions";
+ }
if (data.type === "library-metrics") {
return "metrics";
}
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/library/LibraryPage/hooks/library-bulk-selection.utils.unit.spec.ts b/enterprise/frontend/src/metabase-enterprise/data-studio/library/LibraryPage/hooks/library-bulk-selection.utils.unit.spec.ts
index 353b0ee60e7..1d3104ff017 100644
--- a/enterprise/frontend/src/metabase-enterprise/data-studio/library/LibraryPage/hooks/library-bulk-selection.utils.unit.spec.ts
+++ b/enterprise/frontend/src/metabase-enterprise/data-studio/library/LibraryPage/hooks/library-bulk-selection.utils.unit.spec.ts
@@ -1,5 +1,9 @@
import type { TreeItem } from "metabase/data-studio/common/types";
-import type { CollectionId, CollectionType } from "metabase-types/api";
+import type {
+ CollectionId,
+ CollectionNamespace,
+ CollectionType,
+} from "metabase-types/api";
import {
createMockCollection,
createMockCollectionItem,
@@ -26,6 +30,15 @@ const SECTION_TYPE: Record<LibrarySection, CollectionType | null> = {
metrics: "library-metrics",
dashboards: "library-dashboards",
snippets: null,
+ actions: null,
+};
+
+const SECTION_NAMESPACE: Record<LibrarySection, CollectionNamespace> = {
+ data: null,
+ metrics: null,
+ dashboards: null,
+ snippets: "snippets",
+ actions: "data-actions",
};
function tableItem(
@@ -120,7 +133,7 @@ function subCollection(
...createMockCollection({
id,
type: SECTION_TYPE[section],
- namespace: section === "snippets" ? "snippets" : null,
+ namespace: SECTION_NAMESPACE[section],
is_library_root: false,
parent_id: opts.parentId ?? null,
can_write: opts.canWrite ?? true,
@@ -132,7 +145,8 @@ function subCollection(
}
function sectionRoot(section: LibrarySection, children: TreeItem[]): TreeItem {
- const id: CollectionId = section === "snippets" ? "root" : 100;
+ const isNamespaceRoot = SECTION_NAMESPACE[section] != null;
+ const id: CollectionId = isNamespaceRoot ? "root" : 100;
return {
id: `collection:${id}`,
name: section,
@@ -142,8 +156,8 @@ function sectionRoot(section: LibrarySection, children: TreeItem[]): TreeItem {
...createMockCollection({
id,
type: SECTION_TYPE[section],
- namespace: section === "snippets" ? "snippets" : null,
- is_library_root: section !== "snippets",
+ namespace: SECTION_NAMESPACE[section],
+ is_library_root: !isNamespaceRoot,
}),
model: "collection",
},
@@ -151,6 +165,21 @@ function sectionRoot(section: LibrarySection, children: TreeItem[]): TreeItem {
};
}
+function actionItem(id: number): TreeItem {
+ return {
+ id: `action:${id}`,
+ name: `Action ${id}`,
+ icon: "bolt",
+ model: "action",
+ data: createMockCollectionItem({
+ id,
+ model: "action",
+ collection_id: null,
+ can_write: true,
+ }),
+ };
+}
+
function emptyState(): TreeItem {
return {
id: "empty:data",
@@ -179,6 +208,8 @@ describe("library-bulk-selection.utils", () => {
expect(getItemSection(subCollection(3, "metrics"))).toBe("metrics");
expect(getItemSection(subCollection(5, "dashboards"))).toBe("dashboards");
expect(getItemSection(subCollection(4, "snippets"))).toBe("snippets");
+ expect(getItemSection(actionItem(1))).toBe("actions");
+ expect(getItemSection(subCollection(6, "actions"))).toBe("actions");
expect(getItemSection(emptyState())).toBeNull();
});
});
@@ -187,11 +218,14 @@ describe("library-bulk-selection.utils", () => {
it("treats section roots as non-selectable and content items as selectable", () => {
expect(isSectionRoot(sectionRoot("data", []))).toBe(true);
expect(isSectionRoot(sectionRoot("snippets", []))).toBe(true);
+ expect(isSectionRoot(sectionRoot("actions", []))).toBe(true);
expect(isSectionRoot(subCollection(2, "data"))).toBe(false);
expect(isSelectableItem(tableItem(1))).toBe(true);
expect(isSelectableItem(metricItem(1))).toBe(true);
expect(isSelectableItem(snippetItem(1))).toBe(true);
+ expect(isSelectableItem(actionItem(1))).toBe(true);
+ expect(isSelectableItem(subCollection(6, "actions"))).toBe(true);
expect(isSelectableItem(subCollection(2, "data"))).toBe(true);
expect(isSelectableItem(sectionRoot("data", []))).toBe(false);
expect(isSelectableItem(emptyState())).toBe(false);
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/library/LibraryPage/hooks/library-item-updates.ts b/enterprise/frontend/src/metabase-enterprise/data-studio/library/LibraryPage/hooks/library-item-updates.ts
index 6cc46b9ab22..486120cccb8 100644
--- a/enterprise/frontend/src/metabase-enterprise/data-studio/library/LibraryPage/hooks/library-item-updates.ts
+++ b/enterprise/frontend/src/metabase-enterprise/data-studio/library/LibraryPage/hooks/library-item-updates.ts
@@ -19,6 +19,7 @@ export function selectedItemToMovable(item: SelectedItem): MovableItem {
.with({ model: "metric" }, () => ({ model: "metric", id }))
.with({ model: "dashboard" }, () => ({ model: "dashboard", id }))
.with({ model: "snippet" }, () => ({ model: "snippet", id }))
+ .with({ model: "action" }, () => ({ model: "action", id }))
.with({ model: "collection", section: "snippets" }, () => ({
model: "snippet-collection",
id,
@@ -45,6 +46,11 @@ export function selectedItemToArchivable(item: SelectedItem): ArchivableItem {
id,
can_write: canWrite,
}))
+ .with({ model: "action" }, () => ({
+ model: "action",
+ id,
+ can_write: canWrite,
+ }))
.with({ model: "collection", section: "snippets" }, () => ({
model: "snippet-collection",
id,
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/library/LibraryPage/hooks/useLibraryCollectionTree.ts b/enterprise/frontend/src/metabase-enterprise/data-studio/library/LibraryPage/hooks/useLibraryCollectionTree.ts
index 842f60f3cb6..41b2701779b 100644
--- a/enterprise/frontend/src/metabase-enterprise/data-studio/library/LibraryPage/hooks/useLibraryCollectionTree.ts
+++ b/enterprise/frontend/src/metabase-enterprise/data-studio/library/LibraryPage/hooks/useLibraryCollectionTree.ts
@@ -29,6 +29,7 @@ const SECTION_ITEM_MODELS: Record<LibrarySectionType, CollectionItemModel[]> = {
metrics: ["metric", "collection"],
dashboards: ["dashboard", "collection"],
snippets: ["snippet", "collection"],
+ actions: ["action", "collection"],
};
export function useLibraryCollectionTree(
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/library/LibraryPage/hooks/useLibrarySearch.ts b/enterprise/frontend/src/metabase-enterprise/data-studio/library/LibraryPage/hooks/useLibrarySearch.ts
index d58b08cb335..ad2c21d6053 100644
--- a/enterprise/frontend/src/metabase-enterprise/data-studio/library/LibraryPage/hooks/useLibrarySearch.ts
+++ b/enterprise/frontend/src/metabase-enterprise/data-studio/library/LibraryPage/hooks/useLibrarySearch.ts
@@ -12,7 +12,7 @@ const SEARCH_DEBOUNCE_MS = 300;
export function useLibrarySearch(
searchQuery: string,
libraryCollectionId: CollectionId | undefined,
- snippetTree: TreeItem[],
+ localTree: TreeItem[],
) {
const debouncedQuery = useDebouncedValue(searchQuery, SEARCH_DEBOUNCE_MS);
const isActive = debouncedQuery.trim().length > 0;
@@ -126,12 +126,11 @@ export function useLibrarySearch(
}
}
- // Client-side filter snippets
- const filteredSnippets = filterSnippetTree(snippetTree, debouncedQuery);
- sections.push(...filteredSnippets);
+ // Client-side filter snippets and actions
+ sections.push(...filterLocalTree(localTree, debouncedQuery));
return sections;
- }, [isActive, searchResponse, snippetTree, debouncedQuery, getIcon]);
+ }, [isActive, searchResponse, localTree, debouncedQuery, getIcon]);
return {
tree,
@@ -141,16 +140,16 @@ export function useLibrarySearch(
};
}
-function filterSnippetTree(nodes: TreeItem[], query: string): TreeItem[] {
+function filterLocalTree(nodes: TreeItem[], query: string): TreeItem[] {
const lowerQuery = query.toLowerCase();
return nodes.flatMap((node) => {
- if (node.model === "snippet") {
+ if (node.model === "snippet" || node.model === "action") {
return node.name.toLowerCase().includes(lowerQuery) ? [node] : [];
}
if (node.children) {
- const filteredChildren = filterSnippetTree(node.children, query);
+ const filteredChildren = filterLocalTree(node.children, query);
if (filteredChildren.length > 0) {
return [{ ...node, children: filteredChildren }];
}
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/library/LibraryPage/hooks/useLibraryTreeTableInstance.tsx b/enterprise/frontend/src/metabase-enterprise/data-studio/library/LibraryPage/hooks/useLibraryTreeTableInstance.tsx
index da6b5fa455d..e025d31510a 100644
--- a/enterprise/frontend/src/metabase-enterprise/data-studio/library/LibraryPage/hooks/useLibraryTreeTableInstance.tsx
+++ b/enterprise/frontend/src/metabase-enterprise/data-studio/library/LibraryPage/hooks/useLibraryTreeTableInstance.tsx
@@ -1,7 +1,6 @@
import type { ExpandedState } from "@tanstack/react-table";
import { useCallback, useEffect, useMemo, useState } from "react";
import { t } from "ttag";
-import _ from "underscore";
import { DateTime } from "metabase/common/components/DateTime";
import { Link } from "metabase/common/components/Link";
@@ -19,6 +18,9 @@ import {
type TreeTableColumnDef,
useTreeTableInstance,
} from "metabase/ui";
+import { useActionDatabases } from "metabase-enterprise/data-studio/library/actions/hooks/use-action-databases";
+import { useBuildActionTree } from "metabase-enterprise/data-studio/library/actions/hooks/use-build-action-tree";
+import { canCreateActions } from "metabase-enterprise/data-studio/library/actions/utils";
import { getIsRemoteSyncReadOnly } from "metabase-enterprise/remote_sync/selectors";
import type { Collection, CollectionId } from "metabase-types/api";
@@ -50,17 +52,15 @@ export function useLibraryTreeTableInstance({
const [searchParams] = useSearchParams();
const isRemoteSyncReadOnly = useSelector(getIsRemoteSyncReadOnly);
- const expandedIdsFromUrl = useMemo(() => {
- const ids = searchParams.getAll("expandedId");
- if (ids.length === 0) {
- return null;
- }
-
- // Unjustified type cast. FIXME
- return _.object(
- ids.map((id) => [`collection:${id}`, true]),
- ) as ExpandedState;
- }, [searchParams]);
+ const expandedIdsFromUrl = useMemo(
+ (): Record<string, boolean> =>
+ Object.fromEntries(
+ searchParams
+ .getAll("expandedId")
+ .map((id) => [`collection:${id}`, true]),
+ ),
+ [searchParams],
+ );
const {
libraryCollection,
tableCollection,
@@ -101,6 +101,20 @@ export function useLibraryTreeTableInstance({
isLoading: loadingSnippets,
error: snippetsError,
} = useBuildSnippetTree();
+ const { databases: actionDatabases, isLoading: loadingActionDatabases } =
+ useActionDatabases();
+ const {
+ tree: actionTree,
+ isLoading: loadingActions,
+ error: actionsError,
+ } = useBuildActionTree({
+ canCreateActions:
+ !isRemoteSyncReadOnly && canCreateActions(actionDatabases),
+ });
+ const localTree = useMemo(
+ () => [...snippetTree, ...actionTree],
+ [snippetTree, actionTree],
+ );
const refreshSection = useCallback(
(section: LibrarySection, collectionIds: CollectionId[]) => {
@@ -109,6 +123,7 @@ export function useLibraryTreeTableInstance({
metrics: refreshMetricCollections,
dashboards: refreshDashboardCollections,
snippets: undefined,
+ actions: undefined,
}[section];
refreshCollections?.(collectionIds);
},
@@ -119,25 +134,25 @@ export function useLibraryTreeTableInstance({
],
);
- // Server-side search for tables, metrics, and dashboards, client-side for snippets
+ // Server-side search for tables, metrics, and dashboards, client-side for snippets and actions
const {
tree: searchTree,
isActive: isSearchActive,
isLoading: isSearchLoading,
- } = useLibrarySearch(searchQuery, libraryCollection?.id, snippetTree);
+ } = useLibrarySearch(searchQuery, libraryCollection?.id, localTree);
const combinedTree = useMemo(
() =>
isSearchActive
? searchTree
- : [...tablesTree, ...metricsTree, ...dashboardsTree, ...snippetTree],
+ : [...tablesTree, ...metricsTree, ...dashboardsTree, ...localTree],
[
isSearchActive,
searchTree,
tablesTree,
metricsTree,
dashboardsTree,
- snippetTree,
+ localTree,
],
);
@@ -147,9 +162,15 @@ export function useLibraryTreeTableInstance({
loadingMetrics ||
loadingDashboards ||
loadingSnippets ||
+ loadingActions ||
+ loadingActionDatabases ||
isSearchLoading;
useErrorHandling(
- tablesError || metricsError || dashboardsError || snippetsError,
+ tablesError ||
+ metricsError ||
+ dashboardsError ||
+ snippetsError ||
+ actionsError,
);
const libraryHasContent = useMemo(
@@ -267,13 +288,11 @@ export function useLibraryTreeTableInstance({
);
const snippetRootId = snippetTree[0]?.id;
+ const actionRootId = actionTree[0]?.id;
// Controlled expansion: expand all during search, preserve user state when browsing.
- // Default any IDs from the URL. If none are provided, default to Data, Metrics, Dashboards and SQL Snippets expanded
+ // Expand Data, Metrics, Dashboards, SQL Snippets and Data actions, plus any IDs from the URL
const defaultExpanded = useMemo<ExpandedState>(() => {
- if (expandedIdsFromUrl) {
- return expandedIdsFromUrl;
- }
const ids: ExpandedState = {};
if (tableCollection) {
ids[`collection:${tableCollection.id}`] = true;
@@ -289,13 +308,18 @@ export function useLibraryTreeTableInstance({
ids[snippetRootId] = true;
}
- return ids;
+ if (actionRootId) {
+ ids[actionRootId] = true;
+ }
+
+ return { ...ids, ...expandedIdsFromUrl };
}, [
expandedIdsFromUrl,
tableCollection,
metricCollection,
dashboardCollection,
snippetRootId,
+ actionRootId,
]);
const [browseExpanded, setBrowseExpanded] = useState<ExpandedState | null>(
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/library/LibraryPage/utils.ts b/enterprise/frontend/src/metabase-enterprise/data-studio/library/LibraryPage/utils.ts
index 81324b1a47e..19c3baea22e 100644
--- a/enterprise/frontend/src/metabase-enterprise/data-studio/library/LibraryPage/utils.ts
+++ b/enterprise/frontend/src/metabase-enterprise/data-studio/library/LibraryPage/utils.ts
@@ -44,6 +44,9 @@ export const getTreeRowHref = (row: { original: TreeItem }): string | null => {
if (treeItem.model === "snippet") {
return Urls.dataStudioSnippet(entityId);
}
+ if (treeItem.model === "action") {
+ return Urls.dataStudioAction(entityId);
+ }
if (treeItem.model === "table") {
return Urls.dataStudioTable(entityId);
}
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/library/actions/components/ActionEditor/ActionEditor.tsx b/enterprise/frontend/src/metabase-enterprise/data-studio/library/actions/components/ActionEditor/ActionEditor.tsx
new file mode 100644
index 00000000000..1dc13d052e5
--- /dev/null
+++ b/enterprise/frontend/src/metabase-enterprise/data-studio/library/actions/components/ActionEditor/ActionEditor.tsx
@@ -0,0 +1,58 @@
+import { type ReactNode, useMemo } from "react";
+
+import { QueryEditorWithParameters } from "metabase/parameters/components/QueryEditorWithParameters";
+import type {
+ QueryEditorUiOptions,
+ QueryEditorUiState,
+} from "metabase/querying/editor/components/QueryEditor";
+import * as Lib from "metabase-lib";
+import type { Database, DatasetQuery } from "metabase-types/api";
+
+import { useActionQuery } from "../../hooks/use-action-query";
+
+type ActionEditorProps = {
+ datasetQuery: DatasetQuery;
+ uiState: QueryEditorUiState;
+ databases: Database[];
+ readOnly?: boolean;
+ topBarInnerContent?: ReactNode;
+ onChangeDatasetQuery: (datasetQuery: DatasetQuery) => void;
+ onChangeUiState: (uiState: QueryEditorUiState) => void;
+};
+
+export function ActionEditor({
+ datasetQuery,
+ uiState,
+ databases,
+ readOnly = false,
+ topBarInnerContent,
+ onChangeDatasetQuery,
+ onChangeUiState,
+}: ActionEditorProps) {
+ const query = useActionQuery(datasetQuery);
+ const uiOptions = useMemo(
+ (): QueryEditorUiOptions => ({
+ readOnly,
+ hidePreview: true,
+ hideRunButton: true,
+ hidePreviewQueryButton: true,
+ resizable: false,
+ shouldShowLibrary: false,
+ shouldDisableDatabasePickerItem: (item) =>
+ !databases.some((database) => database.id === item.id),
+ }),
+ [databases, readOnly],
+ );
+
+ return (
+ <QueryEditorWithParameters
+ query={query}
+ uiState={uiState}
+ uiOptions={uiOptions}
+ topBarInnerContent={topBarInnerContent}
+ parametersAreUserVisible={false}
+ onChangeQuery={(query) => onChangeDatasetQuery(Lib.toJsQuery(query))}
+ onChangeUiState={onChangeUiState}
+ />
+ );
+}
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/library/actions/components/ActionEditor/index.ts b/enterprise/frontend/src/metabase-enterprise/data-studio/library/actions/components/ActionEditor/index.ts
new file mode 100644
index 00000000000..1ed193b5e40
--- /dev/null
+++ b/enterprise/frontend/src/metabase-enterprise/data-studio/library/actions/components/ActionEditor/index.ts
@@ -0,0 +1 @@
+export { ActionEditor } from "./ActionEditor";
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/library/actions/components/ActionEditorPane/ActionEditorPane.tsx b/enterprise/frontend/src/metabase-enterprise/data-studio/library/actions/components/ActionEditorPane/ActionEditorPane.tsx
new file mode 100644
index 00000000000..c4c722da3ab
--- /dev/null
+++ b/enterprise/frontend/src/metabase-enterprise/data-studio/library/actions/components/ActionEditorPane/ActionEditorPane.tsx
@@ -0,0 +1,22 @@
+import type { ReactNode } from "react";
+
+import { Box } from "metabase/ui";
+
+type ActionEditorPaneProps = {
+ children: ReactNode;
+};
+
+export function ActionEditorPane({ children }: ActionEditorPaneProps) {
+ return (
+ <Box
+ w="100%"
+ bg="background_page-primary"
+ bdrs="sm"
+ bd="1px solid var(--mb-color-border-neutral)"
+ flex={1}
+ style={{ overflow: "hidden" }}
+ >
+ {children}
+ </Box>
+ );
+}
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/library/actions/components/ActionEditorPane/index.ts b/enterprise/frontend/src/metabase-enterprise/data-studio/library/actions/components/ActionEditorPane/index.ts
new file mode 100644
index 00000000000..b6d6f213aed
--- /dev/null
+++ b/enterprise/frontend/src/metabase-enterprise/data-studio/library/actions/components/ActionEditorPane/index.ts
@@ -0,0 +1 @@
+export { ActionEditorPane } from "./ActionEditorPane";
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/library/actions/components/ActionHeader/ActionHeader.tsx b/enterprise/frontend/src/metabase-enterprise/data-studio/library/actions/components/ActionHeader/ActionHeader.tsx
new file mode 100644
index 00000000000..9899d1a0821
--- /dev/null
+++ b/enterprise/frontend/src/metabase-enterprise/data-studio/library/actions/components/ActionHeader/ActionHeader.tsx
@@ -0,0 +1,121 @@
+import type { ReactNode } from "react";
+import { t } from "ttag";
+
+import { useUpdateActionMutation } from "metabase/api";
+import { isRootCollection } from "metabase/common/collections/utils";
+import { Link } from "metabase/common/components/Link";
+import {
+ type PillTab,
+ PillTabNavigation,
+} from "metabase/common/components/PillTabNavigation";
+import { DataStudioBreadcrumbs } from "metabase/common/data-studio/components/DataStudioBreadcrumbs";
+import {
+ PaneHeader,
+ PaneHeaderInput,
+} from "metabase/common/data-studio/components/PaneHeader";
+import { useCollectionPath } from "metabase/common/data-studio/hooks/use-collection-path/useCollectionPath";
+import { useMetadataToasts } from "metabase/common/hooks";
+import type { StackProps } from "metabase/ui";
+import * as Urls from "metabase/urls";
+import type { WritebackAction, WritebackActionId } from "metabase-types/api";
+
+import { ACTION_NAME_MAX_LENGTH } from "../../constants";
+
+import { ActionMoreMenu } from "./ActionMoreMenu";
+
+type ActionHeaderProps = {
+ action: WritebackAction;
+ actions?: ReactNode;
+ isEditMode?: boolean;
+} & Omit<StackProps, "title">;
+
+export function ActionHeader({
+ action,
+ actions,
+ isEditMode = false,
+ ...stackProps
+}: ActionHeaderProps) {
+ const { path, isLoadingPath } = useCollectionPath({
+ collectionId: action.collection_id,
+ namespace: "data-actions",
+ });
+ const folderPath =
+ path?.filter((collection) => !isRootCollection(collection)) ?? [];
+
+ return (
+ <PaneHeader
+ title={<ActionNameInput action={action} />}
+ icon="bolt"
+ menu={
+ !isEditMode && action.can_write && <ActionMoreMenu action={action} />
+ }
+ tabs={!isEditMode && <ActionTabs actionId={action.id} />}
+ actions={actions}
+ data-testid="action-header"
+ breadcrumbs={
+ <DataStudioBreadcrumbs loading={isLoadingPath}>
+ <Link to={Urls.dataStudioLibrary()}>{t`Semantic layer`}</Link>
+ <Link to={Urls.dataStudioLibrary()}>{t`Data actions`}</Link>
+ {folderPath.map((collection, index) => (
+ <Link
+ key={collection.id}
+ to={Urls.dataStudioLibrary({
+ expandedIds: folderPath.slice(0, index + 1).map(({ id }) => id),
+ })}
+ >
+ {collection.name}
+ </Link>
+ ))}
+ {action.name}
+ </DataStudioBreadcrumbs>
+ }
+ {...stackProps}
+ />
+ );
+}
+
+type ActionNameInputProps = {
+ action: WritebackAction;
+};
+
+function ActionNameInput({ action }: ActionNameInputProps) {
+ const [updateAction] = useUpdateActionMutation();
+ const { sendSuccessToast, sendErrorToast } = useMetadataToasts();
+
+ const handleChangeName = async (name: string) => {
+ const { error } = await updateAction({ id: action.id, name });
+ if (error) {
+ sendErrorToast(t`Failed to update action name`);
+ } else {
+ sendSuccessToast(t`Action name updated`);
+ }
+ };
+
+ return (
+ <PaneHeaderInput
+ initialValue={action.name}
+ maxLength={ACTION_NAME_MAX_LENGTH}
+ readOnly={!action.can_write}
+ onChange={handleChangeName}
+ />
+ );
+}
+
+type ActionTabsProps = {
+ actionId: WritebackActionId;
+};
+
+function ActionTabs({ actionId }: ActionTabsProps) {
+ const tabs: PillTab[] = [
+ { label: t`Definition`, to: Urls.dataStudioAction(actionId) },
+ {
+ label: t`Fields`,
+ to: Urls.dataStudioActionFields(actionId),
+ isSelected: (pathname: string) =>
+ pathname.startsWith(Urls.dataStudioActionFields(actionId)),
+ },
+ { label: t`Run`, to: Urls.dataStudioActionRun(actionId) },
+ { label: t`Settings`, to: Urls.dataStudioActionSettings(actionId) },
+ ];
+ return <PillTabNavigation tabs={tabs} />;
+}
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/library/actions/components/ActionHeader/ActionHeader.unit.spec.tsx b/enterprise/frontend/src/metabase-enterprise/data-studio/library/actions/components/ActionHeader/ActionHeader.unit.spec.tsx
new file mode 100644
index 00000000000..5d63fa966a9
--- /dev/null
+++ b/enterprise/frontend/src/metabase-enterprise/data-studio/library/actions/components/ActionHeader/ActionHeader.unit.spec.tsx
@@ -0,0 +1,70 @@
+import userEvent from "@testing-library/user-event";
+
+import { setupCollectionByIdEndpoint } from "__support__/server-mocks";
+import { renderWithProviders, screen } from "__support__/ui";
+import { ROOT_COLLECTION } from "metabase/common/collections/constants";
+import { Route } from "metabase/router";
+import type { WritebackAction } from "metabase-types/api";
+import {
+ createMockCollection,
+ createMockQueryAction,
+} from "metabase-types/api/mocks";
+
+import { ActionHeader } from "./ActionHeader";
+
+type SetupOpts = {
+ action: WritebackAction;
+};
+
+function setup({ action }: SetupOpts) {
+ setupCollectionByIdEndpoint({
+ collections: [createMockCollection(ROOT_COLLECTION)],
+ });
+
+ renderWithProviders(
+ <Route
+ path="/data-studio/data-actions/:actionId"
+ element={<ActionHeader action={action} />}
+ />,
+ {
+ withRouter: true,
+ initialRoute: `/data-studio/data-actions/${action.id}`,
+ },
+ );
+}
+
+describe("ActionHeader", () => {
+ it("should let a user who can edit the action rename, move and archive it", async () => {
+ setup({
+ action: createMockQueryAction({
+ name: "Update order",
+ can_write: true,
+ }),
+ });
+
+ expect(screen.getByDisplayValue("Update order")).toBeEnabled();
+ await userEvent.click(
+ screen.getByRole("button", { name: "Action options" }),
+ );
+ expect(
+ await screen.findByRole("menuitem", { name: /Move/ }),
+ ).toBeInTheDocument();
+ expect(
+ screen.getByRole("menuitem", { name: /Archive/ }),
+ ).toBeInTheDocument();
+ });
+
+ it("should not let a user who can't edit the action rename, move or archive it", () => {
+ setup({
+ action: createMockQueryAction({
+ name: "Update order",
+ can_write: false,
+ }),
+ });
+
+ expect(screen.getByDisplayValue("Update order")).toBeDisabled();
+ expect(
+ screen.queryByRole("button", { name: "Action options" }),
+ ).not.toBeInTheDocument();
+ });
+});
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/library/actions/components/ActionHeader/ActionMoreMenu/ActionMoreMenu.tsx b/enterprise/frontend/src/metabase-enterprise/data-studio/library/actions/components/ActionHeader/ActionMoreMenu/ActionMoreMenu.tsx
new file mode 100644
index 00000000000..0df2743463a
--- /dev/null
+++ b/enterprise/frontend/src/metabase-enterprise/data-studio/library/actions/components/ActionHeader/ActionMoreMenu/ActionMoreMenu.tsx
@@ -0,0 +1,78 @@
+import { useState } from "react";
+import { t } from "ttag";
+
+import { useUpdateActionMutation } from "metabase/api";
+import { useMetadataToasts } from "metabase/common/hooks";
+import { useConfirmation } from "metabase/common/hooks/use-confirmation";
+import { useNavigate } from "metabase/router";
+import { ActionIcon, Icon, Menu } from "metabase/ui";
+import * as Urls from "metabase/urls";
+import type { WritebackAction } from "metabase-types/api";
+
+import { MoveActionModal } from "./MoveActionModal";
+
+type ActionMoreMenuProps = {
+ action: WritebackAction;
+};
+
+export function ActionMoreMenu({ action }: ActionMoreMenuProps) {
+ const [isMoveModalOpened, setIsMoveModalOpened] = useState(false);
+ const { modalContent: confirmationModal, show: showConfirmation } =
+ useConfirmation();
+ const [updateAction] = useUpdateActionMutation();
+ const { sendSuccessToast, sendErrorToast } = useMetadataToasts();
+ const navigate = useNavigate();
+
+ const handleArchive = async () => {
+ const { error } = await updateAction({ id: action.id, archived: true });
+ if (error) {
+ sendErrorToast(t`Failed to archive action`);
+ return;
+ }
+ sendSuccessToast(t`Action archived`);
+ navigate(Urls.dataStudioLibrary());
+ };
+
+ const handleArchiveClick = () => {
+ showConfirmation({
+ title: t`Archive "${action.name}"?`,
+ message: t`Dashboard buttons and public forms that use this action will stop working.`,
+ confirmButtonText: t`Archive`,
+ confirmButtonProps: { color: "negative" },
+ onConfirm: handleArchive,
+ });
+ };
+
+ return (
+ <>
+ <Menu>
+ <Menu.Target>
+ <ActionIcon size="sm" aria-label={t`Action options`}>
+ <Icon name="ellipsis" />
+ </ActionIcon>
+ </Menu.Target>
+ <Menu.Dropdown>
+ <Menu.Item
+ leftSection={<Icon name="move" />}
+ onClick={() => setIsMoveModalOpened(true)}
+ >
+ {t`Move`}
+ </Menu.Item>
+ <Menu.Item
+ leftSection={<Icon name="archive" />}
+ onClick={handleArchiveClick}
+ >
+ {t`Archive`}
+ </Menu.Item>
+ </Menu.Dropdown>
+ </Menu>
+ {isMoveModalOpened && (
+ <MoveActionModal
+ action={action}
+ onClose={() => setIsMoveModalOpened(false)}
+ />
+ )}
+ {confirmationModal}
+ </>
+ );
+}
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/library/actions/components/ActionHeader/ActionMoreMenu/MoveActionModal/MoveActionModal.tsx b/enterprise/frontend/src/metabase-enterprise/data-studio/library/actions/components/ActionHeader/ActionMoreMenu/MoveActionModal/MoveActionModal.tsx
new file mode 100644
index 00000000000..ff9a82f1923
--- /dev/null
+++ b/enterprise/frontend/src/metabase-enterprise/data-studio/library/actions/components/ActionHeader/ActionMoreMenu/MoveActionModal/MoveActionModal.tsx
@@ -0,0 +1,63 @@
+import { useCallback, useMemo } from "react";
+import { c, t } from "ttag";
+
+import { useUpdateActionMutation } from "metabase/api";
+import { canonicalCollectionId } from "metabase/common/collections/utils";
+import type {
+ OmniPickerItem,
+ OmniPickerValue,
+} from "metabase/common/components/Pickers";
+import { CollectionPickerModal } from "metabase/common/components/Pickers/CollectionPicker";
+import { useMetadataToasts } from "metabase/common/hooks";
+import type { WritebackAction } from "metabase-types/api";
+
+import {
+ ACTION_COLLECTION_NAMESPACES,
+ ACTION_COLLECTION_PICKER_OPTIONS,
+} from "../../../../constants";
+
+type MoveActionModalProps = {
+ action: WritebackAction;
+ onClose: () => void;
+};
+
+export function MoveActionModal({ action, onClose }: MoveActionModalProps) {
+ const [updateAction] = useUpdateActionMutation();
+ const { sendSuccessToast, sendErrorToast } = useMetadataToasts();
+
+ const handleChange = useCallback(
+ async ({ id }: OmniPickerItem) => {
+ const { error } = await updateAction({
+ id: action.id,
+ collection_id: canonicalCollectionId(id),
+ });
+ if (error) {
+ sendErrorToast(t`Failed to move action`);
+ } else {
+ sendSuccessToast(t`Action moved`);
+ onClose();
+ }
+ },
+ [action.id, updateAction, sendSuccessToast, sendErrorToast, onClose],
+ );
+
+ const pickerValue = useMemo(
+ (): OmniPickerValue => ({
+ id: action.collection_id ?? "root",
+ model: "collection",
+ }),
+ [action.collection_id],
+ );
+
+ return (
+ <CollectionPickerModal
+ title={c("dialog title for moving an action to another collection")
+ .t`Move "${action.name}"`}
+ value={pickerValue}
+ onChange={handleChange}
+ onClose={onClose}
+ namespaces={ACTION_COLLECTION_NAMESPACES}
+ options={ACTION_COLLECTION_PICKER_OPTIONS}
+ />
+ );
+}
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/library/actions/components/ActionHeader/ActionMoreMenu/MoveActionModal/index.ts b/enterprise/frontend/src/metabase-enterprise/data-studio/library/actions/components/ActionHeader/ActionMoreMenu/MoveActionModal/index.ts
new file mode 100644
index 00000000000..012e7ad18b6
--- /dev/null
+++ b/enterprise/frontend/src/metabase-enterprise/data-studio/library/actions/components/ActionHeader/ActionMoreMenu/MoveActionModal/index.ts
@@ -0,0 +1 @@
+export { MoveActionModal } from "./MoveActionModal";
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/library/actions/components/ActionHeader/ActionMoreMenu/index.ts b/enterprise/frontend/src/metabase-enterprise/data-studio/library/actions/components/ActionHeader/ActionMoreMenu/index.ts
new file mode 100644
index 00000000000..3cfa21c4703
--- /dev/null
+++ b/enterprise/frontend/src/metabase-enterprise/data-studio/library/actions/components/ActionHeader/ActionMoreMenu/index.ts
@@ -0,0 +1 @@
+export { ActionMoreMenu } from "./ActionMoreMenu";
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/library/actions/components/ActionHeader/index.ts b/enterprise/frontend/src/metabase-enterprise/data-studio/library/actions/components/ActionHeader/index.ts
new file mode 100644
index 00000000000..42e10940e2b
--- /dev/null
+++ b/enterprise/frontend/src/metabase-enterprise/data-studio/library/actions/components/ActionHeader/index.ts
@@ -0,0 +1 @@
+export { ActionHeader } from "./ActionHeader";
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/library/actions/components/RootDataActionsMenu/RootDataActionsMenu.tsx b/enterprise/frontend/src/metabase-enterprise/data-studio/library/actions/components/RootDataActionsMenu/RootDataActionsMenu.tsx
new file mode 100644
index 00000000000..4902d1a4288
--- /dev/null
+++ b/enterprise/frontend/src/metabase-enterprise/data-studio/library/actions/components/RootDataActionsMenu/RootDataActionsMenu.tsx
@@ -0,0 +1,61 @@
+import { useDisclosure } from "@mantine/hooks";
+import { t } from "ttag";
+
+import { Link } from "metabase/common/components/Link";
+import { getUserIsAdmin } from "metabase/current-user";
+import { PLUGIN_LIBRARY } from "metabase/plugins";
+import { useSelector } from "metabase/redux";
+import { ActionIcon, FixedSizeIcon, Menu, Tooltip } from "metabase/ui";
+import * as Urls from "metabase/urls";
+import { getIsRemoteSyncReadOnly } from "metabase-enterprise/remote_sync/selectors";
+
+export function RootDataActionsMenu() {
+ const isAdmin = useSelector(getUserIsAdmin);
+ const remoteSyncReadOnly = useSelector(getIsRemoteSyncReadOnly);
+ const canChangePermissions = isAdmin && !remoteSyncReadOnly;
+ const [isPermissionsModalOpen, { toggle: togglePermissionsModal }] =
+ useDisclosure(false);
+ const optionsLabel = t`Data action options`;
+
+ return (
+ <Menu position="bottom-end">
+ <Menu.Target>
+ <Tooltip
+ label={optionsLabel}
+ onClick={(event) => event.stopPropagation()}
+ openDelay={1000}
+ >
+ <ActionIcon aria-label={optionsLabel} size="md">
+ <FixedSizeIcon name="ellipsis" size={16} />
+ </ActionIcon>
+ </Tooltip>
+ </Menu.Target>
+ <Menu.Dropdown>
+ {canChangePermissions && (
+ <Menu.Item
+ leftSection={<FixedSizeIcon name="lock" />}
+ onClick={(event) => {
+ event.stopPropagation();
+ togglePermissionsModal();
+ }}
+ >
+ {t`Change permissions`}
+ </Menu.Item>
+ )}
+ <Menu.Item
+ component={Link}
+ leftSection={<FixedSizeIcon name="view_archive" />}
+ to={Urls.dataStudioArchivedActions()}
+ >
+ {t`View archived actions`}
+ </Menu.Item>
+ </Menu.Dropdown>
+ <PLUGIN_LIBRARY.CollectionPermissionsModal
+ opened={isPermissionsModalOpen}
+ collectionId="root"
+ namespace="data-actions"
+ onClose={togglePermissionsModal}
+ />
+ </Menu>
+ );
+}
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/library/actions/components/RootDataActionsMenu/index.ts b/enterprise/frontend/src/metabase-enterprise/data-studio/library/actions/components/RootDataActionsMenu/index.ts
new file mode 100644
index 00000000000..62884e0951d
--- /dev/null
+++ b/enterprise/frontend/src/metabase-enterprise/data-studio/library/actions/components/RootDataActionsMenu/index.ts
@@ -0,0 +1 @@
+export * from "./RootDataActionsMenu";
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/library/actions/constants.ts b/enterprise/frontend/src/metabase-enterprise/data-studio/library/actions/constants.ts
new file mode 100644
index 00000000000..2bb8b8190bf
--- /dev/null
+++ b/enterprise/frontend/src/metabase-enterprise/data-studio/library/actions/constants.ts
@@ -0,0 +1,18 @@
+import type { EntityPickerOptions } from "metabase/common/components/Pickers";
+import type { CollectionNamespace } from "metabase-types/api";
+
+export const ACTION_NAME_MAX_LENGTH = 254;
+
+export const ACTION_COLLECTION_PICKER_OPTIONS: EntityPickerOptions = {
+ hasSearch: false,
+ hasRecents: false,
+ hasLibrary: false,
+ hasRootCollection: true,
+ hasPersonalCollections: false,
+ hasConfirmButtons: true,
+ canCreateCollections: true,
+};
+
+export const ACTION_COLLECTION_NAMESPACES: CollectionNamespace[] = [
+ "data-actions",
+];
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/library/actions/hooks/use-action-database.ts b/enterprise/frontend/src/metabase-enterprise/data-studio/library/actions/hooks/use-action-database.ts
new file mode 100644
index 00000000000..a44bdc72bea
--- /dev/null
+++ b/enterprise/frontend/src/metabase-enterprise/data-studio/library/actions/hooks/use-action-database.ts
@@ -0,0 +1,21 @@
+import { useMemo } from "react";
+
+import { useListDatabasesQuery } from "metabase/api";
+import type { Database, WritebackAction } from "metabase-types/api";
+
+type ActionDatabaseResult = {
+ database: Database | undefined;
+ isLoading: boolean;
+ error: unknown;
+};
+
+export function useActionDatabase(
+ action: WritebackAction | undefined,
+): ActionDatabaseResult {
+ const { data, isLoading, error } = useListDatabasesQuery();
+ const database = useMemo(
+ () => data?.data.find((database) => database.id === action?.database_id),
+ [data, action?.database_id],
+ );
+ return { database, isLoading, error };
+}
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/library/actions/hooks/use-action-databases.ts b/enterprise/frontend/src/metabase-enterprise/data-studio/library/actions/hooks/use-action-databases.ts
new file mode 100644
index 00000000000..7c524d1e53e
--- /dev/null
+++ b/enterprise/frontend/src/metabase-enterprise/data-studio/library/actions/hooks/use-action-databases.ts
@@ -0,0 +1,20 @@
+import { useMemo } from "react";
+
+import { useListDatabasesQuery } from "metabase/api";
+import { hasActionsEnabled } from "metabase/common/utils/database";
+import type { Database } from "metabase-types/api";
+
+type ActionDatabasesResult = {
+ databases: Database[];
+ isLoading: boolean;
+ error: unknown;
+};
+
+export function useActionDatabases(): ActionDatabasesResult {
+ const { data, isLoading, error } = useListDatabasesQuery();
+ const databases = useMemo(
+ () => data?.data.filter(hasActionsEnabled) ?? [],
+ [data],
+ );
+ return { databases, isLoading, error };
+}
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/library/actions/hooks/use-action-draft.ts b/enterprise/frontend/src/metabase-enterprise/data-studio/library/actions/hooks/use-action-draft.ts
new file mode 100644
index 00000000000..08acd137edf
--- /dev/null
+++ b/enterprise/frontend/src/metabase-enterprise/data-studio/library/actions/hooks/use-action-draft.ts
@@ -0,0 +1,39 @@
+import { useMemo, useState } from "react";
+
+import { getDefaultFormSettings } from "metabase/actions/utils";
+import * as Lib from "metabase-lib";
+import type { ActionFormSettings, DatasetQuery } from "metabase-types/api";
+
+import { type ActionDefinition, getActionDefinition } from "../utils";
+
+import { useActionQuery } from "./use-action-query";
+
+type UseActionDraftOptions = {
+ initialDatasetQuery: DatasetQuery;
+ formSettings?: ActionFormSettings;
+};
+
+type ActionDraft = {
+ datasetQuery: DatasetQuery;
+ definition: ActionDefinition | null;
+ isDirty: boolean;
+ isValid: boolean;
+ setDatasetQuery: (datasetQuery: DatasetQuery) => void;
+};
+
+export function useActionDraft({
+ initialDatasetQuery,
+ formSettings,
+}: UseActionDraftOptions): ActionDraft {
+ const [datasetQuery, setDatasetQuery] = useState(initialDatasetQuery);
+ const query = useActionQuery(datasetQuery);
+
+ const definition = useMemo(
+ () => getActionDefinition(query, getDefaultFormSettings(formSettings)),
+ [query, formSettings],
+ );
+ const isDirty = !Lib.areLegacyQueriesEqual(datasetQuery, initialDatasetQuery);
+ const isValid = definition != null && Lib.canSave(query, "question");
+
+ return { datasetQuery, definition, isDirty, isValid, setDatasetQuery };
+}
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/library/actions/hooks/use-action-fields.ts b/enterprise/frontend/src/metabase-enterprise/data-studio/library/actions/hooks/use-action-fields.ts
new file mode 100644
index 00000000000..a70dff95ccb
--- /dev/null
+++ b/enterprise/frontend/src/metabase-enterprise/data-studio/library/actions/hooks/use-action-fields.ts
@@ -0,0 +1,130 @@
+import { useMemo } from "react";
+import { t } from "ttag";
+
+import {
+ getDefaultFormSettings,
+ sortActionParams,
+} from "metabase/actions/utils";
+import { useUpdateActionMutation } from "metabase/api";
+import { useMetadataToasts } from "metabase/common/hooks";
+import * as Lib from "metabase-lib";
+import type {
+ ActionFormSettings,
+ FieldSettings,
+ UpdateActionRequest,
+ WritebackParameter,
+ WritebackQueryAction,
+} from "metabase-types/api";
+
+import {
+ getFieldSettingsFromQuery,
+ getQueryParameters,
+ setTemplateTagFieldType,
+} from "../utils";
+
+import { useActionQuery } from "./use-action-query";
+
+export type ActionField = {
+ parameter: WritebackParameter;
+ settings: FieldSettings;
+ variableName: string;
+};
+
+type ActionFieldsResult = {
+ fields: ActionField[];
+ updateField: (
+ fieldId: string,
+ patch: Partial<FieldSettings>,
+ ) => Promise<void>;
+ reorderFields: (fieldIds: string[]) => Promise<void>;
+};
+
+export function useActionFields(
+ action: WritebackQueryAction,
+): ActionFieldsResult {
+ const query = useActionQuery(action.dataset_query);
+ const [updateAction] = useUpdateActionMutation();
+ const { sendErrorToast } = useMetadataToasts();
+
+ const formSettings = useMemo(
+ () =>
+ getFieldSettingsFromQuery(
+ query,
+ getDefaultFormSettings(action.visualization_settings),
+ ),
+ [query, action.visualization_settings],
+ );
+
+ const fields = useMemo(() => {
+ const tags = Object.values(Lib.templateTags(query));
+ return [...getQueryParameters(query)]
+ .sort(sortActionParams(formSettings))
+ .flatMap((parameter) => {
+ const settings = formSettings.fields?.[parameter.id];
+ const tag = tags.find((tag) => tag.id === parameter.id);
+ return settings && tag
+ ? [{ parameter, settings, variableName: tag.name }]
+ : [];
+ });
+ }, [query, formSettings]);
+
+ const save = async (request: Omit<UpdateActionRequest, "id">) => {
+ const { error } = await updateAction({ id: action.id, ...request });
+ if (error) {
+ sendErrorToast(t`Failed to update action fields`);
+ }
+ };
+
+ const withFields = (
+ update: (
+ fields: Record<string, FieldSettings>,
+ ) => Record<string, FieldSettings>,
+ ): ActionFormSettings => ({
+ ...formSettings,
+ fields: update(formSettings.fields ?? {}),
+ });
+
+ const updateField = async (
+ fieldId: string,
+ patch: Partial<FieldSettings>,
+ ) => {
+ const field = formSettings.fields?.[fieldId];
+ if (field == null) {
+ return;
+ }
+ const visualizationSettings = withFields((fields) => ({
+ ...fields,
+ [fieldId]: { ...field, ...patch },
+ }));
+
+ if (patch.fieldType != null && patch.fieldType !== field.fieldType) {
+ const nextQuery = setTemplateTagFieldType(
+ query,
+ fieldId,
+ patch.fieldType,
+ );
+ await save({
+ dataset_query: Lib.toJsQuery(nextQuery),
+ parameters: getQueryParameters(nextQuery),
+ visualization_settings: visualizationSettings,
+ });
+ } else {
+ await save({ visualization_settings: visualizationSettings });
+ }
+ };
+
+ const reorderFields = async (fieldIds: string[]) => {
+ await save({
+ visualization_settings: withFields((fields) =>
+ Object.fromEntries(
+ Object.entries(fields).map(([id, field]) => [
+ id,
+ { ...field, order: fieldIds.indexOf(id) },
+ ]),
+ ),
+ ),
+ });
+ };
+
+ return { fields, updateField, reorderFields };
+}
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/library/actions/hooks/use-action-query.ts b/enterprise/frontend/src/metabase-enterprise/data-studio/library/actions/hooks/use-action-query.ts
new file mode 100644
index 00000000000..e42005c9d7e
--- /dev/null
+++ b/enterprise/frontend/src/metabase-enterprise/data-studio/library/actions/hooks/use-action-query.ts
@@ -0,0 +1,13 @@
+import { useMemo } from "react";
+
+import { useMetadataProvider } from "metabase/metadata-store";
+import * as Lib from "metabase-lib";
+import type { DatasetQuery } from "metabase-types/api";
+
+export function useActionQuery(datasetQuery: DatasetQuery): Lib.Query {
+ const metadataProvider = useMetadataProvider(datasetQuery.database);
+ return useMemo(
+ () => Lib.fromJsQuery(metadataProvider, datasetQuery),
+ [metadataProvider, datasetQuery],
+ );
+}
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/library/actions/hooks/use-build-action-tree/index.ts b/enterprise/frontend/src/metabase-enterprise/data-studio/library/actions/hooks/use-build-action-tree/index.ts
new file mode 100644
index 00000000000..e34c13c9b8a
--- /dev/null
+++ b/enterprise/frontend/src/metabase-enterprise/data-studio/library/actions/hooks/use-build-action-tree/index.ts
@@ -0,0 +1,2 @@
+export * from "./use-build-action-tree";
+export * from "./utils";
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/library/actions/hooks/use-build-action-tree/use-build-action-tree.ts b/enterprise/frontend/src/metabase-enterprise/data-studio/library/actions/hooks/use-build-action-tree/use-build-action-tree.ts
new file mode 100644
index 00000000000..b72d6c266cb
--- /dev/null
+++ b/enterprise/frontend/src/metabase-enterprise/data-studio/library/actions/hooks/use-build-action-tree/use-build-action-tree.ts
@@ -0,0 +1,76 @@
+import { useMemo } from "react";
+
+import {
+ skipToken,
+ useListActionsQuery,
+ useListCollectionsQuery,
+} from "metabase/api";
+import type { TreeItem } from "metabase/data-studio/common/types";
+
+import { buildActiveActionTree, buildArchivedActionTree } from "./utils";
+
+type ActionTreeOptions = {
+ archived?: boolean;
+ canCreateActions?: boolean;
+};
+
+export function useBuildActionTree({
+ archived = false,
+ canCreateActions = false,
+}: ActionTreeOptions = {}): {
+ isLoading: boolean;
+ tree: TreeItem[];
+ error?: unknown;
+} {
+ const {
+ data: actions,
+ isLoading: isLoadingActions,
+ error: actionsError,
+ } = useListActionsQuery({ type: "query", archived });
+ const {
+ data: collections,
+ isLoading: isLoadingCollections,
+ error: collectionsError,
+ } = useListCollectionsQuery({ namespace: "data-actions", archived });
+ const {
+ data: activeCollections,
+ isLoading: isLoadingActiveCollections,
+ error: activeCollectionsError,
+ } = useListCollectionsQuery(
+ archived ? { namespace: "data-actions", archived: false } : skipToken,
+ );
+
+ return useMemo(() => {
+ const error = actionsError ?? collectionsError ?? activeCollectionsError;
+ const isLoading =
+ isLoadingActions ||
+ isLoadingCollections ||
+ isLoadingActiveCollections ||
+ !actions ||
+ !collections ||
+ (archived && !activeCollections);
+ if (isLoading) {
+ return { isLoading: true, tree: [], error };
+ }
+
+ return {
+ isLoading: false,
+ error,
+ tree: archived
+ ? buildArchivedActionTree(collections, actions, activeCollections ?? [])
+ : buildActiveActionTree(collections, actions, canCreateActions),
+ };
+ }, [
+ actions,
+ actionsError,
+ activeCollections,
+ activeCollectionsError,
+ archived,
+ canCreateActions,
+ collections,
+ collectionsError,
+ isLoadingActions,
+ isLoadingActiveCollections,
+ isLoadingCollections,
+ ]);
+}
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/library/actions/hooks/use-build-action-tree/utils.ts b/enterprise/frontend/src/metabase-enterprise/data-studio/library/actions/hooks/use-build-action-tree/utils.ts
new file mode 100644
index 00000000000..a6d071526ef
--- /dev/null
+++ b/enterprise/frontend/src/metabase-enterprise/data-studio/library/actions/hooks/use-build-action-tree/utils.ts
@@ -0,0 +1,152 @@
+import { t } from "ttag";
+
+import { isRootCollection } from "metabase/common/collections/utils";
+import type { TreeItem } from "metabase/data-studio/common/types";
+import { createEmptyStateItem } from "metabase/data-studio/common/utils";
+import type {
+ Collection,
+ CollectionId,
+ WritebackAction,
+} from "metabase-types/api";
+
+// The data actions root has the same "root" id as the SQL snippets root, so its node needs its own key.
+const DATA_ACTIONS_ROOT_NODE_KEY = "data-actions-root";
+
+export function getActionCollectionNodeId(collection: Pick<Collection, "id">) {
+ return isRootCollection(collection)
+ ? `collection:${DATA_ACTIONS_ROOT_NODE_KEY}`
+ : `collection:${collection.id}`;
+}
+
+function createActionNode(action: WritebackAction): TreeItem {
+ return {
+ id: `action:${action.id}`,
+ name: action.name,
+ icon: "bolt",
+ model: "action",
+ data: {
+ id: action.id,
+ model: "action",
+ name: action.name,
+ description: action.description,
+ collection_id: action.collection_id,
+ archived: action.archived,
+ can_write: action.can_write,
+ },
+ updatedAt: action.updated_at,
+ };
+}
+
+function buildActionCollectionNode(
+ collection: Collection,
+ collections: Collection[],
+ actions: WritebackAction[],
+): TreeItem {
+ const parentId = isRootCollection(collection) ? null : collection.id;
+ const children = [
+ ...collections
+ .filter((child) => child.parent_id === parentId)
+ .map((child) => buildActionCollectionNode(child, collections, actions)),
+ ...actions
+ .filter((action) => action.collection_id === parentId)
+ .map(createActionNode),
+ ];
+
+ return {
+ id: getActionCollectionNodeId(collection),
+ name: collection.name,
+ model: "collection",
+ icon: isRootCollection(collection) ? "bolt" : "folder",
+ data: { ...collection, model: "collection" },
+ children: children.length > 0 ? children : undefined,
+ };
+}
+
+function isDataAction(
+ action: WritebackAction,
+ collectionIds: Set<CollectionId>,
+) {
+ return (
+ action.model_id == null &&
+ (action.collection_id == null || collectionIds.has(action.collection_id))
+ );
+}
+
+/**
+ * The data actions root with its folders and the actions without a model under it, or nothing without a readable
+ * root or when it is empty and no action can be created.
+ */
+export function buildActiveActionTree(
+ actionCollections: Collection[],
+ actions: WritebackAction[],
+ canCreateActions: boolean,
+): TreeItem[] {
+ const rootCollection = actionCollections.find(isRootCollection);
+ if (!rootCollection) {
+ return [];
+ }
+
+ const collections = actionCollections.filter(
+ (collection) => !collection.archived && !isRootCollection(collection),
+ );
+ const collectionIds = new Set(collections.map((collection) => collection.id));
+ const dataActions = actions.filter(
+ (action) => !action.archived && isDataAction(action, collectionIds),
+ );
+ const rootNode = buildActionCollectionNode(
+ rootCollection,
+ collections,
+ dataActions,
+ );
+ const hasContent = dataActions.length > 0 || collections.length > 0;
+ if (!hasContent && !canCreateActions) {
+ return [];
+ }
+
+ return [
+ {
+ ...rootNode,
+ name: t`Data actions`,
+ children: hasContent
+ ? rootNode.children
+ : [createEmptyStateItem("actions", undefined, !canCreateActions)],
+ },
+ ];
+}
+
+/**
+ * The archived data actions folders with their actions, followed by the archived actions outside of them.
+ */
+export function buildArchivedActionTree(
+ archivedCollections: Collection[],
+ archivedActions: WritebackAction[],
+ activeCollections: Collection[],
+): TreeItem[] {
+ const collectionIds = new Set(
+ archivedCollections.map((collection) => collection.id),
+ );
+ const dataActionCollectionIds = new Set([
+ ...collectionIds,
+ ...activeCollections.map((collection) => collection.id),
+ ]);
+ const topLevelCollections = archivedCollections.filter(
+ (collection) =>
+ collection.parent_id == null || !collectionIds.has(collection.parent_id),
+ );
+ const dataActions = archivedActions.filter((action) =>
+ isDataAction(action, dataActionCollectionIds),
+ );
+
+ return [
+ ...topLevelCollections.map((collection) =>
+ buildActionCollectionNode(collection, archivedCollections, dataActions),
+ ),
+ ...dataActions
+ .filter(
+ (action) =>
+ action.collection_id == null ||
+ !collectionIds.has(action.collection_id),
+ )
+ .map(createActionNode),
+ ];
+}
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/library/actions/hooks/use-build-action-tree/utils.unit.spec.ts b/enterprise/frontend/src/metabase-enterprise/data-studio/library/actions/hooks/use-build-action-tree/utils.unit.spec.ts
new file mode 100644
index 00000000000..96fac5afc18
--- /dev/null
+++ b/enterprise/frontend/src/metabase-enterprise/data-studio/library/actions/hooks/use-build-action-tree/utils.unit.spec.ts
@@ -0,0 +1,92 @@
+import {
+ createMockCollection,
+ createMockImplicitQueryAction,
+ createMockQueryAction,
+} from "metabase-types/api/mocks";
+
+import { buildActiveActionTree, buildArchivedActionTree } from "./utils";
+
+const ROOT = createMockCollection({
+ id: "root",
+ name: "Data actions",
+ namespace: "data-actions",
+});
+const FOLDER = createMockCollection({
+ id: 10,
+ name: "Billing",
+ namespace: "data-actions",
+ parent_id: null,
+});
+
+describe("buildActiveActionTree", () => {
+ it("should put actions without a model under the root and their folders", () => {
+ const tree = buildActiveActionTree(
+ [ROOT, FOLDER],
+ [
+ createMockQueryAction({ id: 1, name: "At root", collection_id: null }),
+ createMockQueryAction({ id: 2, name: "In folder", collection_id: 10 }),
+ ],
+ true,
+ );
+
+ expect(tree).toHaveLength(1);
+ expect(tree[0]).toMatchObject({
+ id: "collection:data-actions-root",
+ name: "Data actions",
+ children: [
+ {
+ id: "collection:10",
+ children: [{ id: "action:2", model: "action" }],
+ },
+ { id: "action:1", model: "action" },
+ ],
+ });
+ });
+
+ it("should leave out model actions and actions outside data actions folders", () => {
+ const tree = buildActiveActionTree(
+ [ROOT],
+ [
+ createMockImplicitQueryAction({ id: 3, model_id: 5 }),
+ createMockQueryAction({ id: 4, collection_id: 99 }),
+ ],
+ true,
+ );
+
+ expect(tree[0].children).toEqual([
+ expect.objectContaining({ model: "empty-state" }),
+ ]);
+ });
+
+ it("should build no tree when it is empty and no action can be created", () => {
+ expect(buildActiveActionTree([ROOT], [], false)).toEqual([]);
+ });
+
+ it("should show the empty state when an action can be created", () => {
+ expect(buildActiveActionTree([ROOT], [], true)[0].children).toEqual([
+ expect.objectContaining({ model: "empty-state" }),
+ ]);
+ });
+
+ it("should build no tree without a readable root", () => {
+ expect(buildActiveActionTree([FOLDER], [], true)).toEqual([]);
+ });
+});
+
+describe("buildArchivedActionTree", () => {
+ it("should list archived folders and the archived data actions outside of them", () => {
+ const archivedFolder = { ...FOLDER, archived: true };
+ const tree = buildArchivedActionTree(
+ [archivedFolder],
+ [
+ createMockQueryAction({ id: 5, collection_id: 10, archived: true }),
+ createMockQueryAction({ id: 6, collection_id: null, archived: true }),
+ createMockQueryAction({ id: 7, collection_id: 99, archived: true }),
+ ],
+ [],
+ );
+
+ expect(tree.map((node) => node.id)).toEqual(["collection:10", "action:6"]);
+ expect(tree[0].children?.map((node) => node.id)).toEqual(["action:5"]);
+ });
+});
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/library/actions/hooks/use-route-action.ts b/enterprise/frontend/src/metabase-enterprise/data-studio/library/actions/hooks/use-route-action.ts
new file mode 100644
index 00000000000..e33355dc172
--- /dev/null
+++ b/enterprise/frontend/src/metabase-enterprise/data-studio/library/actions/hooks/use-route-action.ts
@@ -0,0 +1,29 @@
+import { t } from "ttag";
+
+import { skipToken, useGetActionQuery } from "metabase/api";
+import { useParams } from "metabase/router";
+import * as Urls from "metabase/urls";
+import type { WritebackQueryAction } from "metabase-types/api";
+
+type RouteActionResult = {
+ action: WritebackQueryAction | undefined;
+ isLoading: boolean;
+ error: unknown;
+};
+
+export function useRouteAction(): RouteActionResult {
+ const params = useParams<{ actionId: string }>();
+ const actionId = Urls.extractEntityId(params.actionId);
+ const { currentData, isFetching, error } = useGetActionQuery(
+ actionId != null ? { id: actionId } : skipToken,
+ );
+ const action = currentData?.type === "query" ? currentData : undefined;
+ const isLoading = currentData === undefined && isFetching;
+ const isNotFound = !isLoading && error === undefined && action === undefined;
+
+ return {
+ action,
+ isLoading,
+ error: isNotFound ? t`Action not found.` : error,
+ };
+}
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/library/actions/pages/ActionFieldsPage/ActionFieldDetails/ActionFieldDetails.tsx b/enterprise/frontend/src/metabase-enterprise/data-studio/library/actions/pages/ActionFieldsPage/ActionFieldDetails/ActionFieldDetails.tsx
new file mode 100644
index 00000000000..4e62016b13f
--- /dev/null
+++ b/enterprise/frontend/src/metabase-enterprise/data-studio/library/actions/pages/ActionFieldsPage/ActionFieldDetails/ActionFieldDetails.tsx
@@ -0,0 +1,227 @@
+import { useMemo } from "react";
+import { t } from "ttag";
+
+import { getFieldTypes, getInputTypes } from "metabase/actions/constants";
+import { inputTypeHasOptions } from "metabase/actions/utils";
+import { TitledSection } from "metabase/metadata/components";
+import {
+ Alert,
+ Code,
+ Icon,
+ SegmentedControl,
+ Select,
+ Stack,
+ Switch,
+ Text,
+ TextInput,
+ Textarea,
+} from "metabase/ui";
+import type { FieldSettings, FieldType } from "metabase-types/api";
+
+import type { ActionField } from "../../../hooks/use-action-fields";
+import { getFieldSettingsForFieldType } from "../../../utils";
+
+import { getDefaultValueInputType, textToOptions } from "./utils";
+
+type ActionFieldDetailsProps = {
+ field: ActionField;
+ readOnly: boolean;
+ canChangeFieldType: boolean;
+ onChange: (patch: Partial<FieldSettings>) => void;
+};
+
+export function ActionFieldDetails({
+ field,
+ readOnly,
+ canChangeFieldType,
+ onChange,
+}: ActionFieldDetailsProps) {
+ const { settings, variableName } = field;
+ const inputTypes = useMemo(
+ () => getInputTypes()[settings.fieldType],
+ [settings.fieldType],
+ );
+ const isHiddenWithoutDefault =
+ settings.hidden && settings.required && settings.defaultValue == null;
+
+ const handleFieldTypeChange = (fieldType: FieldType) => {
+ onChange(getFieldSettingsForFieldType(settings, fieldType));
+ };
+
+ return (
+ <Stack gap="lg" pb="xl" data-testid="action-field-details">
+ <TitledSection>
+ <BlurTextInput
+ label={t`Display name`}
+ value={settings.title}
+ readOnly={readOnly}
+ onChange={(title) => onChange({ title })}
+ />
+ <BlurTextarea
+ label={t`Description`}
+ value={settings.description ?? ""}
+ readOnly={readOnly}
+ onChange={(description) => onChange({ description })}
+ />
+ <Stack gap="xs">
+ <Text fw="bold">{t`SQL variable`}</Text>
+ <Code w="fit-content">{`{{${variableName}}}`}</Code>
+ </Stack>
+ </TitledSection>
+ <TitledSection>
+ <Stack gap="xs">
+ <Text fw="bold">{t`Field type`}</Text>
+ <Text c="text-secondary" size="sm">
+ {t`What kind of value this field takes`}
+ </Text>
+ <SegmentedControl
+ w="fit-content"
+ value={settings.fieldType}
+ data={getFieldTypes().map(({ value, name }) => ({
+ value,
+ label: name,
+ }))}
+ disabled={readOnly || !canChangeFieldType}
+ onChange={(value) => {
+ const fieldType = getFieldTypes().find(
+ (option) => option.value === value,
+ )?.value;
+ if (fieldType != null) {
+ handleFieldTypeChange(fieldType);
+ }
+ }}
+ />
+ </Stack>
+ <Select
+ label={t`Input type`}
+ value={settings.inputType}
+ data={inputTypes.map(({ value, name }) => ({ value, label: name }))}
+ readOnly={readOnly}
+ allowDeselect={false}
+ onChange={(value) => {
+ const inputType = inputTypes.find(
+ (option) => option.value === value,
+ )?.value;
+ if (inputType != null) {
+ onChange({ inputType });
+ }
+ }}
+ />
+ {inputTypeHasOptions(settings.inputType) && (
+ <BlurTextarea
+ label={t`Options`}
+ description={t`One option per line`}
+ value={(settings.valueOptions ?? []).join("\n")}
+ readOnly={readOnly}
+ onChange={(value) =>
+ onChange({
+ valueOptions: textToOptions(value, settings.fieldType),
+ })
+ }
+ />
+ )}
+ <BlurTextInput
+ label={t`Placeholder`}
+ value={settings.placeholder ?? ""}
+ readOnly={readOnly}
+ onChange={(placeholder) => onChange({ placeholder })}
+ />
+ <BlurTextInput
+ label={t`Default value`}
+ placeholder={t`No default`}
+ type={getDefaultValueInputType(settings.inputType)}
+ value={
+ settings.defaultValue != null ? String(settings.defaultValue) : ""
+ }
+ readOnly={readOnly}
+ onChange={(value) =>
+ onChange({
+ defaultValue: parseDefaultValue(value, settings.fieldType),
+ })
+ }
+ />
+ </TitledSection>
+ <TitledSection>
+ <Switch
+ label={t`Required`}
+ description={t`People must fill in this field to run the action`}
+ checked={settings.required}
+ disabled={readOnly}
+ onChange={(event) =>
+ onChange({ required: event.currentTarget.checked })
+ }
+ />
+ <Switch
+ label={t`Show field`}
+ description={t`Hidden fields use their default value`}
+ checked={!settings.hidden}
+ disabled={readOnly}
+ onChange={(event) =>
+ onChange({ hidden: !event.currentTarget.checked })
+ }
+ />
+ {isHiddenWithoutDefault && (
+ <Alert color="warning" icon={<Icon name="warning" />}>
+ {t`Your action has a hidden required field with no default value. There's a good chance this will cause the action to fail.`}
+ </Alert>
+ )}
+ </TitledSection>
+ </Stack>
+ );
+}
+
+function parseDefaultValue(
+ value: string,
+ fieldType: FieldType,
+): FieldSettings["defaultValue"] {
+ if (value.trim() === "") {
+ return undefined;
+ }
+ if (fieldType === "number") {
+ const number = Number(value);
+ return Number.isFinite(number) ? number : undefined;
+ }
+ return value;
+}
+
+type BlurInputProps = {
+ label: string;
+ description?: string;
+ placeholder?: string;
+ type?: string;
+ value: string;
+ readOnly: boolean;
+ onChange: (value: string) => void;
+};
+
+function BlurTextInput({ value, onChange, ...props }: BlurInputProps) {
+ return (
+ <TextInput
+ {...props}
+ key={value}
+ defaultValue={value}
+ onBlur={(event) => {
+ if (event.currentTarget.value !== value) {
+ onChange(event.currentTarget.value);
+ }
+ }}
+ />
+ );
+}
+
+function BlurTextarea({ value, onChange, ...props }: BlurInputProps) {
+ return (
+ <Textarea
+ {...props}
+ key={value}
+ defaultValue={value}
+ autosize
+ minRows={2}
+ onBlur={(event) => {
+ if (event.currentTarget.value !== value) {
+ onChange(event.currentTarget.value);
+ }
+ }}
+ />
+ );
+}
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/library/actions/pages/ActionFieldsPage/ActionFieldDetails/ActionFieldDetails.unit.spec.tsx b/enterprise/frontend/src/metabase-enterprise/data-studio/library/actions/pages/ActionFieldsPage/ActionFieldDetails/ActionFieldDetails.unit.spec.tsx
new file mode 100644
index 00000000000..35345f1249a
--- /dev/null
+++ b/enterprise/frontend/src/metabase-enterprise/data-studio/library/actions/pages/ActionFieldsPage/ActionFieldDetails/ActionFieldDetails.unit.spec.tsx
@@ -0,0 +1,98 @@
+import userEvent from "@testing-library/user-event";
+
+import { renderWithProviders, screen } from "__support__/ui";
+import type { FieldSettings } from "metabase-types/api";
+import {
+ createMockActionParameter,
+ createMockFieldSettings,
+} from "metabase-types/api/mocks";
+
+import { ActionFieldDetails } from "./ActionFieldDetails";
+
+type SetupOpts = {
+ settings?: Partial<FieldSettings>;
+ canChangeFieldType?: boolean;
+};
+
+function setup({ settings, canChangeFieldType = true }: SetupOpts = {}) {
+ const onChange = jest.fn();
+
+ renderWithProviders(
+ <ActionFieldDetails
+ field={{
+ parameter: createMockActionParameter({ id: "status" }),
+ settings: createMockFieldSettings({
+ id: "status",
+ title: "Status",
+ ...settings,
+ }),
+ variableName: "status",
+ }}
+ readOnly={false}
+ canChangeFieldType={canChangeFieldType}
+ onChange={onChange}
+ />,
+ );
+
+ return { onChange };
+}
+
+describe("ActionFieldDetails", () => {
+ it("should save dropdown options without duplicates", async () => {
+ const { onChange } = setup({ settings: { inputType: "select" } });
+
+ await userEvent.type(screen.getByLabelText("Options"), "a{enter}b{enter}a");
+ await userEvent.tab();
+
+ expect(onChange).toHaveBeenCalledWith({ valueOptions: ["a", "b"] });
+ });
+
+ it("should save the default value of a number field as a number", async () => {
+ const { onChange } = setup({
+ settings: { fieldType: "number", inputType: "number" },
+ });
+
+ await userEvent.type(screen.getByLabelText("Default value"), "42");
+ await userEvent.tab();
+
+ expect(onChange).toHaveBeenCalledWith({ defaultValue: 42 });
+ });
+
+ it("should keep the dropdown and its options when switching from text to number", async () => {
+ const { onChange } = setup({
+ settings: { inputType: "select", valueOptions: ["1", "2", "shipped"] },
+ });
+
+ await userEvent.click(screen.getByText("Number"));
+
+ expect(onChange).toHaveBeenCalledWith(
+ expect.objectContaining({
+ fieldType: "number",
+ inputType: "select",
+ valueOptions: [1, 2],
+ }),
+ );
+ });
+
+ it("should warn about a hidden required field without a default value", () => {
+ setup({ settings: { hidden: true, required: true } });
+
+ expect(
+ screen.getByText(/hidden required field with no default value/),
+ ).toBeInTheDocument();
+ });
+
+ it("should not warn about a hidden required field with a default value", () => {
+ setup({ settings: { hidden: true, required: true, defaultValue: "new" } });
+
+ expect(
+ screen.queryByText(/hidden required field with no default value/),
+ ).not.toBeInTheDocument();
+ });
+
+ it("should not allow changing the field type without native query permissions", () => {
+ setup({ canChangeFieldType: false });
+
+ expect(screen.getByRole("radio", { name: "Number" })).toBeDisabled();
+ });
+});
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/library/actions/pages/ActionFieldsPage/ActionFieldDetails/index.ts b/enterprise/frontend/src/metabase-enterprise/data-studio/library/actions/pages/ActionFieldsPage/ActionFieldDetails/index.ts
new file mode 100644
index 00000000000..612d27d6f64
--- /dev/null
+++ b/enterprise/frontend/src/metabase-enterprise/data-studio/library/actions/pages/ActionFieldsPage/ActionFieldDetails/index.ts
@@ -0,0 +1 @@
+export { ActionFieldDetails } from "./ActionFieldDetails";
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/library/actions/pages/ActionFieldsPage/ActionFieldDetails/utils.ts b/enterprise/frontend/src/metabase-enterprise/data-studio/library/actions/pages/ActionFieldsPage/ActionFieldDetails/utils.ts
new file mode 100644
index 00000000000..35772d95930
--- /dev/null
+++ b/enterprise/frontend/src/metabase-enterprise/data-studio/library/actions/pages/ActionFieldsPage/ActionFieldDetails/utils.ts
@@ -0,0 +1,34 @@
+import type {
+ FieldType,
+ FieldValueOptions,
+ InputSettingType,
+} from "metabase-types/api";
+
+import { cleanOptionValues } from "../../../utils";
+
+const DEFAULT_VALUE_INPUT_TYPES: Record<InputSettingType, string> = {
+ string: "text",
+ text: "textarea",
+ date: "date",
+ datetime: "datetime-local",
+ time: "time",
+ number: "number",
+ boolean: "boolean",
+ select: "text",
+ radio: "text",
+};
+
+export function getDefaultValueInputType(inputType: InputSettingType): string {
+ return DEFAULT_VALUE_INPUT_TYPES[inputType];
+}
+
+export function textToOptions(
+ text: string,
+ fieldType: FieldType,
+): FieldValueOptions {
+ const options = text
+ .split("\n")
+ .map((option) => option.trim())
+ .filter(Boolean);
+ return [...new Set(cleanOptionValues(options, fieldType))];
+}
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/library/actions/pages/ActionFieldsPage/ActionFieldDetails/utils.unit.spec.ts b/enterprise/frontend/src/metabase-enterprise/data-studio/library/actions/pages/ActionFieldsPage/ActionFieldDetails/utils.unit.spec.ts
new file mode 100644
index 00000000000..4ac658d18b8
--- /dev/null
+++ b/enterprise/frontend/src/metabase-enterprise/data-studio/library/actions/pages/ActionFieldsPage/ActionFieldDetails/utils.unit.spec.ts
@@ -0,0 +1,15 @@
+import { textToOptions } from "./utils";
+
+describe("textToOptions", () => {
+ it("should filter duplicates", () => {
+ expect(textToOptions("1\n2\n1\n1\n2", "string")).toEqual(["1", "2"]);
+ });
+
+ it("should filter empty values and trim empty space", () => {
+ expect(textToOptions(" \n 1\n2 \n\n\n ", "string")).toEqual(["1", "2"]);
+ });
+
+ it("should convert number options and drop the ones that are not numbers", () => {
+ expect(textToOptions("1\nabc\n2.5\n01", "number")).toEqual([1, 2.5]);
+ });
+});
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/library/actions/pages/ActionFieldsPage/ActionFieldList/ActionFieldItem/ActionFieldItem.module.css b/enterprise/frontend/src/metabase-enterprise/data-studio/library/actions/pages/ActionFieldsPage/ActionFieldList/ActionFieldItem/ActionFieldItem.module.css
new file mode 100644
index 00000000000..33a61bd40d8
--- /dev/null
+++ b/enterprise/frontend/src/metabase-enterprise/data-studio/library/actions/pages/ActionFieldsPage/ActionFieldList/ActionFieldItem/ActionFieldItem.module.css
@@ -0,0 +1,20 @@
+.sortableField {
+ border-radius: var(--default-border-radius);
+}
+
+.card {
+ box-shadow: 0 2px 4px 0 hsla(0, 0%, 0%, 0.05) !important;
+ cursor: pointer;
+
+ &.active {
+ border-color: var(--mb-color-core-brand) !important;
+ }
+
+ &:hover:not(.active) {
+ background-color: var(--mb-color-background_surface-hover) !important;
+ }
+
+ &:hover .grabber {
+ color: var(--mb-color-core-brand);
+ }
+}
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/library/actions/pages/ActionFieldsPage/ActionFieldList/ActionFieldItem/ActionFieldItem.tsx b/enterprise/frontend/src/metabase-enterprise/data-studio/library/actions/pages/ActionFieldsPage/ActionFieldList/ActionFieldItem/ActionFieldItem.tsx
new file mode 100644
index 00000000000..faa1a7587bf
--- /dev/null
+++ b/enterprise/frontend/src/metabase-enterprise/data-studio/library/actions/pages/ActionFieldsPage/ActionFieldList/ActionFieldItem/ActionFieldItem.tsx
@@ -0,0 +1,77 @@
+import cx from "classnames";
+
+import { Link } from "metabase/common/components/Link";
+import { Sortable } from "metabase/common/components/Sortable";
+import { Badge, Card, Code, Group, Icon, Stack, Text } from "metabase/ui";
+
+import type { ActionField } from "../../../../hooks/use-action-fields";
+
+import S from "./ActionFieldItem.module.css";
+import { getFieldIcon, getFieldSummary } from "./utils";
+
+type ActionFieldItemProps = {
+ field: ActionField;
+ href: string;
+ isActive: boolean;
+ isDraggable: boolean;
+};
+
+export function ActionFieldItem({
+ field,
+ href,
+ isActive,
+ isDraggable,
+}: ActionFieldItemProps) {
+ const { parameter, settings, variableName } = field;
+ const title = settings.title || parameter.name;
+
+ return (
+ <Sortable
+ className={S.sortableField}
+ id={parameter.id}
+ disabled={!isDraggable}
+ draggingStyle={{ opacity: 0.5 }}
+ >
+ <Card
+ component={Link}
+ to={href}
+ aria-label={title}
+ role="listitem"
+ className={cx(S.card, { [S.active]: isActive })}
+ bg={
+ isActive
+ ? "background_surface-brand-subtle"
+ : "background_page-primary"
+ }
+ px="lg"
+ py="md"
+ withBorder
+ >
+ <Group gap="sm" wrap="nowrap" align="flex-start">
+ {isDraggable && (
+ <Icon className={S.grabber} name="grabber" c="text-tertiary" />
+ )}
+ <Stack gap="xs" miw={0} flex={1}>
+ <Group gap="sm" wrap="nowrap">
+ <Icon name={getFieldIcon(settings.fieldType)} c="core-brand" />
+ <Text fw="bold" lineClamp={1}>
+ {title}
+ </Text>
+ </Group>
+ {settings.description && (
+ <Text c="text-secondary" lineClamp={2}>
+ {settings.description}
+ </Text>
+ )}
+ <Group gap="sm">
+ <Code>{`{{ ${variableName} }}`}</Code>
+ <Badge variant="light" color="neutral">
+ {getFieldSummary(settings)}
+ </Badge>
+ </Group>
+ </Stack>
+ </Group>
+ </Card>
+ </Sortable>
+ );
+}
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/library/actions/pages/ActionFieldsPage/ActionFieldList/ActionFieldItem/index.ts b/enterprise/frontend/src/metabase-enterprise/data-studio/library/actions/pages/ActionFieldsPage/ActionFieldList/ActionFieldItem/index.ts
new file mode 100644
index 00000000000..8d280e9205f
--- /dev/null
+++ b/enterprise/frontend/src/metabase-enterprise/data-studio/library/actions/pages/ActionFieldsPage/ActionFieldList/ActionFieldItem/index.ts
@@ -0,0 +1 @@
+export { ActionFieldItem } from "./ActionFieldItem";
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/library/actions/pages/ActionFieldsPage/ActionFieldList/ActionFieldItem/utils.ts b/enterprise/frontend/src/metabase-enterprise/data-studio/library/actions/pages/ActionFieldsPage/ActionFieldList/ActionFieldItem/utils.ts
new file mode 100644
index 00000000000..d368bdba4db
--- /dev/null
+++ b/enterprise/frontend/src/metabase-enterprise/data-studio/library/actions/pages/ActionFieldsPage/ActionFieldList/ActionFieldItem/utils.ts
@@ -0,0 +1,22 @@
+import { t } from "ttag";
+
+import { getFieldTypes } from "metabase/actions/constants";
+import type { FieldSettings, FieldType, IconName } from "metabase-types/api";
+
+export function getFieldIcon(fieldType: FieldType): IconName {
+ switch (fieldType) {
+ case "number":
+ return "int";
+ case "date":
+ return "calendar";
+ default:
+ return "string";
+ }
+}
+
+export function getFieldSummary({ fieldType, required }: FieldSettings) {
+ const typeName =
+ getFieldTypes().find((option) => option.value === fieldType)?.name ??
+ t`Text`;
+ return required ? t`${typeName} · Required` : t`${typeName} · Optional`;
+}
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/library/actions/pages/ActionFieldsPage/ActionFieldList/ActionFieldList.tsx b/enterprise/frontend/src/metabase-enterprise/data-studio/library/actions/pages/ActionFieldsPage/ActionFieldList/ActionFieldList.tsx
new file mode 100644
index 00000000000..62e8dd57d45
--- /dev/null
+++ b/enterprise/frontend/src/metabase-enterprise/data-studio/library/actions/pages/ActionFieldsPage/ActionFieldList/ActionFieldList.tsx
@@ -0,0 +1,71 @@
+import { PointerSensor, useSensor } from "@dnd-kit/core";
+import { t } from "ttag";
+
+import {
+ type DragEndEvent,
+ SortableList,
+} from "metabase/common/components/Sortable";
+import { Stack, Text, Title } from "metabase/ui";
+import * as Urls from "metabase/urls";
+import type { WritebackActionId } from "metabase-types/api";
+
+import type { ActionField } from "../../../hooks/use-action-fields";
+
+import { ActionFieldItem } from "./ActionFieldItem";
+
+type ActionFieldListProps = {
+ actionId: WritebackActionId;
+ fields: ActionField[];
+ activeFieldId: string | undefined;
+ readOnly: boolean;
+ onReorder: (fieldIds: string[]) => void;
+};
+
+const getFieldId = (field: ActionField) => field.parameter.id;
+
+export function ActionFieldList({
+ actionId,
+ fields,
+ activeFieldId,
+ readOnly,
+ onReorder,
+}: ActionFieldListProps) {
+ const pointerSensor = useSensor(PointerSensor, {
+ activationConstraint: { distance: 15 },
+ });
+ const isDraggable = !readOnly && fields.length > 1;
+
+ const handleSortEnd = ({ itemIds }: DragEndEvent) => {
+ onReorder(itemIds.map(String));
+ };
+
+ return (
+ <Stack gap="lg" py="xl">
+ <Stack gap="xs">
+ <Title order={4}>{t`Fields`}</Title>
+ <Text c="text-secondary">
+ {fields.length > 0
+ ? t`One field per {{variable}} in the SQL. Drag to reorder the form.`
+ : t`This action has no variables in its SQL.`}
+ </Text>
+ </Stack>
+ <Stack gap="md" role="list">
+ <SortableList<ActionField>
+ items={fields}
+ getId={getFieldId}
+ sensors={[pointerSensor]}
+ renderItem={({ item: field }) => (
+ <ActionFieldItem
+ key={field.parameter.id}
+ field={field}
+ href={Urls.dataStudioActionFields(actionId, field.parameter.id)}
+ isActive={field.parameter.id === activeFieldId}
+ isDraggable={isDraggable}
+ />
+ )}
+ onSortEnd={handleSortEnd}
+ />
+ </Stack>
+ </Stack>
+ );
+}
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/library/actions/pages/ActionFieldsPage/ActionFieldList/index.ts b/enterprise/frontend/src/metabase-enterprise/data-studio/library/actions/pages/ActionFieldsPage/ActionFieldList/index.ts
new file mode 100644
index 00000000000..5d885921f08
--- /dev/null
+++ b/enterprise/frontend/src/metabase-enterprise/data-studio/library/actions/pages/ActionFieldsPage/ActionFieldList/index.ts
@@ -0,0 +1 @@
+export { ActionFieldList } from "./ActionFieldList";
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/library/actions/pages/ActionFieldsPage/ActionFieldsPage.module.css b/enterprise/frontend/src/metabase-enterprise/data-studio/library/actions/pages/ActionFieldsPage/ActionFieldsPage.module.css
new file mode 100644
index 00000000000..308603f6402
--- /dev/null
+++ b/enterprise/frontend/src/metabase-enterprise/data-studio/library/actions/pages/ActionFieldsPage/ActionFieldsPage.module.css
@@ -0,0 +1,13 @@
+.body {
+ overflow-x: auto;
+ border-top: 1px solid var(--mb-color-border-neutral);
+}
+
+.column {
+ overflow-y: auto;
+ border-right: 1px solid var(--mb-color-border-neutral);
+}
+
+.header {
+ z-index: 10;
+}
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/library/actions/pages/ActionFieldsPage/ActionFieldsPage.tsx b/enterprise/frontend/src/metabase-enterprise/data-studio/library/actions/pages/ActionFieldsPage/ActionFieldsPage.tsx
new file mode 100644
index 00000000000..3b4c358abfb
--- /dev/null
+++ b/enterprise/frontend/src/metabase-enterprise/data-studio/library/actions/pages/ActionFieldsPage/ActionFieldsPage.tsx
@@ -0,0 +1,128 @@
+import { t } from "ttag";
+
+import { ForwardRefLink } from "metabase/common/components/Link";
+import { LoadingAndErrorWrapper } from "metabase/common/components/LoadingAndErrorWrapper";
+import { PageContainer } from "metabase/common/data-studio/components/PageContainer";
+import { useParams } from "metabase/router";
+import { Button, Center, Flex, Group, Icon, Stack, Text } from "metabase/ui";
+import * as Urls from "metabase/urls";
+import type { WritebackQueryAction } from "metabase-types/api";
+
+import { ActionHeader } from "../../components/ActionHeader";
+import { useActionDatabases } from "../../hooks/use-action-databases";
+import { useActionFields } from "../../hooks/use-action-fields";
+import { useRouteAction } from "../../hooks/use-route-action";
+import { canEditActionQuery } from "../../utils";
+
+import { ActionFieldDetails } from "./ActionFieldDetails";
+import { ActionFieldList } from "./ActionFieldList";
+import S from "./ActionFieldsPage.module.css";
+
+export function ActionFieldsPage() {
+ const {
+ action,
+ isLoading: isLoadingAction,
+ error: actionError,
+ } = useRouteAction();
+ const {
+ databases,
+ isLoading: isLoadingDatabases,
+ error: databasesError,
+ } = useActionDatabases();
+ const isLoading = isLoadingAction || isLoadingDatabases;
+ const error = actionError ?? databasesError;
+
+ if (isLoading || error != null || action == null) {
+ return (
+ <Center h="100%">
+ <LoadingAndErrorWrapper loading={isLoading} error={error} />
+ </Center>
+ );
+ }
+
+ return (
+ <ActionFieldsPageBody
+ action={action}
+ canChangeFieldType={canEditActionQuery(action, databases)}
+ />
+ );
+}
+
+type ActionFieldsPageBodyProps = {
+ action: WritebackQueryAction;
+ canChangeFieldType: boolean;
+};
+
+function ActionFieldsPageBody({
+ action,
+ canChangeFieldType,
+}: ActionFieldsPageBodyProps) {
+ const readOnly = !action.can_write;
+ const { fieldId } = useParams<{ fieldId?: string }>();
+ const { fields, updateField, reorderFields } = useActionFields(action);
+ const field = fields.find((field) => field.parameter.id === fieldId);
+
+ return (
+ <PageContainer data-testid="action-fields" gap="lg" px={0} pb={0}>
+ <ActionHeader action={action} px="3.5rem" />
+ <Flex className={S.body} flex={1} mih={0}>
+ <Stack
+ className={S.column}
+ flex="8 1 0"
+ miw={320}
+ maw={640}
+ mih={0}
+ pl="3.5rem"
+ pr="xl"
+ >
+ <ActionFieldList
+ actionId={action.id}
+ fields={fields}
+ activeFieldId={field?.parameter.id}
+ readOnly={readOnly}
+ onReorder={reorderFields}
+ />
+ </Stack>
+ {field != null && (
+ <Stack
+ className={S.column}
+ flex="9 1 0"
+ miw={320}
+ maw={680}
+ mih={0}
+ px="xl"
+ gap={0}
+ >
+ <Group
+ className={S.header}
+ justify="space-between"
+ pt="xl"
+ pb="lg"
+ pos="sticky"
+ top={0}
+ bg="background_page-secondary"
+ >
+ <Text fw="bold">{t`Field details`}</Text>
+ <Button
+ variant="subtle"
+ color="neutral"
+ size="sm"
+ component={ForwardRefLink}
+ to={Urls.dataStudioActionFields(action.id)}
+ aria-label={t`Close`}
+ leftSection={<Icon name="close" />}
+ />
+ </Group>
+ <ActionFieldDetails
+ key={field.parameter.id}
+ field={field}
+ readOnly={readOnly}
+ canChangeFieldType={canChangeFieldType}
+ onChange={(patch) => updateField(field.parameter.id, patch)}
+ />
+ </Stack>
+ )}
+ </Flex>
+ </PageContainer>
+ );
+}
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/library/actions/pages/ActionFieldsPage/ActionFieldsPage.unit.spec.tsx b/enterprise/frontend/src/metabase-enterprise/data-studio/library/actions/pages/ActionFieldsPage/ActionFieldsPage.unit.spec.tsx
new file mode 100644
index 00000000000..73d70039662
--- /dev/null
+++ b/enterprise/frontend/src/metabase-enterprise/data-studio/library/actions/pages/ActionFieldsPage/ActionFieldsPage.unit.spec.tsx
@@ -0,0 +1,145 @@
+import {
+ setupActionEndpoints,
+ setupCollectionByIdEndpoint,
+ setupDatabaseListEndpoint,
+} from "__support__/server-mocks";
+import { createMockState } from "__support__/state";
+import { createMockEntitiesState } from "__support__/store";
+import { renderWithProviders, screen } from "__support__/ui";
+import { ROOT_COLLECTION } from "metabase/common/collections/constants";
+import { Route } from "metabase/router";
+import type { Database, WritebackQueryAction } from "metabase-types/api";
+import {
+ createMockCollection,
+ createMockDatabase,
+ createMockNativeDatasetQuery,
+ createMockNativeQuery,
+ createMockQueryAction,
+ createMockTemplateTag,
+} from "metabase-types/api/mocks";
+
+import { ActionFieldsPage } from "./ActionFieldsPage";
+
+type SetupOpts = {
+ action: WritebackQueryAction;
+ database: Database;
+};
+
+function setup({ action, database }: SetupOpts) {
+ setupActionEndpoints(action);
+ setupDatabaseListEndpoint([database]);
+ setupCollectionByIdEndpoint({
+ collections: [createMockCollection(ROOT_COLLECTION)],
+ });
+
+ renderWithProviders(
+ <Route
+ path="/data-studio/data-actions/:actionId/fields/:fieldId"
+ element={<ActionFieldsPage />}
+ />,
+ {
+ storeInitialState: createMockState({
+ entities: createMockEntitiesState({ databases: [database] }),
+ }),
+ withRouter: true,
+ initialRoute: `/data-studio/data-actions/${action.id}/fields/status`,
+ },
+ );
+}
+
+const DATASET_QUERY = createMockNativeDatasetQuery({
+ database: 1,
+ native: createMockNativeQuery({
+ query: "UPDATE orders SET status = {{status}}",
+ "template-tags": {
+ status: createMockTemplateTag({
+ id: "status",
+ name: "status",
+ "display-name": "Status",
+ type: "text",
+ }),
+ },
+ }),
+});
+
+describe("ActionFieldsPage", () => {
+ it("should let a user who can edit the action change every field setting", async () => {
+ setup({
+ action: createMockQueryAction({
+ database_id: 1,
+ dataset_query: DATASET_QUERY,
+ can_write: true,
+ }),
+ database: createMockDatabase({
+ id: 1,
+ native_permissions: "write",
+ settings: { "database-enable-actions": true },
+ }),
+ });
+
+ expect(await screen.findByLabelText("Display name")).not.toHaveAttribute(
+ "readonly",
+ );
+ expect(screen.getByRole("radio", { name: "Number" })).toBeEnabled();
+ });
+
+ it("should not let a user who can't edit the action change field settings", async () => {
+ setup({
+ action: createMockQueryAction({
+ database_id: 1,
+ dataset_query: DATASET_QUERY,
+ can_write: false,
+ }),
+ database: createMockDatabase({
+ id: 1,
+ native_permissions: "write",
+ settings: { "database-enable-actions": true },
+ }),
+ });
+
+ expect(await screen.findByLabelText("Display name")).toHaveAttribute(
+ "readonly",
+ );
+ expect(screen.getByRole("radio", { name: "Number" })).toBeDisabled();
+ });
+
+ it("should not let a user without native query permissions change the field type", async () => {
+ setup({
+ action: createMockQueryAction({
+ database_id: 1,
+ dataset_query: DATASET_QUERY,
+ can_write: true,
+ }),
+ database: createMockDatabase({
+ id: 1,
+ native_permissions: "none",
+ settings: { "database-enable-actions": true },
+ }),
+ });
+
+ expect(await screen.findByLabelText("Display name")).not.toHaveAttribute(
+ "readonly",
+ );
+ expect(screen.getByRole("radio", { name: "Number" })).toBeDisabled();
+ });
+
+ it("should not let anyone change the field type when actions are disabled for the database", async () => {
+ setup({
+ action: createMockQueryAction({
+ database_id: 1,
+ dataset_query: DATASET_QUERY,
+ can_write: true,
+ }),
+ database: createMockDatabase({
+ id: 1,
+ native_permissions: "write",
+ settings: { "database-enable-actions": false },
+ }),
+ });
+
+ expect(await screen.findByLabelText("Display name")).not.toHaveAttribute(
+ "readonly",
+ );
+ expect(screen.getByRole("radio", { name: "Number" })).toBeDisabled();
+ });
+});
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/library/actions/pages/ActionFieldsPage/index.ts b/enterprise/frontend/src/metabase-enterprise/data-studio/library/actions/pages/ActionFieldsPage/index.ts
new file mode 100644
index 00000000000..85851bc25cb
--- /dev/null
+++ b/enterprise/frontend/src/metabase-enterprise/data-studio/library/actions/pages/ActionFieldsPage/index.ts
@@ -0,0 +1 @@
+export { ActionFieldsPage } from "./ActionFieldsPage";
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/library/actions/pages/ActionQueryPage/ActionQueryPage.tsx b/enterprise/frontend/src/metabase-enterprise/data-studio/library/actions/pages/ActionQueryPage/ActionQueryPage.tsx
new file mode 100644
index 00000000000..ddbf2cc493d
--- /dev/null
+++ b/enterprise/frontend/src/metabase-enterprise/data-studio/library/actions/pages/ActionQueryPage/ActionQueryPage.tsx
@@ -0,0 +1,187 @@
+import { useCallback, useMemo, useRef, useState } from "react";
+import { t } from "ttag";
+
+import { useUpdateActionMutation } from "metabase/api";
+import { getErrorMessage } from "metabase/api/utils";
+import { LeaveRouteConfirmModal } from "metabase/common/components/LeaveConfirmModal";
+import { Link } from "metabase/common/components/Link";
+import { LoadingAndErrorWrapper } from "metabase/common/components/LoadingAndErrorWrapper";
+import { PageContainer } from "metabase/common/data-studio/components/PageContainer";
+import { PaneHeaderActions } from "metabase/common/data-studio/components/PaneHeader";
+import { useMetadataToasts } from "metabase/common/hooks";
+import { hasNativeWritePermissions } from "metabase/common/utils/database";
+import { getInitialUiState } from "metabase/querying/editor/components/QueryEditor";
+import { type Location, useLocation, useNavigate } from "metabase/router";
+import { Button, Center } from "metabase/ui";
+import * as Urls from "metabase/urls";
+import type { Database, WritebackQueryAction } from "metabase-types/api";
+
+import { ActionEditor } from "../../components/ActionEditor";
+import { ActionEditorPane } from "../../components/ActionEditorPane";
+import { ActionHeader } from "../../components/ActionHeader";
+import { useActionDatabases } from "../../hooks/use-action-databases";
+import { useActionDraft } from "../../hooks/use-action-draft";
+import { useRouteAction } from "../../hooks/use-route-action";
+import { canEditActionQuery } from "../../utils";
+
+export function ActionQueryPage() {
+ const { pathname } = useLocation();
+ const isEditRoute = pathname.endsWith("/edit");
+ const {
+ action,
+ isLoading: isLoadingAction,
+ error: actionError,
+ } = useRouteAction();
+ const {
+ databases,
+ isLoading: isLoadingDatabases,
+ error: databasesError,
+ } = useActionDatabases();
+ const editableDatabases = useMemo(
+ () => databases.filter(hasNativeWritePermissions),
+ [databases],
+ );
+ const isLoading = isLoadingAction || isLoadingDatabases;
+ const error = actionError ?? databasesError;
+
+ if (isLoading || error != null || action == null) {
+ return (
+ <Center h="100%">
+ <LoadingAndErrorWrapper loading={isLoading} error={error} />
+ </Center>
+ );
+ }
+
+ const canEditQuery = canEditActionQuery(action, databases);
+
+ return isEditRoute && canEditQuery ? (
+ <ActionEditPage
+ key={action.id}
+ action={action}
+ databases={editableDatabases}
+ />
+ ) : (
+ <ActionDefinitionPage
+ action={action}
+ databases={editableDatabases}
+ canEditQuery={canEditQuery}
+ />
+ );
+}
+
+type ActionPageProps = {
+ action: WritebackQueryAction;
+ databases: Database[];
+};
+
+type ActionDefinitionPageProps = ActionPageProps & {
+ canEditQuery: boolean;
+};
+
+function ActionDefinitionPage({
+ action,
+ databases,
+ canEditQuery,
+}: ActionDefinitionPageProps) {
+ const [uiState, setUiState] = useState(getInitialUiState);
+
+ return (
+ <PageContainer data-testid="action-definition">
+ <ActionHeader action={action} />
+ <ActionEditorPane>
+ <ActionEditor
+ datasetQuery={action.dataset_query}
+ uiState={uiState}
+ databases={databases}
+ readOnly
+ topBarInnerContent={
+ canEditQuery && (
+ <Button
+ component={Link}
+ to={Urls.dataStudioActionEdit(action.id)}
+ size="sm"
+ style={{ flexShrink: 0 }}
+ >
+ {t`Edit definition`}
+ </Button>
+ )
+ }
+ onChangeDatasetQuery={() => undefined}
+ onChangeUiState={setUiState}
+ />
+ </ActionEditorPane>
+ </PageContainer>
+ );
+}
+
+function ActionEditPage({ action, databases }: ActionPageProps) {
+ const draft = useActionDraft({
+ initialDatasetQuery: action.dataset_query,
+ formSettings: action.visualization_settings,
+ });
+ const [uiState, setUiState] = useState(getInitialUiState);
+ const [updateAction, { isLoading: isSaving }] = useUpdateActionMutation();
+ const { sendSuccessToast, sendErrorToast } = useMetadataToasts();
+ const navigate = useNavigate();
+ const isSavedRef = useRef(false);
+ const isLocationAllowed = useCallback(
+ (location?: Location) => !location || isSavedRef.current,
+ [],
+ );
+
+ const handleSave = async () => {
+ if (draft.definition == null) {
+ return;
+ }
+ const { error } = await updateAction({
+ id: action.id,
+ ...draft.definition,
+ });
+ if (error) {
+ const message = getErrorMessage(error);
+ sendErrorToast(
+ message
+ ? t`Failed to update action: ${message}`
+ : t`Failed to update action`,
+ );
+ return;
+ }
+ sendSuccessToast(t`Action updated`);
+ isSavedRef.current = true;
+ navigate(Urls.dataStudioAction(action.id));
+ };
+
+ return (
+ <>
+ <PageContainer data-testid="action-query-editor">
+ <ActionHeader
+ action={action}
+ isEditMode
+ actions={
+ <PaneHeaderActions
+ isValid={draft.isValid}
+ isDirty={draft.isDirty}
+ isSaving={isSaving}
+ alwaysVisible
+ onSave={handleSave}
+ onCancel={() => navigate(Urls.dataStudioAction(action.id))}
+ />
+ }
+ />
+ <ActionEditorPane>
+ <ActionEditor
+ datasetQuery={draft.datasetQuery}
+ uiState={uiState}
+ databases={databases}
+ onChangeDatasetQuery={draft.setDatasetQuery}
+ onChangeUiState={setUiState}
+ />
+ </ActionEditorPane>
+ </PageContainer>
+ <LeaveRouteConfirmModal
+ isEnabled={draft.isDirty}
+ isLocationAllowed={isLocationAllowed}
+ />
+ </>
+ );
+}
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/library/actions/pages/ActionQueryPage/index.ts b/enterprise/frontend/src/metabase-enterprise/data-studio/library/actions/pages/ActionQueryPage/index.ts
new file mode 100644
index 00000000000..54cd84a4917
--- /dev/null
+++ b/enterprise/frontend/src/metabase-enterprise/data-studio/library/actions/pages/ActionQueryPage/index.ts
@@ -0,0 +1 @@
+export { ActionQueryPage } from "./ActionQueryPage";
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/library/actions/pages/ActionRunPage/ActionRunPage.tsx b/enterprise/frontend/src/metabase-enterprise/data-studio/library/actions/pages/ActionRunPage/ActionRunPage.tsx
new file mode 100644
index 00000000000..e428c27ca66
--- /dev/null
+++ b/enterprise/frontend/src/metabase-enterprise/data-studio/library/actions/pages/ActionRunPage/ActionRunPage.tsx
@@ -0,0 +1,66 @@
+import { useDisclosure } from "@mantine/hooks";
+import { t } from "ttag";
+
+import { ActionExecuteModal } from "metabase/actions/containers/ActionExecuteModal";
+import { LoadingAndErrorWrapper } from "metabase/common/components/LoadingAndErrorWrapper";
+import { PageContainer } from "metabase/common/data-studio/components/PageContainer";
+import { TitleSection } from "metabase/common/data-studio/components/TitleSection";
+import { Button, Center, Group, Icon, Tooltip } from "metabase/ui";
+
+import { ActionHeader } from "../../components/ActionHeader";
+import { useActionDatabase } from "../../hooks/use-action-database";
+import { useRouteAction } from "../../hooks/use-route-action";
+
+import { getRunDisabledReason } from "./utils";
+
+export function ActionRunPage() {
+ const {
+ action,
+ isLoading: isLoadingAction,
+ error: actionError,
+ } = useRouteAction();
+ const {
+ database,
+ isLoading: isLoadingDatabase,
+ error: databaseError,
+ } = useActionDatabase(action);
+ const [isModalOpened, { open: openModal, close: closeModal }] =
+ useDisclosure();
+ const isLoading = isLoadingAction || isLoadingDatabase;
+ const error = actionError ?? databaseError;
+
+ if (isLoading || error != null || action == null) {
+ return (
+ <Center h="100%">
+ <LoadingAndErrorWrapper loading={isLoading} error={error} />
+ </Center>
+ );
+ }
+
+ const disabledReason = getRunDisabledReason(database);
+
+ return (
+ <PageContainer data-testid="action-run">
+ <ActionHeader action={action} />
+ <TitleSection label={t`Run this action`}>
+ <Group p="xl">
+ <Tooltip label={disabledReason} disabled={disabledReason == null}>
+ <Button
+ variant="filled"
+ leftSection={<Icon name="play_outlined" />}
+ disabled={disabledReason != null}
+ onClick={openModal}
+ >
+ {t`Run`}
+ </Button>
+ </Tooltip>
+ </Group>
+ </TitleSection>
+ <ActionExecuteModal
+ opened={isModalOpened}
+ actionId={action.id}
+ onClose={closeModal}
+ />
+ </PageContainer>
+ );
+}
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/library/actions/pages/ActionRunPage/ActionRunPage.unit.spec.tsx b/enterprise/frontend/src/metabase-enterprise/data-studio/library/actions/pages/ActionRunPage/ActionRunPage.unit.spec.tsx
new file mode 100644
index 00000000000..2ca6016d3b2
--- /dev/null
+++ b/enterprise/frontend/src/metabase-enterprise/data-studio/library/actions/pages/ActionRunPage/ActionRunPage.unit.spec.tsx
@@ -0,0 +1,90 @@
+import {
+ setupActionEndpoints,
+ setupCollectionByIdEndpoint,
+ setupDatabasesEndpoints,
+} from "__support__/server-mocks";
+import { renderWithProviders, screen } from "__support__/ui";
+import { ROOT_COLLECTION } from "metabase/common/collections/constants";
+import { Route } from "metabase/router";
+import type { Database, WritebackQueryAction } from "metabase-types/api";
+import {
+ createMockCollection,
+ createMockDatabase,
+ createMockQueryAction,
+} from "metabase-types/api/mocks";
+
+import { ActionRunPage } from "./ActionRunPage";
+
+type SetupOpts = {
+ action: WritebackQueryAction;
+ database: Database;
+};
+
+function setup({ action, database }: SetupOpts) {
+ setupActionEndpoints(action);
+ setupDatabasesEndpoints([database]);
+ setupCollectionByIdEndpoint({
+ collections: [createMockCollection(ROOT_COLLECTION)],
+ });
+
+ renderWithProviders(
+ <Route
+ path="/data-studio/data-actions/:actionId/run"
+ element={<ActionRunPage />}
+ />,
+ {
+ withRouter: true,
+ initialRoute: `/data-studio/data-actions/${action.id}/run`,
+ },
+ );
+}
+
+describe("ActionRunPage", () => {
+ it("should enable Run when actions are enabled for the action's database", async () => {
+ setup({
+ action: createMockQueryAction({ database_id: 1, can_write: true }),
+ database: createMockDatabase({
+ id: 1,
+ settings: { "database-enable-actions": true },
+ }),
+ });
+
+ expect(await screen.findByRole("button", { name: /Run/ })).toBeEnabled();
+ });
+
+ it("should disable Run when actions are disabled for the action's database", async () => {
+ setup({
+ action: createMockQueryAction({ database_id: 1, can_write: true }),
+ database: createMockDatabase({
+ id: 1,
+ settings: { "database-enable-actions": false },
+ }),
+ });
+
+ expect(await screen.findByRole("button", { name: /Run/ })).toBeDisabled();
+ });
+
+ it("should disable Run when the user can't see the action's database", async () => {
+ setup({
+ action: createMockQueryAction({ database_id: 1, can_write: true }),
+ database: createMockDatabase({
+ id: 2,
+ settings: { "database-enable-actions": true },
+ }),
+ });
+
+ expect(await screen.findByRole("button", { name: /Run/ })).toBeDisabled();
+ });
+
+ it("should enable Run for a user who can't edit the action", async () => {
+ setup({
+ action: createMockQueryAction({ database_id: 1, can_write: false }),
+ database: createMockDatabase({
+ id: 1,
+ settings: { "database-enable-actions": true },
+ }),
+ });
+
+ expect(await screen.findByRole("button", { name: /Run/ })).toBeEnabled();
+ });
+});
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/library/actions/pages/ActionRunPage/index.ts b/enterprise/frontend/src/metabase-enterprise/data-studio/library/actions/pages/ActionRunPage/index.ts
new file mode 100644
index 00000000000..b8127d8d358
--- /dev/null
+++ b/enterprise/frontend/src/metabase-enterprise/data-studio/library/actions/pages/ActionRunPage/index.ts
@@ -0,0 +1 @@
+export { ActionRunPage } from "./ActionRunPage";
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/library/actions/pages/ActionRunPage/utils.ts b/enterprise/frontend/src/metabase-enterprise/data-studio/library/actions/pages/ActionRunPage/utils.ts
new file mode 100644
index 00000000000..79a99d9a575
--- /dev/null
+++ b/enterprise/frontend/src/metabase-enterprise/data-studio/library/actions/pages/ActionRunPage/utils.ts
@@ -0,0 +1,14 @@
+import { t } from "ttag";
+
+import { hasActionsEnabled } from "metabase/common/utils/database";
+import type { Database } from "metabase-types/api";
+
+export function getRunDisabledReason(database: Database | undefined) {
+ if (database == null) {
+ return t`You don't have access to this action's database.`;
+ }
+ if (!hasActionsEnabled(database)) {
+ return t`Actions are disabled for this action's database.`;
+ }
+ return undefined;
+}
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/library/actions/pages/ActionSettingsPage/ActionSettingsPage.tsx b/enterprise/frontend/src/metabase-enterprise/data-studio/library/actions/pages/ActionSettingsPage/ActionSettingsPage.tsx
new file mode 100644
index 00000000000..acfb23a6588
--- /dev/null
+++ b/enterprise/frontend/src/metabase-enterprise/data-studio/library/actions/pages/ActionSettingsPage/ActionSettingsPage.tsx
@@ -0,0 +1,212 @@
+import { useState } from "react";
+import { t } from "ttag";
+
+import {
+ useCreateActionPublicLinkMutation,
+ useDeleteActionPublicLinkMutation,
+ useUpdateActionMutation,
+} from "metabase/api";
+import { CopyTextInput } from "metabase/common/components/CopyTextInput";
+import { LoadingAndErrorWrapper } from "metabase/common/components/LoadingAndErrorWrapper";
+import { PageContainer } from "metabase/common/data-studio/components/PageContainer";
+import { TitleSection } from "metabase/common/data-studio/components/TitleSection";
+import { useMetadataToasts } from "metabase/common/hooks";
+import { useConfirmation } from "metabase/common/hooks/use-confirmation";
+import { hasActionsEnabled } from "metabase/common/utils/database";
+import { getUserIsAdmin } from "metabase/current-user";
+import { useSelector } from "metabase/redux";
+import { useSetting } from "metabase/settings";
+import {
+ Center,
+ Divider,
+ Group,
+ Stack,
+ Switch,
+ Text,
+ Textarea,
+ Tooltip,
+} from "metabase/ui";
+import * as Urls from "metabase/urls";
+import type { WritebackQueryAction } from "metabase-types/api";
+
+import { ActionHeader } from "../../components/ActionHeader";
+import { useActionDatabase } from "../../hooks/use-action-database";
+import { useRouteAction } from "../../hooks/use-route-action";
+
+export function ActionSettingsPage() {
+ const {
+ action,
+ isLoading: isLoadingAction,
+ error: actionError,
+ } = useRouteAction();
+ const {
+ database,
+ isLoading: isLoadingDatabase,
+ error: databaseError,
+ } = useActionDatabase(action);
+ const isAdmin = useSelector(getUserIsAdmin);
+ const isPublicSharingEnabled = useSetting("enable-public-sharing");
+ const isLoading = isLoadingAction || isLoadingDatabase;
+ const error = actionError ?? databaseError;
+
+ if (isLoading || error != null || action == null) {
+ return (
+ <Center h="100%">
+ <LoadingAndErrorWrapper loading={isLoading} error={error} />
+ </Center>
+ );
+ }
+
+ const readOnly = !action.can_write;
+
+ return (
+ <PageContainer data-testid="action-settings">
+ <ActionHeader action={action} />
+ <Stack gap="2.5rem">
+ {isAdmin && isPublicSharingEnabled && (
+ <PublicSharingSection
+ action={action}
+ canMakePublic={database != null && hasActionsEnabled(database)}
+ />
+ )}
+ <SuccessMessageSection
+ key={action.id}
+ action={action}
+ readOnly={readOnly}
+ />
+ </Stack>
+ </PageContainer>
+ );
+}
+
+type SectionProps = {
+ action: WritebackQueryAction;
+ readOnly?: boolean;
+};
+
+type PublicSharingSectionProps = {
+ action: WritebackQueryAction;
+ canMakePublic: boolean;
+};
+
+function PublicSharingSection({
+ action,
+ canMakePublic,
+}: PublicSharingSectionProps) {
+ const siteUrl = useSetting("site-url");
+ const [createPublicLink] = useCreateActionPublicLinkMutation();
+ const [deletePublicLink] = useDeleteActionPublicLinkMutation();
+ const { modalContent: confirmationModal, show: showConfirmation } =
+ useConfirmation();
+ const { sendErrorToast } = useMetadataToasts();
+ const isPublic = action.public_uuid != null;
+
+ const handleDisable = async () => {
+ const { error } = await deletePublicLink({ id: action.id });
+ if (error) {
+ sendErrorToast(t`Failed to disable the public link`);
+ }
+ };
+
+ const handleToggle = async (checked: boolean) => {
+ if (!checked) {
+ showConfirmation({
+ title: t`Disable this public link?`,
+ message: t`The existing link will stop working. If you make the action public again, it will get a new link.`,
+ confirmButtonText: t`Disable link`,
+ confirmButtonProps: { color: "negative" },
+ onConfirm: handleDisable,
+ });
+ return;
+ }
+ const { error } = await createPublicLink({ id: action.id });
+ if (error) {
+ sendErrorToast(t`Failed to create a public link`);
+ }
+ };
+
+ return (
+ <TitleSection
+ label={t`Public sharing`}
+ description={t`Let anyone with the link run this action through a form, without signing in.`}
+ >
+ <Group p="xl" justify="space-between" wrap="nowrap">
+ <Stack gap="xs">
+ <Text fw="bold">{t`Make public`}</Text>
+ <Text c="text-secondary">
+ {t`Creates a publicly shareable link to this action form.`}
+ </Text>
+ </Stack>
+ <Tooltip
+ label={t`Actions are disabled for this action's database.`}
+ disabled={isPublic || canMakePublic}
+ >
+ <Switch
+ aria-label={t`Make public`}
+ checked={isPublic}
+ disabled={!isPublic && !canMakePublic}
+ onChange={(event) => handleToggle(event.currentTarget.checked)}
+ />
+ </Tooltip>
+ </Group>
+ {action.public_uuid != null && (
+ <>
+ <Divider />
+ <Stack p="xl" gap="sm">
+ <Text fw="bold">{t`Public link`}</Text>
+ <CopyTextInput
+ value={Urls.publicAction(siteUrl, action.public_uuid)}
+ aria-label={t`Public action form URL`}
+ />
+ </Stack>
+ </>
+ )}
+ {confirmationModal}
+ </TitleSection>
+ );
+}
+
+function SuccessMessageSection({ action, readOnly }: SectionProps) {
+ const savedMessage = action.visualization_settings?.successMessage ?? "";
+ const [message, setMessage] = useState(savedMessage);
+ const [updateAction] = useUpdateActionMutation();
+ const { sendSuccessToast, sendErrorToast } = useMetadataToasts();
+
+ const handleBlur = async () => {
+ if (message === savedMessage) {
+ return;
+ }
+ const { error } = await updateAction({
+ id: action.id,
+ visualization_settings: {
+ ...action.visualization_settings,
+ successMessage: message,
+ },
+ });
+ if (error) {
+ sendErrorToast(t`Failed to update success message`);
+ } else {
+ sendSuccessToast(t`Success message updated`);
+ }
+ };
+
+ return (
+ <TitleSection
+ label={t`Success message`}
+ description={t`Shown after the action runs on its public form.`}
+ >
+ <Stack p="xl" gap="sm">
+ <Textarea
+ label={t`Message`}
+ value={message}
+ placeholder={t`Action ran successfully`}
+ readOnly={readOnly}
+ autosize
+ minRows={3}
+ onChange={(event) => setMessage(event.currentTarget.value)}
+ onBlur={handleBlur}
+ />
+ </Stack>
+ </TitleSection>
+ );
+}
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/library/actions/pages/ActionSettingsPage/ActionSettingsPage.unit.spec.tsx b/enterprise/frontend/src/metabase-enterprise/data-studio/library/actions/pages/ActionSettingsPage/ActionSettingsPage.unit.spec.tsx
new file mode 100644
index 00000000000..0f121e24694
--- /dev/null
+++ b/enterprise/frontend/src/metabase-enterprise/data-studio/library/actions/pages/ActionSettingsPage/ActionSettingsPage.unit.spec.tsx
@@ -0,0 +1,144 @@
+import {
+ setupActionEndpoints,
+ setupCollectionByIdEndpoint,
+ setupDatabasesEndpoints,
+} from "__support__/server-mocks";
+import { mockSettings } from "__support__/settings";
+import { createMockState } from "__support__/state";
+import { renderWithProviders, screen } from "__support__/ui";
+import { ROOT_COLLECTION } from "metabase/common/collections/constants";
+import { Route } from "metabase/router";
+import type { Database, User, WritebackQueryAction } from "metabase-types/api";
+import {
+ createMockCollection,
+ createMockDatabase,
+ createMockQueryAction,
+ createMockUser,
+} from "metabase-types/api/mocks";
+
+import { ActionSettingsPage } from "./ActionSettingsPage";
+
+type SetupOpts = {
+ action: WritebackQueryAction;
+ database: Database;
+ user: User;
+};
+
+function setup({ action, database, user }: SetupOpts) {
+ setupActionEndpoints(action);
+ setupDatabasesEndpoints([database]);
+ setupCollectionByIdEndpoint({
+ collections: [createMockCollection(ROOT_COLLECTION)],
+ });
+
+ renderWithProviders(
+ <Route
+ path="/data-studio/data-actions/:actionId/settings"
+ element={<ActionSettingsPage />}
+ />,
+ {
+ storeInitialState: createMockState({
+ currentUser: user,
+ settings: mockSettings({ "enable-public-sharing": true }),
+ }),
+ withRouter: true,
+ initialRoute: `/data-studio/data-actions/${action.id}/settings`,
+ },
+ );
+}
+
+describe("ActionSettingsPage", () => {
+ describe("success message", () => {
+ it("should be editable when the user can edit the action", async () => {
+ setup({
+ action: createMockQueryAction({ database_id: 1, can_write: true }),
+ database: createMockDatabase({ id: 1 }),
+ user: createMockUser({ is_superuser: true }),
+ });
+
+ const input = await screen.findByLabelText("Message");
+ expect(input).not.toHaveAttribute("readonly");
+ });
+
+ it("should be read-only when the user can't edit the action", async () => {
+ setup({
+ action: createMockQueryAction({ database_id: 1, can_write: false }),
+ database: createMockDatabase({ id: 1 }),
+ user: createMockUser({ is_superuser: false }),
+ });
+
+ const input = await screen.findByLabelText("Message");
+ expect(input).toHaveAttribute("readonly");
+ });
+ });
+
+ describe("public sharing", () => {
+ it("should not be shown to non-admins", async () => {
+ setup({
+ action: createMockQueryAction({ database_id: 1, can_write: true }),
+ database: createMockDatabase({
+ id: 1,
+ settings: { "database-enable-actions": true },
+ }),
+ user: createMockUser({ is_superuser: false }),
+ });
+
+ expect(await screen.findByLabelText("Message")).toBeInTheDocument();
+ expect(screen.queryByText("Public sharing")).not.toBeInTheDocument();
+ });
+
+ it("should let admins make the action public when actions are enabled for its database", async () => {
+ setup({
+ action: createMockQueryAction({
+ database_id: 1,
+ can_write: true,
+ public_uuid: null,
+ }),
+ database: createMockDatabase({
+ id: 1,
+ settings: { "database-enable-actions": true },
+ }),
+ user: createMockUser({ is_superuser: true }),
+ });
+
+ expect(await screen.findByLabelText("Make public")).toBeEnabled();
+ });
+
+ it("should not let admins make the action public when actions are disabled for its database", async () => {
+ setup({
+ action: createMockQueryAction({
+ database_id: 1,
+ can_write: true,
+ public_uuid: null,
+ }),
+ database: createMockDatabase({
+ id: 1,
+ settings: { "database-enable-actions": false },
+ }),
+ user: createMockUser({ is_superuser: true }),
+ });
+
+ expect(await screen.findByLabelText("Make public")).toBeDisabled();
+ });
+
+ it("should let admins remove the public link when actions are disabled for its database", async () => {
+ setup({
+ action: createMockQueryAction({
+ database_id: 1,
+ can_write: true,
+ public_uuid: "a8b6c4f2-1d3e-4f5a-9b7c-2e1d0f9a8b7c",
+ }),
+ database: createMockDatabase({
+ id: 1,
+ settings: { "database-enable-actions": false },
+ }),
+ user: createMockUser({ is_superuser: true }),
+ });
+
+ expect(await screen.findByLabelText("Make public")).toBeEnabled();
+ expect(
+ screen.getByLabelText("Public action form URL"),
+ ).toBeInTheDocument();
+ });
+ });
+});
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/library/actions/pages/ActionSettingsPage/index.ts b/enterprise/frontend/src/metabase-enterprise/data-studio/library/actions/pages/ActionSettingsPage/index.ts
new file mode 100644
index 00000000000..5b8808b225b
--- /dev/null
+++ b/enterprise/frontend/src/metabase-enterprise/data-studio/library/actions/pages/ActionSettingsPage/index.ts
@@ -0,0 +1 @@
+export { ActionSettingsPage } from "./ActionSettingsPage";
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/library/actions/pages/ArchivedActionsPage/ArchivedActionsPage.tsx b/enterprise/frontend/src/metabase-enterprise/data-studio/library/actions/pages/ArchivedActionsPage/ArchivedActionsPage.tsx
new file mode 100644
index 00000000000..eada77a8f6f
--- /dev/null
+++ b/enterprise/frontend/src/metabase-enterprise/data-studio/library/actions/pages/ArchivedActionsPage/ArchivedActionsPage.tsx
@@ -0,0 +1,193 @@
+import { useCallback, useMemo, useState } from "react";
+import { t } from "ttag";
+
+import { useUpdateActionMutation } from "metabase/api";
+import { getErrorMessage } from "metabase/api/utils";
+import { CollectionRowMenu } from "metabase/common/collections/components/CollectionRowMenu";
+import { Link } from "metabase/common/components/Link";
+import { LoadingAndErrorWrapper } from "metabase/common/components/LoadingAndErrorWrapper";
+import { DataStudioBreadcrumbs } from "metabase/common/data-studio/components/DataStudioBreadcrumbs";
+import { PaneHeader } from "metabase/common/data-studio/components/PaneHeader";
+import { useMetadataToasts } from "metabase/common/hooks";
+import { SectionLayout } from "metabase/data-studio/app/components/SectionLayout";
+import type { TreeItem } from "metabase/data-studio/common/types";
+import {
+ isCollectionData,
+ isEmptyStateData,
+} from "metabase/data-studio/common/utils";
+import { useSelector } from "metabase/redux";
+import {
+ ActionIcon,
+ Card,
+ Center,
+ EntityNameCell,
+ FixedSizeIcon,
+ Icon,
+ Stack,
+ TextInput,
+ Tooltip,
+ TreeTable,
+ type TreeTableColumnDef,
+ useTreeTableInstance,
+} from "metabase/ui";
+import * as Urls from "metabase/urls";
+import { getIsRemoteSyncReadOnly } from "metabase-enterprise/remote_sync/selectors";
+
+import { useBuildActionTree } from "../../hooks/use-build-action-tree";
+
+export function ArchivedActionsPage() {
+ const [searchQuery, setSearchQuery] = useState("");
+ const { tree, isLoading, error } = useBuildActionTree({ archived: true });
+ const { sendSuccessToast, sendErrorToast } = useMetadataToasts();
+ const [updateAction] = useUpdateActionMutation();
+ const remoteSyncReadOnly = useSelector(getIsRemoteSyncReadOnly);
+
+ const handleUnarchive = useCallback(
+ async ({ id, name }: { id: number; name: string }) => {
+ try {
+ await updateAction({ id, archived: false }).unwrap();
+ sendSuccessToast(t`"${name}" unarchived`);
+ } catch (error) {
+ sendErrorToast(getErrorMessage(error, t`Failed to unarchive action`));
+ }
+ },
+ [sendErrorToast, sendSuccessToast, updateAction],
+ );
+
+ const columns = useMemo<TreeTableColumnDef<TreeItem>[]>(
+ () => [
+ {
+ id: "name",
+ header: t`Name`,
+ enableSorting: true,
+ accessorKey: "name",
+ minWidth: 200,
+ cell: ({ row }) => (
+ <EntityNameCell
+ data-testid={`${row.original.model}-name`}
+ icon={row.original.icon}
+ name={row.original.name}
+ />
+ ),
+ },
+ {
+ id: "actions",
+ width: 48,
+ cell: ({ row }) => (
+ <ArchivedItemMenu
+ treeItem={row.original}
+ readOnly={remoteSyncReadOnly}
+ onUnarchive={handleUnarchive}
+ />
+ ),
+ },
+ ],
+ [handleUnarchive, remoteSyncReadOnly],
+ );
+
+ const treeTableInstance = useTreeTableInstance({
+ data: tree,
+ columns,
+ getSubRows: (node) => node.children,
+ getNodeId: (node) => node.id,
+ globalFilter: searchQuery,
+ onGlobalFilterChange: setSearchQuery,
+ defaultExpanded: true,
+ });
+
+ if (isLoading || error) {
+ return (
+ <Center h="100%">
+ <LoadingAndErrorWrapper loading={isLoading} error={error} />
+ </Center>
+ );
+ }
+
+ return (
+ <SectionLayout>
+ <PaneHeader
+ breadcrumbs={
+ <DataStudioBreadcrumbs>
+ <Link to={Urls.dataStudioLibrary()}>{t`Semantic layer`}</Link>
+ <Link to={Urls.dataStudioLibrary()}>{t`Data actions`}</Link>
+ {t`Archived actions`}
+ </DataStudioBreadcrumbs>
+ }
+ px="3.5rem"
+ py={0}
+ />
+ <Stack
+ bg="background_page-secondary"
+ data-testid="archived-actions-page"
+ pb="2rem"
+ px="3.5rem"
+ style={{ overflow: "hidden" }}
+ >
+ <TextInput
+ placeholder={t`Search...`}
+ leftSection={<Icon name="search" />}
+ bdrs="sm"
+ value={searchQuery}
+ onChange={(event) => setSearchQuery(event.target.value)}
+ />
+ <Card withBorder p={0}>
+ <TreeTable
+ instance={treeTableInstance}
+ emptyState={t`No archived actions`}
+ onRowClick={(row) => {
+ if (row.getCanExpand()) {
+ row.toggleExpanded();
+ }
+ }}
+ renderRowLink={(row, props) => {
+ const { data } = row.original;
+ return data.model === "action" ? (
+ <Link to={Urls.dataStudioAction(Number(data.id))} {...props} />
+ ) : (
+ props.children
+ );
+ }}
+ />
+ </Card>
+ </Stack>
+ </SectionLayout>
+ );
+}
+
+type ArchivedItemMenuProps = {
+ treeItem: TreeItem;
+ readOnly: boolean;
+ onUnarchive: (item: { id: number; name: string }) => void;
+};
+
+function ArchivedItemMenu({
+ treeItem,
+ readOnly,
+ onUnarchive,
+}: ArchivedItemMenuProps) {
+ const { data } = treeItem;
+
+ if (readOnly || isEmptyStateData(data)) {
+ return null;
+ }
+
+ if (isCollectionData(data)) {
+ return <CollectionRowMenu collection={data} />;
+ }
+
+ return (
+ <Tooltip label={t`Unarchive action`}>
+ <ActionIcon
+ aria-label={t`Unarchive action`}
+ size="md"
+ onClick={(event) => {
+ event.stopPropagation();
+ event.preventDefault();
+ onUnarchive({ id: Number(data.id), name: data.name });
+ }}
+ >
+ <FixedSizeIcon name="unarchive" c="text-primary" />
+ </ActionIcon>
+ </Tooltip>
+ );
+}
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/library/actions/pages/ArchivedActionsPage/index.ts b/enterprise/frontend/src/metabase-enterprise/data-studio/library/actions/pages/ArchivedActionsPage/index.ts
new file mode 100644
index 00000000000..84a2320b808
--- /dev/null
+++ b/enterprise/frontend/src/metabase-enterprise/data-studio/library/actions/pages/ArchivedActionsPage/index.ts
@@ -0,0 +1 @@
+export * from "./ArchivedActionsPage";
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/library/actions/pages/NewActionPage/CreateActionModal/CreateActionModal.tsx b/enterprise/frontend/src/metabase-enterprise/data-studio/library/actions/pages/NewActionPage/CreateActionModal/CreateActionModal.tsx
new file mode 100644
index 00000000000..732674de20b
--- /dev/null
+++ b/enterprise/frontend/src/metabase-enterprise/data-studio/library/actions/pages/NewActionPage/CreateActionModal/CreateActionModal.tsx
@@ -0,0 +1,115 @@
+import { useMemo } from "react";
+import { t } from "ttag";
+import * as Yup from "yup";
+
+import { useCreateActionMutation } from "metabase/api";
+import FormCollectionPicker from "metabase/common/collections/containers/FormCollectionPicker";
+import {
+ Form,
+ FormErrorMessage,
+ FormProvider,
+ FormSubmitButton,
+ FormTextInput,
+ FormTextarea,
+} from "metabase/forms";
+import { Alert, Box, Button, Group, Icon, Modal, Stack } from "metabase/ui";
+import * as Errors from "metabase/utils/errors";
+import type { WritebackAction } from "metabase-types/api";
+
+import {
+ ACTION_COLLECTION_NAMESPACES,
+ ACTION_COLLECTION_PICKER_OPTIONS,
+ ACTION_NAME_MAX_LENGTH,
+} from "../../../constants";
+import type { ActionDefinition } from "../../../utils";
+
+const getValidationSchema = () =>
+ Yup.object({
+ name: Yup.string()
+ .required(Errors.required)
+ .max(ACTION_NAME_MAX_LENGTH, Errors.maxLength),
+ description: Yup.string().nullable().defined(),
+ collection_id: Yup.number().nullable().defined(),
+ });
+
+type NewActionValues = Yup.InferType<ReturnType<typeof getValidationSchema>>;
+
+type CreateActionModalProps = {
+ definition: ActionDefinition;
+ defaultName: string;
+ defaultCollectionId: NewActionValues["collection_id"];
+ onCreate: (action: WritebackAction) => void;
+ onClose: () => void;
+};
+
+export function CreateActionModal({
+ definition,
+ defaultName,
+ defaultCollectionId,
+ onCreate,
+ onClose,
+}: CreateActionModalProps) {
+ const [createAction] = useCreateActionMutation();
+ const validationSchema = useMemo(getValidationSchema, []);
+ const initialValues: NewActionValues = {
+ name: defaultName,
+ description: null,
+ collection_id: defaultCollectionId,
+ };
+
+ const handleSubmit = async ({
+ name,
+ description,
+ collection_id,
+ }: NewActionValues) => {
+ const action = await createAction({
+ ...definition,
+ type: "query",
+ name,
+ description: description || null,
+ collection_id,
+ }).unwrap();
+ onCreate(action);
+ };
+
+ return (
+ <Modal title={t`Save your action`} opened padding="xxl" onClose={onClose}>
+ <FormProvider
+ initialValues={initialValues}
+ validationSchema={validationSchema}
+ onSubmit={handleSubmit}
+ >
+ <Form>
+ <Stack gap="xl" mt="sm">
+ <FormTextInput name="name" label={t`Name`} data-autofocus />
+ <FormTextarea
+ name="description"
+ label={t`Description`}
+ placeholder={t`What does this action change?`}
+ nullable
+ />
+ <FormCollectionPicker
+ name="collection_id"
+ title={t`Folder`}
+ style={{ marginBottom: 0 }}
+ collectionPickerModalProps={{
+ namespaces: ACTION_COLLECTION_NAMESPACES,
+ options: ACTION_COLLECTION_PICKER_OPTIONS,
+ }}
+ />
+ <Alert variant="light" icon={<Icon name="info" />}>
+ {t`Anyone who can view this folder can run this action.`}
+ </Alert>
+ <Group>
+ <Box flex={1}>
+ <FormErrorMessage />
+ </Box>
+ <Button onClick={onClose}>{t`Back`}</Button>
+ <FormSubmitButton label={t`Save`} variant="filled" />
+ </Group>
+ </Stack>
+ </Form>
+ </FormProvider>
+ </Modal>
+ );
+}
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/library/actions/pages/NewActionPage/CreateActionModal/index.ts b/enterprise/frontend/src/metabase-enterprise/data-studio/library/actions/pages/NewActionPage/CreateActionModal/index.ts
new file mode 100644
index 00000000000..0e1fc2d863f
--- /dev/null
+++ b/enterprise/frontend/src/metabase-enterprise/data-studio/library/actions/pages/NewActionPage/CreateActionModal/index.ts
@@ -0,0 +1 @@
+export { CreateActionModal } from "./CreateActionModal";
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/library/actions/pages/NewActionPage/NewActionPage.tsx b/enterprise/frontend/src/metabase-enterprise/data-studio/library/actions/pages/NewActionPage/NewActionPage.tsx
new file mode 100644
index 00000000000..d628cb14b72
--- /dev/null
+++ b/enterprise/frontend/src/metabase-enterprise/data-studio/library/actions/pages/NewActionPage/NewActionPage.tsx
@@ -0,0 +1,146 @@
+import { useDisclosure } from "@mantine/hooks";
+import { useCallback, useMemo, useRef, useState } from "react";
+import { t } from "ttag";
+
+import { LeaveRouteConfirmModal } from "metabase/common/components/LeaveConfirmModal";
+import { Link } from "metabase/common/components/Link";
+import { LoadingAndErrorWrapper } from "metabase/common/components/LoadingAndErrorWrapper";
+import { DataStudioBreadcrumbs } from "metabase/common/data-studio/components/DataStudioBreadcrumbs";
+import { PageContainer } from "metabase/common/data-studio/components/PageContainer";
+import {
+ PaneHeader,
+ PaneHeaderActions,
+ PaneHeaderInput,
+} from "metabase/common/data-studio/components/PaneHeader";
+import { hasNativeWritePermissions } from "metabase/common/utils/database";
+import { getInitialUiState } from "metabase/querying/editor/components/QueryEditor";
+import { type Location, useNavigate } from "metabase/router";
+import { Center } from "metabase/ui";
+import * as Urls from "metabase/urls";
+import Question from "metabase-lib/v1/Question";
+import type { Database, WritebackAction } from "metabase-types/api";
+
+import { ActionEditor } from "../../components/ActionEditor";
+import { ActionEditorPane } from "../../components/ActionEditorPane";
+import { ACTION_NAME_MAX_LENGTH } from "../../constants";
+import { useActionDatabases } from "../../hooks/use-action-databases";
+import { useActionDraft } from "../../hooks/use-action-draft";
+
+import { CreateActionModal } from "./CreateActionModal";
+
+export function NewActionPage() {
+ const { databases, isLoading, error } = useActionDatabases();
+ const editableDatabases = useMemo(
+ () => databases.filter(hasNativeWritePermissions),
+ [databases],
+ );
+
+ if (isLoading || error != null) {
+ return (
+ <Center h="100%">
+ <LoadingAndErrorWrapper loading={isLoading} error={error} />
+ </Center>
+ );
+ }
+
+ if (editableDatabases.length === 0) {
+ return (
+ <Center h="100%">
+ <LoadingAndErrorWrapper
+ error={t`To create an action, you need permission to write native queries on a database with actions enabled.`}
+ />
+ </Center>
+ );
+ }
+
+ return <NewActionPageBody databases={editableDatabases} />;
+}
+
+type NewActionPageBodyProps = {
+ databases: Database[];
+};
+
+function NewActionPageBody({ databases }: NewActionPageBodyProps) {
+ const initialDatasetQuery = useMemo(
+ () =>
+ Question.create({
+ DEPRECATED_RAW_MBQL_type: "native",
+ DEPRECATED_RAW_MBQL_databaseId: databases[0]?.id,
+ }).datasetQuery(),
+ [databases],
+ );
+ const draft = useActionDraft({ initialDatasetQuery });
+ const [name, setName] = useState("");
+ const [uiState, setUiState] = useState(getInitialUiState);
+ const [isModalOpened, { open: openModal, close: closeModal }] =
+ useDisclosure();
+ const navigate = useNavigate();
+ const isSavedRef = useRef(false);
+ const isDirty = draft.isDirty || name.trim().length > 0;
+
+ const handleCreate = (action: WritebackAction) => {
+ isSavedRef.current = true;
+ navigate(Urls.dataStudioAction(action.id));
+ };
+
+ const isLocationAllowed = useCallback(
+ (location?: Location) => !location || isSavedRef.current,
+ [],
+ );
+
+ return (
+ <>
+ <PageContainer pos="relative" data-testid="action-query-editor">
+ <PaneHeader
+ title={
+ <PaneHeaderInput
+ initialValue={name}
+ placeholder={t`New action`}
+ maxLength={ACTION_NAME_MAX_LENGTH}
+ isOptional
+ onChange={setName}
+ />
+ }
+ icon="bolt"
+ actions={
+ <PaneHeaderActions
+ isValid={draft.isValid}
+ isDirty
+ onSave={openModal}
+ onCancel={() => navigate(Urls.dataStudioLibrary())}
+ />
+ }
+ breadcrumbs={
+ <DataStudioBreadcrumbs>
+ <Link to={Urls.dataStudioLibrary()}>{t`Semantic layer`}</Link>
+ <Link to={Urls.dataStudioLibrary()}>{t`Data actions`}</Link>
+ {t`New action`}
+ </DataStudioBreadcrumbs>
+ }
+ />
+ <ActionEditorPane>
+ <ActionEditor
+ datasetQuery={draft.datasetQuery}
+ uiState={uiState}
+ databases={databases}
+ onChangeDatasetQuery={draft.setDatasetQuery}
+ onChangeUiState={setUiState}
+ />
+ </ActionEditorPane>
+ </PageContainer>
+ {isModalOpened && draft.definition != null && (
+ <CreateActionModal
+ definition={draft.definition}
+ defaultName={name}
+ defaultCollectionId={null}
+ onCreate={handleCreate}
+ onClose={closeModal}
+ />
+ )}
+ <LeaveRouteConfirmModal
+ isEnabled={isDirty}
+ isLocationAllowed={isLocationAllowed}
+ />
+ </>
+ );
+}
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/library/actions/pages/NewActionPage/index.ts b/enterprise/frontend/src/metabase-enterprise/data-studio/library/actions/pages/NewActionPage/index.ts
new file mode 100644
index 00000000000..122fee5cf63
--- /dev/null
+++ b/enterprise/frontend/src/metabase-enterprise/data-studio/library/actions/pages/NewActionPage/index.ts
@@ -0,0 +1 @@
+export { NewActionPage } from "./NewActionPage";
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/library/actions/routes.tsx b/enterprise/frontend/src/metabase-enterprise/data-studio/library/actions/routes.tsx
new file mode 100644
index 00000000000..dcab353b574
--- /dev/null
+++ b/enterprise/frontend/src/metabase-enterprise/data-studio/library/actions/routes.tsx
@@ -0,0 +1,49 @@
+import { Route } from "metabase/router";
+
+/**
+ * The action pages, in one chunk, so moving between an action's tabs costs no fetch.
+ */
+const archivedActionsPage = () =>
+ import(
+ /* webpackChunkName: "data-actions" */ "./pages/ArchivedActionsPage"
+ ).then(({ ArchivedActionsPage }) => ({ Component: ArchivedActionsPage }));
+
+const newActionPage = () =>
+ import(/* webpackChunkName: "data-actions" */ "./pages/NewActionPage").then(
+ ({ NewActionPage }) => ({ Component: NewActionPage }),
+ );
+
+const actionQueryPage = () =>
+ import(/* webpackChunkName: "data-actions" */ "./pages/ActionQueryPage").then(
+ ({ ActionQueryPage }) => ({ Component: ActionQueryPage }),
+ );
+
+const actionFieldsPage = () =>
+ import(
+ /* webpackChunkName: "data-actions" */ "./pages/ActionFieldsPage"
+ ).then(({ ActionFieldsPage }) => ({ Component: ActionFieldsPage }));
+
+const actionRunPage = () =>
+ import(/* webpackChunkName: "data-actions" */ "./pages/ActionRunPage").then(
+ ({ ActionRunPage }) => ({ Component: ActionRunPage }),
+ );
+
+const actionSettingsPage = () =>
+ import(
+ /* webpackChunkName: "data-actions" */ "./pages/ActionSettingsPage"
+ ).then(({ ActionSettingsPage }) => ({ Component: ActionSettingsPage }));
+
+export function getDataStudioActionRoutes() {
+ return (
+ <>
+ <Route path="actions/new" lazy={newActionPage} />
+ <Route path="actions/archived" lazy={archivedActionsPage} />
+ <Route path="actions/:actionId" lazy={actionQueryPage} />
+ <Route path="actions/:actionId/edit" lazy={actionQueryPage} />
+ <Route path="actions/:actionId/fields" lazy={actionFieldsPage} />
+ <Route path="actions/:actionId/fields/:fieldId" lazy={actionFieldsPage} />
+ <Route path="actions/:actionId/run" lazy={actionRunPage} />
+ <Route path="actions/:actionId/settings" lazy={actionSettingsPage} />
+ </>
+ );
+}
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/library/actions/utils.ts b/enterprise/frontend/src/metabase-enterprise/data-studio/library/actions/utils.ts
new file mode 100644
index 00000000000..6161dcf7d80
--- /dev/null
+++ b/enterprise/frontend/src/metabase-enterprise/data-studio/library/actions/utils.ts
@@ -0,0 +1,204 @@
+import { getInputTypes } from "metabase/actions/constants";
+import {
+ getDefaultFieldSettings,
+ inputTypeHasOptions,
+} from "metabase/actions/utils";
+import {
+ hasActionsEnabled,
+ hasNativeWritePermissions,
+} from "metabase/common/utils/database";
+import * as Lib from "metabase-lib";
+import { getTemplateTagParameters } from "metabase-lib/v1/parameters/utils/template-tags";
+import type {
+ ActionFormSettings,
+ CreateActionRequest,
+ Database,
+ FieldSettings,
+ FieldType,
+ FieldValueOptions,
+ TemplateTag,
+ TemplateTagType,
+ WritebackAction,
+ WritebackParameter,
+} from "metabase-types/api";
+
+export type ActionDefinition = Required<
+ Pick<
+ CreateActionRequest,
+ "database_id" | "dataset_query" | "parameters" | "visualization_settings"
+ >
+>;
+
+const TAG_TYPE_BY_FIELD_TYPE: Record<FieldType, TemplateTagType> = {
+ string: "text",
+ number: "number",
+ date: "date",
+};
+
+export function getQueryParameters(query: Lib.Query): WritebackParameter[] {
+ return getTemplateTagParameters(Object.values(Lib.templateTags(query)));
+}
+
+function getFieldTypes(
+ tag: TemplateTag | undefined,
+): Pick<FieldSettings, "fieldType" | "inputType"> {
+ switch (tag?.type) {
+ case "number":
+ return { fieldType: "number", inputType: "number" };
+ case "date":
+ return { fieldType: "date", inputType: "date" };
+ default:
+ return { fieldType: "string", inputType: "string" };
+ }
+}
+
+function getFieldSettings(
+ parameter: WritebackParameter,
+ index: number,
+ tag: TemplateTag | undefined,
+ existing: FieldSettings | undefined,
+): FieldSettings {
+ const fieldTypes = getFieldTypes(tag);
+ if (existing === undefined) {
+ return getDefaultFieldSettings({
+ id: parameter.id,
+ name: parameter.name,
+ title: parameter.name,
+ order: index,
+ required: parameter.required ?? true,
+ ...fieldTypes,
+ });
+ }
+ return existing.fieldType === fieldTypes.fieldType
+ ? existing
+ : getFieldSettingsForFieldType(existing, fieldTypes.fieldType);
+}
+
+/**
+ * The form field settings for the variables of `query`, keeping the settings in `formSettings` and converting those whose variable type changed.
+ */
+export function getFieldSettingsFromQuery(
+ query: Lib.Query,
+ formSettings: ActionFormSettings,
+): ActionFormSettings {
+ const tags = Object.values(Lib.templateTags(query));
+ const fields = Object.fromEntries(
+ getQueryParameters(query).map((parameter, index) => [
+ parameter.id,
+ getFieldSettings(
+ parameter,
+ index,
+ tags.find((tag) => tag.id === parameter.id),
+ formSettings.fields?.[parameter.id],
+ ),
+ ]),
+ );
+ return { ...formSettings, fields };
+}
+
+/**
+ * Whether the current user can change the query of `action`, which needs native query permissions on its database.
+ */
+export function canEditActionQuery(
+ action: WritebackAction,
+ databases: Database[],
+): boolean {
+ return (
+ action.can_write === true &&
+ databases.some(
+ (database) =>
+ database.id === action.database_id &&
+ hasNativeWritePermissions(database),
+ )
+ );
+}
+
+export function setTemplateTagFieldType(
+ query: Lib.Query,
+ parameterId: string,
+ fieldType: FieldType,
+): Lib.Query {
+ const tags = Object.fromEntries(
+ Object.entries(Lib.templateTags(query)).map(([name, tag]) => [
+ name,
+ tag.id === parameterId
+ ? { ...tag, type: TAG_TYPE_BY_FIELD_TYPE[fieldType] }
+ : tag,
+ ]),
+ );
+ return Lib.withTemplateTags(query, tags);
+}
+
+export function getActionDefinition(
+ query: Lib.Query,
+ formSettings: ActionFormSettings,
+): ActionDefinition | null {
+ const databaseId = Lib.databaseID(query);
+ if (databaseId == null) {
+ return null;
+ }
+ return {
+ database_id: databaseId,
+ dataset_query: Lib.toJsQuery(query),
+ parameters: getQueryParameters(query),
+ visualization_settings: getFieldSettingsFromQuery(query, formSettings),
+ };
+}
+
+export function canCreateActions(databases: Database[]): boolean {
+ return databases.some(
+ (database) =>
+ hasActionsEnabled(database) && hasNativeWritePermissions(database),
+ );
+}
+
+function cleanFieldValue(
+ value: string | number | undefined,
+ fieldType: FieldType,
+) {
+ if (value == null) {
+ return value;
+ }
+ switch (fieldType) {
+ case "string":
+ return String(value);
+ case "number": {
+ const number = Number(value);
+ return Number.isNaN(number) ? undefined : number;
+ }
+ default:
+ return undefined;
+ }
+}
+
+export function cleanOptionValues(
+ values: FieldValueOptions,
+ fieldType: FieldType,
+): FieldValueOptions {
+ return values
+ .map((value) => cleanFieldValue(value, fieldType))
+ .filter((value) => value != null);
+}
+
+/**
+ * The field settings converted to `fieldType`, keeping the input type, options and default value where they still apply.
+ */
+export function getFieldSettingsForFieldType(
+ fieldSettings: FieldSettings,
+ fieldType: FieldType,
+): FieldSettings {
+ const inputTypes = getInputTypes()[fieldType].map((option) => option.value);
+ const inputType = inputTypes.includes(fieldSettings.inputType)
+ ? fieldSettings.inputType
+ : inputTypes[0];
+
+ return {
+ ...fieldSettings,
+ fieldType,
+ inputType,
+ valueOptions: inputTypeHasOptions(inputType)
+ ? cleanOptionValues(fieldSettings.valueOptions ?? [], fieldType)
+ : undefined,
+ defaultValue: cleanFieldValue(fieldSettings.defaultValue, fieldType),
+ };
+}
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/library/actions/utils.unit.spec.ts b/enterprise/frontend/src/metabase-enterprise/data-studio/library/actions/utils.unit.spec.ts
new file mode 100644
index 00000000000..1fb9eac1626
--- /dev/null
+++ b/enterprise/frontend/src/metabase-enterprise/data-studio/library/actions/utils.unit.spec.ts
@@ -0,0 +1,152 @@
+import * as Lib from "metabase-lib";
+import { SAMPLE_DATABASE, SAMPLE_METADATA } from "metabase-lib/test-helpers";
+import type { TemplateTag } from "metabase-types/api";
+import {
+ createMockDatabase,
+ createMockFieldSettings,
+ createMockQueryAction,
+} from "metabase-types/api/mocks";
+
+import { canEditActionQuery, getFieldSettingsFromQuery } from "./utils";
+
+const STATUS_TAG: TemplateTag = {
+ id: "status-tag",
+ name: "status",
+ "display-name": "Status",
+ type: "text",
+};
+
+const ID_TAG: TemplateTag = {
+ id: "id-tag",
+ name: "id",
+ "display-name": "ID",
+ type: "number",
+};
+
+function createQuery(tags: TemplateTag[]): Lib.Query {
+ const metadataProvider = Lib.metadataProvider(
+ SAMPLE_DATABASE.id,
+ SAMPLE_METADATA,
+ );
+ const query = Lib.nativeQuery(
+ SAMPLE_DATABASE.id,
+ metadataProvider,
+ `SELECT ${tags.map((tag) => `{{${tag.name}}}`).join(", ")}`,
+ );
+ return Lib.withTemplateTags(
+ query,
+ Object.fromEntries(tags.map((tag) => [tag.name, tag])),
+ );
+}
+
+describe("getFieldSettingsFromQuery", () => {
+ it("should make the fields of new variables required", () => {
+ const { fields } = getFieldSettingsFromQuery(
+ createQuery([STATUS_TAG, ID_TAG]),
+ {},
+ );
+
+ expect(fields?.[STATUS_TAG.id]).toMatchObject({
+ fieldType: "string",
+ required: true,
+ });
+ expect(fields?.[ID_TAG.id]).toMatchObject({
+ fieldType: "number",
+ required: true,
+ });
+ });
+
+ it("should keep the field of a variable that is not required", () => {
+ const { fields } = getFieldSettingsFromQuery(
+ createQuery([{ ...STATUS_TAG, required: false }, ID_TAG]),
+ {},
+ );
+
+ expect(fields?.[STATUS_TAG.id]).toMatchObject({ required: false });
+ });
+
+ it("should keep the settings of a field whose variable type is unchanged", () => {
+ const field = createMockFieldSettings({
+ id: STATUS_TAG.id,
+ title: "Order status",
+ hidden: true,
+ order: 1,
+ });
+
+ const { fields } = getFieldSettingsFromQuery(
+ createQuery([STATUS_TAG, ID_TAG]),
+ { fields: { [STATUS_TAG.id]: field } },
+ );
+
+ expect(fields?.[STATUS_TAG.id]).toEqual(field);
+ });
+
+ it("should keep the settings of a field whose variable type changed", () => {
+ const field = createMockFieldSettings({
+ id: STATUS_TAG.id,
+ title: "Order status",
+ description: "The new status",
+ hidden: true,
+ required: false,
+ order: 1,
+ fieldType: "string",
+ inputType: "select",
+ valueOptions: ["1", "2", "shipped"],
+ defaultValue: "2",
+ });
+
+ const { fields } = getFieldSettingsFromQuery(
+ createQuery([{ ...STATUS_TAG, type: "number" }, ID_TAG]),
+ { fields: { [STATUS_TAG.id]: field } },
+ );
+
+ expect(fields?.[STATUS_TAG.id]).toEqual({
+ ...field,
+ fieldType: "number",
+ inputType: "select",
+ valueOptions: [1, 2],
+ defaultValue: 2,
+ });
+ });
+
+ it("should drop the settings of removed variables", () => {
+ const { fields } = getFieldSettingsFromQuery(createQuery([ID_TAG]), {
+ fields: {
+ removed: createMockFieldSettings({ id: "removed" }),
+ },
+ });
+
+ expect(Object.keys(fields ?? {})).toEqual([ID_TAG.id]);
+ });
+});
+
+describe("canEditActionQuery", () => {
+ const action = createMockQueryAction({ database_id: 1, can_write: true });
+
+ it("should allow editing with native query permissions on the action database", () => {
+ const databases = [
+ createMockDatabase({ id: 1, native_permissions: "write" }),
+ ];
+
+ expect(canEditActionQuery(action, databases)).toBe(true);
+ });
+
+ it("should not allow editing without native query permissions on the action database", () => {
+ const databases = [
+ createMockDatabase({ id: 1, native_permissions: "none" }),
+ createMockDatabase({ id: 2, native_permissions: "write" }),
+ ];
+
+ expect(canEditActionQuery(action, databases)).toBe(false);
+ });
+
+ it("should not allow editing without write access to the action", () => {
+ const databases = [
+ createMockDatabase({ id: 1, native_permissions: "write" }),
+ ];
+
+ expect(canEditActionQuery({ ...action, can_write: false }, databases)).toBe(
+ false,
+ );
+ });
+});
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/library/components/CollectionPermissionsModal/CollectionPermissionsModal.tsx b/enterprise/frontend/src/metabase-enterprise/data-studio/library/components/CollectionPermissionsModal/CollectionPermissionsModal.tsx
index d7219641979..0ac112c0a89 100644
--- a/enterprise/frontend/src/metabase-enterprise/data-studio/library/components/CollectionPermissionsModal/CollectionPermissionsModal.tsx
+++ b/enterprise/frontend/src/metabase-enterprise/data-studio/library/components/CollectionPermissionsModal/CollectionPermissionsModal.tsx
@@ -10,7 +10,9 @@ export function CollectionPermissionsModal({
onClose,
}: CollectionPermissionsModalProps) {
useListCollectionsQuery(
- namespace === "snippets" ? { namespace: "snippets" } : skipToken,
+ namespace === "snippets" || namespace === "data-actions"
+ ? { namespace }
+ : skipToken,
);
return (
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/library/routes.tsx b/enterprise/frontend/src/metabase-enterprise/data-studio/library/routes.tsx
index 54865af2d52..e0347852672 100644
--- a/enterprise/frontend/src/metabase-enterprise/data-studio/library/routes.tsx
+++ b/enterprise/frontend/src/metabase-enterprise/data-studio/library/routes.tsx
@@ -3,6 +3,7 @@ import type { ComponentType } from "react";
import { Route } from "metabase/router";
import { LibrarySectionLayout } from "./LibrarySectionLayout";
+import { getDataStudioActionRoutes } from "./actions/routes";
import { getDataStudioMetricRoutes } from "./metrics/routes";
import { getDataStudioSnippetRoutes } from "./snippets/routes";
import { getDataStudioTableRoutes } from "./tables/routes";
@@ -23,6 +24,7 @@ export const getDataStudioLibraryRoutes = (IsAdmin: ComponentType) => {
{getDataStudioTableRoutes(IsAdmin)}
{getDataStudioMetricRoutes()}
{getDataStudioSnippetRoutes()}
+ {getDataStudioActionRoutes()}
</Route>
);
};
diff --git a/enterprise/frontend/src/metabase-enterprise/database_routing/DatabaseRoutingSection/utils.tsx b/enterprise/frontend/src/metabase-enterprise/database_routing/DatabaseRoutingSection/utils.tsx
index de9411f7fb9..48427aa6b6e 100644
--- a/enterprise/frontend/src/metabase-enterprise/database_routing/DatabaseRoutingSection/utils.tsx
+++ b/enterprise/frontend/src/metabase-enterprise/database_routing/DatabaseRoutingSection/utils.tsx
@@ -31,11 +31,11 @@ export const getDisabledFeatureMessage = (
.with(
{ hasActionsEnabled: true, isPersisted: true },
() =>
- t`Database routing can't be enabled if model actions and persistence are enabled.`,
+ t`Database routing can't be enabled if data actions and model persistence are enabled.`,
)
.with(
{ hasActionsEnabled: true },
- () => t`Database routing can't be enabled if model actions are enabled.`,
+ () => t`Database routing can't be enabled if data actions are enabled.`,
)
.with(
{ isPersisted: true },
diff --git a/enterprise/frontend/src/metabase-enterprise/remote_sync/components/ChangesLists/AllChangesView.tsx b/enterprise/frontend/src/metabase-enterprise/remote_sync/components/ChangesLists/AllChangesView.tsx
index f3efd900d32..2023e610071 100644
--- a/enterprise/frontend/src/metabase-enterprise/remote_sync/components/ChangesLists/AllChangesView.tsx
+++ b/enterprise/frontend/src/metabase-enterprise/remote_sync/components/ChangesLists/AllChangesView.tsx
@@ -54,6 +54,9 @@ export const AllChangesView = ({ entities, title }: AllChangesViewProps) => {
const { data: snippetCollectionTree = [] } = useListCollectionsTreeQuery({
namespace: "snippets",
});
+ const { data: dataActionCollectionTree = [] } = useListCollectionsTreeQuery({
+ namespace: "data-actions",
+ });
// Build namespace-to-collection-ids map in a single pass
const namespaceCollectionMap = useMemo(
@@ -61,8 +64,9 @@ export const AllChangesView = ({ entities, title }: AllChangesViewProps) => {
buildNamespaceCollectionMap([
...collectionTree,
...snippetCollectionTree,
+ ...dataActionCollectionTree,
]),
- [collectionTree, snippetCollectionTree],
+ [collectionTree, snippetCollectionTree, dataActionCollectionTree],
);
// Find the Transforms root entity (id=-1) if it exists
diff --git a/enterprise/frontend/src/metabase-enterprise/remote_sync/components/ChangesLists/EntityLink.tsx b/enterprise/frontend/src/metabase-enterprise/remote_sync/components/ChangesLists/EntityLink.tsx
index 04becd3b9c8..30dca428dcb 100644
--- a/enterprise/frontend/src/metabase-enterprise/remote_sync/components/ChangesLists/EntityLink.tsx
+++ b/enterprise/frontend/src/metabase-enterprise/remote_sync/components/ChangesLists/EntityLink.tsx
@@ -3,7 +3,7 @@ import { useMemo } from "react";
import type { IconData, IconModel } from "metabase/common/utils/icon";
import { useGetIcon } from "metabase/hooks/use-icon";
import { Anchor, Group, Icon, Text } from "metabase/ui";
-import { modelToUrl } from "metabase/urls";
+import * as Urls from "metabase/urls";
import type { RemoteSyncEntity } from "metabase-types/api";
import { getSyncStatusColor, getSyncStatusIcon } from "../../utils";
@@ -15,11 +15,19 @@ interface EntityLinkProps {
}
function getEntityUrl(entity: RemoteSyncEntity): string | null {
- // Action and transform test URLs need the parent entity id, which dirty entries do not carry.
- if (entity.model === "action" || entity.model === "transformtest") {
+ // Transform test URLs need the parent transform id, which dirty entries do not carry.
+ if (entity.model === "transformtest") {
return null;
}
- return modelToUrl(entity);
+ if (entity.model === "action") {
+ if (entity.card_id === undefined) {
+ return null;
+ }
+ return entity.card_id === null
+ ? Urls.dataStudioAction(entity.id)
+ : Urls.action({ id: entity.card_id }, entity.id);
+ }
+ return Urls.modelToUrl(entity);
}
export const EntityLink = ({ entity }: EntityLinkProps) => {
diff --git a/enterprise/frontend/src/metabase-enterprise/remote_sync/displayGroups.ts b/enterprise/frontend/src/metabase-enterprise/remote_sync/displayGroups.ts
index ac77c30fcc8..c204b0e4e0c 100644
--- a/enterprise/frontend/src/metabase-enterprise/remote_sync/displayGroups.ts
+++ b/enterprise/frontend/src/metabase-enterprise/remote_sync/displayGroups.ts
@@ -46,6 +46,8 @@ export type DisplayGroupSpec = {
namespace?: string;
/** Model types that belong to this group */
models?: Set<RemoteSyncEntityModel>;
+ /** Other entities that belong to this group */
+ matches?: (entity: RemoteSyncEntity) => boolean;
/** Synthetic root for groups whose entities have no real collection */
virtualRoot?: VirtualRoot;
/** Icon to display for this group's collections */
@@ -86,6 +88,14 @@ const displayGroupSpecs: DisplayGroupSpec[] = [
pathPrefixGroupId: "library",
priority: 90,
},
+ {
+ id: "data-actions",
+ namespace: "data-actions",
+ matches: (entity) => entity.model === "action" && entity.card_id === null,
+ icon: "bolt",
+ pathPrefixGroupId: "library",
+ priority: 85,
+ },
{
id: "glossary",
models: new Set(["glossary"]),
@@ -163,7 +173,7 @@ const getSpecForEntity = (
namespaceCollectionMap: NamespaceCollectionMap,
): DisplayGroupSpec => {
for (const spec of displayGroupSpecs) {
- if (spec.models?.has(entity.model)) {
+ if (spec.models?.has(entity.model) || spec.matches?.(entity)) {
return spec;
}
if (entity.model === "collection" && spec.namespace) {
@@ -287,7 +297,12 @@ const getPathPrefixSegments = (
libraryCollectionId != null &&
collectionId !== libraryCollectionId &&
collectionId != null &&
- isCollectionInNamespace(collectionId, "snippets", namespaceCollectionMap)
+ spec.namespace != null &&
+ isCollectionInNamespace(
+ collectionId,
+ spec.namespace,
+ namespaceCollectionMap,
+ )
) {
const libraryCollection = collectionMap.get(libraryCollectionId);
if (libraryCollection) {
diff --git a/enterprise/frontend/src/metabase-enterprise/remote_sync/displayGroups.unit.spec.ts b/enterprise/frontend/src/metabase-enterprise/remote_sync/displayGroups.unit.spec.ts
new file mode 100644
index 00000000000..2cd5fcdd1d7
--- /dev/null
+++ b/enterprise/frontend/src/metabase-enterprise/remote_sync/displayGroups.unit.spec.ts
@@ -0,0 +1,45 @@
+import {
+ createMockCollection,
+ createMockRemoteSyncEntity,
+} from "metabase-types/api/mocks";
+
+import { groupEntitiesByCollection } from "./displayGroups";
+
+const LIBRARY_COLLECTION_ID = 1;
+const LIBRARY_COLLECTION = createMockCollection({
+ id: LIBRARY_COLLECTION_ID,
+ name: "Library",
+});
+
+function groupActions(cardId: number | null) {
+ return groupEntitiesByCollection({
+ entities: [
+ createMockRemoteSyncEntity({
+ id: 10,
+ model: "action",
+ collection_id: undefined,
+ card_id: cardId,
+ }),
+ ],
+ transformsRootEntity: undefined,
+ namespaceCollectionMap: new Map(),
+ collectionMap: new Map([[LIBRARY_COLLECTION_ID, LIBRARY_COLLECTION]]),
+ libraryCollectionId: LIBRARY_COLLECTION_ID,
+ getCollectionPathSegments: () => [],
+ });
+}
+
+describe("groupEntitiesByCollection", () => {
+ it("should group a data action at the data actions root under the Library", () => {
+ const [group] = groupActions(null);
+
+ expect(group.spec.id).toBe("data-actions");
+ expect(group.collectionId).toBe(1);
+ });
+
+ it("should not group a model action under the Library", () => {
+ const [group] = groupActions(5);
+
+ expect(group.spec.id).toBe("default");
+ });
+});
diff --git a/enterprise/frontend/src/metabase-enterprise/remote_sync/middleware/register-listeners.ts b/enterprise/frontend/src/metabase-enterprise/remote_sync/middleware/register-listeners.ts
index 58a440deff1..e565106abbd 100644
--- a/enterprise/frontend/src/metabase-enterprise/remote_sync/middleware/register-listeners.ts
+++ b/enterprise/frontend/src/metabase-enterprise/remote_sync/middleware/register-listeners.ts
@@ -68,8 +68,11 @@ function shouldInvalidateForCollection(
return true;
}
- // Also invalidate for snippets namespace collections
- if (newCollection.namespace === "snippets") {
+ // Also invalidate for snippets and data actions namespace collections
+ if (
+ newCollection.namespace === "snippets" ||
+ newCollection.namespace === "data-actions"
+ ) {
return true;
}
diff --git a/frontend/src/metabase-types/api/actions.ts b/frontend/src/metabase-types/api/actions.ts
index ea164f2ee79..f37f9b0a1e8 100644
--- a/frontend/src/metabase-types/api/actions.ts
+++ b/frontend/src/metabase-types/api/actions.ts
@@ -1,21 +1,25 @@
import type { CardId } from "./card";
+import type { CollectionId } from "./collection";
import type { DashCardId, DashboardId } from "./dashboard";
import type { DatabaseId } from "./database";
import type { BaseEntityId } from "./entity-id";
import type { Parameter, ParameterId, ParameterTarget } from "./parameters";
-import type { NativeDatasetQuery } from "./query";
+import type { NativeDatasetQuery, OpaqueDatasetQuery } from "./query";
import type { UserId, UserInfo } from "./user";
export type ListActionsRequest = {
"model-id"?: CardId;
+ type?: WritebackActionType;
+ archived?: boolean;
};
export interface CreateActionRequest {
+ collection_id?: CollectionId | null;
database_id?: DatabaseId;
- dataset_query?: NativeDatasetQuery;
+ dataset_query?: NativeDatasetQuery | OpaqueDatasetQuery;
description?: string | null;
kind?: "row/create" | "row/update" | "row/delete";
- model_id: CardId;
+ model_id?: CardId | null;
name: string;
parameter_mappings?: Record<ParameterId, ParameterTarget>;
parameters?: WritebackParameter[];
@@ -26,8 +30,9 @@ export interface CreateActionRequest {
export interface UpdateActionRequest {
id: WritebackActionId;
archived?: boolean;
+ collection_id?: CollectionId | null;
database_id?: DatabaseId;
- dataset_query?: NativeDatasetQuery;
+ dataset_query?: NativeDatasetQuery | OpaqueDatasetQuery;
description?: string | null;
kind?: "row/create" | "row/update" | "row/delete";
model_id?: CardId;
@@ -47,7 +52,8 @@ export type WritebackActionId = number;
export interface WritebackActionBase {
id: WritebackActionId;
- model_id: CardId;
+ model_id: CardId | null;
+ collection_id: CollectionId | null;
name: string;
description: string | null;
parameters?: WritebackParameter[];
@@ -60,6 +66,7 @@ export interface WritebackActionBase {
public_uuid: string | null;
database_id?: DatabaseId;
database_enabled_actions?: boolean;
+ can_write?: boolean;
entity_id: BaseEntityId;
}
diff --git a/frontend/src/metabase-types/api/collection.ts b/frontend/src/metabase-types/api/collection.ts
index 2bce2f0b6e6..3b5885366fa 100644
--- a/frontend/src/metabase-types/api/collection.ts
+++ b/frontend/src/metabase-types/api/collection.ts
@@ -16,6 +16,7 @@ export type CollectionNamespace =
| null
| "snippets"
| "transforms"
+ | "data-actions"
| "analytics"
| "tenant-specific"
| "shared-tenant-collection";
@@ -104,6 +105,7 @@ export const COLLECTION_ITEM_MODELS = [
"transform",
"measure",
"exploration",
+ "action",
] as const;
export type CollectionItemModel = (typeof COLLECTION_ITEM_MODELS)[number];
diff --git a/frontend/src/metabase-types/api/mocks/actions.ts b/frontend/src/metabase-types/api/mocks/actions.ts
index d51d6fd4faa..c1c46cd602c 100644
--- a/frontend/src/metabase-types/api/mocks/actions.ts
+++ b/frontend/src/metabase-types/api/mocks/actions.ts
@@ -39,7 +39,8 @@ export const createMockQueryAction = ({
dataset_query,
name: "Query Action Mock",
description: null,
- model_id: 1,
+ model_id: null,
+ collection_id: null,
database_id: 1,
parameters: undefined,
creator_id: creator.id,
@@ -65,6 +66,7 @@ export const createMockImplicitQueryAction = ({
name: "Create",
description: "",
model_id: 1,
+ collection_id: null,
database_id: 1,
parameters: undefined,
visualization_settings: undefined,
diff --git a/frontend/src/metabase-types/api/remote-sync.ts b/frontend/src/metabase-types/api/remote-sync.ts
index e32611a8472..5bb1e1438d6 100644
--- a/frontend/src/metabase-types/api/remote-sync.ts
+++ b/frontend/src/metabase-types/api/remote-sync.ts
@@ -43,6 +43,8 @@ export type RemoteSyncEntity = {
table_id?: number;
/** Parent table name for field and segment models */
table_name?: string;
+ /** The model card of an existing action, null for an action without a model */
+ card_id?: number | null;
};
export type RemoteSyncChangesResponse = {
diff --git a/frontend/src/metabase/admin/databases/components/DatabaseModelFeaturesSection/ModelActionsSection/ModelActionsSection.tsx b/frontend/src/metabase/admin/databases/components/DatabaseDataActionsSection/DataActionsSection/DataActionsSection.tsx
similarity index 52%
rename from frontend/src/metabase/admin/databases/components/DatabaseModelFeaturesSection/ModelActionsSection/ModelActionsSection.tsx
rename to frontend/src/metabase/admin/databases/components/DatabaseDataActionsSection/DataActionsSection/DataActionsSection.tsx
index bfa80411044..ce011af5caa 100644
--- a/frontend/src/metabase/admin/databases/components/DatabaseModelFeaturesSection/ModelActionsSection/ModelActionsSection.tsx
+++ b/frontend/src/metabase/admin/databases/components/DatabaseDataActionsSection/DataActionsSection/DataActionsSection.tsx
@@ -6,23 +6,23 @@ import { getResponseErrorMessage } from "metabase/utils/errors";
import { Description, Error, Label } from "../../DatabaseFeatureComponents";
-export interface ModelActionsSectionProps {
- hasModelActionsEnabled: boolean;
- onToggleModelActionsEnabled: (enabled: boolean) => Promise<void>;
+export interface DataActionsSectionProps {
+ hasDataActionsEnabled: boolean;
+ onToggleDataActionsEnabled: (enabled: boolean) => Promise<void>;
disabled: boolean;
}
-export function ModelActionsSection({
- hasModelActionsEnabled,
- onToggleModelActionsEnabled,
+export function DataActionsSection({
+ hasDataActionsEnabled,
+ onToggleDataActionsEnabled,
disabled,
-}: ModelActionsSectionProps) {
+}: DataActionsSectionProps) {
const [error, setError] = useState<string | null>(null);
- const handleToggleModelActionsEnabled = async (enabled: boolean) => {
+ const handleToggleDataActionsEnabled = async (enabled: boolean) => {
try {
setError(null);
- await onToggleModelActionsEnabled(enabled);
+ await onToggleDataActionsEnabled(enabled);
} catch (err) {
setError(getResponseErrorMessage(err) || t`An error occurred`);
}
@@ -31,13 +31,13 @@ export function ModelActionsSection({
return (
<div>
<Flex align="center" justify="space-between" mb="xxs">
- <Label htmlFor="model-actions-toggle">{t`Model actions`}</Label>
+ <Label htmlFor="data-actions-toggle">{t`Data actions`}</Label>
<Box>
<Switch
- id="model-actions-toggle"
- checked={hasModelActionsEnabled}
+ id="data-actions-toggle"
+ checked={hasDataActionsEnabled}
onChange={(e) =>
- handleToggleModelActionsEnabled(e.currentTarget.checked)
+ handleToggleDataActionsEnabled(e.currentTarget.checked)
}
disabled={disabled}
/>
@@ -46,9 +46,7 @@ export function ModelActionsSection({
<Box maw="22.5rem">
{error ? <Error>{error}</Error> : null}
<Description>
- {t`Allow actions from models created from this data to be run. Actions are able to read, write, and possibly delete data.`}
- <br />
- {t`Note: Your database user will need write permissions, either through the main connection or through the write connection.`}
+ {t`Allow data actions that use this database to be run. Actions are able to read, write, and possibly delete data.`}
</Description>
</Box>
{disabled && (
@@ -59,7 +57,7 @@ export function ModelActionsSection({
icon={<Icon name="info" />}
mb="lg"
>
- {t`Model actions can't be enabled when database routing is enabled.`}
+ {t`Data actions can't be enabled when database routing is enabled.`}
</Alert>
</Box>
)}
diff --git a/frontend/src/metabase/admin/databases/components/DatabaseModelFeaturesSection/ModelActionsSection/ModelActionsSection.unit.spec.tsx b/frontend/src/metabase/admin/databases/components/DatabaseDataActionsSection/DataActionsSection/DataActionsSection.unit.spec.tsx
similarity index 56%
rename from frontend/src/metabase/admin/databases/components/DatabaseModelFeaturesSection/ModelActionsSection/ModelActionsSection.unit.spec.tsx
rename to frontend/src/metabase/admin/databases/components/DatabaseDataActionsSection/DataActionsSection/DataActionsSection.unit.spec.tsx
index d39c798ec85..83e5501862d 100644
--- a/frontend/src/metabase/admin/databases/components/DatabaseModelFeaturesSection/ModelActionsSection/ModelActionsSection.unit.spec.tsx
+++ b/frontend/src/metabase/admin/databases/components/DatabaseDataActionsSection/DataActionsSection/DataActionsSection.unit.spec.tsx
@@ -3,14 +3,14 @@ import { useState } from "react";
import { render, screen, waitFor } from "__support__/ui";
-import type { ModelActionsSectionProps } from "./ModelActionsSection";
-import { ModelActionsSection } from "./ModelActionsSection";
+import type { DataActionsSectionProps } from "./DataActionsSection";
+import { DataActionsSection } from "./DataActionsSection";
function ModelActionSectionWrapper({
- hasModelActionsEnabled: initialValue,
- onToggleModelActionsEnabled: onChange,
+ hasDataActionsEnabled: initialValue,
+ onToggleDataActionsEnabled: onChange,
disabled,
-}: ModelActionsSectionProps) {
+}: DataActionsSectionProps) {
const [isEnabled, setEnabled] = useState(initialValue);
const handleChange = async (nextValue: boolean) => {
@@ -19,36 +19,36 @@ function ModelActionSectionWrapper({
};
return (
- <ModelActionsSection
- hasModelActionsEnabled={isEnabled}
- onToggleModelActionsEnabled={handleChange}
+ <DataActionsSection
+ hasDataActionsEnabled={isEnabled}
+ onToggleDataActionsEnabled={handleChange}
disabled={disabled}
/>
);
}
function setup({
- hasModelActionsEnabled = false,
- onToggleModelActionsEnabled = jest.fn(),
+ hasDataActionsEnabled = false,
+ onToggleDataActionsEnabled = jest.fn(),
disabled = false,
-}: Partial<ModelActionsSectionProps>) {
+}: Partial<DataActionsSectionProps>) {
render(
<ModelActionSectionWrapper
- hasModelActionsEnabled={hasModelActionsEnabled}
- onToggleModelActionsEnabled={onToggleModelActionsEnabled}
+ hasDataActionsEnabled={hasDataActionsEnabled}
+ onToggleDataActionsEnabled={onToggleDataActionsEnabled}
disabled={disabled}
/>,
);
- const toggle = screen.getByLabelText("Model actions");
+ const toggle = screen.getByLabelText("Data actions");
- return { toggle, onToggleModelActionsEnabled };
+ return { toggle, onToggleDataActionsEnabled };
}
-describe("ModelActionsSection", () => {
+describe("DataActionsSection", () => {
it("should allow toggling actions", async () => {
- const { toggle, onToggleModelActionsEnabled } = setup({
- hasModelActionsEnabled: false,
+ const { toggle, onToggleDataActionsEnabled } = setup({
+ hasDataActionsEnabled: false,
});
expect(toggle).not.toBeChecked();
@@ -56,12 +56,12 @@ describe("ModelActionsSection", () => {
await userEvent.click(toggle);
await waitFor(() => expect(toggle).toBeChecked());
- expect(onToggleModelActionsEnabled).toHaveBeenLastCalledWith(true);
+ expect(onToggleDataActionsEnabled).toHaveBeenLastCalledWith(true);
await userEvent.click(toggle);
await waitFor(() => expect(toggle).not.toBeChecked());
- expect(onToggleModelActionsEnabled).toHaveBeenLastCalledWith(false);
+ expect(onToggleDataActionsEnabled).toHaveBeenLastCalledWith(false);
});
it("should not allow toggling actions if section is disabled", async () => {
@@ -71,13 +71,13 @@ describe("ModelActionsSection", () => {
it("should handle errors while toggling actions", async () => {
const errorMessage = "Lacking write database permissions";
- const onToggleModelActionsEnabled = jest.fn().mockRejectedValueOnce({
+ const onToggleDataActionsEnabled = jest.fn().mockRejectedValueOnce({
data: { message: errorMessage },
});
const { toggle } = setup({
- hasModelActionsEnabled: false,
- onToggleModelActionsEnabled,
+ hasDataActionsEnabled: false,
+ onToggleDataActionsEnabled,
});
await userEvent.click(toggle);
@@ -87,6 +87,6 @@ describe("ModelActionsSection", () => {
await userEvent.click(toggle);
await waitFor(() => expect(toggle).toBeChecked());
expect(screen.queryByText(errorMessage)).not.toBeInTheDocument();
- expect(onToggleModelActionsEnabled).toHaveBeenLastCalledWith(true);
+ expect(onToggleDataActionsEnabled).toHaveBeenLastCalledWith(true);
});
});
diff --git a/frontend/src/metabase/admin/databases/components/DatabaseDataActionsSection/DataActionsSection/index.ts b/frontend/src/metabase/admin/databases/components/DatabaseDataActionsSection/DataActionsSection/index.ts
new file mode 100644
index 00000000000..53ed4c1f128
--- /dev/null
+++ b/frontend/src/metabase/admin/databases/components/DatabaseDataActionsSection/DataActionsSection/index.ts
@@ -0,0 +1 @@
+export * from "./DataActionsSection";
diff --git a/frontend/src/metabase/admin/databases/components/DatabaseDataActionsSection/DatabaseDataActionsSection.tsx b/frontend/src/metabase/admin/databases/components/DatabaseDataActionsSection/DatabaseDataActionsSection.tsx
new file mode 100644
index 00000000000..a510999119a
--- /dev/null
+++ b/frontend/src/metabase/admin/databases/components/DatabaseDataActionsSection/DatabaseDataActionsSection.tsx
@@ -0,0 +1,55 @@
+import { useCallback } from "react";
+import { t } from "ttag";
+
+import {
+ hasActionsEnabled,
+ hasDbRoutingEnabled,
+} from "metabase/common/utils/database";
+import { hasFeature } from "metabase/databases";
+import type { Database, DatabaseData, DatabaseId } from "metabase-types/api";
+
+import { DatabaseInfoSection } from "../DatabaseInfoSection";
+
+import { DataActionsSection } from "./DataActionsSection";
+
+export const DatabaseDataActionsSection = ({
+ database,
+ updateDatabase,
+}: {
+ database: Database;
+ updateDatabase: (
+ database: { id: DatabaseId } & Partial<DatabaseData>,
+ ) => Promise<void>;
+}) => {
+ const isVisible =
+ !database.is_attached_dwh &&
+ database.id != null &&
+ hasFeature(database, "actions");
+
+ const handleToggle = useCallback(
+ (nextValue: boolean) =>
+ updateDatabase({
+ id: database.id,
+ settings: { "database-enable-actions": nextValue },
+ }),
+ [database.id, updateDatabase],
+ );
+
+ if (!isVisible) {
+ return null;
+ }
+
+ return (
+ <DatabaseInfoSection
+ name={t`Data actions`}
+ description={t`Let saved queries write to this database. This will often require a write connection.`}
+ data-testid="database-data-actions-section"
+ >
+ <DataActionsSection
+ hasDataActionsEnabled={hasActionsEnabled(database)}
+ onToggleDataActionsEnabled={handleToggle}
+ disabled={hasDbRoutingEnabled(database)}
+ />
+ </DatabaseInfoSection>
+ );
+};
diff --git a/frontend/src/metabase/admin/databases/components/DatabaseDataActionsSection/DatabaseDataActionsSection.unit.spec.tsx b/frontend/src/metabase/admin/databases/components/DatabaseDataActionsSection/DatabaseDataActionsSection.unit.spec.tsx
new file mode 100644
index 00000000000..c494f0e31df
--- /dev/null
+++ b/frontend/src/metabase/admin/databases/components/DatabaseDataActionsSection/DatabaseDataActionsSection.unit.spec.tsx
@@ -0,0 +1,121 @@
+import userEvent from "@testing-library/user-event";
+import _ from "underscore";
+
+import {
+ setupDatabaseEndpoints,
+ setupDatabaseUsageInfoEndpoint,
+} from "__support__/server-mocks/database";
+import { createMockState } from "__support__/state";
+import { createMockEntitiesState } from "__support__/store";
+import { renderWithProviders, screen } from "__support__/ui";
+import type { Database } from "metabase-types/api";
+import {
+ COMMON_DATABASE_FEATURES,
+ createMockDatabase,
+} from "metabase-types/api/mocks";
+
+import { DatabaseDataActionsSection } from "./DatabaseDataActionsSection";
+
+interface SetupOpts {
+ database?: Database;
+}
+
+function setup({ database = createMockDatabase() }: SetupOpts = {}) {
+ const state = createMockState({
+ entities: createMockEntitiesState({
+ databases: [database],
+ }),
+ });
+ setupDatabaseEndpoints(database);
+ setupDatabaseUsageInfoEndpoint(database, {
+ question: 0,
+ dataset: 0,
+ metric: 0,
+ segment: 0,
+ transform: 0,
+ });
+
+ // Using mockResolvedValue since `ActionButton` component
+ // the Sidebar is using is expecting these callbacks to be async
+ const updateDatabase = jest.fn().mockResolvedValue({});
+ const dismissSyncSpinner = jest.fn().mockResolvedValue({});
+ const deleteDatabase = jest.fn().mockResolvedValue({});
+
+ const utils = renderWithProviders(
+ <DatabaseDataActionsSection
+ database={database}
+ updateDatabase={updateDatabase}
+ />,
+ { storeInitialState: state },
+ );
+
+ return {
+ ...utils,
+ database,
+ updateDatabase,
+ dismissSyncSpinner,
+ deleteDatabase,
+ };
+}
+
+describe("DatabaseDataActionsSection", () => {
+ describe("data actions control", () => {
+ it("is shown if database supports actions", () => {
+ setup();
+
+ expect(screen.getByLabelText(/Data actions/i)).toBeInTheDocument();
+ });
+
+ it("isn't shown if database doesn't support actions", () => {
+ const features = _.without(COMMON_DATABASE_FEATURES, "actions");
+ setup({ database: createMockDatabase({ features }) });
+
+ expect(screen.queryByText(/Data actions/i)).not.toBeInTheDocument();
+ });
+
+ it("shows if actions are enabled", () => {
+ setup({
+ database: createMockDatabase({
+ settings: { "database-enable-actions": true },
+ }),
+ });
+
+ expect(screen.getByLabelText(/Data actions/i)).toBeChecked();
+ });
+
+ it("shows if actions are disabled", () => {
+ setup({
+ database: createMockDatabase({
+ settings: { "database-enable-actions": false },
+ }),
+ });
+
+ expect(screen.getByLabelText(/Data actions/i)).not.toBeChecked();
+ });
+
+ it("enables actions", async () => {
+ const { database, updateDatabase } = setup();
+
+ await userEvent.click(screen.getByLabelText(/Data actions/i));
+
+ expect(updateDatabase).toHaveBeenCalledWith({
+ id: database.id,
+ settings: { "database-enable-actions": true },
+ });
+ });
+
+ it("disables actions", async () => {
+ const database = createMockDatabase({
+ settings: { "database-enable-actions": true },
+ });
+ const { updateDatabase } = setup({ database });
+
+ await userEvent.click(screen.getByLabelText(/Data actions/i));
+
+ expect(updateDatabase).toHaveBeenCalledWith({
+ id: database.id,
+ settings: { "database-enable-actions": false },
+ });
+ });
+ });
+});
diff --git a/frontend/src/metabase/admin/databases/components/DatabaseDataActionsSection/index.tsx b/frontend/src/metabase/admin/databases/components/DatabaseDataActionsSection/index.tsx
new file mode 100644
index 00000000000..71a8f418d47
--- /dev/null
+++ b/frontend/src/metabase/admin/databases/components/DatabaseDataActionsSection/index.tsx
@@ -0,0 +1 @@
+export * from "./DatabaseDataActionsSection";
diff --git a/frontend/src/metabase/admin/databases/components/DatabaseModelFeaturesSection/DatabaseModelFeaturesSection.tsx b/frontend/src/metabase/admin/databases/components/DatabaseModelFeaturesSection/DatabaseModelFeaturesSection.tsx
deleted file mode 100644
index 488951936a9..00000000000
--- a/frontend/src/metabase/admin/databases/components/DatabaseModelFeaturesSection/DatabaseModelFeaturesSection.tsx
+++ /dev/null
@@ -1,76 +0,0 @@
-import { useCallback } from "react";
-import { t } from "ttag";
-
-import {
- hasActionsEnabled,
- hasDbRoutingEnabled,
-} from "metabase/common/utils/database";
-import { hasFeature } from "metabase/databases";
-import { Flex } from "metabase/ui";
-import type { Database, DatabaseData, DatabaseId } from "metabase-types/api";
-
-import { DatabaseInfoSection } from "../DatabaseInfoSection";
-
-import { ModelActionsSection } from "./ModelActionsSection";
-import { ModelCachingControl } from "./ModelCachingControl";
-
-export const DatabaseModelFeaturesSection = ({
- database,
- isModelPersistenceEnabled,
- updateDatabase,
-}: {
- database: Database;
- isModelPersistenceEnabled: boolean;
- updateDatabase: (
- database: { id: DatabaseId } & Partial<DatabaseData>,
- ) => Promise<void>;
-}) => {
- const isEditingDatabase = !!database.id;
-
- const contentVisibility = {
- showModelActions: isEditingDatabase && hasFeature(database, "actions"),
- showModelCachingSection:
- isModelPersistenceEnabled && hasFeature(database, "persist-models"),
- };
- const hasNoContent = Object.values(contentVisibility).every(
- (x) => x === false,
- );
-
- const handleToggleModelActionsEnabled = useCallback(
- (nextValue: boolean) =>
- updateDatabase({
- id: database.id,
- settings: { "database-enable-actions": nextValue },
- }),
- [database.id, updateDatabase],
- );
-
- if (database.is_attached_dwh || hasNoContent) {
- return null;
- }
-
- return (
- <DatabaseInfoSection
- name={t`Model features`}
- description={t`Choose whether to enable features related to Metabase models. These will often require a write connection.`}
- data-testid="database-model-features-section"
- >
- <Flex direction="column" gap="lg">
- {contentVisibility.showModelActions && (
- <ModelActionsSection
- hasModelActionsEnabled={hasActionsEnabled(database)}
- onToggleModelActionsEnabled={handleToggleModelActionsEnabled}
- disabled={hasDbRoutingEnabled(database)}
- />
- )}
-
- {contentVisibility.showModelCachingSection && (
- <ModelCachingControl
- database={database}
- disabled={hasDbRoutingEnabled(database)}
- />
- )}
- </Flex>
- </DatabaseInfoSection>
- );
-};
diff --git a/frontend/src/metabase/admin/databases/components/DatabaseModelFeaturesSection/ModelActionsSection/index.ts b/frontend/src/metabase/admin/databases/components/DatabaseModelFeaturesSection/ModelActionsSection/index.ts
deleted file mode 100644
index 5881e003d83..00000000000
--- a/frontend/src/metabase/admin/databases/components/DatabaseModelFeaturesSection/ModelActionsSection/index.ts
+++ /dev/null
@@ -1 +0,0 @@
-export * from "./ModelActionsSection";
diff --git a/frontend/src/metabase/admin/databases/components/DatabaseModelFeaturesSection/index.tsx b/frontend/src/metabase/admin/databases/components/DatabaseModelFeaturesSection/index.tsx
deleted file mode 100644
index 57c46a479b4..00000000000
--- a/frontend/src/metabase/admin/databases/components/DatabaseModelFeaturesSection/index.tsx
+++ /dev/null
@@ -1 +0,0 @@
-export * from "./DatabaseModelFeaturesSection";
diff --git a/frontend/src/metabase/admin/databases/components/DatabaseModelPersistenceSection/DatabaseModelPersistenceSection.tsx b/frontend/src/metabase/admin/databases/components/DatabaseModelPersistenceSection/DatabaseModelPersistenceSection.tsx
new file mode 100644
index 00000000000..752a89ead79
--- /dev/null
+++ b/frontend/src/metabase/admin/databases/components/DatabaseModelPersistenceSection/DatabaseModelPersistenceSection.tsx
@@ -0,0 +1,39 @@
+import { t } from "ttag";
+
+import { hasDbRoutingEnabled } from "metabase/common/utils/database";
+import { hasFeature } from "metabase/databases";
+import type { Database } from "metabase-types/api";
+
+import { DatabaseInfoSection } from "../DatabaseInfoSection";
+
+import { ModelCachingControl } from "./ModelCachingControl";
+
+export const DatabaseModelPersistenceSection = ({
+ database,
+ isModelPersistenceEnabled,
+}: {
+ database: Database;
+ isModelPersistenceEnabled: boolean;
+}) => {
+ const isVisible =
+ !database.is_attached_dwh &&
+ isModelPersistenceEnabled &&
+ hasFeature(database, "persist-models");
+
+ if (!isVisible) {
+ return null;
+ }
+
+ return (
+ <DatabaseInfoSection
+ name={t`Model persistence`}
+ description={t`Store the results of models in this database so questions built on them run faster. This will often require a write connection.`}
+ data-testid="database-model-persistence-section"
+ >
+ <ModelCachingControl
+ database={database}
+ disabled={hasDbRoutingEnabled(database)}
+ />
+ </DatabaseInfoSection>
+ );
+};
diff --git a/frontend/src/metabase/admin/databases/components/DatabaseModelFeaturesSection/DatabaseModelFeaturesSection.unit.spec.tsx b/frontend/src/metabase/admin/databases/components/DatabaseModelPersistenceSection/DatabaseModelPersistenceSection.unit.spec.tsx
similarity index 55%
rename from frontend/src/metabase/admin/databases/components/DatabaseModelFeaturesSection/DatabaseModelFeaturesSection.unit.spec.tsx
rename to frontend/src/metabase/admin/databases/components/DatabaseModelPersistenceSection/DatabaseModelPersistenceSection.unit.spec.tsx
index 9e452feab01..70c03a43915 100644
--- a/frontend/src/metabase/admin/databases/components/DatabaseModelFeaturesSection/DatabaseModelFeaturesSection.unit.spec.tsx
+++ b/frontend/src/metabase/admin/databases/components/DatabaseModelPersistenceSection/DatabaseModelPersistenceSection.unit.spec.tsx
@@ -1,4 +1,3 @@
-import userEvent from "@testing-library/user-event";
import _ from "underscore";
import {
@@ -14,7 +13,7 @@ import {
createMockDatabase,
} from "metabase-types/api/mocks";
-import { DatabaseModelFeaturesSection } from "./DatabaseModelFeaturesSection";
+import { DatabaseModelPersistenceSection } from "./DatabaseModelPersistenceSection";
interface SetupOpts {
database?: Database;
@@ -41,15 +40,13 @@ function setup({
// Using mockResolvedValue since `ActionButton` component
// the Sidebar is using is expecting these callbacks to be async
- const updateDatabase = jest.fn().mockResolvedValue({});
const dismissSyncSpinner = jest.fn().mockResolvedValue({});
const deleteDatabase = jest.fn().mockResolvedValue({});
const utils = renderWithProviders(
- <DatabaseModelFeaturesSection
+ <DatabaseModelPersistenceSection
database={database}
isModelPersistenceEnabled={isModelPersistenceEnabled}
- updateDatabase={updateDatabase}
/>,
{ storeInitialState: state },
);
@@ -57,77 +54,15 @@ function setup({
return {
...utils,
database,
- updateDatabase,
dismissSyncSpinner,
deleteDatabase,
};
}
-describe("DatabaseModelFeaturesSection", () => {
- describe("model actions control", () => {
- it("is shown if database supports actions", () => {
- setup();
-
- expect(screen.getByLabelText(/Model actions/i)).toBeInTheDocument();
- });
-
- it("isn't shown if database doesn't support actions", () => {
- const features = _.without(COMMON_DATABASE_FEATURES, "actions");
- setup({ database: createMockDatabase({ features }) });
-
- expect(screen.queryByText(/Model actions/i)).not.toBeInTheDocument();
- });
-
- it("shows if actions are enabled", () => {
- setup({
- database: createMockDatabase({
- settings: { "database-enable-actions": true },
- }),
- });
-
- expect(screen.getByLabelText(/Model actions/i)).toBeChecked();
- });
-
- it("shows if actions are disabled", () => {
- setup({
- database: createMockDatabase({
- settings: { "database-enable-actions": false },
- }),
- });
-
- expect(screen.getByLabelText(/Model actions/i)).not.toBeChecked();
- });
-
- it("enables actions", async () => {
- const { database, updateDatabase } = setup();
-
- await userEvent.click(screen.getByLabelText(/Model actions/i));
-
- expect(updateDatabase).toHaveBeenCalledWith({
- id: database.id,
- settings: { "database-enable-actions": true },
- });
- });
-
- it("disables actions", async () => {
- const database = createMockDatabase({
- settings: { "database-enable-actions": true },
- });
- const { updateDatabase } = setup({ database });
-
- await userEvent.click(screen.getByLabelText(/Model actions/i));
-
- expect(updateDatabase).toHaveBeenCalledWith({
- id: database.id,
- settings: { "database-enable-actions": false },
- });
- });
- });
-
+describe("DatabaseModelPersistenceSection", () => {
describe("model caching control", () => {
it("isn't shown if model caching is turned off globally", () => {
setup({ isModelPersistenceEnabled: false });
- expect(screen.getByLabelText("Model actions")).toBeInTheDocument();
expect(
screen.queryByLabelText("Model persistence"),
).not.toBeInTheDocument();
@@ -140,7 +75,6 @@ describe("DatabaseModelFeaturesSection", () => {
features: _.without(COMMON_DATABASE_FEATURES, "persist-models"),
}),
});
- expect(screen.getByLabelText("Model actions")).toBeInTheDocument();
expect(
screen.queryByLabelText("Model persistence"),
).not.toBeInTheDocument();
@@ -159,7 +93,6 @@ describe("DatabaseModelFeaturesSection", () => {
features: [...COMMON_DATABASE_FEATURES, "persist-models-enabled"],
}),
});
- expect(screen.getByLabelText("Model actions")).toBeInTheDocument();
expect(screen.getByLabelText("Model persistence")).toBeInTheDocument();
expect(screen.getByLabelText("Model persistence")).toBeChecked();
});
diff --git a/frontend/src/metabase/admin/databases/components/DatabaseModelFeaturesSection/ModelCachingControl/ModelCachingControl.tsx b/frontend/src/metabase/admin/databases/components/DatabaseModelPersistenceSection/ModelCachingControl/ModelCachingControl.tsx
similarity index 100%
rename from frontend/src/metabase/admin/databases/components/DatabaseModelFeaturesSection/ModelCachingControl/ModelCachingControl.tsx
rename to frontend/src/metabase/admin/databases/components/DatabaseModelPersistenceSection/ModelCachingControl/ModelCachingControl.tsx
diff --git a/frontend/src/metabase/admin/databases/components/DatabaseModelFeaturesSection/ModelCachingControl/index.ts b/frontend/src/metabase/admin/databases/components/DatabaseModelPersistenceSection/ModelCachingControl/index.ts
similarity index 100%
rename from frontend/src/metabase/admin/databases/components/DatabaseModelFeaturesSection/ModelCachingControl/index.ts
rename to frontend/src/metabase/admin/databases/components/DatabaseModelPersistenceSection/ModelCachingControl/index.ts
diff --git a/frontend/src/metabase/admin/databases/components/DatabaseModelPersistenceSection/index.tsx b/frontend/src/metabase/admin/databases/components/DatabaseModelPersistenceSection/index.tsx
new file mode 100644
index 00000000000..8c45151f74b
--- /dev/null
+++ b/frontend/src/metabase/admin/databases/components/DatabaseModelPersistenceSection/index.tsx
@@ -0,0 +1 @@
+export * from "./DatabaseModelPersistenceSection";
diff --git a/frontend/src/metabase/admin/databases/containers/DatabaseEditApp.tsx b/frontend/src/metabase/admin/databases/containers/DatabaseEditApp.tsx
index 35125881fe1..d8aeb28fe81 100644
--- a/frontend/src/metabase/admin/databases/containers/DatabaseEditApp.tsx
+++ b/frontend/src/metabase/admin/databases/containers/DatabaseEditApp.tsx
@@ -29,7 +29,8 @@ import type { DatabaseId, Database as DatabaseType } from "metabase-types/api";
import { DatabaseConnectionInfoSection } from "../components/DatabaseConnectionInfoSection";
import { DatabaseDangerZoneSection } from "../components/DatabaseDangerZoneSection";
-import { DatabaseModelFeaturesSection } from "../components/DatabaseModelFeaturesSection";
+import { DatabaseDataActionsSection } from "../components/DatabaseDataActionsSection";
+import { DatabaseModelPersistenceSection } from "../components/DatabaseModelPersistenceSection";
import { ExistingDatabaseHeader } from "../components/ExistingDatabaseHeader";
import { deleteDatabase, updateDatabase } from "../database";
@@ -120,12 +121,6 @@ function DatabaseEditAppInner({
database={database}
/>
- <DatabaseModelFeaturesSection
- database={database}
- isModelPersistenceEnabled={isModelPersistenceEnabled}
- updateDatabase={updateDatabase}
- />
-
<PLUGIN_DATABASE_REPLICATION.DatabaseReplicationSection
database={database}
/>
@@ -136,6 +131,16 @@ function DatabaseEditAppInner({
updateDatabase={updateDatabase}
/>
+ <DatabaseDataActionsSection
+ database={database}
+ updateDatabase={updateDatabase}
+ />
+
+ <DatabaseModelPersistenceSection
+ database={database}
+ isModelPersistenceEnabled={isModelPersistenceEnabled}
+ />
+
<PLUGIN_DB_ROUTING.DatabaseRoutingSection
database={database}
/>
diff --git a/frontend/src/metabase/admin/databases/containers/DatabaseEditApp.unit.spec.tsx b/frontend/src/metabase/admin/databases/containers/DatabaseEditApp.unit.spec.tsx
index 6cbd51df396..a5d54fe98d5 100644
--- a/frontend/src/metabase/admin/databases/containers/DatabaseEditApp.unit.spec.tsx
+++ b/frontend/src/metabase/admin/databases/containers/DatabaseEditApp.unit.spec.tsx
@@ -52,7 +52,7 @@ describe("DatabaseEditApp", () => {
await screen.findByTestId("database-connection-info-section"),
).toBeInTheDocument();
expect(
- screen.getByTestId("database-model-features-section"),
+ screen.getByTestId("database-data-actions-section"),
).toBeInTheDocument();
expect(
screen.getByTestId("database-danger-zone-section"),
@@ -68,7 +68,7 @@ describe("DatabaseEditApp", () => {
await screen.findByTestId("database-connection-info-section"),
).toBeInTheDocument();
expect(
- screen.queryByTestId("database-model-features-section"),
+ screen.queryByTestId("database-data-actions-section"),
).not.toBeInTheDocument();
expect(
screen.getByTestId("database-danger-zone-section"),
diff --git a/frontend/src/metabase/admin/permissions/components/CollectionPermissionsModal/CollectionPermissionsModal.tsx b/frontend/src/metabase/admin/permissions/components/CollectionPermissionsModal/CollectionPermissionsModal.tsx
index 4aa877d360f..fafe2c3ecb1 100644
--- a/frontend/src/metabase/admin/permissions/components/CollectionPermissionsModal/CollectionPermissionsModal.tsx
+++ b/frontend/src/metabase/admin/permissions/components/CollectionPermissionsModal/CollectionPermissionsModal.tsx
@@ -31,8 +31,11 @@ import { PermissionsTable } from "../PermissionsTable";
import S from "./CollectionPermissionsModal.module.css";
+const isFolderNamespace = (namespace?: CollectionNamespace) =>
+ namespace === "snippets" || namespace === "data-actions";
+
const getDefaultTitle = (namespace?: CollectionNamespace) =>
- namespace === "snippets"
+ isFolderNamespace(namespace)
? t`Permissions for this folder`
: t`Permissions for this collection`;
@@ -148,7 +151,7 @@ const CollectionPermissionsModal = ({
onClose={onClose}
className={CS.overflowHidden}
footer={[
- ...(namespace === "snippets"
+ ...(isFolderNamespace(namespace)
? []
: [
<Link
diff --git a/frontend/src/metabase/admin/permissions/selectors/collection-permissions.tsx b/frontend/src/metabase/admin/permissions/selectors/collection-permissions.tsx
index fec44af59aa..5a93db6858f 100644
--- a/frontend/src/metabase/admin/permissions/selectors/collection-permissions.tsx
+++ b/frontend/src/metabase/admin/permissions/selectors/collection-permissions.tsx
@@ -193,10 +193,16 @@ const getCollection = createSelector(
},
);
-const getFolder = (state: State, props: CollectionIdProps) => {
+const FOLDER_NAMESPACES: CollectionNamespace[] = ["snippets", "data-actions"];
+
+const getFolder = (
+ state: State,
+ props: CollectionIdProps,
+ namespace: CollectionNamespace,
+) => {
const folderId = getCurrentCollectionId(state, props);
const folders = collectionApi.endpoints.listCollections.select({
- namespace: "snippets",
+ namespace,
})(state).data;
return folders?.find((folder: Collection) => folder.id === folderId);
@@ -206,8 +212,9 @@ export const getCollectionEntity = (
state: State,
props: CollectionIdProps,
): Collection | undefined => {
- return props.namespace === "snippets"
- ? getFolder(state, props)
+ const namespace = props.namespace ?? null;
+ return FOLDER_NAMESPACES.includes(namespace)
+ ? getFolder(state, props, namespace)
: (getCollection(state, props) ?? undefined);
};
@@ -221,7 +228,7 @@ const getNamespace = (_state: State, props: CollectionIdProps) =>
props.namespace;
const getToggleLabel = (namespace?: CollectionNamespace) =>
- namespace === "snippets"
+ FOLDER_NAMESPACES.includes(namespace ?? null)
? t`Also change sub-folders`
: t`Also change sub-collections`;
diff --git a/frontend/src/metabase/admin/settings/components/widgets/PublicLinksListing/PublicResources.tsx b/frontend/src/metabase/admin/settings/components/widgets/PublicLinksListing/PublicResources.tsx
index 0c43e59b814..0884550a36b 100644
--- a/frontend/src/metabase/admin/settings/components/widgets/PublicLinksListing/PublicResources.tsx
+++ b/frontend/src/metabase/admin/settings/components/widgets/PublicLinksListing/PublicResources.tsx
@@ -8,6 +8,7 @@ import {
useListPublicCardsQuery,
useListPublicDashboardsQuery,
} from "metabase/api";
+import { PLUGIN_LIBRARY } from "metabase/plugins";
import { useSetting } from "metabase/settings";
import * as Urls from "metabase/urls";
import type {
@@ -65,7 +66,15 @@ export const PublicLinksActionListing = () => {
return (
<PublicLinksListing<GetPublicAction>
revoke={revoke}
- getUrl={(action) => Urls.action({ id: action.model_id }, action.id)}
+ getUrl={(action) => {
+ if (action.model_id != null) {
+ return Urls.action({ id: action.model_id }, action.id);
+ }
+ if (!PLUGIN_LIBRARY.isEnabled && action.public_uuid != null) {
+ return Urls.publicAction(siteUrl, action.public_uuid);
+ }
+ return Urls.dataStudioAction(action.id);
+ }}
getPublicUrl={({ public_uuid }) => {
if (public_uuid) {
return Urls.publicAction(siteUrl, public_uuid);
diff --git a/frontend/src/metabase/api/action.ts b/frontend/src/metabase/api/action.ts
index e11309fc0eb..8c312427ca1 100644
--- a/frontend/src/metabase/api/action.ts
+++ b/frontend/src/metabase/api/action.ts
@@ -55,16 +55,10 @@ export const actionApi = Api.injectEndpoints({
query: (body) => ({
method: "PUT",
url: `/api/action/${body.id}`,
- // The action editor passes the full WritebackAction it fetched
- // (including server-managed fields like `creator`, `created_at`,
- // `database_enabled_actions`, ...). The backend routes anything
- // outside the Action columns to the type-specific update table
- // (query_action / implicit_action), where those
- // columns don't exist and the request 500s. Whitelist only the
- // fields that the API endpoint actually accepts.
body: _.pick(body, [
"id",
"archived",
+ "collection_id",
"database_id",
"dataset_query",
"description",
@@ -73,7 +67,6 @@ export const actionApi = Api.injectEndpoints({
"name",
"parameter_mappings",
"parameters",
- "public_uuid",
"visualization_settings",
]),
}),
@@ -84,6 +77,21 @@ export const actionApi = Api.injectEndpoints({
idTag("action", action.id),
])
: [],
+ onQueryStarted: async (
+ { id, ...patch },
+ { dispatch, queryFulfilled },
+ ) => {
+ const patchResult = dispatch(
+ actionApi.util.updateQueryData("getAction", { id }, (draft) => {
+ Object.assign(draft, patch);
+ }),
+ );
+ try {
+ await queryFulfilled;
+ } catch {
+ patchResult.undo();
+ }
+ },
}),
deleteAction: builder.mutation<WritebackAction, WritebackActionId>({
query: (id) => ({
diff --git a/frontend/src/metabase/api/action.unit.spec.ts b/frontend/src/metabase/api/action.unit.spec.ts
new file mode 100644
index 00000000000..6afb31d0c09
--- /dev/null
+++ b/frontend/src/metabase/api/action.unit.spec.ts
@@ -0,0 +1,66 @@
+import { waitFor } from "@testing-library/react";
+import fetchMock from "fetch-mock";
+
+import { getStore } from "__support__/entities-store";
+import { createMockQueryAction } from "metabase-types/api/mocks";
+
+import { actionApi } from "./action";
+import { Api } from "./api";
+
+const ACTION = createMockQueryAction({ id: 1, name: "Old name" });
+
+let activeStore: ReturnType<typeof getStore> | undefined;
+
+async function setup() {
+ fetchMock.get(`path:/api/action/${ACTION.id}`, ACTION);
+
+ const store = getStore({ [Api.reducerPath]: Api.reducer }, {}, [
+ Api.middleware,
+ ]);
+ activeStore = store;
+
+ const getCachedAction = () =>
+ actionApi.endpoints.getAction.select({ id: ACTION.id })(store.getState())
+ .data;
+
+ store.dispatch(actionApi.endpoints.getAction.initiate({ id: ACTION.id }));
+ await waitFor(() => expect(getCachedAction()).toBeDefined());
+
+ return { store, getCachedAction };
+}
+
+describe("actionApi cache updates", () => {
+ afterEach(() => {
+ activeStore?.dispatch(Api.util.resetApiState());
+ activeStore = undefined;
+ fetchMock.removeRoutes().clearHistory();
+ });
+
+ it("should apply an update to the cached action before the request finishes", async () => {
+ const { store, getCachedAction } = await setup();
+ fetchMock.put(`path:/api/action/${ACTION.id}`, new Promise(() => {}));
+
+ store.dispatch(
+ actionApi.endpoints.updateAction.initiate({
+ id: ACTION.id,
+ name: "New name",
+ }),
+ );
+
+ await waitFor(() => expect(getCachedAction()?.name).toBe("New name"));
+ });
+
+ it("should revert the cached action when the update fails", async () => {
+ const { store, getCachedAction } = await setup();
+ fetchMock.put(`path:/api/action/${ACTION.id}`, 500);
+
+ await store.dispatch(
+ actionApi.endpoints.updateAction.initiate({
+ id: ACTION.id,
+ name: "New name",
+ }),
+ );
+
+ expect(getCachedAction()?.name).toBe("Old name");
+ });
+});
diff --git a/frontend/src/metabase/archive/analytics.ts b/frontend/src/metabase/archive/analytics.ts
index b854cabccff..26002373653 100644
--- a/frontend/src/metabase/archive/analytics.ts
+++ b/frontend/src/metabase/archive/analytics.ts
@@ -13,7 +13,8 @@ type MoveToTrashEventDetail =
| "table"
| "transform"
| "measure"
- | "exploration";
+ | "exploration"
+ | "action";
type MoveToTrashTriggeredFrom =
| "collection"
diff --git a/frontend/src/metabase/collections/components/CollectionBulkActions/use-bulk-bookmark.ts b/frontend/src/metabase/collections/components/CollectionBulkActions/use-bulk-bookmark.ts
index 96ca1631e19..20dcf1f3cf2 100644
--- a/frontend/src/metabase/collections/components/CollectionBulkActions/use-bulk-bookmark.ts
+++ b/frontend/src/metabase/collections/components/CollectionBulkActions/use-bulk-bookmark.ts
@@ -32,10 +32,11 @@ export const useBulkBookmark = (
try {
await Promise.all(
itemsToBookmark.map(async (item) => {
- await createBookmark({
- id: item.id,
- type: getItemBookmarkType(item),
- }).unwrap();
+ const type = getItemBookmarkType(item);
+ if (type == null) {
+ return;
+ }
+ await createBookmark({ id: item.id, type }).unwrap();
trackCollectionItemBookmarked(item);
}),
);
diff --git a/frontend/src/metabase/common/collections/components/ActionMenu/ActionMenu.tsx b/frontend/src/metabase/common/collections/components/ActionMenu/ActionMenu.tsx
index 9d8adc49934..c666e72d00d 100644
--- a/frontend/src/metabase/common/collections/components/ActionMenu/ActionMenu.tsx
+++ b/frontend/src/metabase/common/collections/components/ActionMenu/ActionMenu.tsx
@@ -135,11 +135,15 @@ function ActionMenuInner({
const handler = () => {
const toggleBookmark = isBookmarked ? deleteBookmark : createBookmark;
+ const type = getItemBookmarkType(item);
+ if (type == null) {
+ return;
+ }
if (!isBookmarked) {
trackCollectionItemBookmarked(item);
}
- toggleBookmark?.({ id: item.id, type: getItemBookmarkType(item) });
+ toggleBookmark?.({ id: item.id, type });
};
return handler;
}, [createBookmark, deleteBookmark, isBookmarked, item]);
diff --git a/frontend/src/metabase/common/collections/components/CollectionRowMenu/CollectionRowMenu.tsx b/frontend/src/metabase/common/collections/components/CollectionRowMenu/CollectionRowMenu.tsx
index 8ffc4b42ebf..f2b65dd28fa 100644
--- a/frontend/src/metabase/common/collections/components/CollectionRowMenu/CollectionRowMenu.tsx
+++ b/frontend/src/metabase/common/collections/components/CollectionRowMenu/CollectionRowMenu.tsx
@@ -1,7 +1,9 @@
import { useDisclosure } from "@mantine/hooks";
+import { match } from "ts-pattern";
import { t } from "ttag";
import {
+ actionApi,
collectionApi,
snippetApi,
transformApi,
@@ -71,6 +73,9 @@ export function CollectionRowMenu(props: CollectionRowMenuProps) {
dispatch(snippetApi.util.invalidateTags([listTag("snippet")]));
} else if (collection.namespace === "transforms") {
dispatch(transformApi.util.invalidateTags([listTag("transform")]));
+ } else if (collection.namespace === "data-actions") {
+ dispatch(actionApi.util.invalidateTags([listTag("action")]));
+ dispatch(collectionApi.util.invalidateTags([listTag("collection")]));
} else {
dispatch(collectionApi.util.invalidateTags([listTag("collection")]));
}
@@ -120,10 +125,10 @@ export function CollectionRowMenu(props: CollectionRowMenuProps) {
}
};
- const label =
- collection.namespace === "snippets"
- ? t`Unarchive snippet folder`
- : t`Unarchive collection`;
+ const label = match(collection.namespace)
+ .with("snippets", () => t`Unarchive snippet folder`)
+ .with("data-actions", () => t`Unarchive folder`)
+ .otherwise(() => t`Unarchive collection`);
return (
<Tooltip label={label}>
@@ -141,10 +146,13 @@ export function CollectionRowMenu(props: CollectionRowMenuProps) {
);
}
- const optionsLabel =
- collection.namespace === "snippets"
- ? t`Snippet folder options`
- : t`Collection options`;
+ const optionsLabel = match(collection.namespace)
+ .with("snippets", () => t`Snippet folder options`)
+ .with("data-actions", () => t`Folder options`)
+ .otherwise(() => t`Collection options`);
+ const isFolder =
+ collection.namespace === "snippets" ||
+ collection.namespace === "data-actions";
return (
<Box onClick={(e) => e.stopPropagation()}>
@@ -166,9 +174,7 @@ export function CollectionRowMenu(props: CollectionRowMenuProps) {
leftSection={<Icon name="pencil" />}
onClick={toggleEditModal}
>
- {collection.namespace === "snippets"
- ? t`Edit folder details`
- : t`Edit collection details`}
+ {isFolder ? t`Edit folder details` : t`Edit collection details`}
</Menu.Item>
)}
{showPermissionsOption && (
diff --git a/frontend/src/metabase/common/collections/containers/CreateCollectionModal.tsx b/frontend/src/metabase/common/collections/containers/CreateCollectionModal.tsx
index 509a4f8ac68..b48800d54aa 100644
--- a/frontend/src/metabase/common/collections/containers/CreateCollectionModal.tsx
+++ b/frontend/src/metabase/common/collections/containers/CreateCollectionModal.tsx
@@ -45,18 +45,7 @@ function CreateCollectionModal({
return;
}
- let visitUrl = Urls.collection(collection);
-
- if (
- PLUGIN_LIBRARY.isLibraryCollectionType(collection.type) ||
- collection.namespace === "snippets"
- ) {
- visitUrl = Urls.dataStudioLibrary({
- expandedIds: getCollectionPathAsArray(collection),
- });
- }
-
- navigate(visitUrl);
+ navigate(getCreatedCollectionUrl(collection));
}
},
[createCollection, onCreate, onClose, shouldNavigateOnCreate, navigate],
@@ -82,3 +71,16 @@ function CreateCollectionModal({
// eslint-disable-next-line import/no-default-export -- deprecated usage
export default CreateCollectionModal;
+
+export function getCreatedCollectionUrl(collection: Collection): string {
+ if (
+ PLUGIN_LIBRARY.isLibraryCollectionType(collection.type) ||
+ collection.namespace === "snippets" ||
+ collection.namespace === "data-actions"
+ ) {
+ return Urls.dataStudioLibrary({
+ expandedIds: getCollectionPathAsArray(collection),
+ });
+ }
+ return Urls.collection(collection);
+}
diff --git a/frontend/src/metabase/common/collections/containers/CreateCollectionModal.unit.spec.ts b/frontend/src/metabase/common/collections/containers/CreateCollectionModal.unit.spec.ts
new file mode 100644
index 00000000000..342c73ffbbe
--- /dev/null
+++ b/frontend/src/metabase/common/collections/containers/CreateCollectionModal.unit.spec.ts
@@ -0,0 +1,23 @@
+import { createMockCollection } from "metabase-types/api/mocks";
+
+import { getCreatedCollectionUrl } from "./CreateCollectionModal";
+
+describe("getCreatedCollectionUrl", () => {
+ it("opens a new data actions folder in the Library with its path expanded", () => {
+ const collection = createMockCollection({
+ id: 12,
+ namespace: "data-actions",
+ location: "/10/",
+ });
+
+ expect(getCreatedCollectionUrl(collection)).toBe(
+ "/data-studio/library?expandedId=10&expandedId=12",
+ );
+ });
+
+ it("opens a new regular collection in the main app", () => {
+ const collection = createMockCollection({ id: 12, name: "Sales" });
+
+ expect(getCreatedCollectionUrl(collection)).toBe("/collection/12-sales");
+ });
+});
diff --git a/frontend/src/metabase/common/collections/containers/FormCollectionPicker/FormCollectionPicker.tsx b/frontend/src/metabase/common/collections/containers/FormCollectionPicker/FormCollectionPicker.tsx
index 8560d8629ad..c3ca10cd318 100644
--- a/frontend/src/metabase/common/collections/containers/FormCollectionPicker/FormCollectionPicker.tsx
+++ b/frontend/src/metabase/common/collections/containers/FormCollectionPicker/FormCollectionPicker.tsx
@@ -11,6 +11,7 @@ import {
isValidCollectionId,
} from "metabase/common/collections/utils";
import { CollectionName } from "metabase/common/components/CollectionName";
+import { DataActionCollectionName } from "metabase/common/components/DataActionCollectionName";
import {
CollectionPickerModal,
type EntityPickerModalProps,
@@ -52,6 +53,10 @@ function ItemName({
return <TransformCollectionName id={id} />;
}
+ if (namespace === "data-actions") {
+ return <DataActionCollectionName id={id} />;
+ }
+
// Check for tenant namespace display name via plugin
if (id === null) {
const namespaceDisplayName =
diff --git a/frontend/src/metabase/common/collections/utils.ts b/frontend/src/metabase/common/collections/utils.ts
index 8daced02786..fea2c6d587f 100644
--- a/frontend/src/metabase/common/collections/utils.ts
+++ b/frontend/src/metabase/common/collections/utils.ts
@@ -12,6 +12,7 @@ import { color } from "metabase/ui/colors";
import type { ColorName } from "metabase/ui/colors/types";
import {
type Bookmark,
+ type BookmarkType,
type CardType,
type Collection,
type CollectionContentModel,
@@ -239,10 +240,18 @@ export function isReadOnlyCollection(collection: CollectionItem) {
* product sense, call it "card" because they are treated the same in the
* back-end bookmark API.
*/
-export function getItemBookmarkType(item: CollectionItem) {
- return item.model === "dataset" || item.model === "metric"
- ? "card"
- : item.model;
+export function getItemBookmarkType(
+ item: CollectionItem,
+): BookmarkType | undefined {
+ switch (item.model) {
+ case "dataset":
+ case "metric":
+ return "card";
+ case "action":
+ return undefined;
+ default:
+ return item.model;
+ }
}
export function isItemBookmarked(item: CollectionItem, bookmarks: Bookmark[]) {
@@ -265,6 +274,7 @@ export function canBookmarkItem({ model, type, archived }: CollectionItem) {
switch (model) {
case "table":
+ case "action":
return false;
case "collection":
return !isLibraryCollection({ type });
diff --git a/frontend/src/metabase/common/components/DataActionCollectionName.tsx b/frontend/src/metabase/common/components/DataActionCollectionName.tsx
new file mode 100644
index 00000000000..abcc75b5462
--- /dev/null
+++ b/frontend/src/metabase/common/components/DataActionCollectionName.tsx
@@ -0,0 +1,23 @@
+import { t } from "ttag";
+
+import { useGetCollectionQuery } from "metabase/api";
+import { isRootCollection } from "metabase/common/collections/utils";
+import type { CollectionId } from "metabase-types/api";
+
+export function DataActionCollectionName({ id }: { id: CollectionId }) {
+ if (isRootCollection({ id })) {
+ return <span>{t`Data actions`}</span>;
+ }
+ if (!Number.isSafeInteger(id)) {
+ return null;
+ }
+ return <DataActionCollectionNameLoader id={id} />;
+}
+
+function DataActionCollectionNameLoader({ id }: { id: CollectionId }) {
+ const { data: collection } = useGetCollectionQuery({
+ id,
+ namespace: "data-actions",
+ });
+ return <span>{collection?.name ?? ""}</span>;
+}
diff --git a/frontend/src/metabase/common/components/DataActionCollectionName.unit.spec.tsx b/frontend/src/metabase/common/components/DataActionCollectionName.unit.spec.tsx
new file mode 100644
index 00000000000..92a1f5cf33a
--- /dev/null
+++ b/frontend/src/metabase/common/components/DataActionCollectionName.unit.spec.tsx
@@ -0,0 +1,26 @@
+import { setupCollectionByIdEndpoint } from "__support__/server-mocks";
+import { renderWithProviders, screen } from "__support__/ui";
+import { createMockCollection } from "metabase-types/api/mocks";
+
+import { DataActionCollectionName } from "./DataActionCollectionName";
+
+describe("DataActionCollectionName", () => {
+ it("names the root after data actions", () => {
+ renderWithProviders(<DataActionCollectionName id="root" />);
+
+ expect(screen.getByText("Data actions")).toBeInTheDocument();
+ });
+
+ it("shows the name of a data actions folder", async () => {
+ const folder = createMockCollection({
+ id: 12,
+ name: "Billing",
+ namespace: "data-actions",
+ });
+ setupCollectionByIdEndpoint({ collections: [folder] });
+
+ renderWithProviders(<DataActionCollectionName id={12} />);
+
+ expect(await screen.findByText("Billing")).toBeInTheDocument();
+ });
+});
diff --git a/frontend/src/metabase/common/components/Pickers/EntityPicker/components/NewCollectionDialog/NewCollectionDialog.tsx b/frontend/src/metabase/common/components/Pickers/EntityPicker/components/NewCollectionDialog/NewCollectionDialog.tsx
index 695316e3ea0..387e26edd40 100644
--- a/frontend/src/metabase/common/components/Pickers/EntityPicker/components/NewCollectionDialog/NewCollectionDialog.tsx
+++ b/frontend/src/metabase/common/components/Pickers/EntityPicker/components/NewCollectionDialog/NewCollectionDialog.tsx
@@ -107,7 +107,8 @@ export const NewCollectionDialog = () => {
<>
<Button onClick={open} disabled={!canCreateHere}>
{lastCollection?.namespace === "transforms" ||
- lastCollection?.namespace === "snippets"
+ lastCollection?.namespace === "snippets" ||
+ lastCollection?.namespace === "data-actions"
? t`New folder`
: t`New collection`}
</Button>
diff --git a/frontend/src/metabase/common/components/Pickers/EntityPicker/hooks/use-get-root-items.ts b/frontend/src/metabase/common/components/Pickers/EntityPicker/hooks/use-get-root-items.ts
index bc5e3d07fda..9521e392362 100644
--- a/frontend/src/metabase/common/components/Pickers/EntityPicker/hooks/use-get-root-items.ts
+++ b/frontend/src/metabase/common/components/Pickers/EntityPicker/hooks/use-get-root-items.ts
@@ -224,6 +224,17 @@ async function getRootItems({
});
}
+ if (namespaces.includes("data-actions")) {
+ collectionItems.push({
+ ...(await getRootCollectionItem({
+ namespace: "data-actions",
+ dispatch,
+ })),
+ here: ["collection"],
+ below: validCollectionModels,
+ });
+ }
+
if (namespaces.includes("transforms") && transformsEnabled) {
collectionItems.push({
...(await getRootCollectionItem({
diff --git a/frontend/src/metabase/common/components/Pickers/EntityPicker/hooks/utils.ts b/frontend/src/metabase/common/components/Pickers/EntityPicker/hooks/utils.ts
index 2113742277f..dab1287f27e 100644
--- a/frontend/src/metabase/common/components/Pickers/EntityPicker/hooks/utils.ts
+++ b/frontend/src/metabase/common/components/Pickers/EntityPicker/hooks/utils.ts
@@ -91,6 +91,19 @@ export const getRootCollectionItem = async ({
};
}
+ if (namespace === "data-actions") {
+ return {
+ model: "collection",
+ id: "root",
+ namespace: "data-actions",
+ location: "/",
+ can_write: canWrite,
+ name: t`Data actions`,
+ here: ["collection", "action"],
+ below: ["collection", "action"],
+ };
+ }
+
return {
...getOurAnalytics(),
// if we failed to fetch our analytics, the user doesn't have access to it
diff --git a/frontend/src/metabase/common/hooks/use-set-collection.ts b/frontend/src/metabase/common/hooks/use-set-collection.ts
index e8de15369ce..e7553fe091b 100644
--- a/frontend/src/metabase/common/hooks/use-set-collection.ts
+++ b/frontend/src/metabase/common/hooks/use-set-collection.ts
@@ -4,6 +4,7 @@ import { match } from "ts-pattern";
import { t } from "ttag";
import {
+ actionApi,
cardApi,
collectionApi,
dashboardApi,
@@ -12,6 +13,7 @@ import {
snippetApi,
tableApi,
timelineApi,
+ useUpdateActionMutation,
useUpdateCardMutation,
useUpdateCollectionMutation,
useUpdateDashboardMutation,
@@ -41,6 +43,7 @@ import type {
NativeQuerySnippet,
Table,
Timeline,
+ WritebackAction,
} from "metabase-types/api";
type Movable<
@@ -60,6 +63,7 @@ export type MovableItem =
| Movable<"collection", Collection>
| Movable<"snippet-collection", Collection>
| Movable<"snippet", NativeQuerySnippet>
+ | Movable<"action", WritebackAction>
| Movable<"document", Document>
| Movable<"exploration", Exploration>
| Movable<"table", Table>
@@ -77,13 +81,15 @@ type MovedEntity<T extends MovableItem> = T extends {
? Collection
: T extends { model: "snippet" }
? NativeQuerySnippet
- : T extends { model: "document" }
- ? Document
- : T extends { model: "exploration" }
- ? Exploration
- : T extends { model: "table" }
- ? Table
- : Timeline;
+ : T extends { model: "action" }
+ ? WritebackAction
+ : T extends { model: "document" }
+ ? Document
+ : T extends { model: "exploration" }
+ ? Exploration
+ : T extends { model: "table" }
+ ? Table
+ : Timeline;
const MOVABLE_MODELS = new Set<MovableModel>([
"card",
@@ -93,6 +99,7 @@ const MOVABLE_MODELS = new Set<MovableModel>([
"collection",
"snippet-collection",
"snippet",
+ "action",
"document",
"exploration",
"timeline",
@@ -118,6 +125,7 @@ const LABELS = {
collection: () => t`collection`,
"snippet-collection": () => t`folder`,
snippet: () => t`snippet`,
+ action: () => t`action`,
document: () => t`document`,
exploration: () => t`research`,
table: () => t`table`,
@@ -138,6 +146,7 @@ function isCollectionDestination(
export function useSetCollection() {
const dispatch = useDispatch();
+ const [updateAction] = useUpdateActionMutation();
const [updateCard] = useUpdateCardMutation();
const [updateDashboard] = useUpdateDashboardMutation();
const [updateCollection] = useUpdateCollectionMutation();
@@ -235,6 +244,16 @@ export function useSetCollection() {
archived,
}).unwrap();
})
+ .with({ model: "action" }, ({ id }) => {
+ if (!isCollectionDestination(destination)) {
+ throw new Error("Cannot move an action into a dashboard");
+ }
+ return updateAction({
+ id,
+ collection_id: canonicalCollectionId(destination.id),
+ archived,
+ }).unwrap();
+ })
.with({ model: "table" }, ({ id }) => {
if (!isCollectionDestination(destination)) {
throw new Error("Cannot move a table into a dashboard");
@@ -263,6 +282,7 @@ export function useSetCollection() {
return moved as Promise<MovedEntity<T>>;
},
[
+ updateAction,
updateCard,
updateDashboard,
updateCollection,
@@ -353,6 +373,17 @@ export function useSetCollection() {
archived: snippet.archived,
});
})
+ .with({ model: "action" }, async ({ id }) => {
+ const action = await dispatch(
+ actionApi.endpoints.getAction.initiate({ id }),
+ ).unwrap();
+ return () =>
+ updateAction({
+ id,
+ collection_id: action.collection_id,
+ archived: action.archived,
+ });
+ })
.with({ model: "table" }, async ({ id }) => {
const table = await dispatch(
tableApi.endpoints.getTable.initiate({ id }),
@@ -378,6 +409,7 @@ export function useSetCollection() {
.exhaustive(),
[
dispatch,
+ updateAction,
updateCard,
updateDashboard,
updateCollection,
diff --git a/frontend/src/metabase/common/utils/database.ts b/frontend/src/metabase/common/utils/database.ts
index 916d1a04b68..683db4bd84f 100644
--- a/frontend/src/metabase/common/utils/database.ts
+++ b/frontend/src/metabase/common/utils/database.ts
@@ -34,6 +34,12 @@ export const hasActionsEnabled = (database: Pick<Database, "settings">) => {
return Boolean(database.settings?.["database-enable-actions"]);
};
+export const hasNativeWritePermissions = (
+ database: Pick<Database, "native_permissions">,
+) => {
+ return database.native_permissions === "write";
+};
+
export const hasWritableConnectionDetails = (
database: Pick<Database, "write_data_details">,
) => {
diff --git a/frontend/src/metabase/dashboard/components/ActionViz/ActionVizForm.tsx b/frontend/src/metabase/dashboard/components/ActionViz/ActionVizForm.tsx
index 3a877763cad..4c8d225dd75 100644
--- a/frontend/src/metabase/dashboard/components/ActionViz/ActionVizForm.tsx
+++ b/frontend/src/metabase/dashboard/components/ActionViz/ActionVizForm.tsx
@@ -177,7 +177,7 @@ function ActionVizForm({
>
<ActionCreator
action={action}
- modelId={action.model_id}
+ modelId={action.model_id ?? undefined}
databaseId={action.database_id}
actionId={action.id}
onSubmit={onActionEdit}
diff --git a/frontend/src/metabase/data-studio/common/types.ts b/frontend/src/metabase/data-studio/common/types.ts
index 605db899848..7e3c8d0c371 100644
--- a/frontend/src/metabase/data-studio/common/types.ts
+++ b/frontend/src/metabase/data-studio/common/types.ts
@@ -6,7 +6,12 @@ import type {
Table,
} from "metabase-types/api";
-export type LibrarySectionType = "data" | "metrics" | "dashboards" | "snippets";
+export type LibrarySectionType =
+ | "data"
+ | "metrics"
+ | "dashboards"
+ | "snippets"
+ | "actions";
export type EmptyStateData = {
model: "empty-state";
@@ -27,6 +32,7 @@ export type CollectionItemData = Pick<CollectionItem, "model" | "name"> &
| "collection_position"
| "last-edit-info"
| "namespace"
+ | "can_write"
>
>;
diff --git a/frontend/src/metabase/data-studio/common/utils/create-empty-space-item.ts b/frontend/src/metabase/data-studio/common/utils/create-empty-space-item.ts
index fa30ff7fd54..fbbeea126d6 100644
--- a/frontend/src/metabase/data-studio/common/utils/create-empty-space-item.ts
+++ b/frontend/src/metabase/data-studio/common/utils/create-empty-space-item.ts
@@ -35,6 +35,10 @@ const getEmptyStateConfig = (
description: t`Reusable bits of code that save your time`,
actionLabel: t`New snippet`,
},
+ actions: {
+ description: t`Queries that change data`,
+ actionLabel: t`New action`,
+ },
};
return config[sectionType];
@@ -52,6 +56,8 @@ export const createEmptyStateItem = (
actionUrl = Urls.newDataStudioMetric({ collectionId: collectionId });
} else if (sectionType === "snippets" && !hideAction) {
actionUrl = Urls.newDataStudioSnippet();
+ } else if (sectionType === "actions" && !hideAction) {
+ actionUrl = Urls.newDataStudioAction();
}
// "data" and "dashboards" sections open a modal, so no actionUrl
diff --git a/frontend/src/metabase/new/components/NewModals/NewModals.tsx b/frontend/src/metabase/new/components/NewModals/NewModals.tsx
index 44d022d3691..b267f53db39 100644
--- a/frontend/src/metabase/new/components/NewModals/NewModals.tsx
+++ b/frontend/src/metabase/new/components/NewModals/NewModals.tsx
@@ -36,7 +36,10 @@ export const NewModals = () => {
const handleActionCreated = useCallback(
(action: WritebackAction) => {
- const nextLocation = Urls.modelDetail({ id: action.model_id }, "actions");
+ const nextLocation = Urls.modelDetail(
+ { id: action.model_id ?? undefined },
+ "actions",
+ );
navigate(nextLocation);
},
[navigate],
diff --git a/frontend/src/metabase/querying/components/NativeQueryEditor/NativeQueryEditorActionButtons/NativeQueryEditorActionButtons.tsx b/frontend/src/metabase/querying/components/NativeQueryEditor/NativeQueryEditorActionButtons/NativeQueryEditorActionButtons.tsx
index ab1ca4011df..0be50c250b5 100644
--- a/frontend/src/metabase/querying/components/NativeQueryEditor/NativeQueryEditorActionButtons/NativeQueryEditorActionButtons.tsx
+++ b/frontend/src/metabase/querying/components/NativeQueryEditor/NativeQueryEditorActionButtons/NativeQueryEditorActionButtons.tsx
@@ -69,9 +69,10 @@ export const NativeQueryEditorActionButtons = (
align="center"
>
{promptButton}
- {PreviewQueryButton.shouldRender({ question }) && (
- <PreviewQueryButton {...props} />
- )}
+ {features.previewQuery !== false &&
+ PreviewQueryButton.shouldRender({ question }) && (
+ <PreviewQueryButton {...props} />
+ )}
{features.dataReference && (
<DataReferenceButton
{...props}
diff --git a/frontend/src/metabase/querying/editor/components/QueryEditor/QueryEditor.tsx b/frontend/src/metabase/querying/editor/components/QueryEditor/QueryEditor.tsx
index 05fbed09b25..19b24741c5c 100644
--- a/frontend/src/metabase/querying/editor/components/QueryEditor/QueryEditor.tsx
+++ b/frontend/src/metabase/querying/editor/components/QueryEditor/QueryEditor.tsx
@@ -138,6 +138,8 @@ export function QueryEditor({
onChangeNativeEditorSelection={setSelectionRange}
editorHeight={uiOptions?.editorHeight}
hideRunButton={uiOptions?.hideRunButton}
+ hidePreview={uiOptions?.hidePreview}
+ hidePreviewQueryButton={uiOptions?.hidePreviewQueryButton}
onBlur={onBlur}
topBarInnerContent={topBarInnerContent}
extraButton={extraEditorButton}
diff --git a/frontend/src/metabase/querying/editor/components/QueryEditor/QueryEditorBody/QueryEditorBody.module.css b/frontend/src/metabase/querying/editor/components/QueryEditor/QueryEditorBody/QueryEditorBody.module.css
index d5299bbe148..2cc23c79e28 100644
--- a/frontend/src/metabase/querying/editor/components/QueryEditor/QueryEditorBody/QueryEditorBody.module.css
+++ b/frontend/src/metabase/querying/editor/components/QueryEditor/QueryEditorBody/QueryEditorBody.module.css
@@ -9,7 +9,7 @@
max-height: 100%;
overflow: hidden;
- &.readOnly {
+ &.fullHeight {
border-bottom: none;
height: 100%;
}
diff --git a/frontend/src/metabase/querying/editor/components/QueryEditor/QueryEditorBody/QueryEditorBody.tsx b/frontend/src/metabase/querying/editor/components/QueryEditor/QueryEditorBody/QueryEditorBody.tsx
index b5084786ef4..121aebfc91a 100644
--- a/frontend/src/metabase/querying/editor/components/QueryEditor/QueryEditorBody/QueryEditorBody.tsx
+++ b/frontend/src/metabase/querying/editor/components/QueryEditor/QueryEditorBody/QueryEditorBody.tsx
@@ -74,6 +74,8 @@ type QueryEditorBodyProps = {
onOpenModal: (type: QueryModalType) => void;
editorHeight?: number;
hideRunButton?: boolean;
+ hidePreview?: boolean;
+ hidePreviewQueryButton?: boolean;
topBarInnerContent?: ReactNode;
availableHeight?: number;
};
@@ -111,6 +113,8 @@ export function QueryEditorBody({
onOpenModal,
editorHeight: editorHeightOverride,
hideRunButton,
+ hidePreview,
+ hidePreviewQueryButton,
topBarInnerContent,
availableHeight,
}: QueryEditorBodyProps) {
@@ -167,7 +171,7 @@ export function QueryEditorBody({
return (
<NativeQueryEditor
className={cx(S.nativeQueryEditor, {
- [S.readOnly]: readOnly,
+ [S.fullHeight]: readOnly || hidePreview,
})}
availableHeight={availableHeight}
question={question}
@@ -203,7 +207,10 @@ export function QueryEditorBody({
<NativeQueryEditor.TopBar leftContent={parametersList}>
{topBarInnerContent}
<NativeQueryEditor.Sidebar
- features={NATIVE_EDITOR_SIDEBAR_FEATURES}
+ features={{
+ ...NATIVE_EDITOR_SIDEBAR_FEATURES,
+ previewQuery: !hidePreviewQueryButton,
+ }}
/>
<NativeQueryEditor.VisibilityToggler />
</NativeQueryEditor.TopBar>
diff --git a/frontend/src/metabase/querying/editor/types.ts b/frontend/src/metabase/querying/editor/types.ts
index 30ae24e3fd4..8eaa052da32 100644
--- a/frontend/src/metabase/querying/editor/types.ts
+++ b/frontend/src/metabase/querying/editor/types.ts
@@ -29,6 +29,7 @@ export type SidebarFeatures = {
variables?: boolean;
snippets?: boolean;
formatQuery?: boolean;
+ previewQuery?: boolean;
};
export type QueryEditorSidebarType =
@@ -80,6 +81,7 @@ export type QueryEditorUiOptions = {
shouldShowLibrary?: false;
hidePreview?: boolean;
hideRunButton?: boolean;
+ hidePreviewQueryButton?: boolean;
resizable?: boolean;
};
diff --git a/frontend/src/metabase/urls/data-studio.ts b/frontend/src/metabase/urls/data-studio.ts
index 280ba7cbf72..95104cca7dd 100644
--- a/frontend/src/metabase/urls/data-studio.ts
+++ b/frontend/src/metabase/urls/data-studio.ts
@@ -9,6 +9,7 @@ import type {
SchemaName,
SegmentId,
TableId,
+ WritebackActionId,
} from "metabase-types/api";
const ROOT_URL = "/data-studio";
@@ -345,6 +346,40 @@ export function dataStudioArchivedSnippets() {
return `${dataStudioLibrary()}/snippets/archived`;
}
+export function dataStudioAction(actionId: WritebackActionId) {
+ return `${dataStudioLibrary()}/actions/${actionId}`;
+}
+
+export function dataStudioActionEdit(actionId: WritebackActionId) {
+ return `${dataStudioAction(actionId)}/edit`;
+}
+
+export function dataStudioActionFields(
+ actionId: WritebackActionId,
+ fieldId?: string,
+) {
+ const fieldsUrl = `${dataStudioAction(actionId)}/fields`;
+ return fieldId != null
+ ? `${fieldsUrl}/${encodeURIComponent(fieldId)}`
+ : fieldsUrl;
+}
+
+export function dataStudioActionRun(actionId: WritebackActionId) {
+ return `${dataStudioAction(actionId)}/run`;
+}
+
+export function dataStudioActionSettings(actionId: WritebackActionId) {
+ return `${dataStudioAction(actionId)}/settings`;
+}
+
+export function newDataStudioAction() {
+ return `${dataStudioLibrary()}/actions/new`;
+}
+
+export function dataStudioArchivedActions() {
+ return `${dataStudioLibrary()}/actions/archived`;
+}
+
export function dataStudioSettings() {
return `${dataStudio()}/settings`;
}
diff --git a/src/metabase/actions/core.clj b/src/metabase/actions/core.clj
index 1bf6cf053e1..9af2c735fdc 100644
--- a/src/metabase/actions/core.clj
+++ b/src/metabase/actions/core.clj
@@ -60,7 +60,6 @@
select-action
select-actions
select-actions-for-ids
- select-actions-for-models
update!]
[metabase.actions.events
publish-action-success!]
diff --git a/src/metabase/actions/db.clj b/src/metabase/actions/db.clj
index 58273033f19..f1d7141e656 100644
--- a/src/metabase/actions/db.clj
+++ b/src/metabase/actions/db.clj
@@ -7,7 +7,6 @@
[metabase.queries.card-schema :as queries.card-schema]
[metabase.queries.schema :as queries.schema]
[metabase.util.malli :as mu]
- [metabase.util.malli.schema :as ms]
[metabase.warehouse-schema-overlay.core :as warehouse-schema-overlay]
[toucan2.core :as t2]))
@@ -66,6 +65,16 @@
[collection-id :- ::lib.schema.id/collection]
(t2/exists? :model/Collection :id collection-id))
+(mu/defn collection-namespace
+ "The namespace of the Collection with `collection-id`, or nil."
+ [collection-id :- ::lib.schema.id/collection]
+ (t2/select-one-fn :namespace [:model/Collection :namespace] :id collection-id))
+
+(mu/defn collection-namespace-with-entity-id
+ "The namespace of the Collection with `entity-id`, or nil."
+ [entity-id :- :string]
+ (t2/select-one-fn :namespace [:model/Collection :namespace] :entity_id entity-id))
+
(mu/defn unarchived-collection-exists?
"Whether the unarchived Collection with `collection-id` exists."
[collection-id :- ::lib.schema.id/collection]
@@ -195,11 +204,6 @@
[entity-id :- :string]
(t2/select :model/Action :entity_id entity-id))
-(mu/defn unarchived-actions-for-models
- "The unarchived Actions whose `:model_id` is in `model-ids`."
- [model-ids :- [:sequential ms/PositiveInt]]
- (t2/select :model/Action :model_id [:in model-ids] :archived false))
-
(mu/defn fields-for-parameters
"The id, base type, display name, and description of the Fields with `field-ids`."
[field-ids :- [:set ::lib.schema.id/field]]
diff --git a/src/metabase/actions/models.clj b/src/metabase/actions/models.clj
index f9ba37513d4..c6d58be1995 100644
--- a/src/metabase/actions/models.clj
+++ b/src/metabase/actions/models.clj
@@ -16,6 +16,7 @@
[metabase.public-sharing.core :as public-sharing]
[metabase.queries.models.query :as query]
[metabase.queries.schema :as queries.schema]
+ [metabase.remote-sync.core :as remote-sync]
[metabase.search.core :as search]
[metabase.util :as u]
[metabase.util.i18n :refer [tru]]
@@ -104,16 +105,37 @@
(throw (ex-info (tru "Implicit actions are not supported for models with clauses.")
{:status-code 400}))))
-;; A data app's resource collection holds the copies of the actions the app runs.
+;; A data app's resource collection holds the copies of the actions the app runs, and actions without a model live in
+;; the data actions namespace.
(defmethod collection/allowed-namespaces :model/Action
[_]
- (conj collection/default-allowed-namespaces collection/data-apps-ns))
+ (conj collection/default-allowed-namespaces collection/data-apps-ns collection/data-actions-ns))
-(defn- check-collection-content
- "Throws unless an Action may go in the Collection with `collection-id`."
+(def ^:private model-less-namespaces
+ "The Collection namespaces an Action without a model may go in, besides the data actions root."
+ #{collection/data-actions-ns collection/data-apps-ns})
+
+(defn- collection-namespace
+ "The namespace of the Collection with `collection-id` as a keyword, or nil."
[collection-id]
+ (some-> collection-id actions.db/collection-namespace keyword))
+
+(defn- check-model-less-collection
+ "Throws a 400 unless an Action without a model is in the data actions root or a data actions or data app Collection."
+ [{model-id :model_id, collection-id :collection_id}]
+ (when (and (nil? model-id)
+ collection-id
+ (not (contains? model-less-namespaces (collection-namespace collection-id))))
+ (let [msg (tru "An action without a model can only go in a data actions or data app collection.")]
+ (throw (ex-info msg {:status-code 400
+ :errors {:collection_id msg}})))))
+
+(defn- check-collection-content
+ "Throws unless `action` may go in its Collection."
+ [{collection-id :collection_id, :as action}]
(collection/check-collection-namespace :model/Action collection-id)
- (collection/check-allowed-content :action collection-id))
+ (collection/check-allowed-content :action collection-id)
+ (check-model-less-collection action))
(defn- set-model-collection
"`action` with the `:collection_id` of its model Card."
@@ -126,7 +148,7 @@
model-id set-model-collection)
(when (implicit? action)
(check-implicit-action-model model-id))
- (check-collection-content (:collection_id <>))))
+ (check-collection-content <>)))
(t2/define-before-update :model/Action
[{model-id :model_id, :as action}]
@@ -137,8 +159,8 @@
(when (and (implicit? action) (or (changed? :type) (changed? :model_id)))
(check-implicit-action-model model-id)
(check-implicit-actions-supported action))
- (when (contains? (t2/changes <>) :collection_id)
- (check-collection-content (:collection_id <>))))))
+ (when (some #(contains? (t2/changes <>) %) [:collection_id :model_id])
+ (check-collection-content <>)))))
(defn- set-query-database
"`query-action` with the `:database_id` of its query, when it has one."
@@ -187,12 +209,29 @@
(when collection-id
(api/check-404 (actions.db/collection-exists? collection-id))))))
+(defmethod mi/perms-objects-set :model/Action
+ [{model-id :model_id, collection-id :collection_id, :as action} read-or-write]
+ (cond
+ model-id
+ ((get-method mi/perms-objects-set :perms/use-parent-collection-perms) action read-or-write)
+
+ (and (= read-or-write :write)
+ (not (remote-sync/model-editable? :model/Action (assoc action :model_id nil))))
+ #{"___no-remote-sync-access"}
+
+ (nil? collection-id)
+ (perms/perms-objects-set-for-parent-collection collection/data-actions-ns nil read-or-write)
+
+ :else
+ ((get-method mi/perms-objects-set :perms/use-parent-collection-perms) action read-or-write)))
+
(defn- collection-writable?
"Whether the current user can write the Collection `action` goes in."
- [action]
- ((get-method mi/can-create? :perms/use-parent-collection-perms)
- :model/Action
- (assoc action :collection_id (effective-collection-id action))))
+ [{model-id :model_id, :as action}]
+ (let [action (assoc action :collection_id (effective-collection-id action))]
+ (if model-id
+ ((get-method mi/can-create? :perms/use-parent-collection-perms) :model/Action action)
+ (mi/current-user-has-full-permissions? ((get-method mi/perms-objects-set :model/Action) action :write)))))
(defmethod mi/can-create? :model/Action
[_model action]
@@ -493,15 +532,6 @@
action-ids :- [:sequential ::lib.schema.id/action]]
(enrich-actions-with-implicit-params known-models (normalize-actions-by-type (actions.db/actions-with-ids action-ids))))
-(mu/defn select-actions-for-models :- [:maybe [:sequential ::actions.schema/action]]
- "Find the unarchived Actions whose `:model_id` is in `model-ids`, filling in implicit parameters as
- [[select-actions]] does.
-
- Pass in known-models to save a second Card lookup."
- [known-models :- [:maybe [:sequential ::queries.schema/card]]
- model-ids :- [:sequential ms/PositiveInt]]
- (enrich-actions-with-implicit-params known-models (normalize-actions-by-type (actions.db/unarchived-actions-for-models model-ids))))
-
(mu/defn select-action :- [:maybe ::actions.schema/action]
"Selects an Action and fills in the subtype data and implicit parameters.
`options` is interpreted by [[select-actions-matching-options]]."
@@ -581,6 +611,14 @@
:import serdes/import-visualization-settings}}
:defaults {:archived false, :archived_directly false}})
+(defmethod serdes/storage-path "Action" [{:keys [model_id collection_id] :as action} ctx]
+ (if (and (nil? model_id)
+ (or (nil? collection_id)
+ (= collection/data-actions-ns
+ (some-> (actions.db/collection-namespace-with-entity-id collection_id) keyword))))
+ (serdes/storage-default-collection-path action ctx (name collection/data-actions-ns))
+ (serdes/storage-default-collection-path action ctx)))
+
(defmethod serdes/load-one! "Action" [ingested maybe-local]
(when-not (= "http" (some-> (:type ingested) name))
(serdes/default-load-one! ingested maybe-local)))
diff --git a/src/metabase/actions/schema.clj b/src/metabase/actions/schema.clj
index fdeaaf86950..205e6e330cf 100644
--- a/src/metabase/actions/schema.clj
+++ b/src/metabase/actions/schema.clj
@@ -125,7 +125,8 @@
(mr/def ::action.parameters
[:sequential [:ref ::action.parameter]])
-(mu/defn- action-schema [schema-type :- [:enum :select :update :insert]]
+(mu/defn- action-schema [schema-type :- [:enum :select :update :insert]
+ request? :- :boolean]
;; `required-for-insert` = you have to specify this when you insert a row
;;
;; `not-null-in-app-db` = this is `NOT NULL` in the app DB, and will always come back when you `SELECT` something,
@@ -138,7 +139,8 @@
cat
[(case schema-type
:select [[:id ::id]
- [:creator {:optional true} [:maybe ::users.schema/user]]]
+ [:creator {:optional true} [:maybe ::users.schema/user]]
+ [:can_write {:optional true} :boolean]]
:update [[:id {:optional true} ::id]]
:insert nil)
[[:name required-for-insert :string]
@@ -152,14 +154,15 @@
[:database_id {:optional true} [:maybe ::lib.schema.id/database]]
[:parameter_mappings {:optional true} [:maybe ::parameters.schema/parameter-mappings]]
[:visualization_settings {:optional true} [:maybe ms/VisualizationSettings]]]
- [[:created_at {:optional true} (ms/InstanceOfClass java.time.temporal.Temporal)]
- [:updated_at {:optional true} (ms/InstanceOfClass java.time.temporal.Temporal)]
- [:public_uuid {:optional true} [:maybe ms/UUIDString]]
- [:public_uuid_prefix {:optional true} [:maybe :string]]
- [:made_public_by_id {:optional true} [:maybe ::lib.schema.id/user]]
- [:creator_id {:optional true} [:maybe ::lib.schema.id/user]]
- [:entity_id {:optional true} [:maybe :string]]
- [:legacy_query {:optional true} [:maybe :string]]]])]
+ (when-not request?
+ [[:created_at {:optional true} (ms/InstanceOfClass java.time.temporal.Temporal)]
+ [:updated_at {:optional true} (ms/InstanceOfClass java.time.temporal.Temporal)]
+ [:public_uuid {:optional true} [:maybe ms/UUIDString]]
+ [:public_uuid_prefix {:optional true} [:maybe :string]]
+ [:made_public_by_id {:optional true} [:maybe ::lib.schema.id/user]]
+ [:creator_id {:optional true} [:maybe ::lib.schema.id/user]]
+ [:entity_id {:optional true} [:maybe :string]]
+ [:legacy_query {:optional true} [:maybe :string]]])])]
[:merge
(into [:map {:closed true}] common)
[:multi {:decode/normalize lib.schema.common/normalize-map-no-kebab-case
@@ -171,15 +174,23 @@
(mr/def ::action
"An Action as it should appear when we `SELECT` it from the app DB."
- (action-schema :select))
+ (action-schema :select false))
(mr/def ::action.for-insert
- "Schema for inserting a new Action (REST API or internally)."
- (action-schema :insert))
+ "Schema for inserting a new Action internally."
+ (action-schema :insert false))
(mr/def ::action.for-update
- "Schema for updating an Action (REST API or internally)."
- (action-schema :update))
+ "Schema for updating an Action internally."
+ (action-schema :update false))
+
+(mr/def ::action.create-request
+ "Schema for the REST API body that creates an Action, without the columns the server populates."
+ (action-schema :insert true))
+
+(mr/def ::action.update-request
+ "Schema for the REST API body that updates an Action, without the columns the server populates."
+ (action-schema :update true))
(mr/def ::implicit-action.row
"A ImplicitAction as selected from the app DB: every column of `:implicit_action`."
diff --git a/src/metabase/actions_rest/api.clj b/src/metabase/actions_rest/api.clj
index 1aeb0454706..44527df0c60 100644
--- a/src/metabase/actions_rest/api.clj
+++ b/src/metabase/actions_rest/api.clj
@@ -11,6 +11,7 @@
[metabase.eid-translation.core :as eid-translation]
[metabase.events.core :as events]
[metabase.lib.schema.id :as lib.schema.id]
+ [metabase.models.interface :as mi]
[metabase.permissions.core :as perms]
[metabase.public-sharing.validation :as public-sharing.validation]
[metabase.util :as u]
@@ -21,18 +22,23 @@
(set! *warn-on-reflection* true)
(api.macros/defendpoint :get "/" :- [:sequential ::actions.schema/action]
- "Returns the unarchived actions in collections the current user can read. Pass optional `?model-id=<model-id>` to
- limit to the actions of a particular model."
+ "Returns the actions the current user can read, unarchived unless `?archived=true`. Pass optional
+ `?model-id=<model-id>` to limit to the actions of a particular model, and optional `?type=<type>` to limit to actions
+ of that type."
{:scope api-scope/data-app}
[_route-params
- {:keys [model-id]} :- [:map {:closed true}
- [:model-id {:optional true} [:maybe ::lib.schema.id/card]]]]
- (let [actions (if model-id
- (let [model (api/read-check :model/Card model-id)]
- (actions/select-actions-for-models [model] [model-id]))
- (when-let [action-ids (seq (actions-rest.db/unarchived-action-ids-visible-to-user))]
- (actions/select-actions-for-ids nil (vec action-ids))))]
- (t2/hydrate (vec actions) :creator)))
+ {:keys [model-id archived]
+ action-type :type} :- [:map {:closed true}
+ [:model-id {:optional true} [:maybe ::lib.schema.id/card]]
+ [:type {:optional true} [:maybe ::actions.schema/type]]
+ [:archived {:default false} :boolean]]]
+ (let [model (when model-id
+ (api/read-check :model/Card model-id))
+ action-ids (actions-rest.db/action-ids-visible-to-user
+ {:type action-type, :model-id model-id, :archived archived})
+ actions (when (seq action-ids)
+ (actions/select-actions-for-ids (when model [model]) action-ids))]
+ (t2/hydrate (filterv mi/can-read? actions) :creator :can_write)))
(api.macros/defendpoint :get "/public" :- [:sequential ::actions.schema/action]
"Fetch a list of Actions with public UUIDs. These actions are publicly-accessible *if* public sharing is enabled."
@@ -47,7 +53,7 @@
[{:keys [action-id]} :- [:map {:closed true}
[:action-id ms/PositiveInt]]]
(-> (actions/select-action :id action-id :archived false)
- (t2/hydrate :creator)
+ (t2/hydrate :creator :can_write)
api/read-check))
;; TODO (Cam 2025-11-25) please add a response schema to this API endpoint, it makes it easier for our customers to
@@ -73,7 +79,7 @@
_query-params
{:keys [parameters database_id]
action-type :type
- :as action} :- ::actions.schema/action.for-insert]
+ :as action} :- ::actions.schema/action.create-request]
(when (and (nil? database_id)
(= action-type :query))
(throw (ex-info (tru "Must provide a database_id for query actions")
@@ -100,11 +106,12 @@
[{:keys [id]} :- [:map {:closed true}
[:id ::actions.schema/id]]
_query-params
- action :- ::actions.schema/action.for-update]
+ action :- ::actions.schema/action.update-request]
(let [existing-action (api/write-check :model/Action id)
action (api/updates-with-archived-directly existing-action action)]
(api/update-check existing-action action)
- (actions/check-action-databases-enabled (merge (actions/select-action :id id) action))
+ (when (some #(contains? action %) [:dataset_query :database_id :type :kind :model_id])
+ (actions/check-action-databases-enabled (merge (actions/select-action :id id) action)))
(actions/update! (assoc action :id id) existing-action))
(let [{:keys [parameters type] :as action} (actions/select-action :id id)]
(events/publish-event! :event/action-update {:object action :user-id api/*current-user-id*})
@@ -152,7 +159,6 @@
(perms/check-has-application-permission :setting)
(public-sharing.validation/check-public-sharing-enabled)
(api/check-exists? :model/Action :id id, :public_uuid [:not= nil], :archived false)
- (actions/check-actions-enabled id)
(actions-rest.db/set-action-public-uuid! id nil nil)
{:status 204, :body nil})
diff --git a/src/metabase/actions_rest/db.clj b/src/metabase/actions_rest/db.clj
index 6afda99af11..8511d3d61d6 100644
--- a/src/metabase/actions_rest/db.clj
+++ b/src/metabase/actions_rest/db.clj
@@ -2,17 +2,30 @@
"Application database queries for the actions REST module. Every function here is a direct Toucan 2 call with no
additional logic, so the rest of the module only touches `toucan2.core` for hydration."
(:require
+ [metabase.actions.schema :as actions.schema]
[metabase.collections.models.collection :as collection]
[metabase.lib.schema.id :as lib.schema.id]
[metabase.util.malli :as mu]
[toucan2.core :as t2]))
-(mu/defn unarchived-action-ids-visible-to-user
- "The ids of the unarchived Actions in Collections the current user can read."
- []
+(mu/defn action-ids-visible-to-user
+ "The ids of the Actions that are `:archived` or not, of the model `:model-id`, or else in Collections the current
+ user can read or in the data actions root without a model, limited to actions of `:type` if given."
+ [{action-type :type, model-id :model-id, :keys [archived]} :- [:map {:closed true}
+ [:type {:optional true} [:maybe ::actions.schema/type]]
+ [:model-id {:optional true} [:maybe ::lib.schema.id/card]]
+ [:archived :boolean]]]
(t2/select-pks-vec :model/Action {:where [:and
- [:= :archived false]
- (collection/visible-collection-filter-clause)]}))
+ [:= :archived archived]
+ (when action-type
+ [:= :type (name action-type)])
+ (if model-id
+ [:= :model_id model-id]
+ [:or
+ (collection/visible-collection-filter-clause
+ :collection_id
+ {:include-archived-items (if archived :all :exclude)})
+ [:and [:= :model_id nil] [:= :collection_id nil]]])]}))
(mu/defn public-actions
"The name, id, public uuid, and model id of the unarchived Actions that are publicly shared."
diff --git a/src/metabase/collections/children.clj b/src/metabase/collections/children.clj
index 50339f5fca8..71437ec01a2 100644
--- a/src/metabase/collections/children.clj
+++ b/src/metabase/collections/children.clj
@@ -818,6 +818,12 @@
(map :collection_id)
(into #{}))
+ collections-containing-actions
+ (->> (when (seq descendant-collection-ids)
+ (collections.db/unarchived-action-collection-ids-in descendant-collection-ids))
+ (map :collection_id)
+ (into #{}))
+
;; the set of collections that contain collections (in terms of *effective* location)
collections-containing-collections
(->> (t2/hydrate descendant-collections :effective_parent :is_remote_synced)
@@ -831,7 +837,8 @@
{:table collections-containing-tables
:collection collections-containing-collections
:dashboard collections-containing-dashboards
- :transform collections-containing-transforms})
+ :transform collections-containing-transforms
+ :action collections-containing-actions})
;; why are we calling `annotate-collections` on all descendants, when we only need the collections in `colls`
;; to be annotated? Because `annotate-collections` works by looping through the collections it's passed and
diff --git a/src/metabase/collections/core.clj b/src/metabase/collections/core.clj
index fdce5467241..9c0a8d199e5 100644
--- a/src/metabase/collections/core.clj
+++ b/src/metabase/collections/core.clj
@@ -46,6 +46,7 @@
shared-tenant-collection?
transforms-ns
data-apps-ns
+ data-actions-ns
default-allowed-namespaces]
[metabase.collections.util
annotate-dashboards])
diff --git a/src/metabase/collections/db.clj b/src/metabase/collections/db.clj
index 2d1e7ee1021..a55625783d4 100644
--- a/src/metabase/collections/db.clj
+++ b/src/metabase/collections/db.clj
@@ -612,6 +612,15 @@
[:in :collection_id collection-ids]
[:in :source_type source-types]]}))
+(defn unarchived-action-collection-ids-in
+ "The distinct `:collection_id`s of the unarchived Actions in the Collections with `collection-ids`."
+ [collection-ids]
+ (t2/query {:select-distinct [:collection_id]
+ :from :action
+ :where [:and
+ [:= :archived false]
+ [:in :collection_id collection-ids]]}))
+
(defn unarchived-dashboard-collection-ids-in
"The distinct `:collection_id`s of the unarchived Dashboards in the Collections with `collection-ids`."
[collection-ids]
diff --git a/src/metabase/collections/models/collection.clj b/src/metabase/collections/models/collection.clj
index 0a5e1563008..0751d84c736 100644
--- a/src/metabase/collections/models/collection.clj
+++ b/src/metabase/collections/models/collection.clj
@@ -103,6 +103,10 @@
"Namespace for the resource collections of data apps"
:data-apps)
+(def data-actions-ns
+ "Namespace for the collections of actions without a model"
+ :data-actions)
+
(defn- trash-collection* []
(collections.db/collection-of-type trash-collection-type))
@@ -1375,6 +1379,9 @@
(collections.db/instances-with-columns [model-key :id :namespace :is_remote_synced] ids)
:model/Table
(collections.db/instances-with-columns [model-key :id :collection_id :is_published] ids)
+ ;; Actions without a model are synced with the Library rather than their collection
+ :model/Action
+ (collections.db/instances-with-columns [model-key :id :collection_id :model_id] ids)
;; DashboardCard and DashboardCardSeries are nested under Dashboard - skip separate eligibility check
(:model/DashboardCard :model/DashboardCardSeries)
nil
@@ -2218,9 +2225,10 @@
(defmethod serdes/storage-path "Collection" [coll {:keys [collections]}]
(let [path (get collections (:entity_id coll))
ns-folder (case (:namespace coll)
- :snippets "snippets"
- :transforms "transforms"
- nil "main"
+ :snippets "snippets"
+ :transforms "transforms"
+ :data-actions "data-actions"
+ nil "main"
"main")]
(into [{:label "collections"} {:label ns-folder}] path)))
diff --git a/src/metabase/collections/models/collection/root.clj b/src/metabase/collections/models/collection/root.clj
index 510c86c3414..4966b3d1731 100644
--- a/src/metabase/collections/models/collection/root.clj
+++ b/src/metabase/collections/models/collection/root.clj
@@ -58,6 +58,7 @@
:shared-tenant-collections (tru "Shared collections")
:snippets (tru "SQL snippets")
:transforms (tru "Transforms")
+ :data-actions (tru "Data actions")
(tru "Our analytics"))
:namespace collection-namespace
:is_personal false
diff --git a/src/metabase/collections/schema.clj b/src/metabase/collections/schema.clj
index 7b0c6b43e51..f156d7224ce 100644
--- a/src/metabase/collections/schema.clj
+++ b/src/metabase/collections/schema.clj
@@ -32,7 +32,8 @@
"indexed-entity"
"document"
"exploration"
- "table"])
+ "table"
+ "action"])
(mr/def ::Collection
[:map
diff --git a/src/metabase/collections_rest/api.clj b/src/metabase/collections_rest/api.clj
index 4d2d4a482c4..8ed0f8a594e 100644
--- a/src/metabase/collections_rest/api.clj
+++ b/src/metabase/collections_rest/api.clj
@@ -175,6 +175,9 @@
:metric #{}
:card #{}}
(collections-rest.db/unarchived-card-collection-types-reducible))
+ {:action (->> (collections-rest.db/unarchived-action-collection-ids)
+ (map :collection_id)
+ (into #{}))}
;; Tables in collections are an EE feature (library)
(when (premium-features/has-feature? :library)
{:table (->> (collections-rest.db/published-table-collection-ids)
diff --git a/src/metabase/collections_rest/db.clj b/src/metabase/collections_rest/db.clj
index 080ac511427..c8bca4c826d 100644
--- a/src/metabase/collections_rest/db.clj
+++ b/src/metabase/collections_rest/db.clj
@@ -29,6 +29,15 @@
:from [:report_card]
:where [:= :archived false]}))
+(mu/defn unarchived-action-collection-ids
+ "The distinct `:collection_id`s of the unarchived Actions."
+ []
+ (t2/query {:select-distinct [:collection_id]
+ :from [:action]
+ :where [:and
+ [:= :archived false]
+ [:not= :collection_id nil]]}))
+
(mu/defn published-table-collection-ids
"The distinct `:collection_id`s of the published, unarchived Tables."
[]
diff --git a/test/metabase/actions/models_test.clj b/test/metabase/actions/models_test.clj
index 43ca9d6474c..f66c2029bfc 100644
--- a/test/metabase/actions/models_test.clj
+++ b/test/metabase/actions/models_test.clj
@@ -230,7 +230,7 @@
(deftest query-action-without-model-test
(mt/test-drivers (mt/normal-drivers-with-feature :actions/custom)
(testing "a query action can be inserted and updated without a model, and keeps its own collection"
- (mt/with-temp [:model/Collection {coll-id :id} {}]
+ (mt/with-temp [:model/Collection {coll-id :id} {:namespace "data-actions"}]
(mt/with-model-cleanup [:model/Action]
(let [action-id (action/insert! (lib/normalize ::actions.schema/action.for-insert
{:type :query
@@ -447,3 +447,14 @@
:serdes/meta [{:model "Action" :id entity-id}]}
nil)
(is (not (t2/exists? :model/Action :entity_id entity-id))))))
+
+(deftest storage-path-test
+ (testing "actions without a model in the data actions root or namespace are stored in the data-actions folder"
+ (mt/with-temp [:model/Collection {folder-eid :entity_id} {:namespace "data-actions"}
+ :model/Collection {app-eid :entity_id} {:namespace "data-apps"}]
+ (let [folder-label (fn [action]
+ (:label (second (serdes/storage-path (assoc action :serdes/meta [{:model "Action"}]) {}))))]
+ (is (= "data-actions" (folder-label {:name "At root" :entity_id "x" :model_id nil :collection_id nil})))
+ (is (= "data-actions" (folder-label {:name "In folder" :entity_id "x" :model_id nil :collection_id folder-eid})))
+ (is (= "main" (folder-label {:name "App copy" :entity_id "x" :model_id nil :collection_id app-eid})))
+ (is (= "main" (folder-label {:name "On a model" :entity_id "x" :model_id "model-eid" :collection_id nil})))))))
diff --git a/test/metabase/actions_rest/api_test.clj b/test/metabase/actions_rest/api_test.clj
index d17034e9d62..96ed6f5251a 100644
--- a/test/metabase/actions_rest/api_test.clj
+++ b/test/metabase/actions_rest/api_test.clj
@@ -487,17 +487,24 @@
:parameters [{:id "id" :slug "id" :type "number" :target [:variable [:template-tag "id"]]}
{:id "name" :slug "name" :type "text" :target [:variable [:template-tag "name"]]}]})
+(defn- data-actions-root
+ "The data actions root Collection, for granting permissions on it."
+ []
+ (assoc collection/root-collection :namespace (name collection/data-actions-ns)))
+
(deftest action-without-model-test
- (testing "a query action without a model can be created, moved between collections, and executed"
+ (testing "a query action without a model can be created, moved between data actions collections, and executed"
(mt/with-actions-test-data-and-actions-enabled
(mt/with-model-cleanup [:model/Action]
- (mt/with-temp [:model/Collection {coll-id :id} {}
- :model/Collection {other-id :id} {}]
+ (mt/with-temp [:model/Collection {coll-id :id} {:namespace "data-actions"}
+ :model/Collection {other-id :id} {:namespace "data-actions"}]
(let [created (mt/user-http-request :crowberto :post 200 "action" (model-less-query-action coll-id))
path (str "action/" (:id created))]
(is (=? {:model_id nil :collection_id coll-id :database_id (mt/id)} created))
(is (=? {:name "Renamed" :model_id nil :collection_id other-id}
(mt/user-http-request :crowberto :put 200 path {:name "Renamed" :collection_id other-id})))
+ (is (=? {:name "Renamed" :model_id nil :collection_id nil}
+ (mt/user-http-request :crowberto :put 200 path {:collection_id nil})))
(is (=? {:rows-affected 1}
(mt/user-http-request :crowberto :post 200 (str path "/execute")
{:parameters {:id 1 :name "Renamed Category"}})))
@@ -507,33 +514,113 @@
ffirst)))))))))
(deftest action-without-model-collection-perms-test
- (testing "creating or moving an action without a model requires write permission on its collection"
+ (testing "creating or moving an action without a model requires write permission on its data actions collection"
(mt/with-actions-test-data-and-actions-enabled
- (mt/with-non-admin-groups-no-root-collection-perms
+ (perms.test-util/with-restored-perms!
(mt/with-model-cleanup [:model/Action]
- (mt/with-temp [:model/Collection {locked-id :id} {}]
- (let [personal-id (:id (collection/user->personal-collection (mt/user->id :rasta)))]
+ (mt/with-temp [:model/Collection {locked-id :id} {:namespace "data-actions"}
+ :model/Collection {writable-id :id} {:namespace "data-actions"}]
+ (perms/grant-collection-readwrite-permissions! (perms/all-users-group) writable-id)
+ (is (= "You don't have permissions to do that."
+ (mt/user-http-request :rasta :post 403 "action" (model-less-query-action locked-id))))
+ (testing "the data actions root needs its own permission"
(is (= "You don't have permissions to do that."
- (mt/user-http-request :rasta :post 403 "action" (model-less-query-action locked-id))))
- (let [created (mt/user-http-request :rasta :post 200 "action" (model-less-query-action personal-id))]
- (is (=? {:collection_id personal-id} created))
- (is (= "You don't have permissions to do that."
- (mt/user-http-request :rasta :put 403 (str "action/" (:id created)) {:collection_id locked-id})))
- (is (= personal-id (t2/select-one-fn :collection_id :model/Action :id (:id created))))))))))))
+ (mt/user-http-request :rasta :post 403 "action" (model-less-query-action nil))))
+ (perms/grant-collection-readwrite-permissions! (perms/all-users-group) (data-actions-root))
+ (is (=? {:collection_id nil}
+ (mt/user-http-request :rasta :post 200 "action" (model-less-query-action nil)))))
+ (let [created (mt/user-http-request :rasta :post 200 "action" (model-less-query-action writable-id))]
+ (is (=? {:collection_id writable-id} created))
+ (is (= "You don't have permissions to do that."
+ (mt/user-http-request :rasta :put 403 (str "action/" (:id created)) {:collection_id locked-id})))
+ (is (= writable-id (t2/select-one-fn :collection_id :model/Action :id (:id created)))))))))))
(deftest list-actions-without-model-test
- (testing "the action list includes actions without a model, filtered by collection permissions"
+ (testing "the action list includes actions without a model, filtered by data actions collection permissions"
(mt/with-actions-test-data-and-actions-enabled
- (mt/with-non-admin-groups-no-root-collection-perms
+ (perms.test-util/with-restored-perms!
(mt/with-model-cleanup [:model/Action]
- (mt/with-temp [:model/Collection {locked-id :id} {}]
- (let [personal-id (:id (collection/user->personal-collection (mt/user->id :rasta)))
- visible (mt/user-http-request :crowberto :post 200 "action" (model-less-query-action personal-id))
- hidden (mt/user-http-request :crowberto :post 200 "action" (model-less-query-action locked-id))
- listed-ids (fn [user] (set (map :id (mt/user-http-request user :get 200 "action"))))]
- (is (set/subset? #{(:id visible) (:id hidden)} (listed-ids :crowberto)))
+ (mt/with-temp [:model/Collection {visible-coll-id :id} {:namespace "data-actions"}
+ :model/Collection {locked-id :id} {:namespace "data-actions"}]
+ (perms/grant-collection-read-permissions! (perms/all-users-group) visible-coll-id)
+ (let [visible (mt/user-http-request :crowberto :post 200 "action" (model-less-query-action visible-coll-id))
+ hidden (mt/user-http-request :crowberto :post 200 "action" (model-less-query-action locked-id))
+ at-root (mt/user-http-request :crowberto :post 200 "action" (model-less-query-action nil))
+ listed-ids (fn [user] (set (map :id (mt/user-http-request user :get 200 "action"))))]
+ (is (set/subset? #{(:id visible) (:id hidden) (:id at-root)} (listed-ids :crowberto)))
(is (contains? (listed-ids :rasta) (:id visible)))
- (is (not (contains? (listed-ids :rasta) (:id hidden)))))))))))
+ (is (not-any? #{(:id hidden) (:id at-root)} (listed-ids :rasta)))
+ (testing "with read permission on the data actions root"
+ (perms/grant-collection-read-permissions! (perms/all-users-group) (data-actions-root))
+ (is (contains? (listed-ids :rasta) (:id at-root)))))))))))
+
+(deftest list-archived-actions-test
+ (testing "GET /api/action?archived=true lists archived actions instead of unarchived ones"
+ (mt/with-actions-test-data-and-actions-enabled
+ (mt/with-model-cleanup [:model/Action]
+ (let [active (mt/user-http-request :crowberto :post 200 "action" (model-less-query-action nil))
+ archived (mt/user-http-request :crowberto :post 200 "action" (model-less-query-action nil))
+ _ (mt/user-http-request :crowberto :put 200 (str "action/" (:id archived)) {:archived true})
+ listed-ids (fn [& params] (set (map :id (apply mt/user-http-request :crowberto :get 200 "action" params))))]
+ (is (contains? (listed-ids) (:id active)))
+ (is (not (contains? (listed-ids) (:id archived))))
+ (is (contains? (listed-ids :archived true) (:id archived)))
+ (is (not (contains? (listed-ids :archived true) (:id active))))
+ (testing "actions in an archived data actions folder are listed as archived"
+ (mt/with-temp [:model/Collection {folder-id :id} {:namespace "data-actions"}]
+ (let [in-folder (mt/user-http-request :crowberto :post 200 "action" (model-less-query-action folder-id))]
+ (mt/user-http-request :crowberto :put 200 (str "collection/" folder-id) {:archived true})
+ (is (contains? (listed-ids :archived true) (:id in-folder)))
+ (is (not (contains? (listed-ids) (:id in-folder))))))))))))
+
+(deftest list-actions-by-type-test
+ (testing "GET /api/action?type= returns only actions of that type, alone or combined with model-id"
+ (mt/with-actions-test-data-and-actions-enabled
+ (mt/with-model-cleanup [:model/Action]
+ (mt/with-actions [{model-id :id} {:type :model :dataset_query (mt/mbql-query categories)}
+ {query-id :action-id} {}
+ {implicit-id :action-id} {:type :implicit :kind "row/update"}]
+ (let [model-less (mt/user-http-request :crowberto :post 200 "action" (model-less-query-action nil))
+ list-ids (fn [& params]
+ (set (map :id (apply mt/user-http-request :crowberto :get 200 "action" params))))]
+ (testing "type=query includes query actions, and no implicit actions"
+ (let [ids (list-ids :type "query")]
+ (is (set/subset? #{query-id (:id model-less)} ids))
+ (is (not (contains? ids implicit-id)))
+ (is (= #{"query"}
+ (set (map :type (mt/user-http-request :crowberto :get 200 "action" :type "query")))))))
+ (testing "type=implicit returns only implicit actions"
+ (let [ids (list-ids :type "implicit")]
+ (is (contains? ids implicit-id))
+ (is (not-any? #{query-id (:id model-less)} ids))))
+ (testing "type combines with model-id"
+ (is (= #{query-id} (list-ids :model-id model-id :type "query")))
+ (is (= #{implicit-id} (list-ids :model-id model-id :type "implicit")))
+ (is (= #{query-id implicit-id} (list-ids :model-id model-id))))
+ (testing "a model-less query action is returned with its creator"
+ (is (=? {:id (:id model-less)
+ :creator {:id (mt/user->id :crowberto)}}
+ (m/find-first #(= (:id model-less) (:id %))
+ (mt/user-http-request :crowberto :get 200 "action" :type "query")))))
+ (testing "an unknown type is rejected"
+ (mt/user-http-request :crowberto :get 400 "action" :type "http"))))))))
+
+(deftest action-can-write-test
+ (testing "GET /api/action and GET /api/action/:id hydrate :can_write from the action's collection"
+ (mt/with-actions-test-data-and-actions-enabled
+ (mt/with-model-cleanup [:model/Action]
+ (mt/with-temp [:model/Collection {coll-id :id} {:namespace "data-actions"}]
+ (perms/grant-collection-read-permissions! (perms/all-users-group) coll-id)
+ (let [action-id (:id (mt/user-http-request :crowberto :post 200 "action" (model-less-query-action coll-id)))
+ listed (fn [user]
+ (m/find-first #(= action-id (:id %))
+ (mt/user-http-request user :get 200 "action" :type "query")))]
+ (testing "a user who can write the collection"
+ (is (=? {:can_write true} (listed :crowberto)))
+ (is (=? {:can_write true} (mt/user-http-request :crowberto :get 200 (str "action/" action-id)))))
+ (testing "a user who can only read the collection"
+ (is (=? {:can_write false} (listed :rasta)))
+ (is (=? {:can_write false} (mt/user-http-request :rasta :get 200 (str "action/" action-id)))))))))))
(deftest attached-action-keeps-model-collection-test
(testing "an action with a model stays in the model's collection whatever collection_id an update sends"
@@ -546,18 +633,25 @@
(is (= model-collection (t2/select-one-fn :collection_id :model/Action :id action-id)))))))))
(deftest action-without-model-collection-guards-test
- (testing "an action without a model can only go in an existing, unarchived Collection of the default namespace"
+ (testing "an action without a model can only go in the data actions root or an existing, unarchived data actions or data app collection"
(mt/with-actions-test-data-and-actions-enabled
(mt/with-model-cleanup [:model/Action]
- (mt/with-temp [:model/Collection {coll-id :id} {}
+ (mt/with-temp [:model/Collection {coll-id :id} {:namespace "data-actions"}
+ :model/Collection {app-id :id} {:namespace "data-apps"}
+ :model/Collection {default-id :id} {}
:model/Collection {snippets-id :id} {:namespace "snippets"}
- :model/Collection {archived-id :id} {:archived true}]
+ :model/Collection {archived-id :id} {:namespace "data-actions" :archived true}]
(is (re-find #"can only go in Collections in the"
(str (mt/user-http-request :crowberto :post 400 "action" (model-less-query-action snippets-id)))))
+ (is (re-find #"can only go in a data actions or data app collection"
+ (str (mt/user-http-request :crowberto :post 400 "action" (model-less-query-action default-id)))))
(is (= "Not found."
(mt/user-http-request :crowberto :post 404 "action" (model-less-query-action Integer/MAX_VALUE))))
+ (is (=? {:collection_id app-id}
+ (mt/user-http-request :crowberto :post 200 "action" (model-less-query-action app-id))))
(let [path (str "action/" (:id (mt/user-http-request :crowberto :post 200 "action" (model-less-query-action coll-id))))]
(mt/user-http-request :crowberto :put 400 path {:collection_id archived-id})
+ (mt/user-http-request :crowberto :put 400 path {:collection_id default-id})
(is (= coll-id (:collection_id (mt/user-http-request :crowberto :get 200 path))))))))))
(deftest action-with-missing-model-test
@@ -582,14 +676,43 @@
(mt/user-http-request :crowberto :put 200 (str "action/" action-id) {:archived false})
(is (= [false false] (state))))))))
+(deftest server-populated-columns-not-writable-test
+ (testing "creating or updating an action ignores the columns the server populates"
+ (mt/with-actions-test-data-and-actions-enabled
+ (mt/with-model-cleanup [:model/Action]
+ (mt/with-temp [:model/Collection {coll-id :id} {:namespace "data-actions"}]
+ (perms/grant-collection-readwrite-permissions! (perms/all-users-group) coll-id)
+ (let [spoofed {:creator_id (mt/user->id :crowberto)
+ :made_public_by_id (mt/user->id :crowberto)
+ :public_uuid (str (random-uuid))}
+ stored #(t2/select-one [:model/Action :creator_id :made_public_by_id :public_uuid] :id %)
+ created (mt/user-http-request :rasta :post 200 "action"
+ (merge (model-less-query-action coll-id) spoofed))]
+ (is (= {:creator_id (mt/user->id :rasta) :made_public_by_id nil :public_uuid nil}
+ (into {} (stored (:id created)))))
+ (mt/user-http-request :rasta :put 200 (str "action/" (:id created)) (assoc spoofed :name "Renamed"))
+ (is (= {:creator_id (mt/user->id :rasta) :made_public_by_id nil :public_uuid nil}
+ (into {} (stored (:id created)))))))))))
+
(deftest update-checks-actions-enabled-test
- (testing "any update of a query action is refused while actions are disabled on its database"
+ (testing "while actions are disabled on its database, a query action's query can't change but the rest of it can"
(mt/with-actions-test-data-and-actions-enabled
(mt/with-model-cleanup [:model/Action]
- (let [path (str "action/" (:id (mt/user-http-request :crowberto :post 200 "action" (model-less-query-action nil))))]
+ (let [created (mt/user-http-request :crowberto :post 200 "action" (model-less-query-action nil))
+ path (str "action/" (:id created))]
(mt/with-actions-disabled
- (is (= "Actions are not enabled."
- (:cause (mt/user-http-request :crowberto :put 400 path {:name "Renamed"}))))))))))
+ (testing "changing the query is refused"
+ (is (= "Actions are not enabled."
+ (:cause (mt/user-http-request :crowberto :put 400 path
+ {:dataset_query (:dataset_query created)})))))
+ (testing "renaming, settings and archiving are allowed"
+ (is (=? {:name "Renamed"}
+ (mt/user-http-request :crowberto :put 200 path {:name "Renamed"})))
+ (is (=? {:visualization_settings {:successMessage "Done"}}
+ (mt/user-http-request :crowberto :put 200 path
+ {:visualization_settings {:successMessage "Done"}})))
+ (mt/user-http-request :crowberto :put 200 path {:archived true})
+ (is (true? (t2/select-one-fn :archived :model/Action :id (:id created)))))))))))
(deftest remap-parameter-keys-test
(testing "remap-parameter-keys translates incoming parameter keys to the destination parameter's :id"
@@ -709,13 +832,9 @@
(mt/with-actions-enabled
(let [action-opts (shared-action-opts)]
(mt/with-actions [{:keys [action-id]} action-opts]
- (testing "We *cannot* unshare an action if actions are disabled"
+ (testing "We can unshare an action even when actions are disabled"
(mt/with-actions-disabled
- (is (= "Actions are not enabled."
- (:cause
- (mt/user-http-request :crowberto :delete 400 (format "action/%d/public_link" action-id)))))))
- (testing "Test that we can unshare an action"
- (mt/user-http-request :crowberto :delete 204 (format "action/%d/public_link" action-id))
+ (mt/user-http-request :crowberto :delete 204 (format "action/%d/public_link" action-id)))
(is (= false
(t2/exists? :model/Action :id action-id, :public_uuid (:public_uuid action-opts)))))))
(testing "Test that we cannot unshare an action if it's archived"
diff --git a/test/metabase/collections/models/collection_test.clj b/test/metabase/collections/models/collection_test.clj
index c6c0945b83f..5a55f87572d 100644
--- a/test/metabase/collections/models/collection_test.clj
+++ b/test/metabase/collections/models/collection_test.clj
@@ -230,7 +230,7 @@
(deftest delete-collection-deletes-actions-test
(testing "deleting a Collection deletes the Actions in it, including the ones without a model"
- (mt/with-temp [:model/Collection collection {}
+ (mt/with-temp [:model/Collection collection {:namespace "data-actions"}
:model/Action action {:type :query :name "No model" :model_id nil
:collection_id (u/the-id collection)}]
(t2/delete! :model/Collection :id (u/the-id collection))
diff --git a/test/metabase/collections_rest/api_test.clj b/test/metabase/collections_rest/api_test.clj
index 7bdd83a1311..5bec0f37eac 100644
--- a/test/metabase/collections_rest/api_test.clj
+++ b/test/metabase/collections_rest/api_test.clj
@@ -2138,6 +2138,11 @@
(with-some-children-of-collection! nil
(mt/user-http-request :crowberto :get 200 "collection/root")))))))
+(deftest fetch-data-actions-root-collection-test
+ (testing "GET /api/collection/root?namespace=data-actions names the root after data actions"
+ (is (=? {:id "root" :name "Data actions" :namespace "data-actions"}
+ (mt/user-http-request :crowberto :get 200 "collection/root" :namespace "data-actions")))))
+
(deftest fetch-root-collection-permissions-test
(testing "GET /api/collection/root"
(testing "403s (not silently filters) for a user without root read perms"
diff --git a/test/metabase/typed_schemas/source_test.clj b/test/metabase/typed_schemas/source_test.clj
index 837176b1930..044f626b94c 100644
--- a/test/metabase/typed_schemas/source_test.clj
+++ b/test/metabase/typed_schemas/source_test.clj
@@ -111,7 +111,7 @@
(deftest actions-test
(mt/with-temp [:model/Database {other-db-id :id} {}
- :model/Collection {hidden-coll-id :id} {:name "Hidden actions"}
+ :model/Collection {hidden-coll-id :id} {:name "Hidden actions" :namespace "data-actions"}
:model/Card {model-id :id} {:type :model
:dataset_query (lib/query (mt/metadata-provider)
(lib.metadata/table (mt/metadata-provider)
diff --git a/test/metabase/typed_schemas_rest/api_test.clj b/test/metabase/typed_schemas_rest/api_test.clj
index 4980ab397ff..0f4c9bd54cc 100644
--- a/test/metabase/typed_schemas_rest/api_test.clj
+++ b/test/metabase/typed_schemas_rest/api_test.clj
@@ -83,7 +83,7 @@
:model/QueryAction _ {:action_id (:id standalone)
:dataset_query (lib/native-query (mt/metadata-provider)
"UPDATE orders SET discount = 0")}
- :model/Collection copies {:name "Data App: orders"}
+ :model/Collection copies {:name "Data App: orders", :namespace "data-apps"}
:model/Action copy {:name "Copied order", :type :query, :collection_id (:id copies)}
:model/QueryAction _ {:action_id (:id copy)
:dataset_query (lib/native-query (mt/metadata-provider)