Skip to content

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

[METABOT] Project Code Gen (#63313)

Tyler Pluded9060d941c80
diff --git a/.clj-kondo/config.edn b/.clj-kondo/config.edn
index f356a2e396e..9f6e6db9ca3 100644
--- a/.clj-kondo/config.edn
+++ b/.clj-kondo/config.edn
@@ -522,6 +522,7 @@
metabase-enterprise.advanced-permissions.models.permissions.application-permissions-test/with-new-group-and-current-graph hooks.common/with-two-top-level-bindings
metabase-enterprise.audit-app.pages-test/with-temp-objects hooks.common/with-one-binding
metabase-enterprise.cache.config-test/with-temp-persist-models hooks.common/with-seven-bindings
+ metabase-enterprise.metabot-v3.tools.dependencies-test/with-dependent-transforms! hooks.common/with-two-bindings
metabase-enterprise.semantic-search.db.connection/with-migrate-tx hooks.common/let-one-with-optional-value
metabase-enterprise.serialization.test-util/with-temp-dpc hooks.toucan2.tools.with-temp/with-temp
metabase-enterprise.transforms-python.drivers-test/with-test-table hooks.common/with-two-bindings
diff --git a/.clj-kondo/config/modules/config.edn b/.clj-kondo/config/modules/config.edn
index 205ba4a6f24..7a31d2a17a7 100644
--- a/.clj-kondo/config/modules/config.edn
+++ b/.clj-kondo/config/modules/config.edn
@@ -1073,6 +1073,7 @@
audit-app
collections
config
+ driver
events
lib
lib-be
@@ -1708,7 +1709,7 @@
enterprise/dependencies
{:team "Querying"
:api #{metabase-enterprise.dependencies.api
- #_metabase-enterprise.dependencies.core
+ metabase-enterprise.dependencies.core
metabase-enterprise.dependencies.init}
:uses #{analyze
api
@@ -1837,6 +1838,7 @@
lib
lib-be
models
+ native-query-snippets
permissions
premium-features
pulse
@@ -1853,7 +1855,10 @@
util
warehouse-schema
warehouses
- enterprise/documents}}
+ enterprise/dependencies
+ enterprise/documents
+ enterprise/transforms
+ enterprise/transforms-python}}
enterprise/permission-debug
{:team "UX West"
@@ -2014,6 +2019,7 @@
lib-be
models
premium-features
+ queries
query-processor
request
search
diff --git a/e2e/support/helpers/e2e-metabot-helpers.ts b/e2e/support/helpers/e2e-metabot-helpers.ts
index 835676a0a34..d2a0edd8ad0 100644
--- a/e2e/support/helpers/e2e-metabot-helpers.ts
+++ b/e2e/support/helpers/e2e-metabot-helpers.ts
@@ -2,8 +2,12 @@ import type { StaticResponse } from "cypress/types/net-stubbing";
import { appBar } from "./e2e-ui-elements-helpers";
+export function metabotChatSidebar() {
+ return cy.findByTestId("metabot-chat");
+}
+
export function assertChatVisibility(visibility: "visible" | "not.visible") {
- cy.findByTestId("metabot-chat").should(
+ metabotChatSidebar().should(
visibility === "visible" ? "be.visible" : "not.exist",
);
}
@@ -60,7 +64,6 @@ export function sendMetabotMessage(input: string) {
metabotChatInput()
.should("not.be.disabled")
.click()
- .should("be.focused")
.type(input)
.type("{Enter}");
}
@@ -78,6 +81,7 @@ export const mockMetabotResponse = (response: StaticResponse) => {
return cy
.intercept("POST", "/api/ee/metabot-v3/agent-streaming", (req) => {
req.reply({
+ status: 200,
...response,
headers: {
"content-type": "text/event-stream; charset=utf-8",
diff --git a/e2e/support/helpers/e2e-transform-helpers.ts b/e2e/support/helpers/e2e-transform-helpers.ts
index ee0beb942c5..44ea8c425f7 100644
--- a/e2e/support/helpers/e2e-transform-helpers.ts
+++ b/e2e/support/helpers/e2e-transform-helpers.ts
@@ -1,9 +1,15 @@
+import { WRITABLE_DB_ID } from "e2e/support/cypress_data";
import type {
ListTransformRunsResponse,
+ PythonTransformTableAliases,
TransformId,
TransformRun,
+ TransformTagId,
} from "metabase-types/api";
+import { createTransform } from "./api";
+import { getTableId } from "./e2e-qa-databases-helpers";
+
export function visitTransform(transformId: TransformId) {
cy.visit(`/admin/transforms/${transformId}`);
}
@@ -35,3 +41,122 @@ export function waitForSucceededTransformRuns() {
runs.length > 0 && runs.every((run) => run.status === "succeeded"),
);
}
+
+export function createMbqlTransform({
+ sourceTable,
+ targetTable,
+ targetSchema,
+ tagIds,
+ databaseId,
+ name,
+ visitTransform,
+}: {
+ sourceTable: string;
+ targetTable: string;
+ targetSchema: string | null;
+ tagIds?: TransformTagId[];
+ name: string;
+ databaseId?: number;
+ visitTransform?: boolean;
+}) {
+ return getTableId({ databaseId, name: sourceTable }).then((tableId) => {
+ return createTransform(
+ {
+ name,
+ source: {
+ type: "query",
+ query: {
+ database: WRITABLE_DB_ID,
+ type: "query",
+ query: {
+ "source-table": tableId,
+ limit: 5,
+ },
+ },
+ },
+ target: {
+ type: "table",
+ database: WRITABLE_DB_ID,
+ name: targetTable,
+ schema: targetSchema,
+ },
+ tag_ids: tagIds,
+ },
+ { visitTransform },
+ );
+ });
+}
+
+export function createSqlTransform({
+ sourceQuery,
+ targetTable,
+ targetSchema,
+ tagIds,
+ visitTransform,
+}: {
+ sourceQuery: string;
+ targetTable: string;
+ targetSchema: string;
+ tagIds?: TransformTagId[];
+ visitTransform?: boolean;
+}) {
+ return createTransform(
+ {
+ name: "SQL transform",
+ source: {
+ type: "query",
+ query: {
+ database: WRITABLE_DB_ID,
+ type: "native",
+ native: {
+ query: sourceQuery,
+ },
+ },
+ },
+ target: {
+ type: "table",
+ database: WRITABLE_DB_ID,
+ name: targetTable,
+ schema: targetSchema,
+ },
+ tag_ids: tagIds,
+ },
+ { wrapId: true, visitTransform },
+ );
+}
+
+export function createPythonTransform({
+ body,
+ sourceTables,
+ targetTable,
+ targetSchema,
+ tagIds,
+ visitTransform,
+}: {
+ body: string;
+ sourceTables: PythonTransformTableAliases;
+ targetTable: string;
+ targetSchema: string;
+ tagIds?: TransformTagId[];
+ visitTransform?: boolean;
+}) {
+ return createTransform(
+ {
+ name: "Python transform",
+ source: {
+ type: "python",
+ "source-database": WRITABLE_DB_ID,
+ "source-tables": sourceTables,
+ body,
+ },
+ target: {
+ type: "table",
+ database: WRITABLE_DB_ID,
+ name: targetTable,
+ schema: targetSchema,
+ },
+ tag_ids: tagIds,
+ },
+ { wrapId: true, visitTransform },
+ );
+}
diff --git a/e2e/test/scenarios/admin/transforms.cy.spec.ts b/e2e/test/scenarios/admin/transforms.cy.spec.ts
index 6da4fbc2769..7aff731a268 100644
--- a/e2e/test/scenarios/admin/transforms.cy.spec.ts
+++ b/e2e/test/scenarios/admin/transforms.cy.spec.ts
@@ -2840,96 +2840,41 @@ function runJobAndWaitForFailure() {
getRunButton().should("have.text", "Run failed");
}
-function createMbqlTransform({
- sourceTable = SOURCE_TABLE,
- targetTable = TARGET_TABLE,
- targetSchema = TARGET_SCHEMA,
- tagIds,
- databaseId,
- name = "MBQL transform",
- visitTransform,
-}: {
- sourceTable?: string;
- targetTable?: string;
- targetSchema?: string | null;
- tagIds?: TransformTagId[];
- name?: string;
- databaseId?: number;
- visitTransform?: boolean;
-} = {}) {
- return H.getTableId({ databaseId, name: sourceTable }).then((tableId) => {
- return H.createTransform(
- {
- name,
- source: {
- type: "query",
- query: {
- database: WRITABLE_DB_ID,
- type: "query",
- query: {
- "source-table": tableId,
- limit: 5,
- },
- },
- },
- target: {
- type: "table",
- database: WRITABLE_DB_ID,
- name: targetTable,
- schema: targetSchema,
- },
- tag_ids: tagIds,
- },
- { visitTransform },
- );
+function createMbqlTransform(
+ opts: {
+ sourceTable?: string;
+ targetTable?: string;
+ targetSchema?: string | null;
+ tagIds?: TransformTagId[];
+ name?: string;
+ databaseId?: number;
+ visitTransform?: boolean;
+ } = {},
+) {
+ return H.createMbqlTransform({
+ sourceTable: SOURCE_TABLE,
+ targetTable: TARGET_TABLE,
+ targetSchema: TARGET_SCHEMA,
+ name: "MBQL transform",
+ ...opts,
});
}
-function createSqlTransform({
- sourceQuery,
- targetTable = TARGET_TABLE,
- targetSchema = TARGET_SCHEMA,
- tagIds,
- visitTransform,
-}: {
+function createSqlTransform(opts: {
sourceQuery: string;
targetTable?: string;
targetSchema?: string;
tagIds?: TransformTagId[];
visitTransform?: boolean;
}) {
- H.createTransform(
- {
- name: "SQL transform",
- source: {
- type: "query",
- query: {
- database: WRITABLE_DB_ID,
- type: "native",
- native: {
- query: sourceQuery,
- },
- },
- },
- target: {
- type: "table",
- database: WRITABLE_DB_ID,
- name: targetTable,
- schema: targetSchema,
- },
- tag_ids: tagIds,
- },
- { wrapId: true, visitTransform },
- );
+ return H.createSqlTransform({
+ targetTable: TARGET_TABLE,
+ targetSchema: TARGET_SCHEMA,
+ ...opts,
+ });
}
-function createPythonTransform({
- body,
- sourceTables,
- targetTable = TARGET_TABLE,
- targetSchema = TARGET_SCHEMA,
- tagIds,
- visitTransform,
-}: {
+
+function createPythonTransform(opts: {
body: string;
sourceTables: PythonTransformTableAliases;
targetTable?: string;
@@ -2937,25 +2882,11 @@ function createPythonTransform({
tagIds?: TransformTagId[];
visitTransform?: boolean;
}) {
- H.createTransform(
- {
- name: "Python transform",
- source: {
- type: "python",
- "source-database": WRITABLE_DB_ID,
- "source-tables": sourceTables,
- body,
- },
- target: {
- type: "table",
- database: WRITABLE_DB_ID,
- name: targetTable,
- schema: targetSchema,
- },
- tag_ids: tagIds,
- },
- { wrapId: true, visitTransform },
- );
+ return H.createPythonTransform({
+ targetTable: TARGET_TABLE,
+ targetSchema: TARGET_SCHEMA,
+ ...opts,
+ });
}
function visitTableQuestion({
diff --git a/e2e/test/scenarios/metabot/transforms-codegen.cy.spec.ts b/e2e/test/scenarios/metabot/transforms-codegen.cy.spec.ts
new file mode 100644
index 00000000000..dcb27233a4e
--- /dev/null
+++ b/e2e/test/scenarios/metabot/transforms-codegen.cy.spec.ts
@@ -0,0 +1,418 @@
+import dedent from "ts-dedent";
+
+import { WRITABLE_DB_ID } from "e2e/support/cypress_data";
+
+const { H } = cy;
+
+const SOURCE_TABLE = "Animals";
+
+// Helper functions for metabot transform interactions
+const visitTransformListPage = () => cy.visit("/admin/transforms");
+
+const suggestions = () => cy.findAllByTestId("metabot-chat-suggestion");
+// eslint-disable-next-line no-unsafe-element-filtering
+const lastSuggestion = () => suggestions().last();
+
+const viewLastSuggestion = () =>
+ lastSuggestion()
+ .findAllByRole("button", { name: /apply|create/i })
+ .click();
+
+const acceptSuggestionBtn = () =>
+ cy.findByTestId("accept-proposed-changes-button");
+const acceptSuggestion = () => acceptSuggestionBtn().click();
+
+const rejectSuggestionBtn = () =>
+ cy.findByTestId("reject-proposed-changes-button");
+const rejectSuggestion = () => rejectSuggestionBtn().click();
+
+type EditorType = "native" | "python";
+const editor = (editorType: EditorType) =>
+ editorType === "native" ? H.NativeEditor : H.PythonEditor;
+
+const assertEditorContent = (editorType: EditorType, content: string) => {
+ editor(editorType).get().should("contain", content);
+};
+
+const makeManualEdit = (editorType: EditorType, newContent: string) =>
+ editor(editorType).clear().paste(newContent);
+
+const assertSuggestionInSidebar = (values: {
+ oldSourcePartial?: string;
+ newSourcePartial: string;
+}) => {
+ lastSuggestion().should("contain", values.newSourcePartial);
+ if (values.oldSourcePartial) {
+ lastSuggestion().should("contain", values.oldSourcePartial);
+ }
+};
+
+const assertEditorDiffState = (opts: { exists: boolean }) => {
+ const should = opts.exists ? "exist" : "not.exist";
+ cy.findByRole("button", { name: /apply|create/i }).should(should);
+ cy.findByRole("button", { name: /reject/i }).should(should);
+};
+
+const assertAcceptRejectUI = (opts: { visible: boolean }) => {
+ const should = opts.visible ? "be.visible" : "not.exist";
+ acceptSuggestionBtn().should(should);
+ rejectSuggestionBtn().should(should);
+};
+
+H.describeWithSnowplowEE("scenarios > metabot > transforms codegen", () => {
+ beforeEach(() => {
+ H.restore("postgres-writable");
+ H.resetTestTable({ type: "postgres", table: "many_schemas" });
+ H.resetSnowplow();
+ cy.signInAsAdmin();
+ H.activateToken("bleeding-edge");
+ H.resyncDatabase({ dbId: WRITABLE_DB_ID, tableName: SOURCE_TABLE });
+
+ cy.intercept("POST", "/api/ee/metabot-v3/agent-streaming").as("agentReq");
+ cy.intercept("POST", "/api/ee/transform").as("createTransform");
+ cy.intercept("PUT", "/api/ee/transform/*").as("updateTransform");
+ });
+
+ describe("Native SQL transform tests", () => {
+ describe("create new transform", () => {
+ it("should create SQL transform via metabot", () => {
+ visitTransformListPage();
+ H.openMetabotViaSearchButton(true);
+
+ cy.log("Ask metabot for a new transform");
+ H.mockMetabotResponse({
+ body: createMockTransformSuggestionResponse(
+ "I'll create a new transform that gets the number 1 for you.",
+ createMockNativeTransformJSON(null, WRITABLE_DB_ID, "SELECT 1"),
+ ),
+ });
+ H.sendMetabotMessage(
+ "Create a new native SQL transform that gives me the number 1",
+ );
+ assertSuggestionInSidebar({ newSourcePartial: "SELECT 1" });
+
+ cy.log("Should be able to visit and the see new transform");
+ viewLastSuggestion();
+ cy.url().should("include", "/admin/transforms/new/native");
+ assertEditorDiffState({ exists: false }); // nothing to diff, so we shouldn't show the UI for it
+ assertEditorContent("native", "SELECT 1");
+
+ // User should ask metabot for a change
+ cy.log("Ask metabot for an edit");
+ H.mockMetabotResponse({
+ body: createMockTransformSuggestionResponse(
+ "Let me make that update for you.",
+ createMockNativeTransformJSON(null, WRITABLE_DB_ID, "SELECT 2"),
+ ),
+ });
+ H.sendMetabotMessage("Make this give me the number 2 instead");
+ assertSuggestionInSidebar({
+ oldSourcePartial: "SELECT 1",
+ newSourcePartial: "SELECT 2",
+ });
+ assertAcceptRejectUI({ visible: true });
+
+ // User can accept a change (editor should have new value)
+ cy.log("Should be able to select an edit");
+ acceptSuggestion();
+ assertEditorContent("native", "SELECT 2");
+ assertAcceptRejectUI({ visible: false });
+
+ // User should make changes to the source
+ cy.log("Should diff with user edits");
+ makeManualEdit("native", "SELECT 3");
+ H.mockMetabotResponse({
+ body: createMockTransformSuggestionResponse(
+ "Let me make that change for you.",
+ createMockNativeTransformJSON(null, WRITABLE_DB_ID, "SELECT 4"),
+ ),
+ });
+ H.sendMetabotMessage("Make this give me the number 4 instead");
+ assertSuggestionInSidebar({
+ oldSourcePartial: "SELECT 3",
+ newSourcePartial: "SELECT 4",
+ });
+ assertAcceptRejectUI({ visible: true });
+
+ cy.log("Should be able to reject an edit");
+ rejectSuggestion();
+ assertEditorContent("native", "SELECT 3");
+ assertAcceptRejectUI({ visible: false });
+ });
+
+ it("should create Python transform via metabot", () => {
+ visitTransformListPage();
+ H.openMetabotViaSearchButton(true);
+
+ cy.log("Ask metabot for a new transform");
+ H.mockMetabotResponse({
+ body: createMockTransformSuggestionResponse(
+ "I'll create a new transform that gets the number 1 for you.",
+ createMockPythonTransformJSON(
+ null,
+ WRITABLE_DB_ID,
+ { metabase_table_df: 152 },
+ "import pandas as pd\\n\\ndef transform(metabase_table_df):\\n return pd.DataFrame({'value': [1]})",
+ ),
+ ),
+ });
+ H.sendMetabotMessage(
+ "Create a new native python transform that gives me the number 1",
+ );
+ assertSuggestionInSidebar({
+ newSourcePartial: "pd.DataFrame({'value': [1]})",
+ });
+
+ cy.log("Should be able to visit and the see new transform");
+ viewLastSuggestion();
+ cy.url().should("include", "/admin/transforms/new/python");
+ assertEditorDiffState({ exists: false }); // nothing to diff, so we shouldn't show the UI for it
+ assertEditorContent("python", "pd.DataFrame({'value': [1]})");
+
+ // User should ask metabot for a change
+ cy.log("Ask metabot for an edit");
+ H.mockMetabotResponse({
+ body: createMockTransformSuggestionResponse(
+ "Let me make that update for you.",
+ createMockPythonTransformJSON(
+ null,
+ WRITABLE_DB_ID,
+ { metabase_table_df: 152 },
+ "import pandas as pd\\n\\ndef transform(metabase_table_df):\\n return pd.DataFrame({'value': [2]})",
+ ),
+ ),
+ });
+ H.sendMetabotMessage("Make this give me the number 2 instead");
+ assertSuggestionInSidebar({
+ oldSourcePartial: "pd.DataFrame({'value': [1]})",
+ newSourcePartial: "pd.DataFrame({'value': [2]})",
+ });
+ assertAcceptRejectUI({ visible: true });
+
+ // User can accept a change (editor should have new value)
+ cy.log("Should be able to select an edit");
+ acceptSuggestion();
+ assertEditorContent("python", "pd.DataFrame({'value': [2]})");
+ assertAcceptRejectUI({ visible: false });
+
+ // User should make changes to the source
+ cy.log("Should diff with user edits");
+ makeManualEdit(
+ "python",
+ dedent`
+ import pandas as pd
+
+ def transform(metabase_table_df):
+ return pd.DataFrame({'value': [3]})`,
+ );
+ H.mockMetabotResponse({
+ body: createMockTransformSuggestionResponse(
+ "Let me make that change for you.",
+ createMockPythonTransformJSON(
+ null,
+ WRITABLE_DB_ID,
+ { metabase_table_df: 152 },
+ "import pandas as pd\\n\\ndef transform(metabase_table_df):\\n return pd.DataFrame({'value': [4]})",
+ ),
+ ),
+ });
+ H.sendMetabotMessage("Make this give me the number 4 instead");
+ assertSuggestionInSidebar({
+ oldSourcePartial: "pd.DataFrame({'value': [3]})",
+ newSourcePartial: "pd.DataFrame({'value': [4]})",
+ });
+ assertAcceptRejectUI({ visible: true });
+
+ cy.log("Should be able to reject an edit");
+ rejectSuggestion();
+ assertEditorContent("python", "pd.DataFrame({'value': [3]})");
+ assertAcceptRejectUI({ visible: false });
+ });
+ });
+
+ describe("update existing transform", () => {
+ it("should update existing SQL transform via metabot", () => {
+ H.createSqlTransform({
+ sourceQuery: "SELECT 1",
+ targetTable: "table_a",
+ targetSchema: "Schema A",
+ }).as("transformId");
+
+ visitTransformListPage();
+ H.openMetabotViaSearchButton(true);
+
+ // Ask metabot for a change to existing transform
+ cy.get("@transformId").then((transformId) => {
+ H.mockMetabotResponse({
+ body: createMockTransformSuggestionResponse(
+ "Let me make that update for you.",
+ createMockNativeTransformJSON(
+ Number(transformId),
+ WRITABLE_DB_ID,
+ "SELECT 2",
+ ),
+ ),
+ });
+ });
+ H.sendMetabotMessage(
+ "Update my SQL transform to select 2 instead of 1.",
+ );
+ assertSuggestionInSidebar({
+ oldSourcePartial: "SELECT 1",
+ newSourcePartial: "SELECT 2",
+ });
+
+ cy.log("Should be able to visit and the see the updated transform");
+ viewLastSuggestion();
+ assertAcceptRejectUI({ visible: true });
+
+ // User can accept a change (editor should have new value)
+ cy.log("Should be able to select an edit");
+ acceptSuggestion();
+ assertEditorContent("native", "SELECT 2");
+ assertAcceptRejectUI({ visible: false });
+
+ // User should make changes to the source
+ cy.log("Should diff with user edits");
+ makeManualEdit("native", "SELECT 3");
+ cy.get("@transformId").then((transformId) => {
+ H.mockMetabotResponse({
+ body: createMockTransformSuggestionResponse(
+ "Let me make that change for you.",
+ createMockNativeTransformJSON(
+ Number(transformId),
+ WRITABLE_DB_ID,
+ "SELECT 4",
+ ),
+ ),
+ });
+ });
+ H.sendMetabotMessage("Make this give me the number 4 instead");
+ assertSuggestionInSidebar({
+ oldSourcePartial: "SELECT 3",
+ newSourcePartial: "SELECT 4",
+ });
+ assertAcceptRejectUI({ visible: true });
+
+ cy.log("Should be able to reject an edit");
+ rejectSuggestion();
+ assertEditorContent("native", "SELECT 3");
+ assertAcceptRejectUI({ visible: false });
+ });
+
+ it("should update existing Python transform via metabot", () => {
+ H.getTableId({ name: SOURCE_TABLE, databaseId: WRITABLE_DB_ID }).then(
+ (tableId) => {
+ H.createPythonTransform({
+ targetTable: "transform_table",
+ targetSchema: "Schema A",
+ body: dedent`
+ import pandas as pd
+
+ def transform(foo):
+ return pd.DataFrame({'value': [1]})
+ `,
+ sourceTables: { foo: tableId },
+ }).then((transformId) => {
+ visitTransformListPage();
+ H.openMetabotViaSearchButton(true);
+
+ // Ask metabot for a change to existing transform
+ cy.get("@transformId").then((transformId) => {
+ H.mockMetabotResponse({
+ body: createMockTransformSuggestionResponse(
+ "Let me make that update for you.",
+ createMockPythonTransformJSON(
+ Number(transformId),
+ WRITABLE_DB_ID,
+ { foo: tableId },
+ "import pandas as pd\\n\\ndef transform(foo):\\n return pd.DataFrame({'value': [2]})",
+ ),
+ ),
+ });
+ });
+ H.sendMetabotMessage(
+ "Update my SQL transform to select 2 instead of 1.",
+ );
+ assertSuggestionInSidebar({
+ oldSourcePartial: "pd.DataFrame({'value': [1]})",
+ newSourcePartial: "pd.DataFrame({'value': [2]})",
+ });
+
+ cy.log(
+ "Should be able to visit and the see the updated transform",
+ );
+ viewLastSuggestion();
+ assertAcceptRejectUI({ visible: true });
+
+ // User can accept a change (editor should have new value)
+ cy.log("Should be able to select an edit");
+ acceptSuggestion();
+ assertEditorContent("python", "pd.DataFrame({'value': [2]})");
+ assertAcceptRejectUI({ visible: false });
+
+ // User should make changes to the source
+ cy.log("Should diff with user edits");
+ makeManualEdit(
+ "python",
+ dedent`
+ import pandas as pd
+
+ def transform(foo):
+ return pd.DataFrame({'value': [3]})`,
+ );
+
+ H.mockMetabotResponse({
+ body: createMockTransformSuggestionResponse(
+ "Let me make that change for you.",
+ createMockPythonTransformJSON(
+ Number(transformId),
+ WRITABLE_DB_ID,
+ { metabase_table_df: 152 },
+ "import pandas as pd\\n\\ndef transform(foo):\\n return pd.DataFrame({'value': [4]})",
+ ),
+ ),
+ });
+ H.sendMetabotMessage("Make this give me the number 4 instead");
+ assertSuggestionInSidebar({
+ oldSourcePartial: "pd.DataFrame({'value': [3]})",
+ newSourcePartial: "pd.DataFrame({'value': [4]})",
+ });
+ assertAcceptRejectUI({ visible: true });
+
+ cy.log("Should be able to reject an edit");
+ rejectSuggestion();
+ assertEditorContent("python", "pd.DataFrame({'value': [3]})");
+ assertAcceptRejectUI({ visible: false });
+ });
+ },
+ );
+ });
+ });
+ });
+});
+
+const createMockNativeTransformJSON = (
+ id: number | null,
+ databaseId: number,
+ sql: string,
+) =>
+ `{"id":${id},"name":"A number","entity_id":null,"description":"","source":{"type":"query","query":{"database":${databaseId},"type":"native","native":{"query":"${sql}","template-tags":{}}}},"target":{"type":"table","name":""},"created_at":null,"updated_at":null}`;
+
+const createMockPythonTransformJSON = (
+ id: number | null,
+ databaseId: number,
+ sourceTables: { [tableName: string]: number },
+ body: string,
+) =>
+ `{"id":${id},"name":"A number","entity_id":null,"description":"","source":{"type":"python","source-database":${databaseId},"source-tables":${JSON.stringify(sourceTables)},"body":"${body}"},"target":{"type":"table","name":""},"created_at":null,"updated_at":null}`;
+
+const createMockTransformSuggestionResponse = (
+ text: string,
+ transformJSON: string,
+) => {
+ return `0:"${text}"
+2:{"type":"transform_suggestion","version":1,"value":${transformJSON}}
+2:{"type":"state","version":1,"value":{}}
+d:{"finishReason":"stop","usage":{}}`;
+};
diff --git a/enterprise/backend/src/metabase_enterprise/dependencies/api.clj b/enterprise/backend/src/metabase_enterprise/dependencies/api.clj
index 43add0deadc..c21b528367d 100644
--- a/enterprise/backend/src/metabase_enterprise/dependencies/api.clj
+++ b/enterprise/backend/src/metabase_enterprise/dependencies/api.clj
@@ -89,10 +89,9 @@
"Check a proposed edit to a transform, and return the card, transform, etc. IDs for things that will break."
[_route-params
_query-params
- {:keys [id source target] :as _body} :- ::transform-body]
+ {:keys [id source target]} :- ::transform-body]
(api/read-check :model/Transform id)
- (if (= (keyword (:type source))
- :query)
+ (if (= (keyword (:type source)) :query)
(let [database-id (-> source :query :database)
base-provider (lib-be/application-database-metadata-provider database-id)
original (lib.metadata/transform base-provider id)
diff --git a/enterprise/backend/src/metabase_enterprise/metabot_v3/api.clj b/enterprise/backend/src/metabase_enterprise/metabot_v3/api.clj
index e3776bf8554..68361385fc1 100644
--- a/enterprise/backend/src/metabase_enterprise/metabot_v3/api.clj
+++ b/enterprise/backend/src/metabase_enterprise/metabot_v3/api.clj
@@ -75,7 +75,6 @@
"Send a chat message to the LLM via the AI Proxy."
[_route-params
_query-params
-
body :- [:map
[:profile_id {:optional true} :string]
[:metabot_id {:optional true} :string]
diff --git a/enterprise/backend/src/metabase_enterprise/metabot_v3/context.clj b/enterprise/backend/src/metabase_enterprise/metabot_v3/context.clj
index 0baa3f153ce..16ea04cffa6 100644
--- a/enterprise/backend/src/metabase_enterprise/metabot_v3/context.clj
+++ b/enterprise/backend/src/metabase_enterprise/metabot_v3/context.clj
@@ -46,7 +46,9 @@
[:set :string])
(defn backend-metabot-capabilities
- "Set of backend capabilities available to the AI service. Those are determined by the endpoints available to ai-service. When an endpoint would change in a non-backward compatible way, we should create a new version of this capability."
+ "Set of backend capabilities available to the AI service. Those are determined by the endpoints available to
+ ai-service. When an endpoint would change in a non-backward compatible way, we should create a new version of this
+ capability."
[]
;; 20 ns per call, safe to keep unmemoized
(for [[[_method url _params] _spec] (-> (the-ns 'metabase-enterprise.metabot-v3.tools.api)
@@ -54,6 +56,18 @@
:api/endpoints)]
(str "backend:/api/ee/metabot-tools" url)))
+(defn- query-for-sql-parsing
+ "Given an item in context, return the query if it is a native query or SQL transform that can have table usage parsed
+ from it, otherwise nil."
+ [item]
+ (when-let [query (case (:type item)
+ "transform" (-> item :source :query)
+ "adhoc" (-> item :query)
+ (-> item :query))]
+ (when (and (#{:native "native"} (:type query))
+ (:database query))
+ query)))
+
(defn- database-tables-for-context
"Get database tables formatted for metabot context. Only includes tables used in the query, formatted for API output.
Removes duplicate tables by id while preserving first occurrence order."
@@ -70,19 +84,48 @@
(log/error e "Error getting database tables for context")
[])))
+(defn- python-transform-db-and-table-ids
+ "Returns a map with :database-id and :table-ids, or nil if not a Python transform."
+ [item]
+ (when (and (= (:type item) "transform")
+ (= (get-in item [:source :type]) "python"))
+ (when-let [source-database (get-in item [:source :source-database])]
+ (when-let [source-tables (not-empty (get-in item [:source :source-tables]))]
+ {:database-id source-database
+ :table-ids (vals source-tables)}))))
+
+(defn- python-transform-tables-for-context
+ "Get tables for Python transform formatted for metabot context."
+ [{:keys [database-id table-ids]}]
+ (try
+ (when (and database-id (seq table-ids))
+ (when-let [tables (not-empty (table-utils/used-tables-from-ids database-id table-ids))]
+ (table-utils/enhanced-database-tables database-id
+ {:priority-tables tables
+ :all-tables-limit (count tables)})))
+ (catch Exception e
+ (log/error e "Error getting Python transform tables for context")
+ [])))
+
(defn- enhance-context-with-schema
- "Enhance context by adding table schema information for native queries"
+ "Enhance context by adding table schema information for native queries, SQL transforms, and Python transforms"
[context]
(if-let [user-viewing (get context :user_is_viewing)]
(let [enhanced-viewing
(mapv (fn [item]
- (if (and (#{:native "native"} (get-in item [:query :type]))
- (get-in item [:query :database]))
- (let [tables (database-tables-for-context {:query (:query item)})]
- (if (seq tables)
- (assoc item :used_tables tables)
- item))
- item))
+ (or
+ ;; Handle native queries and SQL transforms
+ (when-let [query (query-for-sql-parsing item)]
+ (when-let [tables (seq (database-tables-for-context {:query query}))]
+ (assoc item :used_tables tables)))
+
+ ;; Handle Python transforms
+ (when-let [db-and-table-ids (python-transform-db-and-table-ids item)]
+ (when-let [tables (seq (python-transform-tables-for-context db-and-table-ids))]
+ (assoc item :used_tables tables)))
+
+ ;; Unknown item: return unchanged
+ item))
user-viewing)]
(assoc context :user_is_viewing enhanced-viewing))
context))
diff --git a/enterprise/backend/src/metabase_enterprise/metabot_v3/table_utils.clj b/enterprise/backend/src/metabase_enterprise/metabot_v3/table_utils.clj
index 562b09a5ddd..9ebb63715d0 100644
--- a/enterprise/backend/src/metabase_enterprise/metabot_v3/table_utils.clj
+++ b/enterprise/backend/src/metabase_enterprise/metabot_v3/table_utils.clj
@@ -152,6 +152,15 @@
(nil? tschema)
(similar? uschema tschema))))
+(defn- visible-filter-clause
+ []
+ (mi/visible-filter-clause :model/Table
+ :id
+ {:user-id api/*current-user-id*
+ :is-superuser? api/*is-superuser?*}
+ {:perms/view-data :unrestricted
+ :perms/create-queries :query-builder-and-native}))
+
(defn find-matching-tables
"Find tables in the database that are similar to the unrecognized tables using fuzzy matching.
@@ -175,17 +184,26 @@
:db_id database-id
:active true
:visibility_type nil
- (cond-> {:where (mi/visible-filter-clause :model/Table
- :id
- {:user-id api/*current-user-id*
- :is-superuser? api/*is-superuser?*}
- {:perms/view-data :unrestricted
- :perms/create-queries :query-builder-and-native})
+ (cond-> {:where (visible-filter-clause)
:limit 10000}
(seq used-ids) (update :where #(if %
[:and % [:not-in :id used-ids]]
[:not-in :id used-ids]))))))
+(defn used-tables-from-ids
+ "Return table info for `table-ids` in the same shape as [[used-tables]].
+
+ Useful for cases where you don't have a native query (e.g. python transforms), but do have a seq of used table ids."
+ [database-id table-ids]
+ (if-not (seq table-ids)
+ []
+ (t2/select [:model/Table :id :name :schema]
+ :db_id database-id
+ :id [:in table-ids]
+ :active true
+ :visibility_type nil
+ {:where (visible-filter-clause)})))
+
(defn used-tables
"Return all tables used in the query, including fuzzy-matched ones.
diff --git a/enterprise/backend/src/metabase_enterprise/metabot_v3/tools/api.clj b/enterprise/backend/src/metabase_enterprise/metabot_v3/tools/api.clj
index b33a2ed4555..7205c7eccb4 100644
--- a/enterprise/backend/src/metabase_enterprise/metabot_v3/tools/api.clj
+++ b/enterprise/backend/src/metabase_enterprise/metabot_v3/tools/api.clj
@@ -14,11 +14,14 @@
[metabase-enterprise.metabot-v3.table-utils :as table-utils]
[metabase-enterprise.metabot-v3.tools.create-dashboard-subscription
:as metabot-v3.tools.create-dashboard-subscription]
+ [metabase-enterprise.metabot-v3.tools.dependencies :as metabot-v3.tools.dependencies]
[metabase-enterprise.metabot-v3.tools.field-stats :as metabot-v3.tools.field-stats]
[metabase-enterprise.metabot-v3.tools.filters :as metabot-v3.tools.filters]
[metabase-enterprise.metabot-v3.tools.find-outliers :as metabot-v3.tools.find-outliers]
[metabase-enterprise.metabot-v3.tools.generate-insights :as metabot-v3.tools.generate-insights]
[metabase-enterprise.metabot-v3.tools.search :as metabot-v3.tools.search]
+ [metabase-enterprise.metabot-v3.tools.snippets :as metabot-v3.tools.snippets]
+ [metabase-enterprise.metabot-v3.tools.transforms :as metabot-v3.tools.transforms]
[metabase-enterprise.metabot-v3.util :as metabot-v3.u]
[metabase.api.macros :as api.macros]
[metabase.api.response :as api.response]
@@ -620,6 +623,62 @@
[:structured_output ::table-result]]
[:map [:output :string]]])
+(mr/def ::basic-transform
+ [:map
+ {:decode/tool-api-response #(update-keys % metabot-v3.u/safe->snake_case_en)}
+ [:id :int]
+ [:name :string]
+ [:description {:optional true} [:maybe :string]]
+ [:entity_id {:optional true} [:maybe :string]]
+ ;; :source keys are not snake_cased to match what the FE expects / provides in user_is_viewing context
+ [:source ::metabot-v3.tools.transforms/transform-source]])
+
+(mr/def ::full-transform
+ [:merge
+ ::basic-transform
+ [:map {:decode/tool-api-response #(update-keys % metabot-v3.u/safe->snake_case_en)}
+ [:created_at ms/TemporalString]
+ [:updated_at ms/TemporalString]
+ ;; :target keys are not snake_cased to match what the FE expects / provides in user_is_viewing context
+ [:target ::metabot-v3.tools.transforms/transform-target]]])
+
+(mr/def ::get-transforms-result
+ [:or
+ [:map
+ {:decode/tool-api-response #(update-keys % metabot-v3.u/safe->snake_case_en)}
+ [:structured_output [:sequential ::basic-transform]]]
+ [:map [:output :string]]])
+
+(mr/def ::get-transform-details-arguments
+ [:and
+ [:map
+ [:transform_id :int]]
+ [:map {:encode/tool-api-request
+ #(set/rename-keys % {:transform_id :transform-id})}]])
+
+(mr/def ::get-transform-details-result
+ [:or
+ [:map {:decode/tool-api-response #(update-keys % metabot-v3.u/safe->snake_case_en)}
+ [:structured_output [:sequential ::full-transform]]]
+ [:map [:output :string]]])
+
+(mr/def ::get-transform-python-library-details-arguments
+ [:and
+ [:map
+ [:path :string]]
+ [:map {:encode/tool-api-request
+ #(update-keys % metabot-v3.u/safe->kebab-case-en)}]])
+
+(mr/def ::get-transform-python-library-details-result
+ [:or
+ [:map {:decode/tool-api-response #(update-keys % metabot-v3.u/safe->snake_case_en)}
+ [:structured_output [:map {:decode/tool-api-response #(update-keys % metabot-v3.u/safe->snake_case_en)}
+ [:source :string]
+ [:path :string]
+ [:created_at ms/TemporalString]
+ [:updated_at ms/TemporalString]]]]
+ [:map [:output :string]]])
+
(mr/def ::answer-sources-result
[:or
[:map
@@ -629,6 +688,36 @@
[:models [:sequential ::table-result]]]]]
[:map [:output :string]]])
+(mr/def ::basic-snippet
+ [:map {:decode/tool-api-response #(update-keys % metabot-v3.u/safe->snake_case_en)}
+ [:id :int]
+ [:name :string]
+ [:description {:optional true} [:maybe :string]]])
+
+(mr/def ::full-snippet
+ [:merge
+ ::basic-snippet
+ [:map {:decode/tool-api-response #(update-keys % metabot-v3.u/safe->snake_case_en)}
+ [:content :string]]])
+
+(mr/def ::get-snippets-result
+ "Schema for SQL snippet list results"
+ [:map
+ {:decode/tool-api-response #(update-keys % metabot-v3.u/safe->snake_case_en)}
+ [:structured_output [:sequential ::basic-snippet]]])
+
+(mr/def ::get-snippet-details-arguments
+ [:and
+ [:map
+ [:snippet_id :int]]
+ [:map {:encode/tool-api-request
+ #(set/rename-keys % {:snippet_id :snippet-id})}]])
+
+(mr/def ::get-snippet-details-result
+ "Schema for SQL snippet detail results"
+ [:map {:decode/tool-api-response #(update-keys % metabot-v3.u/safe->snake_case_en)}
+ [:structured_output ::full-snippet]])
+
(api.macros/defendpoint :post "/answer-sources" :- [:merge ::answer-sources-result ::tool-request]
"Return top level meta information about available information sources."
[_route-params
@@ -850,6 +939,54 @@
(assoc :conversation_id conversation_id))
(metabot-v3.context/log :llm.log/be->llm))))
+(api.macros/defendpoint :post "/get-transforms" :- [:merge ::get-transforms-result ::tool-request]
+ "Get a list of all known transforms."
+ [_route-params
+ _query-params
+ {:keys [conversation_id] :as body} :- ::tool-request]
+ (metabot-v3.context/log (assoc body :api :get-transforms) :llm.log/llm->be)
+ (doto (-> (mc/decode ::get-transforms-result
+ (metabot-v3.tools.transforms/get-transforms)
+ (mtx/transformer {:name :tool-api-response}))
+ (assoc :conversation_id conversation_id))
+ (metabot-v3.context/log :llm.log/be->llm)))
+
+(api.macros/defendpoint :post "/get-transform-details" :- [:merge ::get-transform-details-result ::tool-request]
+ "Get information about a transform."
+ [_route-params
+ _query-params
+ {:keys [arguments conversation_id] :as body} :- [:merge
+ [:map [:arguments ::get-transform-details-arguments]]
+ ::tool-request]]
+ (metabot-v3.context/log (assoc body :api :get-transform-details) :llm.log/llm->be)
+ (let [arguments (mc/encode ::get-transform-details-arguments arguments (mtx/transformer {:name :tool-api-request}))
+ transform-id (:transform-id arguments)]
+ (doto (-> (mc/decode ::get-transform-details-result
+ (metabot-v3.tools.transforms/get-transform-details transform-id)
+ (mtx/transformer {:name :tool-api-response}))
+ (assoc :conversation_id conversation_id))
+ (metabot-v3.context/log :llm.log/be->llm))))
+
+(api.macros/defendpoint :post "/get-transform-python-library-details" :- [:merge
+ ::get-transform-python-library-details-result
+ ::tool-request]
+ "Get information about a Python library by path."
+ [_route-params
+ _query-params
+ {:keys [arguments conversation_id] :as body} :- [:merge
+ [:map [:arguments
+ ::get-transform-python-library-details-arguments]]
+ ::tool-request]]
+ (metabot-v3.context/log (assoc body :api :get-transform-python-library-details) :llm.log/llm->be)
+ (let [arguments (mc/encode ::get-transform-python-library-details-arguments
+ arguments (mtx/transformer {:name :tool-api-request}))
+ path (:path arguments)]
+ (doto (-> (mc/decode ::get-transform-python-library-details-result
+ (metabot-v3.tools.transforms/get-transform-python-library-details path)
+ (mtx/transformer {:name :tool-api-response}))
+ (assoc :conversation_id conversation_id))
+ (metabot-v3.context/log :llm.log/be->llm))))
+
(api.macros/defendpoint :post "/query-metric" :- [:merge ::filtering-result ::tool-request]
"Construct a query from a metric."
[_route-params
@@ -902,13 +1039,14 @@
(mr/def ::search-arguments
[:and
[:map
- [:term_queries {:optional true} [:maybe [:sequential :string]]]
- [:semantic_queries {:optional true} [:maybe [:sequential :string]]]
- [:entity_types {:optional true} [:maybe [:sequential [:enum "table" "model" "question" "dashboard" "metric" "database"]]]]
- [:database_id {:optional true} [:maybe :int]]
- [:created_at {:optional true} [:maybe ms/NonBlankString]]
- [:last_edited_at {:optional true} [:maybe ms/NonBlankString]]
- [:limit {:optional true, :default 50} [:and :int [:fn #(<= 1 % 100)]]]]
+ [:term_queries {:optional true} [:maybe [:sequential :string]]]
+ [:semantic_queries {:optional true} [:maybe [:sequential :string]]]
+ [:entity_types {:optional true} [:maybe [:sequential [:enum "table" "model" "question" "dashboard" "metric" "database" "transform"]]]]
+ [:database_id {:optional true} [:maybe :int]]
+ [:created_at {:optional true} [:maybe ms/NonBlankString]]
+ [:last_edited_at {:optional true} [:maybe ms/NonBlankString]]
+ [:search_native_query {:optional true, :default false} [:maybe :boolean]]
+ [:limit {:optional true, :default 50} [:and :int [:fn #(<= 1 % 100)]]]]
[:map {:encode/tool-api-request
#(update-keys % (comp keyword u/->kebab-case-en))}]])
@@ -916,7 +1054,7 @@
"Unified schema for search result items."
[:map {:decode/tool-api-response #(update-keys % metabot-v3.u/safe->snake_case_en)}
[:id :int]
- [:type [:enum :table :model :dashboard :question :metric :database]]
+ [:type [:enum :table :model :dashboard :question :metric :database :transform]]
[:name :string]
[:display_name {:optional true} [:maybe :string]]
[:description {:optional true} [:maybe :string]]
@@ -938,15 +1076,9 @@
[:total_count :int]]]]
[:map [:output :string]]])
-(api.macros/defendpoint :post "/search" :- [:merge ::search-result ::tool-request]
- "Enhanced search with term and semantic queries using Reciprocal Rank Fusion."
- [_route-params
- _query-params
- {:keys [arguments conversation_id] :as body} :- [:merge
- [:map [:arguments {:optional true} ::search-arguments]]
- ::tool-request]
- request]
- (metabot-v3.context/log (assoc body :api :search) :llm.log/llm->be)
+(defn- search
+ "Shared handler for the /search and /search_v2 endpoints."
+ [arguments conversation_id request]
(try
(let [options (mc/encode ::search-arguments
arguments (mtx/transformer {:name :tool-api-request}))
@@ -966,6 +1098,103 @@
(assoc :conversation_id conversation_id))
(metabot-v3.context/log :llm.log/be->llm)))))
+(api.macros/defendpoint :post "/search" :- [:merge ::search-result ::tool-request]
+ "Enhanced search with term and semantic queries using Reciprocal Rank Fusion."
+ [_route-params
+ _query-params
+ {:keys [arguments conversation_id] :as body} :- [:merge
+ [:map [:arguments {:optional true} ::search-arguments]]
+ ::tool-request]
+ request]
+ (metabot-v3.context/log (assoc body :api :search) :llm.log/llm->be)
+ (search arguments conversation_id request))
+
+(api.macros/defendpoint :post "/search_v2" :- [:merge ::search-result ::tool-request]
+ "Enhanced search with term and semantic queries using Reciprocal Rank Fusion. This is identical to /search, but
+ duplicated in order to add a new capability to AI service that indicates that Metabot can search transforms. The
+ /search endpoint is kept around for backward compatibility."
+ [_route-params
+ _query-params
+ {:keys [arguments conversation_id] :as body} :- [:merge
+ [:map [:arguments {:optional true} ::search-arguments]]
+ ::tool-request]
+ request]
+ (metabot-v3.context/log (assoc body :api :search_v2) :llm.log/llm->be)
+ (search arguments conversation_id request))
+
+(api.macros/defendpoint :post "/get-snippets" :- [:merge ::get-snippets-result ::tool-request]
+ "Get a list of all known SQL snippets."
+ [_route-params
+ _query-params
+ {:keys [conversation_id] :as body} :- ::tool-request]
+ (metabot-v3.context/log (assoc body :api :get-snippets) :llm.log/llm->be)
+ (doto (-> (mc/decode ::get-snippets-result
+ (metabot-v3.tools.snippets/get-snippets)
+ (mtx/transformer {:name :tool-api-response}))
+ (assoc :conversation_id conversation_id))
+ (metabot-v3.context/log :llm.log/be->llm)))
+
+(api.macros/defendpoint :post "/get-snippet-details" :- [:merge ::get-snippet-details-result ::tool-request]
+ "Get the content of a single SQL snippet."
+ [_route-params
+ _query-params
+ {:keys [arguments conversation_id] :as body} :- [:merge
+ [:map [:arguments ::get-snippet-details-arguments]]
+ ::tool-request]]
+
+ (metabot-v3.context/log (assoc body :api :get-snippet-details) :llm.log/llm->be)
+ (let [arguments (mc/encode ::get-snippet-details-arguments arguments (mtx/transformer {:name :tool-api-request}))
+ snippet-id (:snippet-id arguments)]
+ (doto (-> (mc/decode ::get-snippet-details-result
+ (metabot-v3.tools.snippets/get-snippet-details snippet-id)
+ (mtx/transformer {:name :tool-api-response}))
+ (assoc :conversation_id conversation_id))
+ (metabot-v3.context/log :llm.log/be->llm))))
+
+(mr/def ::check-transform-dependencies-arguments
+ [:and
+ [:map
+ [:transform_id :int]
+ [:source ::metabot-v3.tools.transforms/transform-source]]
+ [:map {:encode/tool-api-request
+ #(set/rename-keys % {:transform_id :id})}]])
+
+(mr/def ::broken-question
+ [:map {:decode/tool-api-response #(update-keys % metabot-v3.u/safe->snake_case_en)}
+ [:id :int]
+ [:name :string]])
+
+(mr/def ::broken-transform
+ [:map {:decode/tool-api-response #(update-keys % metabot-v3.u/safe->snake_case_en)}
+ [:id :int]
+ [:name :string]])
+
+(mr/def ::check-transform-dependencies-result
+ [:or
+ [:map {:decode/tool-api-response #(update-keys % metabot-v3.u/safe->snake_case_en)}
+ [:structured_output [:map
+ [:success :boolean]
+ [:bad_transform_count :int]
+ [:bad_transforms [:sequential ::broken-transform]]
+ [:bad_question_count :int]
+ [:bad_questions [:sequential ::broken-question]]]]]
+ [:map [:output :string]]])
+
+(api.macros/defendpoint :post "/check-transform-dependencies" :- [:merge ::check-transform-dependencies-result ::tool-request]
+ "Check a proposed edit to a transform and return details of cards or transforms that would be broken by the change."
+ [_route-params
+ _query-params
+ {:keys [arguments conversation_id] :as body} :- [:merge
+ [:map [:arguments ::check-transform-dependencies-arguments]]
+ ::tool-request]]
+ (metabot-v3.context/log (assoc body :api :check-transform-dependencies) :llm.log/llm->be)
+ (let [arguments (mc/encode ::check-transform-dependencies-arguments arguments (mtx/transformer {:name :tool-api-request}))]
+ (doto (-> (mc/decode ::check-transform-dependencies-result
+ (metabot-v3.tools.dependencies/check-transform-dependencies arguments)
+ (mtx/transformer {:name :tool-api-response}))
+ (assoc :conversation_id conversation_id))
+ (metabot-v3.context/log :llm.log/be->llm))))
+
(defn- enforce-authentication
"Middleware that returns a 401 response if no `ai-session` can be found for `request`."
[handler]
diff --git a/enterprise/backend/src/metabase_enterprise/metabot_v3/tools/dependencies.clj b/enterprise/backend/src/metabase_enterprise/metabot_v3/tools/dependencies.clj
new file mode 100644
index 00000000000..11b55216bb1
--- /dev/null
+++ b/enterprise/backend/src/metabase_enterprise/metabot_v3/tools/dependencies.clj
@@ -0,0 +1,66 @@
+(ns metabase-enterprise.metabot-v3.tools.dependencies
+ (:require
+ [metabase-enterprise.dependencies.core :as dependencies]
+ [metabase-enterprise.metabot-v3.tools.util :as metabot-v3.tools.u]
+ [metabase.api.common :as api]
+ [metabase.lib-be.core :as lib-be]
+ [metabase.models.interface :as mi]
+ [toucan2.core :as t2]))
+
+(def ^:private ^:dynamic *max-reported-broken-transforms* 10)
+
+(defn- format-broken-transforms
+ "Format the breakages into a response suitable for Metabot."
+ [edited-transform-id {transform-errors :transform
+ card-errors :card}]
+ (let [broken-transform-ids (set (keys transform-errors))
+ ;; Limit the number of broken transforms/cards we report back to avoid overwhelming context
+ transforms-to-report (if (contains? transform-errors edited-transform-id)
+ (concat [edited-transform-id]
+ (take (dec *max-reported-broken-transforms*)
+ (disj broken-transform-ids edited-transform-id)))
+ (take *max-reported-broken-transforms* broken-transform-ids))
+ broken-transforms (when (seq transforms-to-report)
+ (->> (t2/select :model/Transform :id [:in transforms-to-report])
+ (filter mi/can-read?)
+ (map #(select-keys % [:id :name]))))
+ broken-card-ids (set (keys card-errors))
+ cards-to-report (take *max-reported-broken-transforms* broken-card-ids)
+ broken-cards (when (seq cards-to-report)
+ (->> (t2/select :model/Card :id [:in cards-to-report])
+ (filter mi/can-read?)
+ (map #(select-keys % [:id :name]))))]
+ {:success (empty? broken-transform-ids)
+ :bad_transform_count (count broken-transform-ids)
+ :bad_transforms (mapv
+ (fn [transform]
+ {:transform transform :errors (get transform-errors (:id transform))})
+ broken-transforms)
+ ;; Use "question" terminology rather than "card" to avoid confusing Metabot
+ :bad_question_count (count broken-card-ids)
+ :bad_questions (when (seq broken-card-ids)
+ (mapv (fn [card]
+ {:question card :errors (get card-errors (:id card))})
+ broken-cards))}))
+
+(defn check-transform-dependencies
+ "Check a proposed edit to a SQL transform, and return transforms that will break in a format
+ suitable for Metabot. Takes a map with :id and :source keys."
+ [{:keys [id source]}]
+ (try
+ (let [transform-to-check (api/check-404 (t2/select-one :model/Transform :id id))]
+ (api/read-check transform-to-check)
+ (let [result (if (= (keyword (:type source)) :query)
+ (let [database-id (-> source :query :database)
+ base-provider (lib-be/application-database-metadata-provider database-id)
+ metadata (lib-be/instance->metadata transform-to-check :metadata/transform)
+ updated-metadata (cond-> metadata
+ source (assoc :source source))
+ edits {:transform [updated-metadata]}
+ breakages (dependencies/errors-from-proposed-edits base-provider edits)]
+ (format-broken-transforms id breakages))
+ ;; If this is a non-SQL query, we don't do any checks yet, so just return success
+ {:success true :bad_transforms []})]
+ {:structured_output result}))
+ (catch Exception e
+ (metabot-v3.tools.u/handle-agent-error e))))
diff --git a/enterprise/backend/src/metabase_enterprise/metabot_v3/tools/search.clj b/enterprise/backend/src/metabase_enterprise/metabot_v3/tools/search.clj
index 32b394bfe80..e6613195562 100644
--- a/enterprise/backend/src/metabase_enterprise/metabot_v3/tools/search.clj
+++ b/enterprise/backend/src/metabase_enterprise/metabot_v3/tools/search.clj
@@ -6,10 +6,11 @@
[metabase.api.common :as api]
[metabase.permissions.core :as perms]
[metabase.search.core :as search]
+ [metabase.util.log :as log]
[toucan2.core :as t2]))
(def ^:private metabot-search-models
- #{"table" "dataset" "card" "dashboard" "metric" "database"})
+ #{"table" "dataset" "card" "dashboard" "metric" "database" "transform"})
(def ^:private search-model-mappings
"Maps metabot entity types to search engine model types"
@@ -24,18 +25,18 @@
[search-model]
(get (set/map-invert search-model-mappings) search-model search-model))
-(defn- transform-search-result
+(defn- postprocess-search-result
"Transform a single search result to match the appropriate entity-specific schema."
[{:keys [verified moderated_status collection] :as result}]
(let [model (:model result)
verified? (or (boolean verified) (= moderated_status "verified"))
collection-info (select-keys collection [:name :authority_level])
- common-fields {:id (:id result)
- :type (search-model->result-type model)
- :name (:name result)
- :description (:description result)
- :updated_at (:updated_at result)
- :created_at (:created_at result)}]
+ common-fields {:id (:id result)
+ :type (search-model->result-type model)
+ :name (:name result)
+ :description (:description result)
+ :updated_at (:updated_at result)
+ :created_at (:created_at result)}]
(case model
"database"
common-fields
@@ -49,14 +50,18 @@
"dashboard"
(merge common-fields
- {:verified verified?
- :collection collection-info})
+ {:verified verified?
+ :collection collection-info})
+
+ "transform"
+ (merge common-fields
+ {:database_id (:database_id result)})
;; Questions, metrics, and datasets
(merge common-fields
- {:database_id (:database_id result)
- :verified verified?
- :collection collection-info}))))
+ {:database_id (:database_id result)
+ :verified verified?
+ :collection collection-info}))))
(defn- search-result-id
"Generate a unique identifier for a search result based on its id and model."
@@ -95,13 +100,24 @@
(map :search-result)))))
(defn search
- "Search for data sources (tables, models, cards, dashboards, metrics) in Metabase.
+ "Search for data sources (tables, models, cards, dashboards, metrics, transforms) in Metabase.
Abstracted from the API endpoint logic."
[{:keys [term-queries semantic-queries database-id created-at last-edited-at
- entity-types limit metabot-id]}]
+ entity-types limit metabot-id search-native-query]}]
+ (log/infof "[METABOT-SEARCH] Starting search with params: %s"
+ {:term-queries term-queries
+ :semantic-queries semantic-queries
+ :database-id database-id
+ :created-at created-at
+ :last-edited-at last-edited-at
+ :entity-types entity-types
+ :limit limit
+ :metabot-id metabot-id
+ :search-native-query search-native-query})
(let [search-models (if (seq entity-types)
(set (distinct (keep entity-type->search-model entity-types)))
metabot-search-models)
+ _ (log/infof "[METABOT-SEARCH] Converted entity-types %s to search-models %s" entity-types search-models)
all-queries (distinct (concat (or term-queries []) (or semantic-queries [])))
metabot (t2/select-one :model/Metabot :entity_id (get-in metabot-v3.config/metabot-config [metabot-id :entity-id] metabot-id))
use-verified-content? (if metabot-id
@@ -125,12 +141,21 @@
:archived false
:limit limit
:offset 0}
+ ;; Don't include search-native-query key if nil so that we don't
+ ;; inadvertently filter out search models that don't support it
+ (when search-native-query
+ {:search-native-query (boolean search-native-query)})
(when use-verified-content?
{:verified true})))
- search-results (search/search search-context)]
- (:data search-results)))
+ _ (log/infof "[METABOT-SEARCH] Search context models for query '%s': %s"
+ query (:models search-context))
+ search-results (search/search search-context)
+ data (:data search-results)
+ result-models (frequencies (map :model data))]
+ (log/infof "[METABOT-SEARCH] Query '%s' returned entity types: %s" query result-models)
+ data))
;; Create futures for parallel execution
futures (mapv #(future (search-fn %)) all-queries)
result-lists (mapv deref futures)
fused-results (take limit (reciprocal-rank-fusion result-lists))]
- (map transform-search-result fused-results)))
+ (map postprocess-search-result fused-results)))
diff --git a/enterprise/backend/src/metabase_enterprise/metabot_v3/tools/snippets.clj b/enterprise/backend/src/metabase_enterprise/metabot_v3/tools/snippets.clj
new file mode 100644
index 00000000000..b029ecd9526
--- /dev/null
+++ b/enterprise/backend/src/metabase_enterprise/metabot_v3/tools/snippets.clj
@@ -0,0 +1,25 @@
+(ns metabase-enterprise.metabot-v3.tools.snippets
+ (:require
+ [metabase-enterprise.metabot-v3.tools.util :as metabot-v3.tools.u]
+ [metabase.native-query-snippets.core :as snippets]))
+
+(defn get-snippets
+ "Lists SQL snippets available to the current user."
+ []
+ (try
+ {:structured_output
+ (->> (snippets/list-native-query-snippets)
+ (map #(select-keys % [:id :name :description])))}
+ (catch Exception e
+ (metabot-v3.tools.u/handle-agent-error e))))
+
+(defn get-snippet-details
+ "Retrieve a specific SQL snippet by ID, including its content."
+ [snippet-id]
+ (try
+ {:structured_output
+ (when snippet-id
+ (when-let [snippet (snippets/get-native-query-snippet snippet-id)]
+ (select-keys snippet [:id :name :description :content])))}
+ (catch Exception e
+ (metabot-v3.tools.u/handle-agent-error e))))
diff --git a/enterprise/backend/src/metabase_enterprise/metabot_v3/tools/transforms.clj b/enterprise/backend/src/metabase_enterprise/metabot_v3/tools/transforms.clj
new file mode 100644
index 00000000000..c402785638f
--- /dev/null
+++ b/enterprise/backend/src/metabase_enterprise/metabot_v3/tools/transforms.clj
@@ -0,0 +1,40 @@
+(ns metabase-enterprise.metabot-v3.tools.transforms
+ (:require
+ [metabase-enterprise.metabot-v3.tools.util :as metabot-v3.tools.u]
+ [metabase-enterprise.transforms-python.api :as transforms-python.api]
+ [metabase-enterprise.transforms.api :as api.transforms]
+ [metabase-enterprise.transforms.core :as transforms]
+ [metabase.util.malli.registry :as mr]))
+
+(mr/def ::transform-source ::api.transforms/transform-source)
+(mr/def ::transform-target ::api.transforms/transform-target)
+
+(defn get-transforms
+ "Get a list of all known transforms."
+ []
+ (try
+ {:structured_output
+ (->> (api.transforms/get-transforms)
+ (into [] (comp (map #(select-keys % [:id :entity_id :name :description :source]))
+ (filter #(or (transforms/python-transform? %)
+ (transforms/native-query-transform? %))))))}
+ (catch Exception e
+ (metabot-v3.tools.u/handle-agent-error e))))
+
+(defn get-transform-details
+ "Get information about a transform."
+ [transform-id]
+ (try
+ {:structured_output
+ (api.transforms/get-transform transform-id)}
+ (catch Exception e
+ (metabot-v3.tools.u/handle-agent-error e))))
+
+(defn get-transform-python-library-details
+ "Get information about a Python library by path."
+ [path]
+ (try
+ {:structured_output
+ (transforms-python.api/get-python-library-by-path path)}
+ (catch Exception e
+ (metabot-v3.tools.u/handle-agent-error e))))
diff --git a/enterprise/backend/src/metabase_enterprise/semantic_search/scoring.clj b/enterprise/backend/src/metabase_enterprise/semantic_search/scoring.clj
index 40b9cdeb007..fe3e01d23b7 100644
--- a/enterprise/backend/src/metabase_enterprise/semantic_search/scoring.clj
+++ b/enterprise/backend/src/metabase_enterprise/semantic_search/scoring.clj
@@ -1,6 +1,7 @@
(ns metabase-enterprise.semantic-search.scoring
(:require
[clojure.core.memoize :as memoize]
+ [clojure.set :as set]
[honey.sql :as sql]
[honey.sql.helpers :as sql.helpers]
[medley.core :as m]
@@ -175,11 +176,13 @@
(into #{} (map name activity-feed/rv-models)))
(def ^:private appdb-scorer-models
- (into recent-views-models (map name search.scoring/bookmarked-models-and-sub-models)))
+ (-> recent-views-models
+ ;; Add "transform" here because it's not a recent-views model, but should still be scored
+ (conj "transform")
+ (into (map name) search.scoring/bookmarked-models-and-sub-models)))
(comment
- (require '[clojure.set :as set]
- '[metabase.search.spec :as search.spec])
+ (require '[metabase.search.spec :as search.spec])
;; #{"segment" "database" "action" "indexed-entity"}
(set/difference (set search.spec/search-models) appdb-scorer-models))
diff --git a/enterprise/backend/src/metabase_enterprise/transforms/api.clj b/enterprise/backend/src/metabase_enterprise/transforms/api.clj
index f6a3c81a326..b02dfa12275 100644
--- a/enterprise/backend/src/metabase_enterprise/transforms/api.clj
+++ b/enterprise/backend/src/metabase_enterprise/transforms/api.clj
@@ -15,11 +15,11 @@
[metabase.api.util.handlers :as handlers]
[metabase.driver.util :as driver.u]
[metabase.events.core :as events]
+ [metabase.queries.schema :as queries.schema]
[metabase.request.core :as request]
[metabase.util :as u]
[metabase.util.i18n :refer [deferred-tru]]
[metabase.util.jvm :as u.jvm]
- [metabase.util.log :as log]
[metabase.util.malli.registry :as mr]
[metabase.util.malli.schema :as ms]
[ring.util.response :as response]
@@ -35,7 +35,7 @@
[:query
[:map
[:type [:= "query"]]
- [:query [:map [:database :int]]]]]
+ [:query ::queries.schema/query]]]
[:python
[:map {:closed true}
[:source-database {:optional true} :int]
@@ -85,14 +85,9 @@
(api/check (transforms.util/check-feature-enabled transform)
[402 (deferred-tru "Premium features required for this transform type are not enabled.")]))
-(api.macros/defendpoint :get "/"
+(defn get-transforms
"Get a list of transforms."
- [_route-params
- {:keys [last_run_start_time last_run_statuses tag_ids]} :-
- [:map
- [:last_run_start_time {:optional true} [:maybe ms/NonBlankString]]
- [:last_run_statuses {:optional true} [:maybe (ms/QueryVectorOf [:enum "started" "succeeded" "failed" "timeout"])]]
- [:tag_ids {:optional true} [:maybe (ms/QueryVectorOf ms/IntGreaterThanOrEqualToZero)]]]]
+ [& {:keys [last_run_start_time last_run_statuses tag_ids]}]
(api/check-superuser)
(let [transforms (t2/select :model/Transform)]
(into []
@@ -102,6 +97,16 @@
(map #(update % :last_run transforms.util/localize-run-timestamps)))
(t2/hydrate transforms :last_run :transform_tag_ids))))
+(api.macros/defendpoint :get "/"
+ "Get a list of transforms."
+ [_route-params
+ query-params :-
+ [:map
+ [:last_run_start_time {:optional true} [:maybe ms/NonBlankString]]
+ [:last_run_statuses {:optional true} [:maybe (ms/QueryVectorOf [:enum "started" "succeeded" "failed" "timeout"])]]
+ [:tag_ids {:optional true} [:maybe (ms/QueryVectorOf ms/IntGreaterThanOrEqualToZero)]]]]
+ (get-transforms query-params))
+
(api.macros/defendpoint :post "/"
"Create a new transform."
[_route-params
@@ -131,11 +136,9 @@
(events/publish-event! :event/transform-create {:object transform :user-id api/*current-user-id*})
transform))
-(api.macros/defendpoint :get "/:id"
+(defn get-transform
"Get a specific transform."
- [{:keys [id]} :- [:map
- [:id ms/PositiveInt]]]
- (log/info "get transform" id)
+ [id]
(api/check-superuser)
(let [{:keys [target] :as transform} (api/check-404 (t2/select-one :model/Transform id))
target-table (transforms.util/target-table (transforms.i/target-db-id transform) target :active true)]
@@ -144,11 +147,16 @@
(u/update-some :last_run transforms.util/localize-run-timestamps)
(assoc :table target-table))))
+(api.macros/defendpoint :get "/:id"
+ "Get a specific transform."
+ [{:keys [id]} :- [:map
+ [:id ms/PositiveInt]]]
+ (get-transform id))
+
(api.macros/defendpoint :get "/:id/dependencies"
"Get the dependencies of a specific transform."
[{:keys [id]} :- [:map
[:id ms/PositiveInt]]]
- (log/info "get dependencies for transform" id)
(api/check-superuser)
(let [id->transform (t2/select-pk->fn identity :model/Transform)
_ (api/check-404 (get id->transform id))
@@ -169,7 +177,6 @@
[:start_time {:optional true} [:maybe ms/NonBlankString]]
[:end_time {:optional true} [:maybe ms/NonBlankString]]
[:run_methods {:optional true} [:maybe (ms/QueryVectorOf [:enum "manual" "cron"])]]]]
- (log/info "get runs")
(api/check-superuser)
(-> (transform-run/paged-runs (assoc query-params
:offset (request/offset)
@@ -188,7 +195,6 @@
[:target {:optional true} ::transform-target]
[:run_trigger {:optional true} ::run-trigger]
[:tag_ids {:optional true} [:sequential ms/PositiveInt]]]]
- (log/info "put transform" id)
(api/check-superuser)
(let [transform (t2/with-transaction [_]
;; Cycle detection should occur within the transaction to avoid race
@@ -218,7 +224,6 @@
"Delete a transform."
[{:keys [id]} :- [:map
[:id ms/PositiveInt]]]
- (log/info "delete transform" id)
(api/check-superuser)
(t2/delete! :model/Transform id)
nil)
@@ -227,7 +232,6 @@
"Delete a transform's output table."
[{:keys [id]} :- [:map
[:id ms/PositiveInt]]]
- (log/info "delete transform target table" id)
(api/check-superuser)
(transforms.util/delete-target-table-by-id! id)
nil)
@@ -236,7 +240,6 @@
"Cancel the current run for a given transform."
[{:keys [id]} :- [:map
[:id ms/PositiveInt]]]
- (log/info "canceling transform " id)
(api/check-superuser)
(let [transform (api/check-404 (t2/select-one :model/Transform id))
run (api/check-404 (transform-run/running-run-for-transform-id id))]
@@ -249,7 +252,6 @@
"Run a transform."
[{:keys [id]} :- [:map
[:id ms/PositiveInt]]]
- (log/info "run transform" id)
(api/check-superuser)
(let [transform (api/check-404 (t2/select-one :model/Transform id))
_ (check-feature-enabled! transform)
diff --git a/enterprise/backend/src/metabase_enterprise/transforms/core.clj b/enterprise/backend/src/metabase_enterprise/transforms/core.clj
index f76b1d7bee9..68ca09edd10 100644
--- a/enterprise/backend/src/metabase_enterprise/transforms/core.clj
+++ b/enterprise/backend/src/metabase_enterprise/transforms/core.clj
@@ -3,10 +3,15 @@
(:require
[metabase-enterprise.transforms.models.transform-run]
[metabase-enterprise.transforms.settings]
+ [metabase-enterprise.transforms.util]
[potemkin :as p]))
(p/import-vars
[metabase-enterprise.transforms.settings
transform-timeout]
+ [metabase-enterprise.transforms.util
+ native-query-transform?
+ python-transform?
+ query-transform?]
[metabase-enterprise.transforms.models.transform-run
timeout-run!])
diff --git a/enterprise/backend/src/metabase_enterprise/transforms/models/transform.clj b/enterprise/backend/src/metabase_enterprise/transforms/models/transform.clj
index 57a3b642a8d..488f13ae9b5 100644
--- a/enterprise/backend/src/metabase_enterprise/transforms/models/transform.clj
+++ b/enterprise/backend/src/metabase_enterprise/transforms/models/transform.clj
@@ -9,6 +9,8 @@
[metabase.lib.core :as lib]
[metabase.models.interface :as mi]
[metabase.models.serialization :as serdes]
+ [metabase.search.core :as search.core]
+ [metabase.search.ingestion :as search]
[metabase.search.spec :as search.spec]
[metabase.util :as u]
[methodical.core :as methodical]
@@ -90,6 +92,7 @@
(t2/define-before-delete :model/Transform [transform]
(events/publish-event! :event/delete-transform {:id (:id transform)})
+ (search.core/delete! :model/Transform [(str (:id transform))])
transform)
(defn update-transform-tags!
@@ -221,3 +224,39 @@
(defmethod serdes/storage-path "Transform" [transform _ctx]
(let [{:keys [id label]} (-> transform serdes/path last)]
["transforms" (serdes/storage-leaf-file-name id label)]))
+
+(defn- maybe-extract-transform-query-text
+ "Return the query text (truncated to `max-searchable-value-length`) from transform source; else nil.
+ Extracts SQL from query-type transforms and Python code from python-type transforms."
+ [{:keys [source]}]
+ (let [source-data (transform-source-out source)
+ query-text (case (:type source-data)
+ :query (lib/raw-native-query (:query source-data))
+ :python (:body source-data)
+ nil)]
+ (when query-text
+ (subs query-text 0 (min (count query-text) search/max-searchable-value-length)))))
+
+(defn- extract-transform-db-id
+ "Return the database ID from transform source; else nil."
+ [{:keys [source]}]
+ (let [parsed-source ((:out mi/transform-json) source)]
+ (case (:type parsed-source)
+ "query" (get-in parsed-source [:query :database])
+ "python" (parsed-source :source-database)
+ nil)))
+
+;;; ------------------------------------------------- Search ---------------------------------------------------
+
+(search.spec/define-spec "transform"
+ {:model :model/Transform
+ :attrs {:archived false
+ :collection-id false
+ :created-at true
+ :updated-at true
+ :native-query {:fn maybe-extract-transform-query-text
+ :fields [:source]}
+ :database-id {:fn extract-transform-db-id
+ :fields [:source]}}
+ :search-terms [:name :description]
+ :render-terms {:description true}})
diff --git a/enterprise/backend/src/metabase_enterprise/transforms/util.clj b/enterprise/backend/src/metabase_enterprise/transforms/util.clj
index d0486b9dd66..1e79b66f798 100644
--- a/enterprise/backend/src/metabase_enterprise/transforms/util.clj
+++ b/enterprise/backend/src/metabase_enterprise/transforms/util.clj
@@ -8,6 +8,7 @@
[metabase-enterprise.transforms.models.transform-run :as transform-run]
[metabase-enterprise.transforms.settings :as transforms.settings]
[metabase.driver :as driver]
+ [metabase.lib.query :as lib.query]
[metabase.lib.schema.common :as lib.schema.common]
[metabase.premium-features.core :as premium-features :refer [defenterprise]]
[metabase.query-processor.compile :as qp.compile]
@@ -42,6 +43,13 @@
[transform]
(= :query (-> transform :source :type keyword)))
+(defn native-query-transform?
+ "Check if this is a native query transform"
+ [transform]
+ (when (query-transform? transform)
+ (let [query (-> transform :source :query)]
+ (lib.query/native? query))))
+
(defn python-transform?
"Check if this is a Python transform."
[transform]
diff --git a/enterprise/backend/src/metabase_enterprise/transforms_python/api.clj b/enterprise/backend/src/metabase_enterprise/transforms_python/api.clj
index 75427a69ea4..79a807c3a2c 100644
--- a/enterprise/backend/src/metabase_enterprise/transforms_python/api.clj
+++ b/enterprise/backend/src/metabase_enterprise/transforms_python/api.clj
@@ -14,15 +14,20 @@
[metabase.util.i18n :as i18n]
[metabase.util.json :as json]))
-(api.macros/defendpoint :get "/library/:path"
- "Get the Python library for user modules."
- [{:keys [path]} :- [:map [:path :string]]
- _query-params]
+(defn get-python-library-by-path
+ "Get Python library details by path for use by other APIs."
+ [path]
(api/check-superuser)
(-> (python-library/get-python-library-by-path path)
api/check-404
(select-keys [:source :path :created_at :updated_at])))
+(api.macros/defendpoint :get "/library/:path"
+ "Get the Python library for user modules."
+ [{:keys [path]} :- [:map [:path :string]]
+ _query-params]
+ (get-python-library-by-path path))
+
(api.macros/defendpoint :put "/library/:path"
"Update the Python library source code for user modules."
[{:keys [path]} :- [:map [:path :string]]
diff --git a/enterprise/backend/test/metabase_enterprise/metabot_v3/context_test.clj b/enterprise/backend/test/metabase_enterprise/metabot_v3/context_test.clj
index 2079a8678b4..89d614e7be9 100644
--- a/enterprise/backend/test/metabase_enterprise/metabot_v3/context_test.clj
+++ b/enterprise/backend/test/metabase_enterprise/metabot_v3/context_test.clj
@@ -133,6 +133,46 @@
(is (= 0 @call-count)
"Should not call database-tables-for-context for MBQL queries"))))))
+(deftest enhance-context-with-schema-python-transform
+ (testing "Enhances context with schema for Python transforms"
+ (let [mock-tables [{:id 24 :name "orders" :schema "public"}
+ {:id 31 :name "products" :schema "public"}]]
+ (with-redefs [context/python-transform-tables-for-context
+ (fn [_] mock-tables)]
+ (let [input {:user_is_viewing [{:type "transform"
+ :source {:type "python"
+ :source-database 2
+ :source-tables {:orders 24
+ :products 31}}}]}
+ result (#'context/enhance-context-with-schema input)
+ used-tables (get-in result [:user_is_viewing 0 :used_tables])]
+ (is (= mock-tables used-tables)))))))
+
+(deftest enhance-context-with-schema-python-transform-no-source-tables
+ (testing "Handles Python transform without source-tables"
+ (let [called? (atom false)]
+ (with-redefs [context/python-transform-tables-for-context
+ (fn [_] (reset! called? true) nil)]
+ (let [input {:user_is_viewing [{:type "transform"
+ :source {:type "python"
+ :source-database 2
+ :source-tables {}}}]}
+ result (#'context/enhance-context-with-schema input)]
+ (is (nil? (get-in result [:user_is_viewing 0 :used_tables])))
+ (is (false? @called?)))))))
+
+(deftest enhance-context-with-schema-python-transform-no-source-database
+ (testing "Handles Python transform without source-database"
+ (let [called? (atom false)]
+ (with-redefs [context/python-transform-tables-for-context
+ (fn [_] (reset! called? true) nil)]
+ (let [input {:user_is_viewing [{:type "transform"
+ :source {:type "python"
+ :source-tables {:orders 24}}}]}
+ result (#'context/enhance-context-with-schema input)]
+ (is (nil? (get-in result [:user_is_viewing 0 :used_tables])))
+ (is (false? @called?)))))))
+
(deftest capabilities-signalling
(testing "We signal our capabilities to ai-service"
(is (= (count (-> (the-ns 'metabase-enterprise.metabot-v3.tools.api)
diff --git a/enterprise/backend/test/metabase_enterprise/metabot_v3/table_utils_test.clj b/enterprise/backend/test/metabase_enterprise/metabot_v3/table_utils_test.clj
index 33b17268a1c..8b934cc518a 100644
--- a/enterprise/backend/test/metabase_enterprise/metabot_v3/table_utils_test.clj
+++ b/enterprise/backend/test/metabase_enterprise/metabot_v3/table_utils_test.clj
@@ -206,6 +206,54 @@
(is (>= (count tables) 1)) ; At least the recognized table
(is (some #(= table1-id (:id %)) tables)))))))))
+(deftest used-tables-from-ids-test
+ (testing "used-tables-from-ids function"
+ (mt/with-temp [:model/Database {db-id :id} {}
+ :model/Database {other-db-id :id} {}
+ :model/Table {table1-id :id} {:db_id db-id, :name "users", :schema "public", :active true, :visibility_type nil}
+ :model/Table {table2-id :id} {:db_id db-id, :name "orders", :schema "public", :active true, :visibility_type nil}
+ :model/Table {table3-id :id} {:db_id db-id, :name "products", :schema "inventory", :active true, :visibility_type nil}
+ :model/Table {inactive-id :id} {:db_id db-id, :name "old_data", :schema "public", :active false, :visibility_type nil}
+ :model/Table {hidden-id :id} {:db_id db-id, :name "sensitive", :schema "public", :active true, :visibility_type :hidden}
+ :model/Table {other-db-table-id :id} {:db_id other-db-id, :name "other_table", :schema "public", :active true, :visibility_type nil}]
+
+ (testing "returns tables with correct structure for valid table-ids"
+ (mt/with-current-user (mt/user->id :crowberto)
+ (is (= [{:id table1-id :name "users" :schema "public"}
+ {:id table3-id :name "products" :schema "inventory"}]
+ (table-utils/used-tables-from-ids db-id [table1-id table3-id])))))
+
+ (testing "handles empty table-ids collection"
+ (mt/with-current-user (mt/user->id :crowberto)
+ (is (empty? (table-utils/used-tables-from-ids db-id [])))))
+
+ (testing "filters by database-id"
+ (mt/with-current-user (mt/user->id :crowberto)
+ (is (= [{:id table1-id :name "users" :schema "public"}]
+ (table-utils/used-tables-from-ids db-id [table1-id other-db-table-id])))))
+
+ (testing "filters out inactive tables"
+ (mt/with-current-user (mt/user->id :crowberto)
+ (is (= [{:id table1-id :name "users" :schema "public"}]
+ (table-utils/used-tables-from-ids db-id [table1-id inactive-id])))))
+
+ (testing "filters out hidden tables"
+ (mt/with-current-user (mt/user->id :crowberto)
+ (is (= [{:id table1-id :name "users" :schema "public"}]
+ (table-utils/used-tables-from-ids db-id [table1-id hidden-id])))))
+
+ (testing "handles non-existent table-ids"
+ (mt/with-current-user (mt/user->id :crowberto)
+ (let [fake-id 999999]
+ (is (empty? (table-utils/used-tables-from-ids db-id [fake-id]))))))
+
+ (testing "handles mix of valid and invalid table-ids"
+ (mt/with-current-user (mt/user->id :crowberto)
+ (let [fake-id 999999]
+ (is (= [{:id table1-id :name "users" :schema "public"}
+ {:id table2-id :name "orders" :schema "public"}]
+ (table-utils/used-tables-from-ids db-id [table1-id fake-id table2-id])))))))))
+
;; ======================================
;; Edge Cases and Error Handling
;; ======================================
diff --git a/enterprise/backend/test/metabase_enterprise/metabot_v3/tools/api_test.clj b/enterprise/backend/test/metabase_enterprise/metabot_v3/tools/api_test.clj
index 7cb99b828a6..a5a478b7f6a 100644
--- a/enterprise/backend/test/metabase_enterprise/metabot_v3/tools/api_test.clj
+++ b/enterprise/backend/test/metabase_enterprise/metabot_v3/tools/api_test.clj
@@ -8,6 +8,7 @@
[metabase-enterprise.metabot-v3.dummy-tools :as metabot-v3.tools.dummy-tools]
[metabase-enterprise.metabot-v3.tools.api :as metabot-v3.tools.api]
[metabase-enterprise.metabot-v3.tools.create-dashboard-subscription :as metabot-v3.tools.create-dashboard-subscription]
+ [metabase-enterprise.metabot-v3.tools.dependencies-test :as metabot-v3.tools.dependencies-test]
[metabase-enterprise.metabot-v3.tools.filters :as metabot-v3.tools.filters]
[metabase-enterprise.metabot-v3.tools.find-outliers :as metabot-v3.tools.find-outliers]
[metabase-enterprise.metabot-v3.tools.generate-insights :as metabot-v3.tools.generate-insights]
@@ -1185,3 +1186,244 @@
(is (nil? (-> (request {:table_id (mt/id :orders)
:with_related_tables false})
(get-in [:structured_output :related_tables]))))))))
+
+(deftest get-transforms-test
+ (mt/with-premium-features #{:metabot-v3 :transforms}
+ (let [conversation-id (str (random-uuid))
+ rasta-ai-token (ai-session-token)
+ crowberto-ai-token (ai-session-token :crowberto (str (random-uuid)))]
+ (mt/with-temp [:model/Transform t1 {:name "People Transform"
+ :description "Simple select on People table"
+ :source {:type "query"
+ :query (lib/native-query (mt/metadata-provider) "SELECT * FROM PEOPLE")}
+ :target {:type "table"
+ :name "t1_table"}}
+ :model/Transform t2 {:name "MBQL Transform"
+ :description "Simple MQBL query on Products table"
+ :source {:type "query"
+ :query (mt/mbql-query products)}
+ :target {:type "table"
+ :name "t2_table"}}
+ :model/Transform t3 {:name "Python Transform"
+ :description "Simple python transform"
+ :source {:type "python"
+ :body "print('hello world')"
+ :source-tables {}}
+ :target {:type "table"
+ :name "t2_table"}}]
+ (testing "With insufficient permissions"
+ (is (= "You don't have permissions to do that."
+ (mt/user-http-request :rasta :post 403 "ee/metabot-tools/get-transforms"
+ {:request-options {:headers {"x-metabase-session" rasta-ai-token}}}
+ {:conversation_id conversation-id}))))
+ (testing "With superuser permissions"
+ (is (=? {:structured_output [(mt/obj->json->obj (select-keys t1 [:id :entity_id :name :description :source]))
+ ;; note: t2 not included because it's a (non-native) MBQL query
+ (mt/obj->json->obj (select-keys t3 [:id :entity_id :name :description :source]))]
+ :conversation_id conversation-id}
+ (-> (mt/user-http-request :rasta :post 200 "ee/metabot-tools/get-transforms"
+ {:request-options {:headers {"x-metabase-session" crowberto-ai-token}}}
+ {:conversation_id conversation-id})
+ (update :structured_output (fn [output]
+ (filter #(#{(:id t1) (:id t2) (:id t3)} (:id %))
+ output)))))))))))
+
+(deftest get-transform-test
+ (mt/with-premium-features #{:metabot-v3 :transforms}
+ (let [conversation-id (str (random-uuid))
+ rasta-ai-token (ai-session-token)
+ crowberto-ai-token (ai-session-token :crowberto (str (random-uuid)))]
+ (mt/with-temp [:model/Transform t1 {:name "People Transform"
+ :description "Simple select on People table"
+ :source {:type "query"
+ :query (mt/native-query {:query "SELECT * FROM PEOPLE"})}
+ :target {:type "table"
+ :name "t1_table"}}
+ :model/Transform t2 {:name "Python Transform"
+ :description "Simple Python transform"
+ :source {:type "python"
+ :body "print('hello world')"
+ :source-tables {}}
+ :target {:type "table"
+ :name "t2_table"
+ :database (mt/id)}}]
+ (testing "With insufficient permissions"
+ (is (= "You don't have permissions to do that."
+ (mt/user-http-request :rasta :post 403 "ee/metabot-tools/get-transform-details"
+ {:request-options {:headers {"x-metabase-session" rasta-ai-token}}}
+ {:arguments {:transform_id (:id t1)}
+ :conversation_id conversation-id}))))
+ (testing "With non-existent transform"
+ (is (= "Not found."
+ (mt/user-http-request :rasta :post 404 "ee/metabot-tools/get-transform-details"
+ {:request-options {:headers {"x-metabase-session" crowberto-ai-token}}}
+ {:arguments {:transform_id (+ 10000 (:id t2))}
+ :conversation_id conversation-id}))))
+ (testing "With superuser permissions"
+ (doseq [transform [t1 t2]]
+ (testing (:name transform)
+ (is (=? {:structured_output (mt/obj->json->obj (select-keys transform [:id :entity_id :name :description :source :target]))
+ :conversation_id conversation-id}
+ (mt/user-http-request :rasta :post 200 "ee/metabot-tools/get-transform-details"
+ {:request-options {:headers {"x-metabase-session" crowberto-ai-token}}}
+ {:arguments {:transform_id (:id transform)}
+ :conversation_id conversation-id}))))))))))
+
+(deftest get-transform-python-library-details-test
+ (mt/with-premium-features #{:metabot-v3 :python-transforms}
+ (let [conversation-id (str (random-uuid))
+ rasta-ai-token (ai-session-token)
+ crowberto-ai-token (ai-session-token :crowberto (str (random-uuid)))
+ saved-python-library (t2/select-one :model/PythonLibrary :path "common.py")]
+ (when (seq saved-python-library)
+ (t2/delete! :model/PythonLibrary))
+ (try
+ (testing "With no Python library present"
+ (is (= "Not found."
+ (mt/user-http-request :rasta :post 404 "ee/metabot-tools/get-transform-python-library-details"
+ {:request-options {:headers {"x-metabase-session" crowberto-ai-token}}}
+ {:arguments {:path "common.py"}
+ :conversation_id conversation-id}))))
+ (mt/with-temp [:model/PythonLibrary lib1 {:path "common.py"
+ :source "def hello():\n return 'world'"}]
+ (testing "With insufficient permissions"
+ (is (= "You don't have permissions to do that."
+ (mt/user-http-request :rasta :post 403 "ee/metabot-tools/get-transform-python-library-details"
+ {:request-options {:headers {"x-metabase-session" rasta-ai-token}}}
+ {:arguments {:path (:path lib1)}
+ :conversation_id conversation-id}))))
+ (testing "With non-existent library path"
+ (is (=? {:allowed-paths ["common.py"]
+ :message "Invalid library path. Only 'common' is currently supported."
+ :path "nonexistent.py"}
+ (mt/user-http-request :rasta :post 400 "ee/metabot-tools/get-transform-python-library-details"
+ {:request-options {:headers {"x-metabase-session" crowberto-ai-token}}}
+ {:arguments {:path "nonexistent.py"}
+ :conversation_id conversation-id}))))
+ (testing "With superuser permissions"
+ (is (=? {:structured_output (select-keys lib1 [:source :path :created_at :updated_at])
+ :conversation_id conversation-id}
+ (mt/user-http-request :rasta :post 200 "ee/metabot-tools/get-transform-python-library-details"
+ {:request-options {:headers {"x-metabase-session" crowberto-ai-token}}}
+ {:arguments {:path (:path lib1)}
+ :conversation_id conversation-id})))))
+ (finally
+ (when (seq saved-python-library)
+ (t2/insert! :model/PythonLibrary saved-python-library)))))))
+
+(deftest get-snippets-test
+ (mt/with-premium-features #{:metabot-v3}
+ (let [conversation-id (str (random-uuid))
+ rasta-ai-token (ai-session-token)]
+ (mt/with-temp [:model/NativeQuerySnippet snippet-1 {:content "1"
+ :name "snippet_1"
+ :description "great snippet 1"}
+ :model/NativeQuerySnippet snippet-2 {:content "2"
+ :name "snippet_2"}]
+ (testing "No snippets visible without data perms"
+ (is (=? {:structured_output []
+ :conversation_id conversation-id}
+ (-> (mt/with-no-data-perms-for-all-users!
+ (mt/user-http-request :rasta :post 200 "ee/metabot-tools/get-snippets"
+ {:request-options {:headers {"x-metabase-session" rasta-ai-token}}}
+ {:conversation_id conversation-id}))
+ (update :structured_output (fn [output]
+ (filter #(#{(:id snippet-1) (:id snippet-2)} (:id %))
+ output)))))))
+ (testing "All snippets visible with full data perms"
+ (is (=? {:structured_output [(select-keys snippet-1 [:id :name :description])
+ (select-keys snippet-2 [:id :name :description])]
+ :conversation_id conversation-id}
+ (-> (mt/with-full-data-perms-for-all-users!
+ (mt/user-http-request :rasta :post 200 "ee/metabot-tools/get-snippets"
+ {:request-options {:headers {"x-metabase-session" rasta-ai-token}}}
+ {:conversation_id conversation-id}))
+ (update :structured_output (fn [output]
+ (filter #(#{(:id snippet-1) (:id snippet-2)} (:id %))
+ output)))))))))))
+
+(deftest get-snippet-details-test
+ (mt/with-premium-features #{:metabot-v3}
+ (let [conversation-id (str (random-uuid))
+ rasta-ai-token (ai-session-token)]
+ (mt/with-temp [:model/NativeQuerySnippet snippet-1 {:content "1"
+ :name "snippet_1"
+ :description "great snippet 1"}
+ :model/NativeQuerySnippet _ {:content "2"
+ :name "snippet_2"}]
+ (testing "400 for invalid args"
+ (is (=? {:errors
+ {:arguments {:snippet_id string?}},
+ :specific-errors {:arguments {:snippet_id ["should be an integer, received: nil"]}}}
+ (mt/user-http-request :rasta :post 400 "ee/metabot-tools/get-snippet-details"
+ {:request-options {:headers {"x-metabase-session" rasta-ai-token}}}
+ {:arguments {:snippet_id nil}
+ :conversation_id conversation-id}))))
+ (testing "404 returned for non-existent snippet"
+ (is (= "Not found."
+ (let [max-snippet-id (t2/select-one-fn :max-id [:model/NativeQuerySnippet [:%max.id :max-id]])]
+ (mt/user-http-request :rasta :post 404 "ee/metabot-tools/get-snippet-details"
+ {:request-options {:headers {"x-metabase-session" rasta-ai-token}}}
+ {:arguments {:snippet_id (inc max-snippet-id)}
+ :conversation_id conversation-id})))))
+ (testing "403 returned for missing data perms"
+ (is (= "You don't have permissions to do that."
+ (mt/with-no-data-perms-for-all-users!
+ (mt/user-http-request :rasta :post 403 "ee/metabot-tools/get-snippet-details"
+ {:request-options {:headers {"x-metabase-session" rasta-ai-token}}}
+ {:arguments {:snippet_id (:id snippet-1)}
+ :conversation_id conversation-id})))))
+ (testing "Snippet details returned with sufficient data perms"
+ (is (=? {:structured_output (select-keys snippet-1 [:id :name :description :content])
+ :conversation_id conversation-id}
+ (mt/with-full-data-perms-for-all-users!
+ (mt/user-http-request :rasta :post 200 "ee/metabot-tools/get-snippet-details"
+ {:request-options {:headers {"x-metabase-session" rasta-ai-token}}}
+ {:arguments {:snippet_id (:id snippet-1)}
+ :conversation_id conversation-id})))))))))
+
+(deftest check-transform-dependencies-test
+ ;; This is just a quick sanity check for the API endpoint. The function powering this endpoint is tested more
+ ;; thoroughly in metabase-enterprise.metabot-v3.tools.dependencies-test.
+ (mt/with-premium-features #{:metabot-v3 :transforms :dependencies}
+ (let [conversation-id (str (random-uuid))
+ rasta-ai-token (ai-session-token)
+ crowberto-ai-token (ai-session-token :crowberto (str (random-uuid)))
+ people-query (lib/native-query (mt/metadata-provider) "SELECT * FROM people")
+ modified-source {:type "query" :query people-query}]
+ (metabot-v3.tools.dependencies-test/with-dependent-transforms! [transform1-id _]
+ (testing "400 for invalid args"
+ (is (=? {:errors
+ {:arguments {:source string?}},
+ :specific-errors {:arguments {:source ["missing required key, received: nil"]}}}
+ (mt/user-http-request :rasta :post 400 "ee/metabot-tools/check-transform-dependencies"
+ {:request-options {:headers {"x-metabase-session" crowberto-ai-token}}}
+ {:arguments {:transform_id 1}
+ :conversation_id conversation-id}))))
+ (testing "403 for insufficient permissions"
+ (is (= "You don't have permissions to do that."
+ (mt/user-http-request :rasta :post 403 "ee/metabot-tools/check-transform-dependencies"
+ {:request-options {:headers {"x-metabase-session" rasta-ai-token}}}
+ {:arguments {:transform_id transform1-id
+ :source modified-source}
+ :conversation_id conversation-id}))))
+ (testing "404 returned for non-existent snippet"
+ (is (= "Not found."
+ (let [max-transform-id (t2/select-one-fn :max-id [:model/Transform [:%max.id :max-id]])]
+ (mt/user-http-request :rasta :post 404 "ee/metabot-tools/check-transform-dependencies"
+ {:request-options {:headers {"x-metabase-session" crowberto-ai-token}}}
+ {:arguments {:transform_id (inc max-transform-id)
+ :source modified-source}
+ :conversation_id conversation-id})))))
+ (testing "Edits with broken dependencies"
+ (is (=? {:structured_output {:success false
+ :bad_question_count 0
+ :bad_questions nil
+ :bad_transform_count 1
+ :bad_transforms seq?}
+ :conversation_id conversation-id}
+ (mt/user-http-request :rasta :post 200 "ee/metabot-tools/check-transform-dependencies"
+ {:request-options {:headers {"x-metabase-session" crowberto-ai-token}}}
+ {:arguments {:transform_id transform1-id
+ :source modified-source}
+ :conversation_id conversation-id}))))))))
diff --git a/enterprise/backend/test/metabase_enterprise/metabot_v3/tools/dependencies_test.clj b/enterprise/backend/test/metabase_enterprise/metabot_v3/tools/dependencies_test.clj
new file mode 100644
index 00000000000..5d829164662
--- /dev/null
+++ b/enterprise/backend/test/metabase_enterprise/metabot_v3/tools/dependencies_test.clj
@@ -0,0 +1,256 @@
+(ns metabase-enterprise.metabot-v3.tools.dependencies-test
+ (:require
+ [clojure.test :refer :all]
+ [metabase-enterprise.metabot-v3.tools.dependencies :as metabot.dependencies]
+ [metabase.lib.core :as lib]
+ [metabase.models.interface :as mi]
+ [metabase.permissions.models.permissions :as perms]
+ [metabase.permissions.models.permissions-group :as perms-group]
+ [metabase.test :as mt]
+ [metabase.util :as u]
+ [toucan2.core :as t2]))
+
+(defmacro with-dependent-transforms!
+ "Creates two dependent SQL transforms for testing:
+ - transform1: selects id and total from orders
+ - transform2: selects total from transform1's output table
+
+ Binds symbols transform1-id and transform2-id."
+ [[transform1-binding transform2-binding] & body]
+ `(mt/with-temp
+ [:model/Table {table1-id# :id} {:db_id (mt/id)
+ :schema "public"
+ :name "orders_transform_1"}
+ :model/Transform {transform1-id# :id}
+ {:name "Transform 1"
+ :source {:type "query"
+ :query (lib/native-query (mt/metadata-provider) "SELECT id, total FROM orders")}
+ :target {:type "table"
+ :schema "public"
+ :name "orders_transform_1"}}
+ :model/Transform {transform2-id# :id}
+ {:name "Transform 2"
+ :source {:type "query"
+ :query (lib/native-query (mt/metadata-provider) "SELECT id, total FROM orders_transform_1")}
+ :target {:type "table"
+ :schema "public"
+ :name "orders_transform_2"}}
+ :model/Dependency {} {:from_entity_type "transform"
+ :from_entity_id transform2-id#
+ :to_entity_type "transform"
+ :to_entity_id transform1-id#}]
+ (let [~transform1-binding transform1-id#
+ ~transform2-binding transform2-id#]
+ ~@body)))
+
+(deftest check-transform-dependencies-test
+ (testing "removing total field from transform1 breaks transform2"
+ (mt/as-admin
+ (with-dependent-transforms! [transform1-id transform2-id]
+ (let [modified-source {:type "query"
+ :query (lib/native-query (mt/metadata-provider) "SELECT id FROM orders")}
+ result (metabot.dependencies/check-transform-dependencies
+ {:id transform1-id
+ :source modified-source})]
+ (is (false? (get-in result [:structured_output :success])))
+ (is (= 1 (get-in result [:structured_output :bad_transform_count])))
+ (let [bad-transforms (get-in result [:structured_output :bad_transforms])]
+ (is (= 1 (count bad-transforms)))
+ (is (= transform2-id (get-in (first bad-transforms) [:transform :id])))
+ (is (= "Transform 2" (get-in (first bad-transforms) [:transform :name])))))))))
+
+(deftest check-transform-dependencies-limit-test
+ (testing "max-reported-broken-transforms limit"
+ (mt/as-admin
+ (with-dependent-transforms! [transform1-id _]
+ (mt/with-temp
+ [:model/Transform {transform3-id :id}
+ {:name "Transform 3"
+ :source {:type "query"
+ :query (lib/native-query (mt/metadata-provider) "SELECT total FROM orders_transform_1")}
+ :target {:type "table"
+ :schema "public"
+ :name "orders_transform_3"}}
+ :model/Dependency {}
+ {:from_entity_type "transform"
+ :from_entity_id transform3-id
+ :to_entity_type "transform"
+ :to_entity_id transform1-id}]
+ (testing "when limit is 1, only one broken transform is reported"
+ (binding [metabot.dependencies/*max-reported-broken-transforms* 1]
+ (let [modified-source {:type "query"
+ :query (lib/native-query (mt/metadata-provider) "SELECT id FROM orders")}
+ result (metabot.dependencies/check-transform-dependencies
+ {:id transform1-id
+ :source modified-source})
+ bad-transforms (get-in result [:structured_output :bad_transforms])]
+ ;; Two downstream transforms should be broken (transform2 + transform3)...
+ (is (false? (get-in result [:structured_output :success])))
+ (is (= 2 (get-in result [:structured_output :bad_transform_count])))
+ ;; ...but only one should be reported due to the limit.
+ (is (= 1 (count bad-transforms)))))))))))
+
+(deftest check-transform-dependencies-with-cards-test
+ (testing "removing field from transform breaks dependent card"
+ (mt/as-admin
+ (with-dependent-transforms! [transform1-id _]
+ (mt/with-temp
+ [:model/Card {card-id :id}
+ {:name "Card using Transform 1"
+ :database_id (mt/id)
+ :table_id (mt/id :orders)
+ :dataset_query (lib/native-query (mt/metadata-provider) "SELECT total FROM orders_transform_1")}
+ :model/Dependency {}
+ {:from_entity_type "card"
+ :from_entity_id card-id
+ :to_entity_type "transform"
+ :to_entity_id transform1-id}]
+ (let [modified-source {:type "query"
+ :query (lib/native-query (mt/metadata-provider) "SELECT id FROM orders")}
+ result (metabot.dependencies/check-transform-dependencies
+ {:id transform1-id
+ :source modified-source})]
+ (is (false? (get-in result [:structured_output :success])))
+ (is (= 1 (get-in result [:structured_output :bad_question_count])))
+ (let [bad-questions (get-in result [:structured_output :bad_questions])]
+ (is (= 1 (count bad-questions)))
+ (is (= card-id (get-in (first bad-questions) [:question :id])))
+ (is (= "Card using Transform 1" (get-in (first bad-questions) [:question :name])))
+ (is (some? (:errors (first bad-questions)))))))))))
+
+(deftest check-transform-dependencies-card-limit-test
+ (testing "max-reported-broken-transforms limit applies to cards"
+ (mt/as-admin
+ (with-dependent-transforms! [transform1-id _]
+ (mt/with-temp
+ [:model/Card {card1-id :id}
+ {:name "Card 1 using Transform 1"
+ :database_id (mt/id)
+ :table_id (mt/id :orders)
+ :dataset_query (lib/native-query (mt/metadata-provider) "SELECT total FROM orders_transform_1")}
+ :model/Dependency {}
+ {:from_entity_type "card"
+ :from_entity_id card1-id
+ :to_entity_type "transform"
+ :to_entity_id transform1-id}
+ :model/Card {card2-id :id}
+ {:name "Card 2 using Transform 1"
+ :database_id (mt/id)
+ :table_id (mt/id :orders)
+ :dataset_query (lib/native-query (mt/metadata-provider) "SELECT total FROM orders_transform_1")}
+ :model/Dependency {}
+ {:from_entity_type "card"
+ :from_entity_id card2-id
+ :to_entity_type "transform"
+ :to_entity_id transform1-id}]
+ (testing "when limit is 1, only one broken card is reported"
+ (binding [metabot.dependencies/*max-reported-broken-transforms* 1]
+ (let [modified-source {:type "query"
+ :query (lib/native-query (mt/metadata-provider) "SELECT id FROM orders")}
+ result (metabot.dependencies/check-transform-dependencies
+ {:id transform1-id
+ :source modified-source})
+ bad-cards (get-in result [:structured_output :bad_questions])]
+ ;; Two cards should be broken...
+ (is (false? (get-in result [:structured_output :success])))
+ (is (= 2 (get-in result [:structured_output :bad_question_count])))
+ ;; ...but only one should be reported due to the limit.
+ (is (= 1 (count bad-cards)))))))))))
+
+(deftest check-transform-dependencies-permission-check-test
+ (testing "Permission check on transform being edited"
+ (with-dependent-transforms! [transform1-id _]
+ (testing "Non-superuser cannot check transform dependencies"
+ (mt/with-test-user :rasta
+ (let [modified-source {:type "query"
+ :query (lib/native-query (mt/metadata-provider) "SELECT id FROM orders")}]
+ (is (thrown-with-msg?
+ Exception
+ #"You don't have permissions to do that"
+ (metabot.dependencies/check-transform-dependencies
+ {:id transform1-id
+ :source modified-source})))))))))
+
+(deftest check-transform-dependencies-permission-filtering-test
+ (testing "Broken cards in inaccessible collections are filtered from results"
+ (with-dependent-transforms! [transform1-id _]
+ (mt/with-temp
+ [:model/Collection {restricted-collection-id :id} {:name "Restricted Collection"}
+ :model/Collection {public-collection-id :id} {:name "Public Collection"}
+ :model/Card {public-card-id :id}
+ {:name "Public Card"
+ :collection_id public-collection-id
+ :database_id (mt/id)
+ :table_id (mt/id :orders)
+ :dataset_query (lib/native-query (mt/metadata-provider) "SELECT total FROM orders_transform_1")}
+ :model/Dependency {}
+ {:from_entity_type "card"
+ :from_entity_id public-card-id
+ :to_entity_type "transform"
+ :to_entity_id transform1-id}
+ :model/Card {restricted-card-id :id}
+ {:name "Restricted Card"
+ :collection_id restricted-collection-id
+ :database_id (mt/id)
+ :table_id (mt/id :orders)
+ :dataset_query (lib/native-query (mt/metadata-provider) "SELECT total FROM orders_transform_1")}
+ :model/Dependency {}
+ {:from_entity_type "card"
+ :from_entity_id restricted-card-id
+ :to_entity_type "transform"
+ :to_entity_id transform1-id}]
+ (testing "Superuser sees all broken cards regardless of collection permissions"
+ (mt/with-test-user :crowberto
+ (let [modified-source {:type "query"
+ :query (lib/native-query (mt/metadata-provider) "SELECT id FROM orders")}
+ result (metabot.dependencies/check-transform-dependencies
+ {:id transform1-id
+ :source modified-source})
+ broken-question-ids (set (map #(get-in % [:question :id])
+ (get-in result [:structured_output :bad_questions])))]
+ ;; Both cards should appear in results for superuser
+ (is (contains? broken-question-ids public-card-id))
+ (is (contains? broken-question-ids restricted-card-id)))))
+ (testing "User with restricted collection access only sees cards they can read"
+ (perms/revoke-collection-permissions! (perms-group/all-users) (u/the-id restricted-collection-id))
+ (perms/grant-collection-read-permissions! (perms-group/all-users) (u/the-id public-collection-id))
+ (mt/with-test-user :rasta
+ (let [original-can-read? mi/can-read?]
+ ;; Temporarily allow rasta to read transforms (but preserve normal card permission checking)
+ ;; Non-superusers can't currently read transforms, but this will change, and until then
+ ;; we can test that broken cards are filtered correctly by read access.
+ (with-redefs [mi/can-read? (fn [instance]
+ (if (t2/instance-of? :model/Transform instance)
+ true
+ (original-can-read? instance)))]
+ (let [modified-source {:type "query"
+ :query (lib/native-query (mt/metadata-provider) "SELECT id FROM orders")}
+ result (metabot.dependencies/check-transform-dependencies
+ {:id transform1-id
+ :source modified-source})
+ broken-question-ids (set (map #(get-in % [:question :id])
+ (get-in result [:structured_output :bad_questions])))]
+ ;; Rasta should only see the public card, not the restricted one
+ (is (contains? broken-question-ids public-card-id))
+ (is (not (contains? broken-question-ids restricted-card-id))))))))))))
+
+(deftest check-transform-dependencies-python-bypass-test
+ (testing "Python transforms bypass dependency checking"
+ (mt/with-test-user :crowberto
+ (mt/with-temp [:model/Transform {python-transform-id :id}
+ {:name "Python Transform"
+ :source {:type "python"
+ :body "print('hello')"
+ :source-tables {}}
+ :target {:type "table"
+ :schema "public"
+ :name "python_transform_table"}}]
+ (let [modified-source {:type "python"
+ :body "print('modified')"
+ :source-tables {}}
+ result (metabot.dependencies/check-transform-dependencies
+ {:id python-transform-id
+ :source modified-source})]
+ (is (= {:success true
+ :bad_transforms []}
+ (result :structured_output))))))))
diff --git a/enterprise/backend/test/metabase_enterprise/metabot_v3/tools/search_test.clj b/enterprise/backend/test/metabase_enterprise/metabot_v3/tools/search_test.clj
index aac7579eef4..80915400102 100644
--- a/enterprise/backend/test/metabase_enterprise/metabot_v3/tools/search_test.clj
+++ b/enterprise/backend/test/metabase_enterprise/metabot_v3/tools/search_test.clj
@@ -104,8 +104,8 @@
;; Item 99 appears in all 5 lists at position 2, so should rank very high
(is (= 99 (:id (first result)))))))
-(deftest transform-search-result-test
- (testing "table result transformation"
+(deftest postprocess-search-result-test
+ (testing "table result postprocessing"
(let [result {:model "table"
:id 1
:table_name "orders"
@@ -124,9 +124,9 @@
:database_schema "public"
:updated_at "2024-01-01"
:created_at "2024-01-01"}]
- (is (= expected (#'search/transform-search-result result)))))
+ (is (= expected (#'search/postprocess-search-result result)))))
- (testing "model (dataset) result transformation"
+ (testing "model (dataset) result postprocessing"
(let [result {:model "dataset"
:id 2
:name "Sales Model"
@@ -145,9 +145,26 @@
:collection {}
:updated_at "2024-01-02"
:created_at "2024-01-02"}]
- (is (= expected (#'search/transform-search-result result)))))
+ (is (= expected (#'search/postprocess-search-result result)))))
- (testing "dashboard result transformation"
+ (testing "transform result postprocessing"
+ (let [result {:model "transform"
+ :id 3
+ :name "User Transform"
+ :description "Transform for users"
+ :database_id 44
+ :updated_at "2024-01-03"
+ :created_at "2024-01-03"}
+ expected {:id 3
+ :type "transform"
+ :name "User Transform"
+ :description "Transform for users"
+ :database_id 44
+ :updated_at "2024-01-03"
+ :created_at "2024-01-03"}]
+ (is (= expected (#'search/postprocess-search-result result)))))
+
+ (testing "dashboard result postprocessing"
(let [result {:model "dashboard"
:id 3
:name "Main Dashboard"
@@ -164,9 +181,9 @@
:collection {:name "Finance" :authority_level "official"}
:updated_at "2024-01-03"
:created_at "2024-01-03"}]
- (is (= expected (#'search/transform-search-result result)))))
+ (is (= expected (#'search/postprocess-search-result result)))))
- (testing "question (card) result transformation with moderated_status"
+ (testing "question (card) result postprocessing with moderated_status"
(let [result {:model "card"
:id 4
:name "Q1"
@@ -184,9 +201,9 @@
:collection {:name "Analytics" :authority_level nil}
:updated_at "2024-01-04"
:created_at "2024-01-04"}]
- (is (= expected (#'search/transform-search-result result)))))
+ (is (= expected (#'search/postprocess-search-result result)))))
- (testing "metric result transformation"
+ (testing "metric result postprocessing"
(let [result {:model "metric"
:id 5
:name "Revenue"
@@ -203,9 +220,9 @@
:collection {}
:updated_at "2024-01-05"
:created_at "2024-01-05"}]
- (is (= expected (#'search/transform-search-result result)))))
+ (is (= expected (#'search/postprocess-search-result result)))))
- (testing "database result transformation"
+ (testing "database result postprocessing"
(let [result {:model "database"
:id 6
:name "Production DB"
@@ -218,7 +235,7 @@
:description "Main database"
:updated_at "2024-01-06"
:created_at "2024-01-06"}]
- (is (= expected (#'search/transform-search-result result))))))
+ (is (= expected (#'search/postprocess-search-result result))))))
(deftest search-test
(mt/with-premium-features #{:content-verification}
@@ -240,20 +257,20 @@
perms/sandboxed-user? (fn [] false)
api/*current-user-id* 1]
- (testing "search returns transformed results for term queries"
+ (testing "search returns postprocessed results for term queries"
(with-redefs [search-core/search (fn [_] {:data [order-table]})]
(let [args {:term-queries ["orders"]
:entity-types ["table"]}
results (search/search args)
- expected [(#'search/transform-search-result order-table)]]
+ expected [(#'search/postprocess-search-result order-table)]]
(is (= expected results)))))
- (testing "search returns transformed results for semantic queries"
+ (testing "search returns postprocessed results for semantic queries"
(with-redefs [search-core/search (fn [_] {:data [dashboard]})]
(let [args {:semantic-queries ["sales metrics"]
:entity-types ["dashboard"]}
results (search/search args)
- expected [(#'search/transform-search-result dashboard)]]
+ expected [(#'search/postprocess-search-result dashboard)]]
(is (= expected results)))))
(testing "search combines term and semantic queries using RRF"
@@ -303,3 +320,27 @@
:entity-types ["dashboard"]})]
(is (= 1 (count results)))
(is (= 2 (:id (first results)))))))))))))
+
+(deftest search-native-query-test
+ (mt/with-test-user :rasta
+ (with-redefs [perms/impersonated-user? (fn [] false)
+ perms/sandboxed-user? (fn [] false)
+ api/*current-user-id* 1]
+ (testing ":search-native-query is included in context when true"
+ (with-redefs [search-core/search (fn [context]
+ (is (true? (:search-native-query context)))
+ {:data []})]
+ (search/search {:term-queries ["test"]
+ :entity-types ["card"]
+ :search-native-query true})))
+
+ (testing ":search-native-query is not included in context when nil or false"
+ (with-redefs [search-core/search (fn [context]
+ (is (not (contains? context :search-native-query)))
+ {:data []})]
+ (search/search {:term-queries ["test"]
+ :entity-types ["card"]
+ :search-native-query false})
+ (search/search {:term-queries ["test"]
+ :entity-types ["card"]
+ :search-native-query nil}))))))
diff --git a/enterprise/backend/test/metabase_enterprise/search/scoring_test.clj b/enterprise/backend/test/metabase_enterprise/search/scoring_test.clj
index d7591c8b953..12ea9c70b53 100644
--- a/enterprise/backend/test/metabase_enterprise/search/scoring_test.clj
+++ b/enterprise/backend/test/metabase_enterprise/search/scoring_test.clj
@@ -9,7 +9,10 @@
[metabase.search.appdb.scoring-test :as appdb.scoring-test]
[metabase.search.in-place.scoring :as scoring]
[metabase.test :as mt]
- [metabase.util.json :as json]))
+ [metabase.util.json :as json])
+ (:import [java.time Instant]))
+
+(set! *warn-on-reflection* true)
(deftest ^:parallel verified-score-test
(let [score #'ee-scoring/verified-score
@@ -180,3 +183,31 @@
(is (= [["card" 1 "card normal"]
["card" 2 "card verified"]]
(appdb.scoring-test/search-results* "card")))))))
+
+(deftest ^:parallel transforms-user-recency-test
+ (mt/with-premium-features #{:transforms}
+ (let [user-id (mt/user->id :crowberto)
+ now (Instant/now)
+ recent-view (fn [model-id timestamp]
+ {:model "card"
+ :model_id model-id
+ :user_id user-id
+ :timestamp timestamp})]
+ (mt/with-temp [:model/Card {c1 :id} {}
+ :model/Card {c2 :id} {}
+ :model/Transform {t1 :id} {:name "test transform"
+ :source {:type "query"
+ :query (mt/native-query {:query "SELECT 1"})}
+ :target {:type "table"
+ :name "test_table"}}
+ :model/RecentViews _ (recent-view c1 now)]
+ (appdb.scoring-test/with-index-contents
+ [{:model "card" :id c1 :name "test card recent"}
+ {:model "card" :id c2 :name "test card unseen"}
+ {:model "transform" :id t1 :name "test transform"}]
+ (testing "Transforms get a hardcoded 1-day recency (between recently viewed card and never viewed card)"
+ (is (= [["card" c1 "test card recent"]
+ ["transform" t1 "test transform"]
+ ["card" c2 "test card unseen"]]
+ (appdb.scoring-test/search-results :user-recency "test" {:current-user-id user-id
+ :context :metabot})))))))))
diff --git a/enterprise/backend/test/metabase_enterprise/semantic_search/scoring_test.clj b/enterprise/backend/test/metabase_enterprise/semantic_search/scoring_test.clj
index 5a882bb8ba7..a20897ac77a 100644
--- a/enterprise/backend/test/metabase_enterprise/semantic_search/scoring_test.clj
+++ b/enterprise/backend/test/metabase_enterprise/semantic_search/scoring_test.clj
@@ -325,3 +325,21 @@
["card" c1 "card ancient"]
["dataset" c3 "card unseen"]]
(search-results :user-recency "card" {:current-user-id user-id})))))))))
+
+(deftest transform-user-recency-test
+ (testing "Transforms get a hard-coded intermediate user-recency score since view events are not tracked"
+ (let [user-id (mt/user->id :crowberto)
+ right-now (Instant/now)]
+ (mt/with-temp [:model/Card {c1 :id} {}
+ :model/RecentViews _ {:model "card" :model_id c1 :user_id user-id :timestamp right-now}]
+ (with-index-contents!
+ [{:model "card" :id c1 :name "recently viewed card"}
+ {:model "transform" :id 1 :name "transform no views"}
+ {:model "card" :id 2 :name "never viewed card"}]
+ (testing "Transform ranks between recently viewed and never viewed cards"
+ (let [results (search-results :user-recency "card" {:current-user-id user-id})]
+ (def results results)
+ (is (= [["card" c1 "recently viewed card"]
+ ["transform" 1 "transform no views"]
+ ["card" 2 "never viewed card"]]
+ results)))))))))
diff --git a/enterprise/backend/test/metabase_enterprise/transforms/search_test.clj b/enterprise/backend/test/metabase_enterprise/transforms/search_test.clj
new file mode 100644
index 00000000000..53771da7a05
--- /dev/null
+++ b/enterprise/backend/test/metabase_enterprise/transforms/search_test.clj
@@ -0,0 +1,206 @@
+(ns metabase-enterprise.transforms.search-test
+ (:require
+ [clojure.test :refer :all]
+ [java-time.api :as t]
+ [metabase.app-db.core :as mdb]
+ [metabase.lib.core :as lib]
+ [metabase.search.appdb.index :as search.index]
+ [metabase.search.engine :as search.engine]
+ [metabase.search.ingestion :as search.ingestion]
+ [metabase.search.test-util :as search.tu]
+ [metabase.test :as mt]
+ [metabase.test.fixtures :as fixtures]
+ [toucan2.core :as t2])
+ (:import
+ (org.postgresql.util PGobject)))
+
+(set! *warn-on-reflection* true)
+
+(use-fixtures :once (fixtures/initialize :db :test-users))
+
+(defn- ingest!
+ [model where-clause]
+ (#'search.engine/update!
+ :search.engine/appdb
+ (#'search.ingestion/query->documents
+ (#'search.ingestion/spec-index-reducible model where-clause))))
+
+(defn- fetch-one [model & clauses]
+ (apply t2/select-one (search.index/active-table) :model model clauses))
+
+(defn- ingest-then-fetch!
+ [model entity-name]
+ (ingest! model [:= :this.name entity-name])
+ (fetch-one model :name entity-name))
+
+(def ^:private default-index-entity
+ {:model nil
+ :model_id nil
+ :name nil
+ :official_collection nil
+ :database_id nil
+ :pinned nil
+ :view_count nil
+ :collection_id nil
+ :last_viewed_at nil
+ :model_created_at nil
+ :model_updated_at nil
+ :dashboardcard_count nil
+ :last_edited_at nil
+ :last_editor_id nil
+ :verified nil})
+
+(defn- index-entity
+ [entity]
+ (merge default-index-entity entity))
+
+(deftest transform-ingestion-test
+ (search.tu/with-temp-index-table
+ (testing "A simple SQL transform gets properly ingested & indexed for search"
+ (let [now (t/truncate-to (t/offset-date-time) :millis)]
+ (mt/with-temp [:model/Transform {transform-id :id} {:name "Test transform"
+ :description "A test transform"
+ :source {:type "query"
+ :query (mt/native-query {:query "SELECT 1"})}
+ :target {:database (mt/id)
+ :table "test_table"}
+ :created_at now
+ :updated_at now}]
+ (let [ingested-transform (ingest-then-fetch! "transform" "Test transform")]
+ (is (=? (index-entity
+ {:model "transform"
+ :model_id (str transform-id)
+ :name "Test transform"
+ :database_id (mt/id)
+ :model_created_at now
+ :model_updated_at now})
+ ingested-transform))))))
+
+ (testing "A simple Python transform gets properly ingested & indexed for search"
+ (let [now (t/truncate-to (t/offset-date-time) :millis)]
+ (mt/with-temp [:model/Transform {transform-id :id} {:name "Test Python transform"
+ :description "A Python test transform"
+ :source {:type "python"
+ :source-database (mt/id)
+ :body "import pandas as pd\n"}
+ :target {:database (mt/id)}
+ :created_at now
+ :updated_at now}]
+ (let [ingested-transform (ingest-then-fetch! "transform" "Test Python transform")]
+ (is (=? (index-entity
+ {:model "transform"
+ :model_id (str transform-id)
+ :name "Test Python transform"
+ :database_id (mt/id)
+ :model_created_at now
+ :model_updated_at now})
+ ingested-transform))))))
+
+ (testing "A simple MBQL transform gets properly ingested & indexed for search"
+ (let [now (t/truncate-to (t/offset-date-time) :millis)]
+ (mt/with-temp [:model/Transform {transform-id :id} {:name "Test MBQL transform"
+ :description "An MBQL test transform"
+ :source {:type "query"
+ :query (mt/mbql-query venues {:limit 10})}
+ :target {:database (mt/id)
+ :table "test_mbql_table"}
+ :created_at now
+ :updated_at now}]
+ (let [ingested-transform (ingest-then-fetch! "transform" "Test MBQL transform")]
+ (is (=? (index-entity
+ {:model "transform"
+ :model_id (str transform-id)
+ :name "Test MBQL transform"
+ :database_id (mt/id)
+ :model_created_at now
+ :model_updated_at now})
+ ingested-transform))))))))
+
+(deftest transform-query-ingestion-test
+ (testing "Contents of SQL and Python transform sources are extracted and indexed for full-text search"
+ (when (= (mdb/db-type) :postgres)
+ (mt/with-temp [:model/Transform _ {:target {:database (mt/id)
+ :table "test_table"}
+ :name "Test SQL transform"
+ :source {:type "query"
+ :query (lib/native-query (mt/metadata-provider) "SELECT 1")}}]
+ (let [ingested-transform (ingest-then-fetch! "transform" "Test SQL transform")
+ vector-value (.getValue ^PGobject (:with_native_query_vector ingested-transform))]
+ (is (string? vector-value))
+ (is (re-find #"select" vector-value))
+ (is (re-find #"sql" vector-value))))
+
+ (mt/with-temp [:model/Transform _ {:target {:database (mt/id)}
+ :source {:type "python"
+ :source-database (mt/id)
+ :body "import pandas as pd\n"}
+ :name "Test python transform"}]
+ (let [ingested-transform (ingest-then-fetch! "transform" "Test python transform")
+ vector-value (.getValue ^PGobject (:with_native_query_vector ingested-transform))]
+ (is (string? vector-value))
+ (is (re-find #"import" vector-value))
+ (is (re-find #"panda" vector-value))))
+
+ (testing "MBQL queries are not indexed in with_native_query_vector"
+ (mt/with-temp [:model/Transform _ {:target {:database (mt/id)
+ :table "test_mbql_table"}
+ :name "Test MBQL transform"
+ :source {:type "query"
+ :query (mt/mbql-query venues {:limit 10})}}]
+ (let [ingested-transform (ingest-then-fetch! "transform" "Test MBQL transform")
+ vector-value (.getValue ^PGobject (:with_native_query_vector ingested-transform))]
+ (is (string? vector-value))
+ (is (re-find #"test" vector-value))
+ (is (re-find #"mbql" vector-value))
+ ;; Ensure that the actual MQBL query isn't indexed
+ (is (not (re-find #"source" vector-value)))
+ (is (not (re-find #"table" vector-value)))))))))
+
+(deftest transform-deletion-test
+ (search.tu/with-temp-index-table
+ (testing "Transform is removed from search index when deleted"
+ (binding [search.ingestion/*force-sync* true]
+ (mt/with-temp [:model/Transform {transform-id :id} {:name "Transform to delete"}]
+ (ingest! "transform" [:= :this.id transform-id])
+ (is (some? (fetch-one "transform" :model_id (str transform-id)))
+ "Transform should be in the search index after ingestion")
+ (t2/delete! :model/Transform :id transform-id)
+ (is (nil? (fetch-one "transform" :model_id (str transform-id)))
+ "Transform should be removed from the search index after deletion"))))))
+
+(deftest transform-search-test
+ (mt/with-premium-features #{:transforms}
+ (search.tu/with-temp-index-table
+ (mt/as-admin
+ (testing "Transforms can be indexed and subsequently searched for"
+ (binding [search.ingestion/*force-sync* true]
+ (mt/with-temp [:model/Transform {transform-id :id}
+ {:name "Customer Revenue Analysis"
+ :description "Analyzes revenue by customer segment"
+ :source {:type "query"
+ :query (mt/native-query {:query "SELECT customer_id, SUM(revenue) FROM orders GROUP BY customer_id"})}
+ :target {:database (mt/id)
+ :table "customer_revenue"}}]
+ (ingest! "transform" [:= :this.id transform-id])
+ (testing "Can search by transform name"
+ (let [results (search.tu/search-results "Customer Revenue")]
+ (is (seq results) "Search should return results")
+ (is (some #(and (= "transform" (:model %))
+ (= transform-id (:id %)))
+ results)
+ "Results should include the transform")))
+ (testing "Can search by transform description"
+ (let [results (search.tu/search-results "customer segment")]
+ (is (some #(and (= "transform" (:model %))
+ (= transform-id (:id %)))
+ results)
+ "Should find transform by description text")))
+ (testing "Can filter search results to transforms only"
+ (mt/with-temp [:model/Card _ {:name "Customer Revenue Card"
+ :database_id (mt/id)
+ :table_id (mt/id :orders)
+ :dataset_query (mt/native-query {:query "SELECT 1"})}]
+ (ingest! "card" [:like :this.name "%Customer Revenue%"])
+ (let [transform-only-results (search.tu/search-results "Customer Revenue" {:models #{"transform"}})]
+ (is (every? #(= "transform" (:model %)) transform-only-results)
+ "All results should be transforms when filtered")))))))))))
diff --git a/enterprise/frontend/src/embedding-sdk-bundle/components/public/MetabotQuestion/MetabotChatInput.tsx b/enterprise/frontend/src/embedding-sdk-bundle/components/public/MetabotQuestion/MetabotChatInput.tsx
index 0ff65fcff3b..51faa4ecdc9 100644
--- a/enterprise/frontend/src/embedding-sdk-bundle/components/public/MetabotQuestion/MetabotChatInput.tsx
+++ b/enterprise/frontend/src/embedding-sdk-bundle/components/public/MetabotQuestion/MetabotChatInput.tsx
@@ -1,4 +1,5 @@
import cx from "classnames";
+import type { LegacyRef } from "react";
import { t } from "ttag";
import { useSdkDispatch } from "embedding-sdk-bundle/store";
@@ -65,7 +66,7 @@ export function MetabotChatInput() {
autosize
minRows={1}
maxRows={4}
- ref={metabot.promptInputRef}
+ ref={metabot.promptInputRef as LegacyRef<HTMLTextAreaElement>}
autoFocus
value={metabot.prompt}
disabled={metabot.isDoingScience}
diff --git a/enterprise/frontend/src/metabase-enterprise/api/ai-streaming/schemas.ts b/enterprise/frontend/src/metabase-enterprise/api/ai-streaming/schemas.ts
index 1b28712c695..7f72585f043 100644
--- a/enterprise/frontend/src/metabase-enterprise/api/ai-streaming/schemas.ts
+++ b/enterprise/frontend/src/metabase-enterprise/api/ai-streaming/schemas.ts
@@ -1,16 +1,25 @@
import * as Yup from "yup";
+import type { MetabotTodoItem, SuggestedTransform } from "metabase-types/api";
+
export const dataPartSchema = Yup.object({
type: Yup.string().required(),
version: Yup.number().required(),
value: Yup.mixed(),
});
-export const knownDataPartTypes = ["state", "navigate_to"];
+export const knownDataPartTypes = [
+ "navigate_to",
+ "state",
+ "todo_list",
+ "transform_suggestion",
+];
export type KnownDataPart =
+ | { type: "navigate_to"; version: 1; value: string }
| { type: "state"; version: 1; value: Record<string, any> }
- | { type: "navigate_to"; version: 1; value: string };
+ | { type: "todo_list"; version: 1; value: MetabotTodoItem[] }
+ | { type: "transform_suggestion"; version: 1; value: SuggestedTransform };
export const toolCallPartSchema = Yup.object({
toolCallId: Yup.string().required(),
diff --git a/enterprise/frontend/src/metabase-enterprise/documents/components/Editor/shared/MenuComponents.tsx b/enterprise/frontend/src/metabase-enterprise/documents/components/Editor/shared/MenuComponents.tsx
index 8d8b184d02a..31e4f10dacf 100644
--- a/enterprise/frontend/src/metabase-enterprise/documents/components/Editor/shared/MenuComponents.tsx
+++ b/enterprise/frontend/src/metabase-enterprise/documents/components/Editor/shared/MenuComponents.tsx
@@ -10,8 +10,7 @@ import {
Text,
UnstyledButton,
} from "metabase/ui";
-
-import type { SuggestionModel } from "../types";
+import type { SuggestionModel } from "metabase-enterprise/rich_text_editing/tiptap/extensions/shared/types";
import S from "./MenuItems.module.css";
@@ -29,6 +28,7 @@ export interface MenuItem {
model?: SuggestionModel;
id?: number | string;
href?: string;
+ hasSubmenu?: boolean;
}
export const MenuItemComponent = ({
@@ -65,6 +65,10 @@ export const MenuItemComponent = ({
</Text>
)}
</Stack>
+
+ {item.hasSubmenu && (
+ <Icon name="chevronright" size=".75rem" color="text-light" />
+ )}
</Group>
</UnstyledButton>
);
diff --git a/enterprise/frontend/src/metabase-enterprise/documents/components/Editor/shared/SuggestionPaper.tsx b/enterprise/frontend/src/metabase-enterprise/documents/components/Editor/shared/SuggestionPaper.tsx
index 0774207393f..6ed0c1c4110 100644
--- a/enterprise/frontend/src/metabase-enterprise/documents/components/Editor/shared/SuggestionPaper.tsx
+++ b/enterprise/frontend/src/metabase-enterprise/documents/components/Editor/shared/SuggestionPaper.tsx
@@ -17,7 +17,12 @@ export const SuggestionPaper = ({
children,
"aria-label": ariaLabel,
}: SuggestionPaperProps) => (
- <Box aria-label={ariaLabel} role="dialog" className={S.suggestionPaper}>
+ <Box
+ aria-label={ariaLabel}
+ role="dialog"
+ className={S.suggestionPaper}
+ data-testid="mention-suggestions-popup"
+ >
{children}
</Box>
);
@@ -25,7 +30,13 @@ export const SuggestionPaper = ({
export const LoadingSuggestionPaper = ({
"aria-label": ariaLabel,
}: LoadingSuggestionPaperProps) => (
- <Box aria-label={ariaLabel} ta="center" py="lg" className={S.suggestionPaper}>
+ <Box
+ aria-label={ariaLabel}
+ ta="center"
+ py="lg"
+ className={S.suggestionPaper}
+ data-testid="mention-suggestions-popup"
+ >
<Loader size="sm" />
</Box>
);
diff --git a/enterprise/frontend/src/metabase-enterprise/documents/components/Editor/types.ts b/enterprise/frontend/src/metabase-enterprise/documents/components/Editor/types.ts
index ae51a75c596..9e8b73887a3 100644
--- a/enterprise/frontend/src/metabase-enterprise/documents/components/Editor/types.ts
+++ b/enterprise/frontend/src/metabase-enterprise/documents/components/Editor/types.ts
@@ -1,8 +1,4 @@
-import type { SearchModel } from "metabase-types/api";
-
export interface CardEmbedRef {
id: number;
name?: string;
}
-
-export type SuggestionModel = SearchModel | "user";
diff --git a/enterprise/frontend/src/metabase-enterprise/metabot/components/AIMarkdown/AIMarkdown.module.css b/enterprise/frontend/src/metabase-enterprise/metabot/components/AIMarkdown/AIMarkdown.module.css
index 3d17a9111d7..e302341fa39 100644
--- a/enterprise/frontend/src/metabase-enterprise/metabot/components/AIMarkdown/AIMarkdown.module.css
+++ b/enterprise/frontend/src/metabase-enterprise/metabot/components/AIMarkdown/AIMarkdown.module.css
@@ -47,3 +47,25 @@
.aiMarkdown li > ol {
margin-top: 0.5rem;
}
+
+.smartLink {
+ color: var(--mb-color-brand);
+ font-weight: 700;
+ padding: 0.125rem;
+ border-radius: var(--mantine-radius-sm);
+ transition: 200ms background-color;
+ outline: none;
+
+ &:hover {
+ background-color: var(--mb-color-background-hover);
+ }
+}
+
+.smartLinkInner {
+ border-bottom: 1px solid var(--mb-color-brand-light);
+}
+
+.icon {
+ margin-bottom: -0.125rem;
+ margin-right: 0.25rem;
+}
diff --git a/enterprise/frontend/src/metabase-enterprise/metabot/components/AIMarkdown/AIMarkdown.tsx b/enterprise/frontend/src/metabase-enterprise/metabot/components/AIMarkdown/AIMarkdown.tsx
index 15685dd8af5..4cec2ef8590 100644
--- a/enterprise/frontend/src/metabase-enterprise/metabot/components/AIMarkdown/AIMarkdown.tsx
+++ b/enterprise/frontend/src/metabase-enterprise/metabot/components/AIMarkdown/AIMarkdown.tsx
@@ -3,12 +3,14 @@
import cx from "classnames";
import { memo, useMemo } from "react";
-import Link from "metabase/common/components/Link/Link";
import Markdown, {
type MarkdownProps,
} from "metabase/common/components/Markdown";
+import { parseMetabaseProtocolLink } from "metabase-enterprise/metabot/utils/links";
import S from "./AIMarkdown.module.css";
+import { InternalLink } from "./components/InternalLink";
+import { MarkdownSmartLink } from "./components/MarkdownSmartLink";
type AIMarkdownProps = MarkdownProps & {
onInternalLinkClick?: (link: string) => void;
@@ -28,20 +30,22 @@ const getComponents = ({
node?: any;
[key: string]: any;
}) => {
- if (href && href.startsWith("/")) {
- // A custom handler for internal links (use by Embedding SDK)
- if (onInternalLinkClick) {
- return (
- <a {...rest} onClick={() => onInternalLinkClick(href)}>
- {children}
- </a>
- );
- }
+ const parsed = parseMetabaseProtocolLink(node.properties.href);
+ if (parsed) {
+ return (
+ <MarkdownSmartLink
+ onInternalLinkClick={onInternalLinkClick}
+ name={String(node.children?.[0]?.value ?? "")}
+ {...parsed}
+ />
+ );
+ }
+ if (href?.startsWith("/")) {
return (
- <Link to={href} variant="brand">
+ <InternalLink onInternalLinkClick={onInternalLinkClick} href={href}>
{children}
- </Link>
+ </InternalLink>
);
}
diff --git a/enterprise/frontend/src/metabase-enterprise/metabot/components/AIMarkdown/AIMarkdown.unit.spec.tsx b/enterprise/frontend/src/metabase-enterprise/metabot/components/AIMarkdown/AIMarkdown.unit.spec.tsx
new file mode 100644
index 00000000000..b8492258b79
--- /dev/null
+++ b/enterprise/frontend/src/metabase-enterprise/metabot/components/AIMarkdown/AIMarkdown.unit.spec.tsx
@@ -0,0 +1,37 @@
+import { screen } from "@testing-library/react";
+import fetchMock from "fetch-mock";
+
+import { setupEnterprisePlugins } from "__support__/enterprise";
+import { mockSettings } from "__support__/settings";
+import { renderWithProviders } from "__support__/ui";
+import { createMockCard } from "metabase-types/api/mocks";
+import { createMockState } from "metabase-types/store/mocks";
+
+import { AIMarkdown } from "./AIMarkdown";
+
+const setup = (props: { children: string }) => {
+ setupEnterprisePlugins();
+ const settings = mockSettings({ "site-url": "http://localhost:3000" });
+
+ fetchMock.get(
+ "path:/api/card/123",
+ createMockCard({ id: 123, name: "Test Question" }),
+ );
+
+ return renderWithProviders(<AIMarkdown {...props} />, {
+ storeInitialState: createMockState({ settings }),
+ });
+};
+
+describe("AIMarkdown", () => {
+ it("should render internal links for Metabase protocol links", async () => {
+ setup({ children: "[My Question](metabase://question/123)" });
+
+ // Wait for the component to render
+ const link = await screen.findByText("My Question");
+ expect(link).toBeInTheDocument();
+
+ // Verify it's rendered as a smart link by checking for the icon
+ expect(screen.getByRole("img", { name: /icon/ })).toBeInTheDocument();
+ });
+});
diff --git a/enterprise/frontend/src/metabase-enterprise/metabot/components/AIMarkdown/components/InternalLink.tsx b/enterprise/frontend/src/metabase-enterprise/metabot/components/AIMarkdown/components/InternalLink.tsx
new file mode 100644
index 00000000000..119f4656ed3
--- /dev/null
+++ b/enterprise/frontend/src/metabase-enterprise/metabot/components/AIMarkdown/components/InternalLink.tsx
@@ -0,0 +1,26 @@
+import Link from "metabase/common/components/Link";
+
+export const InternalLink = ({
+ onInternalLinkClick,
+ href,
+ children,
+ ...rest
+}: {
+ onInternalLinkClick?: (href: string) => void;
+ href: string;
+ children: React.ReactNode;
+} & React.AnchorHTMLAttributes<HTMLAnchorElement>) => {
+ if (onInternalLinkClick) {
+ return (
+ <a {...rest} onClick={() => onInternalLinkClick(href)}>
+ {children}
+ </a>
+ );
+ }
+
+ return (
+ <Link to={href} variant="brand" {...rest}>
+ {children}
+ </Link>
+ );
+};
diff --git a/enterprise/frontend/src/metabase-enterprise/metabot/components/AIMarkdown/components/MarkdownSmartLink.tsx b/enterprise/frontend/src/metabase-enterprise/metabot/components/AIMarkdown/components/MarkdownSmartLink.tsx
new file mode 100644
index 00000000000..1c4d9f39825
--- /dev/null
+++ b/enterprise/frontend/src/metabase-enterprise/metabot/components/AIMarkdown/components/MarkdownSmartLink.tsx
@@ -0,0 +1,52 @@
+import { match } from "ts-pattern";
+
+import { getIcon } from "metabase/lib/icon";
+import { modelToUrl } from "metabase/lib/urls";
+import { Icon } from "metabase/ui";
+import type { MetabaseProtocolEntityModel } from "metabase-enterprise/metabot/utils/links";
+import { useEntityData } from "metabase-enterprise/rich_text_editing/tiptap/extensions/SmartLink/SmartLinkNode";
+import { entityToUrlableModel } from "metabase-enterprise/rich_text_editing/tiptap/extensions/shared/suggestionUtils";
+
+import S from "../AIMarkdown.module.css";
+
+import { InternalLink } from "./InternalLink";
+
+export const MarkdownSmartLink = ({
+ onInternalLinkClick,
+ id,
+ name,
+ model,
+}: {
+ onInternalLinkClick?: (href: string) => void;
+ id: number;
+ name: string;
+ model: MetabaseProtocolEntityModel;
+}) => {
+ const entityModel = match(model)
+ .with("model", () => "dataset" as const)
+ .with("question", () => "card" as const)
+ .otherwise((x) => x);
+ const icon = getIcon({ model: entityModel });
+
+ const { entity, isLoading, error } = useEntityData(id, entityModel);
+
+ const entityUrl =
+ !isLoading && !error && entity
+ ? (modelToUrl(entityToUrlableModel(entity, entityModel)) ?? "")
+ : ""; // fallback to linking to nothing
+
+ return (
+ <InternalLink
+ onInternalLinkClick={onInternalLinkClick}
+ href={entityUrl}
+ target="_blank"
+ rel="noreferrer"
+ className={S.smartLink}
+ >
+ <span className={S.smartLinkInner}>
+ <Icon name={icon.name} className={S.icon} />
+ {name}
+ </span>
+ </InternalLink>
+ );
+};
diff --git a/enterprise/frontend/src/metabase-enterprise/metabot/components/Metabot.tsx b/enterprise/frontend/src/metabase-enterprise/metabot/components/Metabot.tsx
index ebc3fce7eb6..c11510e56b4 100644
--- a/enterprise/frontend/src/metabase-enterprise/metabot/components/Metabot.tsx
+++ b/enterprise/frontend/src/metabase-enterprise/metabot/components/Metabot.tsx
@@ -4,17 +4,28 @@ import { tinykeys } from "tinykeys";
import ErrorBoundary from "metabase/ErrorBoundary";
import { useSelector } from "metabase/lib/redux";
import { getUser } from "metabase/selectors/user";
+import type { SuggestionModel } from "metabase-enterprise/rich_text_editing/tiptap/extensions/shared/types";
import { trackMetabotChatOpened } from "../analytics";
import { useMetabotAgent } from "../hooks";
import { MetabotChat } from "./MetabotChat";
+// TODO: add test coverage for these
+export interface MetabotConfig {
+ emptyText?: string;
+ hideSuggestedPrompts?: boolean;
+ preventClose?: boolean;
+ preventRetryMessage?: boolean;
+ suggestionModels: SuggestionModel[];
+}
+
export interface MetabotProps {
hide?: boolean;
+ config?: MetabotConfig;
}
-export const MetabotAuthenticated = ({ hide }: MetabotProps) => {
+export const MetabotAuthenticated = ({ hide, config }: MetabotProps) => {
const { visible, setVisible } = useMetabotAgent();
useEffect(() => {
@@ -44,7 +55,7 @@ export const MetabotAuthenticated = ({ hide }: MetabotProps) => {
return (
<ErrorBoundary errorComponent={() => null}>
- <MetabotChat />
+ <MetabotChat config={config} />
</ErrorBoundary>
);
};
diff --git a/enterprise/frontend/src/metabase-enterprise/metabot/components/MetabotAdminAppBarButton.tsx b/enterprise/frontend/src/metabase-enterprise/metabot/components/MetabotAdminAppBarButton.tsx
new file mode 100644
index 00000000000..820a3c60591
--- /dev/null
+++ b/enterprise/frontend/src/metabase-enterprise/metabot/components/MetabotAdminAppBarButton.tsx
@@ -0,0 +1,39 @@
+import { useLocation } from "react-use";
+import { t } from "ttag";
+
+import { METAKEY } from "metabase/lib/browser";
+import * as Urls from "metabase/lib/urls";
+import { AdminActionButton } from "metabase/nav/components/AdminNavbar/AdminNavbar.styled";
+import { Icon, Tooltip } from "metabase/ui";
+
+import { trackMetabotChatOpened } from "../analytics";
+import { useMetabotAgent } from "../hooks";
+
+export const MetabotAdminAppBarButton = () => {
+ const metabot = useMetabotAgent();
+
+ const location = useLocation();
+ const disabled = !location.pathname?.startsWith(Urls.transformList());
+
+ const handleClick = () => {
+ if (!metabot.visible) {
+ trackMetabotChatOpened("header");
+ }
+
+ metabot.setVisible(!metabot.visible);
+ };
+
+ return (
+ <Tooltip
+ label={
+ disabled
+ ? `Metabot can't be viewed on this page`
+ : t`Chat with Metabot (${METAKEY}+E)`
+ }
+ >
+ <AdminActionButton disabled={disabled} onClick={handleClick}>
+ <Icon name="metabot" />
+ </AdminActionButton>
+ </Tooltip>
+ );
+};
diff --git a/enterprise/frontend/src/metabase-enterprise/metabot/components/MetabotChat/MetabotAgentSuggestionMessage.module.css b/enterprise/frontend/src/metabase-enterprise/metabot/components/MetabotChat/MetabotAgentSuggestionMessage.module.css
new file mode 100644
index 00000000000..4e8ee41d540
--- /dev/null
+++ b/enterprise/frontend/src/metabase-enterprise/metabot/components/MetabotChat/MetabotAgentSuggestionMessage.module.css
@@ -0,0 +1,38 @@
+.container {
+ border: 1px solid var(--mb-color-border);
+}
+
+.headerOpened {
+ border-bottom: 1px solid var(--mb-color-border);
+}
+
+.suggestionEditor {
+ :global {
+ .cm-content {
+ padding: 0;
+ }
+
+ .cm-collapsedLines {
+ padding-left: 0;
+ }
+ }
+}
+
+.suggestionEditorOnlyNew {
+ background: color-mix(in srgb, var(--mb-color-success) 11%, transparent);
+
+ :global {
+ .cm-gutters {
+ background: transparent;
+ }
+ }
+}
+
+.suggestionHeader {
+ cursor: pointer;
+}
+
+.suggestionHeaderCollapsed,
+.suggestionHeaderCollapsed * {
+ user-select: none;
+}
diff --git a/enterprise/frontend/src/metabase-enterprise/metabot/components/MetabotChat/MetabotAgentSuggestionMessage.tsx b/enterprise/frontend/src/metabase-enterprise/metabot/components/MetabotChat/MetabotAgentSuggestionMessage.tsx
new file mode 100644
index 00000000000..6914f7f39c7
--- /dev/null
+++ b/enterprise/frontend/src/metabase-enterprise/metabot/components/MetabotChat/MetabotAgentSuggestionMessage.tsx
@@ -0,0 +1,262 @@
+import { unifiedMergeView } from "@codemirror/merge";
+import { useDisclosure } from "@mantine/hooks";
+import type { UnknownAction } from "@reduxjs/toolkit";
+import cx from "classnames";
+import { useMemo } from "react";
+import { push } from "react-router-redux";
+import { useLocation, useMount } from "react-use";
+import { P, match } from "ts-pattern";
+import { t } from "ttag";
+import _ from "underscore";
+
+import { CodeMirror } from "metabase/common/components/CodeMirror";
+import { useDispatch, useSelector } from "metabase/lib/redux";
+import * as Urls from "metabase/lib/urls";
+import EditorS from "metabase/query_builder/components/NativeQueryEditor/CodeMirrorEditor/CodeMirrorEditor.module.css";
+import { getMetadata } from "metabase/selectors/metadata";
+import {
+ Button,
+ Collapse,
+ Flex,
+ Group,
+ Icon,
+ Loader,
+ Paper,
+ Text,
+} from "metabase/ui";
+import { useLazyGetTransformQuery } from "metabase-enterprise/api";
+import {
+ type MetabotAgentEditSuggestionChatMessage,
+ activateSuggestedTransform,
+ getIsSuggestedTransformActive,
+} from "metabase-enterprise/metabot/state";
+import * as Lib from "metabase-lib";
+import type Metadata from "metabase-lib/v1/metadata/Metadata";
+import type {
+ MetabotTransformInfo,
+ SuggestedTransform,
+} from "metabase-types/api";
+
+import S from "./MetabotAgentSuggestionMessage.module.css";
+
+const PreviewContent = ({
+ oldSource,
+ newSource,
+}: {
+ oldSource: string;
+ newSource: string;
+}) => {
+ const extensions = useMemo(
+ () =>
+ _.compact([
+ oldSource &&
+ unifiedMergeView({
+ original: oldSource,
+ mergeControls: false,
+ collapseUnchanged: {
+ margin: 1,
+ minSize: 1,
+ },
+ }),
+ ]),
+ [oldSource],
+ );
+
+ return (
+ <CodeMirror
+ className={cx(
+ EditorS.editor,
+ S.suggestionEditor,
+ !oldSource && S.suggestionEditorOnlyNew,
+ )}
+ extensions={extensions}
+ value={newSource}
+ readOnly
+ autoCorrect="off"
+ />
+ );
+};
+
+const useGetOldTransform = ({
+ editorTransform,
+ suggestedTransform,
+}: MetabotAgentEditSuggestionChatMessage["payload"]) => {
+ const [trigger, result] = useLazyGetTransformQuery();
+ useMount(() => {
+ !editorTransform && suggestedTransform.id && trigger(suggestedTransform.id);
+ });
+
+ if (editorTransform) {
+ return {
+ data: editorTransform,
+ isLoading: false,
+ error: undefined,
+ } as const;
+ }
+
+ return result;
+};
+
+export const AgentSuggestionMessage = ({
+ message,
+}: {
+ message: MetabotAgentEditSuggestionChatMessage;
+}) => {
+ const dispatch = useDispatch();
+ const metadata = useSelector(getMetadata);
+
+ const { suggestedTransform, editorTransform } = message.payload;
+ const isActive = useSelector((state) =>
+ getIsSuggestedTransformActive(state, suggestedTransform.suggestionId),
+ );
+
+ const [opened, { toggle }] = useDisclosure(true);
+
+ const url = useLocation();
+ const isViewing = url.pathname?.startsWith(
+ getTransformUrl(suggestedTransform),
+ );
+
+ const canApply = !isViewing || !isActive;
+ const isNew = !isViewing && !editorTransform && suggestedTransform.id == null;
+
+ const {
+ data: originalTransform,
+ isLoading,
+ error,
+ } = useGetOldTransform(message.payload);
+
+ const oldSource = originalTransform
+ ? getSourceCode(originalTransform, metadata)
+ : "";
+ const newSource = getSourceCode(suggestedTransform, metadata);
+
+ const handleApply = () => {
+ dispatch(activateSuggestedTransform(suggestedTransform));
+ dispatch(push(getTransformUrl(suggestedTransform)) as UnknownAction);
+ };
+
+ return (
+ <Paper
+ shadow="none"
+ radius="md"
+ bg="white"
+ className={S.container}
+ data-testid="metabot-chat-suggestion"
+ >
+ <Group
+ p="md"
+ align="center"
+ justify="space-between"
+ onClick={toggle}
+ className={cx(opened && S.headerOpened)}
+ >
+ <Flex align="center" gap="sm">
+ <Icon name="refresh_downstream" size="1rem" c="text-secondary" />
+ <Text size="sm">{suggestedTransform.name}</Text>
+ </Flex>
+ <Flex align="center" gap="sm">
+ <Text
+ size="sm"
+ c={isNew ? "var(--mb-color-saturated-blue)" : "text-secondary"}
+ >
+ {isNew ? t`New` : t`Revision`}
+ </Text>
+ <Flex align="center" justify="center" h="md" w="md">
+ <Icon name={opened ? "chevrondown" : "chevronup"} size=".75rem" />
+ </Flex>
+ </Flex>
+ </Group>
+
+ <Collapse
+ in={opened}
+ transitionDuration={0}
+ transitionTimingFunction="linear"
+ >
+ {match({ isLoading, error })
+ .with({ error: P.not(P.nullish) }, () => (
+ <Flex p="md" bg="bg-light" justify="center" align="center" gap="sm">
+ <Text mb="1px" c="danger">{t`Failed to load preview`}</Text>
+ </Flex>
+ ))
+ .with({ isLoading: true }, () => (
+ <Flex p="md" bg="bg-light" justify="center" align="center" gap="sm">
+ <Loader size="xs" color="text-secondary" type="dots" />
+ <Text mb="1px" c="text-secondary">{t`Loading preview`}</Text>
+ </Flex>
+ ))
+ .with({ isLoading: false }, () => (
+ <PreviewContent oldSource={oldSource} newSource={newSource} />
+ ))
+ .exhaustive()}
+
+ <Group
+ py="xs"
+ px="sm"
+ align="center"
+ justify="space-between"
+ style={{
+ borderTop: opened ? `1px solid var(--mb-color-border)` : "",
+ }}
+ >
+ <Flex
+ align="center"
+ justify="flex-end"
+ w="100%"
+ h="1.375rem"
+ gap="sm"
+ >
+ <Button
+ size="compact-xs"
+ variant="subtle"
+ fw="normal"
+ fz="sm"
+ c={canApply ? "success" : "text-light"}
+ disabled={!canApply}
+ onClick={handleApply}
+ >
+ {match({ isNew, canApply })
+ .with({ canApply: false }, () => t`Applied`)
+ .with({ isNew: true }, () => t`Create`)
+ .with({ canApply: true }, () => t`Apply`)
+ .exhaustive()}
+ </Button>
+ </Flex>
+ </Group>
+ </Collapse>
+ </Paper>
+ );
+};
+
+function getSourceCode(
+ transform: Pick<MetabotTransformInfo, "source">,
+ metadata: Metadata,
+): string {
+ return match(transform)
+ .with({ source: { type: "query" } }, (t) => {
+ const metadataProvider = Lib.metadataProvider(
+ t.source.query.database,
+ metadata,
+ );
+ const query = Lib.fromJsQuery(metadataProvider, t.source.query);
+ if (Lib.queryDisplayInfo(query).isNative) {
+ return Lib.rawNativeQuery(query);
+ } else {
+ return "";
+ }
+ })
+ .with({ source: { type: "python" } }, (t) => t.source.body)
+ .otherwise(() => "");
+}
+
+function getTransformUrl(transform: SuggestedTransform): string {
+ return match(transform)
+ .with({ id: P.number }, ({ id }) => Urls.transformQuery(id))
+ .with({ source: { type: "python" } }, () =>
+ Urls.newTransformFromType("python"),
+ )
+ .with({ source: { type: "query" } }, () =>
+ Urls.newTransformFromType("native"),
+ )
+ .exhaustive();
+}
diff --git a/enterprise/frontend/src/metabase-enterprise/metabot/components/MetabotChat/MetabotAgentSuggestionMessage.unit.spec.tsx b/enterprise/frontend/src/metabase-enterprise/metabot/components/MetabotChat/MetabotAgentSuggestionMessage.unit.spec.tsx
new file mode 100644
index 00000000000..dc77e596564
--- /dev/null
+++ b/enterprise/frontend/src/metabase-enterprise/metabot/components/MetabotChat/MetabotAgentSuggestionMessage.unit.spec.tsx
@@ -0,0 +1,156 @@
+import { screen } from "@testing-library/react";
+import userEvent from "@testing-library/user-event";
+
+import { setupEnterprisePlugins } from "__support__/enterprise";
+import { mockSettings } from "__support__/settings";
+import { renderWithProviders } from "__support__/ui";
+import type { MetabotTransformInfo } from "metabase-types/api";
+import {
+ createMockNativeDatasetQuery,
+ createMockUser,
+} from "metabase-types/api/mocks";
+import {
+ createMockPythonTransformSource,
+ createMockTransform,
+} from "metabase-types/api/mocks/transform";
+import { createMockState } from "metabase-types/store/mocks";
+
+import type {
+ MetabotAgentEditSuggestionChatMessage,
+ MetabotSuggestedTransform,
+} from "../../state/reducer";
+
+import { AgentSuggestionMessage } from "./MetabotAgentSuggestionMessage";
+
+const createMockSuggestedTransform = (
+ overrides: Partial<MetabotSuggestedTransform>,
+): MetabotSuggestedTransform => ({
+ ...createMockTransform(),
+ suggestionId: "suggestion-123",
+ active: false,
+ ...overrides,
+});
+
+const createMockTransformInfo = (
+ overrides: Partial<MetabotTransformInfo>,
+): MetabotTransformInfo => ({
+ type: "transform",
+ ...createMockTransform(),
+ ...overrides,
+});
+
+const createMockTransformSuggestionMessage = (
+ overrides: Partial<MetabotAgentEditSuggestionChatMessage>,
+): MetabotAgentEditSuggestionChatMessage => ({
+ id: "msg-123",
+ role: "agent",
+ type: "edit_suggestion",
+ model: "transform",
+ payload: {
+ editorTransform: undefined,
+ suggestedTransform: createMockSuggestedTransform({}),
+ },
+ ...overrides,
+});
+
+const setup = (message: MetabotAgentEditSuggestionChatMessage) => {
+ setupEnterprisePlugins();
+ return renderWithProviders(<AgentSuggestionMessage message={message} />, {
+ storeInitialState: createMockState({
+ settings: mockSettings(),
+ currentUser: createMockUser(),
+ }),
+ });
+};
+
+describe("AgentSuggestionMessage", () => {
+ it("should show proposal for new transforms", async () => {
+ setup(
+ createMockTransformSuggestionMessage({
+ payload: {
+ editorTransform: undefined,
+ suggestedTransform: createMockSuggestedTransform({
+ id: undefined,
+ source: {
+ type: "query",
+ query: createMockNativeDatasetQuery(),
+ },
+ }),
+ },
+ }),
+ );
+
+ expect(await screen.findByText("New")).toBeInTheDocument();
+ expect(await screen.findByRole("textbox")).toHaveValue("SELECT 1");
+ expect(
+ await screen.findByRole("button", { name: /Create/ }),
+ ).toBeInTheDocument();
+ });
+
+ it("should show diff view for edited transforms", async () => {
+ setup(
+ createMockTransformSuggestionMessage({
+ payload: {
+ editorTransform: createMockTransformInfo({
+ id: 123,
+ source: createMockPythonTransformSource({
+ body: "# Original code\nprint('original')",
+ }),
+ }),
+ suggestedTransform: createMockSuggestedTransform({
+ id: 123,
+ source: createMockPythonTransformSource({
+ body: "# Updated code\nprint('updated')",
+ }),
+ }),
+ },
+ }),
+ );
+
+ expect(await screen.findByText("Revision")).toBeInTheDocument();
+ // NOTE: jsdom has limitations around contenteditable, so we can't assert on old source being visible
+ expect(await screen.findByRole("textbox")).toHaveValue(
+ "# Updated code\nprint('updated')",
+ );
+ expect(
+ await screen.findByRole("button", { name: /Apply/ }),
+ ).toBeInTheDocument();
+ });
+
+ it("should be collapsible", async () => {
+ setup(
+ createMockTransformSuggestionMessage({
+ payload: {
+ editorTransform: undefined,
+ suggestedTransform: createMockSuggestedTransform({
+ id: undefined, // Make sure this is a new transform
+ name: "Test Transform",
+ }),
+ },
+ }),
+ );
+
+ // Initially opened (default state) - content should be visible
+ const transformName = await screen.findByText("Test Transform");
+ expect(transformName).toBeInTheDocument();
+ expect(
+ await screen.findByRole("button", { name: /create/i }),
+ ).toBeInTheDocument();
+
+ // Click header to collapse
+ await userEvent.click(transformName);
+
+ // Should be collapsed - content should not be visible
+ expect(
+ screen.queryByRole("button", { name: /create/i }),
+ ).not.toBeInTheDocument();
+
+ // Click header again to expand
+ await userEvent.click(transformName);
+
+ // Should be expanded again - content should be visible
+ expect(
+ await screen.findByRole("button", { name: /create/i }),
+ ).toBeInTheDocument();
+ });
+});
diff --git a/enterprise/frontend/src/metabase-enterprise/metabot/components/MetabotChat/MetabotAgentTodoMessage.module.css b/enterprise/frontend/src/metabase-enterprise/metabot/components/MetabotChat/MetabotAgentTodoMessage.module.css
new file mode 100644
index 00000000000..38b11cc8c45
--- /dev/null
+++ b/enterprise/frontend/src/metabase-enterprise/metabot/components/MetabotChat/MetabotAgentTodoMessage.module.css
@@ -0,0 +1,32 @@
+.todoContainer {
+ border: 1px solid var(--mb-color-brand);
+ background-color: var(--mb-color-brand-lighter);
+}
+
+.todoHeader {
+ cursor: pointer;
+ user-select: none;
+}
+
+.primaryColor {
+ color: var(--mb-color-text-brand);
+}
+
+.todoItem {
+ border-radius: 2px;
+}
+
+.statusIndicator {
+ height: 0.8rem;
+ width: 0.8rem;
+ border-radius: 50%;
+ flex-shrink: 0;
+ margin-top: 2px;
+ background: var(--mb-color-brand);
+}
+
+.pendingIndicator {
+ border: 1.5px solid var(--mb-color-brand);
+ margin-top: 1px;
+ background: none;
+}
diff --git a/enterprise/frontend/src/metabase-enterprise/metabot/components/MetabotChat/MetabotAgentTodoMessage.tsx b/enterprise/frontend/src/metabase-enterprise/metabot/components/MetabotChat/MetabotAgentTodoMessage.tsx
new file mode 100644
index 00000000000..3eda824e0b2
--- /dev/null
+++ b/enterprise/frontend/src/metabase-enterprise/metabot/components/MetabotChat/MetabotAgentTodoMessage.tsx
@@ -0,0 +1,117 @@
+import { useDisclosure } from "@mantine/hooks";
+import cx from "classnames";
+import { match } from "ts-pattern";
+import { t } from "ttag";
+
+import { Collapse, Flex, Group, Icon, Paper, Stack, Text } from "metabase/ui";
+import type { MetabotTodoItem } from "metabase-types/api";
+
+import S from "./MetabotAgentTodoMessage.module.css";
+
+type TodoStatusConfig = {
+ color: string;
+ td?: string;
+};
+
+const todoStatusConfig: Record<MetabotTodoItem["status"], TodoStatusConfig> = {
+ completed: { color: "text-secondary", td: "line-through" },
+ in_progress: { color: "text-primary" },
+ cancelled: { td: "line-through", color: "text-secondary" },
+ pending: { color: "text-primary" },
+};
+
+export const AgentTodoListMessage = ({
+ todos,
+}: {
+ todos: MetabotTodoItem[];
+}) => {
+ const [opened, { toggle }] = useDisclosure(true);
+
+ return (
+ <Paper shadow="none" radius="md" className={S.todoContainer}>
+ <Group
+ align="center"
+ justify="space-between"
+ onClick={toggle}
+ className={S.todoHeader}
+ py="sm"
+ px="md"
+ data-testid="todo-list-header"
+ >
+ <Flex align="center" justify="center">
+ <Icon name="list" size=".75rem" mr="xs" c="brand" />
+ <Text size="sm" fw="bold" c="brand">{t`Todo List`}</Text>
+ </Flex>
+ <Flex align="center" justify="center" h="md">
+ <Icon
+ name={opened ? "chevrondown" : "chevronup"}
+ size=".75rem"
+ c="brand"
+ />
+ </Flex>
+ </Group>
+
+ <Collapse
+ in={opened}
+ transitionDuration={opened ? 200 : 0}
+ pb="sm"
+ px="md"
+ >
+ <Stack gap="sm" w="100%" pb="xs">
+ {todos.map((todo) => {
+ const config = todoStatusConfig[todo.status];
+
+ return (
+ <Flex key={todo.id} bdrs="sm" align="flex-start">
+ {match(todo.status)
+ .with("pending", () => (
+ <Flex
+ className={cx(S.statusIndicator, S.pendingIndicator)}
+ align="center"
+ justify="center"
+ mr="sm"
+ />
+ ))
+ .with("completed", () => (
+ <Flex
+ className={S.statusIndicator}
+ align="center"
+ justify="center"
+ mr="sm"
+ >
+ <Icon name="check" size=".7rem" c="white" />
+ </Flex>
+ ))
+ .with("in_progress", () => (
+ <Flex
+ className={S.statusIndicator}
+ align="center"
+ justify="center"
+ mr="sm"
+ >
+ <Icon name="arrow_right" size=".6rem" c="white" />
+ </Flex>
+ ))
+ .with("cancelled", () => (
+ <Flex
+ className={S.statusIndicator}
+ bg="brand"
+ align="center"
+ justify="center"
+ mr="sm"
+ >
+ <Icon name="close" size=".7rem" c="white" />
+ </Flex>
+ ))
+ .exhaustive()}
+ <Text td={config.td} lh="md" size="sm" c={config.color}>
+ {todo.content}
+ </Text>
+ </Flex>
+ );
+ })}
+ </Stack>
+ </Collapse>
+ </Paper>
+ );
+};
diff --git a/enterprise/frontend/src/metabase-enterprise/metabot/components/MetabotChat/MetabotAgentTodoMessage.unit.spec.tsx b/enterprise/frontend/src/metabase-enterprise/metabot/components/MetabotChat/MetabotAgentTodoMessage.unit.spec.tsx
new file mode 100644
index 00000000000..508f9b29bb2
--- /dev/null
+++ b/enterprise/frontend/src/metabase-enterprise/metabot/components/MetabotChat/MetabotAgentTodoMessage.unit.spec.tsx
@@ -0,0 +1,106 @@
+import { screen } from "@testing-library/react";
+import userEvent from "@testing-library/user-event";
+
+import { renderWithProviders } from "__support__/ui";
+import type { MetabotTodoItem } from "metabase-types/api";
+
+import { AgentTodoListMessage } from "./MetabotAgentTodoMessage";
+
+const createMockTodoItem = (
+ overrides: Partial<MetabotTodoItem> = {},
+): MetabotTodoItem => ({
+ id: "1",
+ content: "Test todo item",
+ status: "pending",
+ priority: "medium",
+ ...overrides,
+});
+
+const setup = (todos: MetabotTodoItem[]) => {
+ return renderWithProviders(<AgentTodoListMessage todos={todos} />);
+};
+
+describe("AgentTodoListMessage", () => {
+ it("should render all todo item status correctly", async () => {
+ setup([
+ createMockTodoItem({
+ id: "1",
+ content: "Pending task",
+ status: "pending",
+ }),
+ createMockTodoItem({
+ id: "2",
+ content: "In progress task",
+ status: "in_progress",
+ }),
+ createMockTodoItem({
+ id: "3",
+ content: "Completed task",
+ status: "completed",
+ }),
+ createMockTodoItem({
+ id: "4",
+ content: "Cancelled task",
+ status: "cancelled",
+ }),
+ ]);
+
+ // Check that all todo items are rendered
+ expect(await screen.findByText("Pending task")).toBeInTheDocument();
+ expect(await screen.findByText("In progress task")).toBeInTheDocument();
+ expect(await screen.findByText("Completed task")).toBeInTheDocument();
+ expect(await screen.findByText("Cancelled task")).toBeInTheDocument();
+
+ // Check status indicators
+ expect(
+ await screen.findByRole("img", { name: /check icon/ }),
+ ).toBeInTheDocument(); // completed
+ expect(
+ await screen.findByRole("img", { name: /arrow_right icon/ }),
+ ).toBeInTheDocument(); // in_progress
+ expect(
+ await screen.findByRole("img", { name: /close icon/ }),
+ ).toBeInTheDocument(); // cancelled
+
+ // Check that completed and cancelled items have strikethrough
+ const completedTask = await screen.findByText("Completed task");
+ const cancelledTask = await screen.findByText("Cancelled task");
+ expect(completedTask).toHaveStyle("text-decoration: line-through");
+ expect(cancelledTask).toHaveStyle("text-decoration: line-through");
+
+ // Check that pending and in_progress items don't have strikethrough
+ const pendingTask = await screen.findByText("Pending task");
+ const inProgressTask = await screen.findByText("In progress task");
+ expect(pendingTask).not.toHaveStyle("text-decoration: line-through");
+ expect(inProgressTask).not.toHaveStyle("text-decoration: line-through");
+ });
+
+ it("should be collapsible", async () => {
+ setup([
+ createMockTodoItem({ id: "1", content: "Test task", status: "pending" }),
+ ]);
+
+ // Initially opened (default state)
+ expect(await screen.findByText("Test task")).toBeInTheDocument();
+ expect(
+ await screen.findByRole("img", { name: /chevrondown icon/ }),
+ ).toBeInTheDocument();
+
+ // Click header to collapse
+ await userEvent.click(await screen.findByTestId("todo-list-header"));
+
+ // Should be collapsed
+ expect(
+ await screen.findByRole("img", { name: /chevronup icon/ }),
+ ).toBeInTheDocument();
+
+ // Click header again to expand
+ await userEvent.click(await screen.findByTestId("todo-list-header"));
+
+ // Should be expanded again
+ expect(
+ await screen.findByRole("img", { name: /chevrondown icon/ }),
+ ).toBeInTheDocument();
+ expect(await screen.findByText("Test task")).toBeInTheDocument();
+ });
+});
diff --git a/enterprise/frontend/src/metabase-enterprise/metabot/components/MetabotChat/MetabotChat.module.css b/enterprise/frontend/src/metabase-enterprise/metabot/components/MetabotChat/MetabotChat.module.css
index 12b624d8515..c5e6e1b2364 100644
--- a/enterprise/frontend/src/metabase-enterprise/metabot/components/MetabotChat/MetabotChat.module.css
+++ b/enterprise/frontend/src/metabase-enterprise/metabot/components/MetabotChat/MetabotChat.module.css
@@ -18,7 +18,7 @@
}
.inputContainer {
- padding: 0 0.75rem 0 0.25rem;
+ padding: 0 0.75rem 0 0.3rem;
display: flex;
align-items: center;
gap: 0.5rem;
@@ -27,7 +27,7 @@
min-height: 3rem;
border: 1px solid var(--mb-color-border);
- &:has(.textarea textarea:focus) {
+ &:focus-within {
border-color: var(--mb-color-brand);
}
}
@@ -36,35 +36,6 @@
background: var(--mb-color-bg-light);
}
-.inputContainerExpanded {
- padding: 1rem var(--padding-x);
- align-items: flex-start;
- height: 8rem;
-}
-
-.textarea textarea {
- border: none;
- border-radius: 0;
- background: transparent;
- outline: none;
- width: 100%;
- line-height: 1.7;
- color: var(--mb-color-text-dark);
-
- &:focus {
- border-color: var(--mb-color-brand);
- }
-}
-
-.textareaExpanded textarea {
- padding: 0;
-}
-
-.textareaLoading textarea:disabled {
- opacity: 1;
- background: transparent;
-}
-
.messagesContainer {
padding: 1rem var(--padding-x) 1.5rem;
height: 100%;
@@ -92,6 +63,12 @@
width: fit-content;
}
+.messageContainerUser :global(.smart-link) {
+ border: 1px solid var(--mb-color-brand-light);
+ position: relative;
+ bottom: -2px;
+}
+
.message {
font-size: 0.875rem;
line-height: 1.4 !important;
@@ -103,6 +80,14 @@
background: var(--mb-color-bg-medium);
}
+.messageUserAction {
+ padding: 0.5rem 1rem;
+ border-radius: 0.5rem;
+ background: var(--mb-color-bg-light);
+ border: 1px solid var(--mb-color-bg-medium);
+ font-weight: bold;
+}
+
.messageActions {
opacity: 0;
transition: all 150ms linear;
diff --git a/enterprise/frontend/src/metabase-enterprise/metabot/components/MetabotChat/MetabotChat.tsx b/enterprise/frontend/src/metabase-enterprise/metabot/components/MetabotChat/MetabotChat.tsx
index 19ac0ebc9a0..d358da3aaa9 100644
--- a/enterprise/frontend/src/metabase-enterprise/metabot/components/MetabotChat/MetabotChat.tsx
+++ b/enterprise/frontend/src/metabase-enterprise/metabot/components/MetabotChat/MetabotChat.tsx
@@ -1,7 +1,6 @@
import cx from "classnames";
-import { useMemo } from "react";
+import { useCallback, useMemo } from "react";
import { t } from "ttag";
-import _ from "underscore";
import EmptyDashboardBot from "assets/img/dashboard-empty.svg?component";
import { Sidebar } from "metabase/nav/containers/MainNavbar/MainNavbar.styled";
@@ -14,23 +13,39 @@ import {
Paper,
Stack,
Text,
- Textarea,
Tooltip,
} from "metabase/ui";
import { useGetSuggestedMetabotPromptsQuery } from "metabase-enterprise/api";
import { MetabotResetLongChatButton } from "metabase-enterprise/metabot/components/MetabotChat/MetabotResetLongChatButton";
import { useMetabotAgent, useMetabotChatHandlers } from "../../hooks";
+import type { MetabotConfig } from "../Metabot";
import Styles from "./MetabotChat.module.css";
+import { MetabotChatEditor } from "./MetabotChatEditor";
import { Messages } from "./MetabotChatMessage";
import { MetabotThinking } from "./MetabotThinking";
import { useScrollManager } from "./hooks";
-export const MetabotChat = () => {
+const defaultConfig: MetabotConfig = {
+ suggestionModels: [
+ "dataset",
+ "metric",
+ "card",
+ "table",
+ "database",
+ "dashboard",
+ ],
+};
+
+export const MetabotChat = ({
+ config = defaultConfig,
+}: {
+ config?: MetabotConfig;
+}) => {
const metabot = useMetabotAgent();
const { handleSubmitInput, handleRetryMessage, handleResetInput } =
- useMetabotChatHandlers();
+ useMetabotChatHandlers(config);
const hasMessages =
metabot.messages.length > 0 || metabot.errorMessages.length > 0;
@@ -52,6 +67,15 @@ export const MetabotChat = () => {
metabot.setVisible(false);
};
+ const handleEditorChange = useCallback(
+ (value: string) => metabot.setPrompt(value),
+ [metabot],
+ );
+
+ const handleEditorSubmit = useCallback(() => {
+ handleSubmitInput(metabot.prompt);
+ }, [handleSubmitInput, metabot.prompt]);
+
return (
<Sidebar
isOpen={metabot.visible}
@@ -64,8 +88,8 @@ export const MetabotChat = () => {
<Box ref={headerRef} className={Styles.header}>
<Flex align-items="center">
<Text lh={1} fz="sm" c="text-secondary">
- {metabot.profile
- ? t`Using profile: ${metabot.profile}`
+ {metabot.profileOverride
+ ? t`Using profile: ${metabot.profileOverride}`
: t`Metabot isn't perfect. Double-check results.`}
</Text>
</Flex>
@@ -79,9 +103,14 @@ export const MetabotChat = () => {
<Icon c="text-primary" name="revert" />
</ActionIcon>
</Tooltip>
- <ActionIcon onClick={handleClose} data-testid="metabot-close-chat">
- <Icon c="text-primary" name="close" />
- </ActionIcon>
+ {!config.preventClose && (
+ <ActionIcon
+ onClick={handleClose}
+ data-testid="metabot-close-chat"
+ >
+ <Icon c="text-primary" name="close" />
+ </ActionIcon>
+ )}
</Flex>
</Box>
@@ -103,33 +132,33 @@ export const MetabotChat = () => {
data-testid="metabot-empty-chat-info"
>
<Box component={EmptyDashboardBot} w="6rem" />
- <Text
- c="text-light"
- maw="12rem"
- ta="center"
- >{t`I can help you explore your metrics and models.`}</Text>
+ <Text c="text-light" maw="12rem" ta="center">
+ {config.emptyText ??
+ t`I can help you explore your metrics and models.`}
+ </Text>
</Flex>
- {/* empty state with suggested prompts */}
- <Stack
- gap="sm"
- className={Styles.promptSuggestionsContainer}
- data-testid="metabot-prompt-suggestions"
- >
- <>
- {suggestedPrompts.map(({ prompt }, index) => (
- <Box key={index}>
- <Button
- fz="sm"
- size="xs"
- onClick={() => handleSubmitInput(prompt)}
- className={Styles.promptSuggestionButton}
- >
- {prompt}
- </Button>
- </Box>
- ))}
- </>
- </Stack>
+ {!config.hideSuggestedPrompts && (
+ <Stack
+ gap="sm"
+ className={Styles.promptSuggestionsContainer}
+ data-testid="metabot-prompt-suggestions"
+ >
+ <>
+ {suggestedPrompts.map(({ prompt }, index) => (
+ <Box key={index}>
+ <Button
+ fz="sm"
+ size="xs"
+ onClick={() => handleSubmitInput(prompt)}
+ className={Styles.promptSuggestionButton}
+ >
+ {prompt}
+ </Button>
+ </Box>
+ ))}
+ </>
+ </Stack>
+ )}
</>
)}
@@ -146,20 +175,12 @@ export const MetabotChat = () => {
isDoingScience={metabot.isDoingScience}
showFeedbackButtons
/>
-
{/* loading */}
{metabot.isDoingScience && (
- <MetabotThinking
- toolCalls={metabot.toolCalls}
- hasStartedResponse={
- _.last(metabot.messages)?.role === "agent"
- }
- />
+ <MetabotThinking toolCalls={metabot.toolCalls} />
)}
-
{/* filler - height gets set via ref mutation */}
<div ref={fillerRef} data-testid="metabot-message-filler" />
-
{/* long convo warning */}
{metabot.isLongConversation && <MetabotResetLongChatButton />}
</Box>
@@ -173,40 +194,15 @@ export const MetabotChat = () => {
metabot.isDoingScience && Styles.inputContainerLoading,
)}
>
- <Textarea
- id="metabot-chat-input"
- data-testid="metabot-chat-input"
- w="100%"
- leftSection={
- <Box h="100%" pt="11px">
- <Icon name="metabot" c="brand" />
- </Box>
- }
- autosize
- minRows={1}
- maxRows={10}
+ <MetabotChatEditor
ref={metabot.promptInputRef}
- autoFocus
value={metabot.prompt}
- className={cx(
- Styles.textarea,
- metabot.isDoingScience && Styles.textareaLoading,
- )}
+ autoFocus
+ disabled={metabot.isDoingScience}
placeholder={t`Tell me to do something, or ask a question`}
- onChange={(e) => metabot.setPrompt(e.target.value)}
- onKeyDown={(e) => {
- if (e.nativeEvent.isComposing) {
- return;
- }
- const isModifiedKeyPress =
- e.shiftKey || e.ctrlKey || e.metaKey || e.altKey;
- if (e.key === "Enter" && !isModifiedKeyPress) {
- // prevent event from inserting new line + interacting with other content
- e.preventDefault();
- e.stopPropagation();
- handleSubmitInput(metabot.prompt);
- }
- }}
+ onChange={handleEditorChange}
+ onSubmit={handleEditorSubmit}
+ suggestionModels={config.suggestionModels}
/>
</Paper>
</Box>
diff --git a/enterprise/frontend/src/metabase-enterprise/metabot/components/MetabotChat/MetabotChatEditor/MetabotChatEditor.module.css b/enterprise/frontend/src/metabase-enterprise/metabot/components/MetabotChat/MetabotChatEditor/MetabotChatEditor.module.css
new file mode 100644
index 00000000000..abec8ce1cd9
--- /dev/null
+++ b/enterprise/frontend/src/metabase-enterprise/metabot/components/MetabotChat/MetabotChatEditor/MetabotChatEditor.module.css
@@ -0,0 +1,70 @@
+.editorContainer {
+ display: flex;
+ align-items: flex-start;
+ width: 100%;
+ height: 100%;
+}
+
+.iconContainer {
+ padding-top: 12px;
+ width: 2.375rem;
+ flex: 0 0 auto;
+ display: flex;
+ justify-content: center;
+}
+
+.contentWrapper {
+ flex: 1;
+ min-width: 0;
+ width: 100%;
+}
+
+.content :global(.ProseMirror) {
+ border: none;
+ border-radius: 0;
+ background: transparent;
+ outline: none;
+ width: 100%;
+ padding: 0.5rem 0;
+ line-height: 1.7;
+ color: var(--mb-color-text-dark);
+ font-size: var(--mantine-font-size-md);
+ min-height: 1.7em;
+ white-space: pre-wrap;
+ word-break: break-word;
+
+ &:focus {
+ outline: none;
+ }
+}
+
+.content :global(.ProseMirror p) {
+ margin: 0;
+}
+
+.content :global(.is-empty:first-child:before) {
+ color: var(--mb-color-text-light);
+ content: attr(data-placeholder);
+ height: 0;
+ pointer-events: none;
+ position: absolute;
+}
+
+.content.disabled :global(.ProseMirror) {
+ opacity: 1;
+ background: transparent;
+ cursor: not-allowed;
+}
+
+.smartLink {
+ display: inline-flex;
+ align-items: center;
+ gap: 0.25rem;
+ padding: 0 0.25rem;
+ background: var(--mb-color-background-hover);
+ border-radius: 0.25rem;
+ color: var(--mb-color-brand);
+ text-decoration: none;
+ font-weight: 500;
+ vertical-align: baseline;
+}
diff --git a/enterprise/frontend/src/metabase-enterprise/metabot/components/MetabotChat/MetabotChatEditor/MetabotChatEditor.tsx b/enterprise/frontend/src/metabase-enterprise/metabot/components/MetabotChat/MetabotChatEditor/MetabotChatEditor.tsx
new file mode 100644
index 00000000000..e2349115376
--- /dev/null
+++ b/enterprise/frontend/src/metabase-enterprise/metabot/components/MetabotChat/MetabotChatEditor/MetabotChatEditor.tsx
@@ -0,0 +1,199 @@
+import Document from "@tiptap/extension-document";
+import HardBreak from "@tiptap/extension-hard-break";
+import Paragraph from "@tiptap/extension-paragraph";
+import { Placeholder } from "@tiptap/extension-placeholder";
+import Text from "@tiptap/extension-text";
+import type { EditorView } from "@tiptap/pm/view";
+import { EditorContent, useEditor } from "@tiptap/react";
+import cx from "classnames";
+import {
+ forwardRef,
+ useCallback,
+ useEffect,
+ useImperativeHandle,
+ useRef,
+} from "react";
+import { t } from "ttag";
+
+import { useSelector } from "metabase/lib/redux";
+import type { MetabotChatInputRef } from "metabase/metabot";
+import { getSetting } from "metabase/selectors/settings";
+import { Box, Icon } from "metabase/ui";
+import { createMentionSuggestion } from "metabase-enterprise/rich_text_editing/tiptap/extensions/Mention/MentionSuggestion";
+import {
+ MetabotMentionExtension,
+ MetabotMentionPluginKey,
+} from "metabase-enterprise/rich_text_editing/tiptap/extensions/MetabotMention/MetabotMentionExtension";
+import { SmartLink } from "metabase-enterprise/rich_text_editing/tiptap/extensions/SmartLink/SmartLinkNode";
+import type { SuggestionModel } from "metabase-enterprise/rich_text_editing/tiptap/extensions/shared/types";
+import { createSuggestionRenderer } from "metabase-enterprise/rich_text_editing/tiptap/extensions/suggestionRenderer";
+
+import S from "./MetabotChatEditor.module.css";
+import {
+ parseMetabotMessageToTiptapDoc,
+ serializeTiptapToMetabotMessage,
+} from "./utils";
+
+interface Props {
+ value: string;
+ placeholder?: string;
+ autoFocus?: boolean;
+ disabled?: boolean;
+ onChange: (value: string) => void;
+ onSubmit: () => void;
+ suggestionModels: SuggestionModel[];
+}
+
+export const MetabotChatEditor = forwardRef<MetabotChatInputRef | null, Props>(
+ (
+ {
+ value,
+ placeholder = t`Tell me to do something, or ask a question`,
+ autoFocus = false,
+ disabled = false,
+ suggestionModels,
+ onChange,
+ onSubmit,
+ },
+ ref,
+ ) => {
+ const siteUrl = useSelector((state) => getSetting(state, "site-url"));
+ const serializedRef = useRef(value);
+
+ // Use refs to avoid recreating the editor when callbacks change - not doing so prepends all characters
+ const onChangeRef = useRef(onChange);
+ const onSubmitRef = useRef(onSubmit);
+ useEffect(() => {
+ onChangeRef.current = onChange;
+ onSubmitRef.current = onSubmit;
+ });
+
+ const extensions = [
+ Document,
+ Paragraph,
+ Text,
+ Placeholder.configure({ placeholder }),
+ HardBreak,
+ SmartLink.configure({
+ HTMLAttributes: { class: S.smartLink },
+ siteUrl,
+ }),
+ MetabotMentionExtension.configure({
+ suggestion: {
+ render: createSuggestionRenderer(
+ createMentionSuggestion({
+ searchModels: suggestionModels,
+ canFilterSearchModels: true,
+ canBrowseAll: false,
+ }),
+ ),
+ },
+ }),
+ ];
+
+ const handleCopyCut = useCallback((view: EditorView, e: ClipboardEvent) => {
+ e.preventDefault();
+ const { from, to } = view.state.selection;
+ const slice = view.state.doc.slice(from, to);
+ const doc = view.state.schema.topNodeType.create(null, slice.content);
+ const serialized = serializeTiptapToMetabotMessage(doc.toJSON());
+ e.clipboardData?.setData("text/plain", serialized);
+ return true;
+ }, []);
+
+ const editor = useEditor(
+ {
+ extensions,
+ content: value,
+ autofocus: autoFocus,
+ immediatelyRender: false,
+ onUpdate: ({ editor }) => {
+ const jsonContent = editor.getJSON();
+ serializedRef.current = serializeTiptapToMetabotMessage(jsonContent);
+ onChangeRef.current(serializedRef.current);
+ },
+ editorProps: {
+ handleDOMEvents: {
+ copy: handleCopyCut,
+ cut: handleCopyCut,
+ },
+ handleKeyDown: (view, event) => {
+ if (event.key === "Enter") {
+ // Defer enter handling to mention UI if open
+ const mentionState = MetabotMentionPluginKey.getState(view.state);
+ if (mentionState?.active) {
+ return false; // Let the suggestion system handle it
+ }
+
+ // Check for any modifier keys (shift, ctrl, meta, alt)
+ const isModifiedKeyPress =
+ event.shiftKey ||
+ event.ctrlKey ||
+ event.metaKey ||
+ event.altKey;
+
+ if (!isModifiedKeyPress) {
+ event.preventDefault();
+ onSubmitRef.current();
+ return true;
+ }
+ }
+
+ return false;
+ },
+ clipboardTextSerializer: (content) => {
+ return serializeTiptapToMetabotMessage(content.toJSON());
+ },
+ },
+ },
+ [],
+ );
+
+ useImperativeHandle(ref, () => {
+ if (!editor) {
+ return null;
+ }
+
+ return Object.assign(editor, {
+ focus: () => editor.commands.focus("end"),
+ get scrollHeight() {
+ return editor.view.dom.scrollHeight;
+ },
+ get scrollTop() {
+ return editor.view.dom.scrollTop;
+ },
+ });
+ }, [editor]);
+
+ // Sync external value changes to editor
+ useEffect(() => {
+ if (value !== serializedRef.current) {
+ editor?.commands.setContent(parseMetabotMessageToTiptapDoc(value));
+ }
+ }, [editor, value]);
+
+ if (!editor) {
+ return null;
+ }
+
+ return (
+ <Box className={S.editorContainer}>
+ <Box className={S.iconContainer}>
+ <Icon name="metabot" c="brand" />
+ </Box>
+ <Box className={S.contentWrapper}>
+ <EditorContent
+ data-testid="metabot-chat-input"
+ editor={editor}
+ className={cx(S.content, {
+ [S.disabled]: disabled,
+ })}
+ />
+ </Box>
+ </Box>
+ );
+ },
+);
+
+// @ts-expect-error - must set a displayName
+MetabotChatEditor.displayName = "MetabotChatEditor";
diff --git a/enterprise/frontend/src/metabase-enterprise/metabot/components/MetabotChat/MetabotChatEditor/MetabotChatEditor.unit.spec.tsx b/enterprise/frontend/src/metabase-enterprise/metabot/components/MetabotChat/MetabotChatEditor/MetabotChatEditor.unit.spec.tsx
new file mode 100644
index 00000000000..f0fde008f51
--- /dev/null
+++ b/enterprise/frontend/src/metabase-enterprise/metabot/components/MetabotChat/MetabotChatEditor/MetabotChatEditor.unit.spec.tsx
@@ -0,0 +1,175 @@
+import { screen } from "@testing-library/react";
+import userEvent from "@testing-library/user-event";
+
+import { setupEnterprisePlugins } from "__support__/enterprise";
+import { setupDatabaseEndpoints } from "__support__/server-mocks";
+import { setupSearchEndpoints } from "__support__/server-mocks/search";
+import { mockSettings } from "__support__/settings";
+import { renderWithProviders } from "__support__/ui";
+import type { SuggestionModel } from "metabase-enterprise/rich_text_editing/tiptap/extensions/shared/types";
+import { createMockUser } from "metabase-types/api/mocks";
+import { createSampleDatabase } from "metabase-types/api/mocks/presets";
+import { createMockSearchResult } from "metabase-types/api/mocks/search";
+import { createMockState } from "metabase-types/store/mocks";
+
+import { MetabotChatEditor } from "./MetabotChatEditor";
+
+const defaultProps = {
+ value: "",
+ onChange: jest.fn(),
+ onSubmit: jest.fn(),
+ suggestionModels: [
+ "table",
+ "database",
+ "card",
+ "dashboard",
+ "collection",
+ ] as SuggestionModel[],
+};
+
+const setup = (props = {}) => {
+ setupEnterprisePlugins();
+ const settings = mockSettings({ "site-url": "http://localhost:3000" });
+
+ return renderWithProviders(
+ <MetabotChatEditor {...defaultProps} {...props} />,
+ {
+ storeInitialState: createMockState({
+ settings,
+ currentUser: createMockUser(),
+ }),
+ },
+ );
+};
+
+const getEditor = () =>
+ // eslint-disable-next-line testing-library/no-node-access
+ document.querySelector('[contenteditable="true"]')! as HTMLElement;
+const getPopup = () => screen.findByTestId("mention-suggestions-popup");
+
+describe("MetabotChatEditor", () => {
+ it("should convert text value to formatted tiptap", async () => {
+ setup({ value: "[Test Model](metabase://model/123)" });
+
+ const editor = await screen.findByTestId("metabot-chat-input");
+ expect(editor).toHaveTextContent("Test Model");
+ });
+
+ it("should emit onChange events with properly serialized content", async () => {
+ const onChange = jest.fn();
+ setup({ onChange });
+
+ await userEvent.type(getEditor(), "Hello world");
+
+ expect(onChange).toHaveBeenCalledWith("Hello world");
+ });
+
+ it("should emit onSubmit events with properly serialized content", async () => {
+ const onSubmit = jest.fn();
+ setup({ onSubmit });
+
+ await userEvent.type(getEditor(), "Hello world{Enter}");
+
+ expect(onSubmit).toHaveBeenCalled();
+ });
+
+ it("should support @mentions", async () => {
+ setup();
+
+ await userEvent.type(getEditor(), "@");
+
+ expect(await getPopup()).toBeInTheDocument();
+ });
+
+ it("should show available models when @ is typed", async () => {
+ setup();
+
+ await userEvent.type(getEditor(), "@");
+
+ const popup = await getPopup();
+ expect(popup).toBeInTheDocument();
+ expect(await screen.findByText("Table")).toBeInTheDocument();
+ expect(await screen.findByText("Database")).toBeInTheDocument();
+ expect(await screen.findByText("Collection")).toBeInTheDocument();
+ });
+
+ it("should filter available models when @d is typed", async () => {
+ setup();
+
+ await userEvent.type(getEditor(), "@d");
+
+ const popup = await getPopup();
+ expect(popup).toBeInTheDocument();
+ expect(await screen.findByText("Database")).toBeInTheDocument();
+ expect(screen.queryByText("Table")).not.toBeInTheDocument();
+ });
+
+ it("should only search selected @mention model when selected", async () => {
+ const db = createSampleDatabase();
+ setupDatabaseEndpoints(db);
+ setupSearchEndpoints([
+ createMockSearchResult({
+ id: db.id,
+ name: db.name,
+ model: "database",
+ }),
+ ]);
+ setup();
+
+ await userEvent.type(getEditor(), "@d{Enter}Sample");
+ expect(getEditor()).toHaveTextContent("@Sample");
+
+ expect(await screen.findByText("Sample Database")).toBeInTheDocument();
+
+ await userEvent.keyboard("{Enter}");
+
+ expect(getEditor()).toHaveTextContent("Sample Database");
+ });
+
+ it("should search all models if @mention input doesn't match any search model name", async () => {
+ setupSearchEndpoints([
+ createMockSearchResult({ id: 1, name: "Test Card", model: "card" }),
+ createMockSearchResult({
+ id: 2,
+ name: "Test Dashboard",
+ model: "dashboard",
+ }),
+ createMockSearchResult({
+ id: 3,
+ name: "Test Collection",
+ model: "collection",
+ }),
+ ]);
+ setup();
+
+ await userEvent.type(getEditor(), "@test");
+
+ expect(await screen.findByText("Test Card")).toBeInTheDocument();
+ expect(await screen.findByText("Test Dashboard")).toBeInTheDocument();
+ expect(await screen.findByText("Test Collection")).toBeInTheDocument();
+ });
+
+ it("should handle paste events with metabase protocol links", async () => {
+ const onChange = jest.fn();
+ setup({ onChange });
+ getEditor().focus();
+
+ await userEvent.paste("[Test Model](metabase://model/123)");
+
+ expect(await screen.findByText("Test Model")).toBeInTheDocument();
+ expect(
+ screen.queryByText("[Test Model](metabase://model/123)"),
+ ).not.toBeInTheDocument();
+ });
+
+ it("should clear editor after submit", async () => {
+ const onChange = jest.fn();
+ const onSubmit = jest.fn();
+ setup({ value: "", onChange, onSubmit });
+
+ await userEvent.type(getEditor(), "Hello world{Enter}");
+
+ expect(onSubmit).toHaveBeenCalled();
+ expect(onChange).toHaveBeenCalledWith("Hello world");
+ });
+});
diff --git a/enterprise/frontend/src/metabase-enterprise/metabot/components/MetabotChat/MetabotChatEditor/index.tsx b/enterprise/frontend/src/metabase-enterprise/metabot/components/MetabotChat/MetabotChatEditor/index.tsx
new file mode 100644
index 00000000000..8ec2077996f
--- /dev/null
+++ b/enterprise/frontend/src/metabase-enterprise/metabot/components/MetabotChat/MetabotChatEditor/index.tsx
@@ -0,0 +1 @@
+export * from "./MetabotChatEditor";
diff --git a/enterprise/frontend/src/metabase-enterprise/metabot/components/MetabotChat/MetabotChatEditor/utils.ts b/enterprise/frontend/src/metabase-enterprise/metabot/components/MetabotChat/MetabotChatEditor/utils.ts
new file mode 100644
index 00000000000..275d9078993
--- /dev/null
+++ b/enterprise/frontend/src/metabase-enterprise/metabot/components/MetabotChat/MetabotChatEditor/utils.ts
@@ -0,0 +1,94 @@
+import type { JSONContent } from "@tiptap/core";
+import { match } from "ts-pattern";
+
+import {
+ METABSE_PROTOCOL_MD_LINK,
+ createMetabaseProtocolLink,
+} from "metabase-enterprise/metabot/utils/links";
+
+function serializeNodes(nodes: JSONContent[]): string {
+ return nodes.map((node) => serializeNode(node)).join("");
+}
+
+function serializeNode(node: JSONContent): string {
+ switch (node.type) {
+ case "paragraph":
+ return serializeNodes(node.content ?? []);
+ case "text":
+ return node.text || "";
+ case "smartLink": {
+ const { entityId, model: entityModel, label } = node.attrs || {};
+ if (!entityId || !entityModel) {
+ console.warn("SmartLink missing required attributes", node);
+ return label || "[unknown]";
+ }
+ return createMetabaseProtocolLink({
+ id: entityId,
+ model: match(entityModel)
+ .with("dataset", () => "model" as const)
+ .with("card", () => "question" as const)
+ .otherwise(() => entityModel),
+ name: label,
+ });
+ }
+ case "hardBreak":
+ return "\n";
+ default:
+ console.warn("Unhandled node type", node);
+ return node.content ? serializeNodes(node.content) : node.text || "";
+ }
+}
+
+export function serializeTiptapToMetabotMessage(content: JSONContent): string {
+ return serializeNodes(content?.content || []);
+}
+
+const MENTION_REGEX = new RegExp(METABSE_PROTOCOL_MD_LINK, "g");
+const MODEL_MAP: Record<string, string | undefined> = {
+ model: "dataset",
+ question: "card",
+};
+
+export function parseMetabotMessageToTiptapDoc(text: string): JSONContent {
+ // Split text by lines to handle paragraphs
+ const content = text.split("\n").map<JSONContent>((line) => {
+ const pContent: JSONContent[] = [];
+ let lastIndex = 0;
+
+ for (const match of line.matchAll(MENTION_REGEX)) {
+ const [fullMatch, label, internalModel, entityId] = match;
+ const model = MODEL_MAP[internalModel] || internalModel;
+
+ // Add text before the mention
+ if (match.index > lastIndex) {
+ pContent.push({
+ type: "text",
+ text: line.slice(lastIndex, match.index),
+ });
+ }
+
+ pContent.push({
+ type: "smartLink",
+ attrs: { label, model, entityId },
+ });
+
+ lastIndex = match.index + fullMatch.length;
+ }
+
+ // Add remaining text after last mention
+ if (lastIndex < line.length) {
+ pContent.push({
+ type: "text",
+ text: line.slice(lastIndex),
+ });
+ }
+
+ return { type: "paragraph", content: pContent };
+ });
+
+ return {
+ type: "doc",
+ content:
+ content.length > 0 ? content : [{ type: "paragraph", content: [] }],
+ };
+}
diff --git a/enterprise/frontend/src/metabase-enterprise/metabot/components/MetabotChat/MetabotChatEditor/utils.unit.spec.ts b/enterprise/frontend/src/metabase-enterprise/metabot/components/MetabotChat/MetabotChatEditor/utils.unit.spec.ts
new file mode 100644
index 00000000000..f3ea4cbe2d8
--- /dev/null
+++ b/enterprise/frontend/src/metabase-enterprise/metabot/components/MetabotChat/MetabotChatEditor/utils.unit.spec.ts
@@ -0,0 +1,52 @@
+import type { JSONContent } from "@tiptap/core";
+
+import {
+ parseMetabotMessageToTiptapDoc,
+ serializeTiptapToMetabotMessage,
+} from "./utils";
+
+describe("MetabotChatEditor > utils", () => {
+ describe("serializeTiptapToMetabotMessage", () => {
+ it("should serialize smark links to metabot protocol links", () => {
+ const input: JSONContent = {
+ type: "doc",
+ content: [
+ {
+ type: "paragraph",
+ content: [
+ {
+ type: "smartLink",
+ attrs: { label: "test", model: "table", entityId: "1" },
+ },
+ ],
+ },
+ ],
+ };
+ const result = serializeTiptapToMetabotMessage(input);
+
+ expect(result).toBe("[test](metabase://table/1)");
+ });
+ });
+
+ describe("parseMetabotMessageToTiptapDoc", () => {
+ it("should parse metabot protocol links", () => {
+ const result = parseMetabotMessageToTiptapDoc(
+ "[test](metabase://table/1)",
+ );
+ expect(result).toEqual({
+ type: "doc",
+ content: [
+ {
+ type: "paragraph",
+ content: [
+ {
+ type: "smartLink",
+ attrs: { label: "test", model: "table", entityId: "1" },
+ },
+ ],
+ },
+ ],
+ });
+ });
+ });
+});
diff --git a/enterprise/frontend/src/metabase-enterprise/metabot/components/MetabotChat/MetabotChatMessage.tsx b/enterprise/frontend/src/metabase-enterprise/metabot/components/MetabotChat/MetabotChatMessage.tsx
index 8ec0edf6b74..f89957f0315 100644
--- a/enterprise/frontend/src/metabase-enterprise/metabot/components/MetabotChat/MetabotChatMessage.tsx
+++ b/enterprise/frontend/src/metabase-enterprise/metabot/components/MetabotChat/MetabotChatMessage.tsx
@@ -14,13 +14,18 @@ import {
} from "metabase/ui";
import { useSubmitMetabotFeedbackMutation } from "metabase-enterprise/api/metabot";
import type {
+ MetabotAgentChatMessage,
+ MetabotAgentTextChatMessage,
MetabotChatMessage,
MetabotErrorMessage,
+ MetabotUserChatMessage,
} from "metabase-enterprise/metabot/state";
import type { MetabotFeedback } from "metabase-types/api";
import { AIMarkdown } from "../AIMarkdown/AIMarkdown";
+import { AgentSuggestionMessage } from "./MetabotAgentSuggestionMessage";
+import { AgentTodoListMessage } from "./MetabotAgentTodoMessage";
import Styles from "./MetabotChat.module.css";
import { MetabotFeedbackModal } from "./MetabotFeedbackModal";
@@ -50,7 +55,8 @@ export const MessageContainer = ({
/>
);
-interface UserMessageProps extends BaseMessageProps {
+interface UserMessageProps extends Omit<BaseMessageProps, "message"> {
+ message: MetabotUserChatMessage;
onCopy: () => void;
}
@@ -62,14 +68,22 @@ export const UserMessage = ({
...props
}: UserMessageProps) => (
<MessageContainer chatRole={message.role} {...props}>
- <Text
- className={cx(
- Styles.message,
- message.role === "user" && Styles.messageUser,
- )}
- >
- {message.message}
- </Text>
+ {message.type === "text" && (
+ <AIMarkdown className={cx(Styles.message, Styles.messageUser)}>
+ {message.message}
+ </AIMarkdown>
+ )}
+
+ {message.type === "action" && (
+ <Flex direction="column" gap="xs">
+ <Flex align="center" gap="xs">
+ <Text className={cx(Styles.message, Styles.messageUserAction)}>
+ {message.userMessage}
+ </Text>
+ </Flex>
+ </Flex>
+ )}
+
<Flex className={Styles.messageActions}>
{!hideActions && (
<ActionIcon
@@ -105,8 +119,9 @@ const FeedbackButton = ({
</ActionIcon>
);
-interface AgentMessageProps extends BaseMessageProps {
- onRetry: (messageId: string) => void;
+interface AgentMessageProps extends Omit<BaseMessageProps, "message"> {
+ message: MetabotAgentChatMessage;
+ onRetry?: (messageId: string) => void;
onCopy: (messageId: string) => void;
showFeedbackButtons: boolean;
setFeedbackMessage?: (data: { messageId: string; positive: boolean }) => void;
@@ -125,66 +140,77 @@ export const AgentMessage = ({
onInternalLinkClick,
hideActions,
...props
-}: AgentMessageProps) => (
- <MessageContainer chatRole={message.role} {...props}>
- <AIMarkdown
- className={Styles.message}
- onInternalLinkClick={onInternalLinkClick}
- >
- {message.message}
- </AIMarkdown>
-
- <Flex className={Styles.messageActions}>
- {!hideActions && (
- <>
- <ActionIcon
- h="sm"
- data-testid="metabot-chat-message-copy"
- onClick={() => onCopy(message.id)}
- >
- <Icon name="copy" size="1rem" />
- </ActionIcon>
- {showFeedbackButtons && setFeedbackMessage && (
- <>
- <FeedbackButton
- data-testid="metabot-chat-message-thumbs-up"
- icon="thumbs_up"
- hasBeenClicked={submittedFeedback === "positive"}
- disabled={!!submittedFeedback}
- onClick={() =>
- setFeedbackMessage({
- messageId: message.id,
- positive: true,
- })
- }
- />
- <FeedbackButton
- data-testid="metabot-chat-message-thumbs-down"
- icon="thumbs_down"
- hasBeenClicked={submittedFeedback === "negative"}
- disabled={!!submittedFeedback}
- onClick={() =>
- setFeedbackMessage({
- messageId: message.id,
- positive: false,
- })
- }
- />
- </>
- )}
-
- <ActionIcon
- onClick={() => onRetry(message.id)}
- h="sm"
- data-testid="metabot-chat-message-retry"
- >
- <Icon name="revert" size="1rem" />
- </ActionIcon>
- </>
+}: AgentMessageProps) => {
+ return (
+ <MessageContainer chatRole={message.role} {...props}>
+ {message.type === "text" && (
+ <AIMarkdown
+ className={Styles.message}
+ onInternalLinkClick={onInternalLinkClick}
+ >
+ {message.message}
+ </AIMarkdown>
)}
- </Flex>
- </MessageContainer>
-);
+ {message.type === "edit_suggestion" && (
+ <AgentSuggestionMessage message={message} />
+ )}
+ {message.type === "todo_list" && (
+ <AgentTodoListMessage todos={message.payload} />
+ )}
+ <Flex className={Styles.messageActions}>
+ {!hideActions && (
+ <>
+ <ActionIcon
+ h="sm"
+ data-testid="metabot-chat-message-copy"
+ onClick={() => onCopy(message.id)}
+ >
+ <Icon name="copy" size="1rem" />
+ </ActionIcon>
+ {showFeedbackButtons && setFeedbackMessage && (
+ <>
+ <FeedbackButton
+ data-testid="metabot-chat-message-thumbs-up"
+ icon="thumbs_up"
+ hasBeenClicked={submittedFeedback === "positive"}
+ disabled={!!submittedFeedback}
+ onClick={() =>
+ setFeedbackMessage({
+ messageId: message.id,
+ positive: true,
+ })
+ }
+ />
+ <FeedbackButton
+ data-testid="metabot-chat-message-thumbs-down"
+ icon="thumbs_down"
+ hasBeenClicked={submittedFeedback === "negative"}
+ disabled={!!submittedFeedback}
+ onClick={() =>
+ setFeedbackMessage({
+ messageId: message.id,
+ positive: false,
+ })
+ }
+ />
+ </>
+ )}
+
+ {onRetry && (
+ <ActionIcon
+ onClick={() => onRetry(message.id)}
+ h="sm"
+ data-testid="metabot-chat-message-retry"
+ >
+ <Icon name="revert" size="1rem" />
+ </ActionIcon>
+ )}
+ </>
+ )}
+ </Flex>
+ </MessageContainer>
+ );
+};
export const AgentErrorMessage = ({
message,
@@ -245,7 +271,7 @@ export const Messages = ({
}: {
messages: MetabotChatMessage[];
errorMessages: MetabotErrorMessage[];
- onRetryMessage: (messageId: string) => void;
+ onRetryMessage?: (messageId: string) => void;
isDoingScience: boolean;
showFeedbackButtons: boolean;
onInternalLinkClick?: (navigateToPath: string) => void;
@@ -285,7 +311,11 @@ export const Messages = ({
const onAgentMessageCopy = useCallback(
(messageId: string) => {
const allMessages = getFullAgentReply(messages, messageId);
- clipboard.copy(allMessages.map((msg) => msg.message).join("\n\n"));
+ const textMessages = allMessages.filter(
+ (msg): msg is MetabotAgentTextChatMessage =>
+ msg.role === "agent" && msg.type === "text",
+ );
+ clipboard.copy(textMessages.map((msg) => msg.message).join("\n\n"));
},
[messages, clipboard],
);
@@ -306,7 +336,7 @@ export const Messages = ({
{messages.map((message, index) =>
message.role === "agent" ? (
<AgentMessage
- key={"msg-" + index}
+ key={"msg-" + message.id}
data-testid="metabot-chat-message"
message={message}
onRetry={onRetryMessage}
@@ -314,16 +344,24 @@ export const Messages = ({
showFeedbackButtons={showFeedbackButtons}
setFeedbackMessage={setFeedbackModal}
submittedFeedback={feedbackState.submitted[message.id]}
- hideActions={messages[index + 1]?.role === "agent"}
+ hideActions={
+ isDoingScience || messages[index + 1]?.role === "agent"
+ }
onInternalLinkClick={onInternalLinkClick}
/>
) : (
<UserMessage
- key={"msg-" + index}
+ key={"msg-" + message.id}
data-testid="metabot-chat-message"
message={message}
hideActions={isDoingScience && messages.length === index + 1}
- onCopy={() => clipboard.copy(message.message)}
+ onCopy={() => {
+ const copyText =
+ message.type === "action"
+ ? `${message.userMessage}: ${message.message}`
+ : message.message;
+ clipboard.copy(copyText);
+ }}
/>
),
)}
diff --git a/enterprise/frontend/src/metabase-enterprise/metabot/components/MetabotChat/MetabotThinking.tsx b/enterprise/frontend/src/metabase-enterprise/metabot/components/MetabotChat/MetabotThinking.tsx
index e08f5630517..b95f6951908 100644
--- a/enterprise/frontend/src/metabase-enterprise/metabot/components/MetabotChat/MetabotThinking.tsx
+++ b/enterprise/frontend/src/metabase-enterprise/metabot/components/MetabotChat/MetabotThinking.tsx
@@ -22,9 +22,9 @@ const ThoughtProcess = ({ toolCalls }: { toolCalls: MetabotToolCall[] }) => {
const slots = new Array(toolCalls.length + 2).fill(null);
return (
- <Stack gap={0} className={S.toolCalls}>
+ <Stack gap={0} mb="sm" className={S.toolCalls}>
{slots.map((_, i) => {
- const tc = toolCalls[i];
+ const tc: MetabotToolCall | undefined = toolCalls[i];
return (
<Transition
key={i}
@@ -35,9 +35,9 @@ const ThoughtProcess = ({ toolCalls }: { toolCalls: MetabotToolCall[] }) => {
{(styles) => (
<Text
style={styles}
- className={cx(tc.status === "started" && S.toolCallStarted)}
+ className={cx(tc?.status === "started" && S.toolCallStarted)}
>
- {tc.message}
+ {tc?.message}
</Text>
)}
</Transition>
@@ -49,30 +49,22 @@ const ThoughtProcess = ({ toolCalls }: { toolCalls: MetabotToolCall[] }) => {
export const MetabotThinking = ({
toolCalls,
- hasStartedResponse,
}: {
toolCalls: MetabotToolCall[];
- hasStartedResponse: boolean;
}) => {
const toolCallsWithMsgs = useMemo(() => {
return toolCalls.filter((tc) => !!tc.message);
}, [toolCalls]);
- const showLoader =
- (!hasStartedResponse && toolCalls.length === 0) ||
- (toolCalls.length > 0 && toolCallsWithMsgs.length === 0);
-
return (
<Stack gap="xs">
<ThoughtProcess toolCalls={toolCallsWithMsgs} />
- {showLoader && (
- <Loader
- color="brand"
- type="dots"
- size="lg"
- data-testid="metabot-response-loader"
- />
- )}
+ <Loader
+ color="brand"
+ type="dots"
+ size="lg"
+ data-testid="metabot-response-loader"
+ />
</Stack>
);
};
diff --git a/enterprise/frontend/src/metabase-enterprise/metabot/components/MetabotChat/hooks.ts b/enterprise/frontend/src/metabase-enterprise/metabot/components/MetabotChat/hooks.ts
index f5857be1747..5c8714ddb50 100644
--- a/enterprise/frontend/src/metabase-enterprise/metabot/components/MetabotChat/hooks.ts
+++ b/enterprise/frontend/src/metabase-enterprise/metabot/components/MetabotChat/hooks.ts
@@ -23,7 +23,8 @@ function calculateFillerHeight(
parseFloat(style.paddingTop) + parseFloat(style.paddingBottom);
const contentHeight = containerHeight - paddingAdjustment;
- return Math.max(0, contentHeight - nonFillerElsHeight);
+ // subtract 1px to prevent a scrollbar appearing due to rounding issues
+ return Math.max(0, Math.floor(contentHeight - nonFillerElsHeight - 1));
}
function resizeFillerArea(
diff --git a/enterprise/frontend/src/metabase-enterprise/metabot/constants.ts b/enterprise/frontend/src/metabase-enterprise/metabot/constants.ts
index 4bdcd01c910..ddaea93bff0 100644
--- a/enterprise/frontend/src/metabase-enterprise/metabot/constants.ts
+++ b/enterprise/frontend/src/metabase-enterprise/metabot/constants.ts
@@ -48,4 +48,28 @@ export const TOOL_CALL_MESSAGES: Record<string, string | undefined> = {
get search_metabase_documentation() {
return t`Consulting the docs`;
},
+ get write_transform_python() {
+ return t`Writing Python`;
+ },
+ get write_transform_sql() {
+ return t`Writing SQL`;
+ },
+ get todo_write() {
+ return t`Planning`;
+ },
+ get todo_read() {
+ return t`Planning`;
+ },
+ get search_transforms() {
+ return t`Searching transforms`;
+ },
+ get get_transform_details() {
+ return t`Getting transform details`;
+ },
+ get get_field_values() {
+ return t`Retrieving table metadata`;
+ },
+ get search_tables() {
+ return t`Searching database tables`;
+ },
};
diff --git a/enterprise/frontend/src/metabase-enterprise/metabot/context.tsx b/enterprise/frontend/src/metabase-enterprise/metabot/context.tsx
index f1c54b37ba5..e6744de46fd 100644
--- a/enterprise/frontend/src/metabase-enterprise/metabot/context.tsx
+++ b/enterprise/frontend/src/metabase-enterprise/metabot/context.tsx
@@ -7,9 +7,11 @@ import { useLazyListDatabasesQuery } from "metabase/api";
import { useStore } from "metabase/lib/redux";
import type {
ChatContextProviderFn,
+ MetabotChatInputRef,
MetabotContext as MetabotCtx,
} from "metabase/metabot";
import { getHasDataAccess, getHasNativeWrite } from "metabase/selectors/data";
+import { getUserIsAdmin } from "metabase/selectors/user";
export const defaultContext = {
prompt: "",
@@ -26,6 +28,8 @@ export const defaultContext = {
export const MetabotContext = createContext<MetabotCtx>(defaultContext);
+export type MetabotPromptInputRef = { focus: () => void };
+
export const MetabotProvider = ({
children,
}: {
@@ -33,7 +37,7 @@ export const MetabotProvider = ({
}) => {
/* Metabot input */
const [prompt, setPrompt] = useState("");
- const promptInputRef = useRef<HTMLTextAreaElement>(null);
+ const promptInputRef = useRef<MetabotChatInputRef>(null);
/* Metabot context */
const providerFnsRef = useRef<Set<ChatContextProviderFn>>(new Set());
@@ -49,6 +53,7 @@ export const MetabotProvider = ({
const databases = dbData?.data ?? [];
const hasDataAccess = getHasDataAccess(databases);
const hasNativeWrite = getHasNativeWrite(databases);
+ const isAdmin = getUserIsAdmin(state);
const ctx = {
user_is_viewing: [],
@@ -57,6 +62,7 @@ export const MetabotProvider = ({
"frontend:navigate_user_v1",
hasDataAccess && "permission:save_questions",
hasNativeWrite && "permission:write_sql_queries",
+ isAdmin && "permission:write_transforms",
]),
};
diff --git a/enterprise/frontend/src/metabase-enterprise/metabot/hooks/use-metabot-agent.ts b/enterprise/frontend/src/metabase-enterprise/metabot/hooks/use-metabot-agent.ts
index afe5034411f..52bcc38aee9 100644
--- a/enterprise/frontend/src/metabase-enterprise/metabot/hooks/use-metabot-agent.ts
+++ b/enterprise/frontend/src/metabase-enterprise/metabot/hooks/use-metabot-agent.ts
@@ -7,12 +7,13 @@ import { useMetabotContext } from "metabase/metabot";
import { trackMetabotRequestSent } from "../analytics";
import {
type MetabotPromptSubmissionResult,
+ type MetabotUserChatMessage,
getAgentErrorMessages,
getIsLongMetabotConversation,
getIsProcessing,
- getLastAgentMessagesByType,
getMessages,
getMetabotId,
+ getMetabotReactionsState,
getMetabotRequestId,
getMetabotVisible,
getProfileOverride,
@@ -36,9 +37,6 @@ export const useMetabotAgent = () => {
const messages = useSelector(getMessages as any) as ReturnType<
typeof getMessages
>;
- const lastAgentMessages = useSelector(
- getLastAgentMessagesByType as any,
- ) as ReturnType<typeof getLastAgentMessagesByType>;
const errorMessages = useSelector(getAgentErrorMessages as any) as ReturnType<
typeof getAgentErrorMessages
@@ -68,10 +66,14 @@ export const useMetabotAgent = () => {
[dispatch],
);
- const profile = useSelector(getProfileOverride as any) as ReturnType<
+ const profileOverride = useSelector(getProfileOverride as any) as ReturnType<
typeof getProfileOverride
>;
+ const reactions = useSelector(getMetabotReactionsState as any) as ReturnType<
+ typeof getMetabotReactionsState
+ >;
+
const resetConversation = useCallback(
() => dispatch(resetConversationAction()),
[dispatch],
@@ -88,18 +90,27 @@ export const useMetabotAgent = () => {
);
const submitInput = useCallback(
- async (prompt: string) => {
+ async (prompt: string | Omit<MetabotUserChatMessage, "id" | "role">) => {
if (!visible) {
setVisible(true);
}
const context = await getChatContext();
const action = await dispatch(
- submitInputAction({
- message: prompt,
- context,
- metabot_id: metabotRequestId,
- }),
+ submitInputAction(
+ typeof prompt === "string"
+ ? {
+ type: "text",
+ message: prompt,
+ context,
+ metabot_id: metabotRequestId,
+ }
+ : {
+ ...prompt,
+ context,
+ metabot_id: metabotRequestId,
+ },
+ ),
);
trackMetabotRequestSent();
@@ -157,7 +168,6 @@ export const useMetabotAgent = () => {
metabotId,
visible,
messages,
- lastAgentMessages,
errorMessages,
isLongConversation,
resetConversation,
@@ -166,6 +176,7 @@ export const useMetabotAgent = () => {
submitInput,
retryMessage,
toolCalls,
- profile,
+ profileOverride,
+ reactions,
};
};
diff --git a/enterprise/frontend/src/metabase-enterprise/metabot/hooks/use-metabot-chat-handlers.ts b/enterprise/frontend/src/metabase-enterprise/metabot/hooks/use-metabot-chat-handlers.ts
index 4c3164b31b4..8c9d07a0e61 100644
--- a/enterprise/frontend/src/metabase-enterprise/metabot/hooks/use-metabot-chat-handlers.ts
+++ b/enterprise/frontend/src/metabase-enterprise/metabot/hooks/use-metabot-chat-handlers.ts
@@ -1,8 +1,12 @@
-import { useCallback } from "react";
+import { useCallback, useMemo } from "react";
+
+import type { MetabotConfig } from "../components/Metabot";
import { useMetabotAgent } from "./use-metabot-agent";
-export const useMetabotChatHandlers = () => {
+export const useMetabotChatHandlers = (
+ config?: Partial<Pick<MetabotConfig, "preventRetryMessage">>,
+) => {
const {
isDoingScience,
setPrompt,
@@ -28,8 +32,12 @@ export const useMetabotChatHandlers = () => {
[isDoingScience, promptInputRef, setPrompt, submitInput],
);
- const handleRetryMessage = useCallback(
- (messageId: string) => {
+ const handleRetryMessage = useMemo(() => {
+ if (config?.preventRetryMessage) {
+ return undefined;
+ }
+
+ return (messageId: string) => {
if (isDoingScience) {
return;
}
@@ -37,9 +45,14 @@ export const useMetabotChatHandlers = () => {
setPrompt("");
promptInputRef?.current?.focus();
retryMessage(messageId).catch((err) => console.error(err));
- },
- [isDoingScience, promptInputRef, retryMessage, setPrompt],
- );
+ };
+ }, [
+ config?.preventRetryMessage,
+ isDoingScience,
+ promptInputRef,
+ retryMessage,
+ setPrompt,
+ ]);
const handleResetInput = useCallback(() => {
setPrompt("");
diff --git a/enterprise/frontend/src/metabase-enterprise/metabot/index.tsx b/enterprise/frontend/src/metabase-enterprise/metabot/index.tsx
index e773923584f..c090a3bd035 100644
--- a/enterprise/frontend/src/metabase-enterprise/metabot/index.tsx
+++ b/enterprise/frontend/src/metabase-enterprise/metabot/index.tsx
@@ -10,6 +10,7 @@ import { hasPremiumFeature } from "metabase-enterprise/settings";
import { Metabot } from "./components/Metabot";
import { MetabotAdminPage } from "./components/MetabotAdmin/MetabotAdminPage";
+import { MetabotAdminAppBarButton } from "./components/MetabotAdminAppBarButton";
import { MetabotAppBarButton } from "./components/MetabotAppBarButton";
import { getMetabotQuickLinks } from "./components/MetabotQuickLinks";
import { MetabotToggleButton } from "./components/MetabotToggleButton";
@@ -49,6 +50,7 @@ if (hasPremiumFeature("metabot_v3")) {
PLUGIN_METABOT.MetabotToggleButton = MetabotToggleButton;
PLUGIN_METABOT.MetabotAppBarButton = MetabotAppBarButton;
+ PLUGIN_METABOT.MetabotAdminAppBarButton = MetabotAdminAppBarButton;
PLUGIN_REDUCERS.metabotPlugin = metabotReducer;
} else if (hasPremiumFeature("offer_metabase_ai")) {
diff --git a/enterprise/frontend/src/metabase-enterprise/metabot/metabot.unit.spec.tsx b/enterprise/frontend/src/metabase-enterprise/metabot/metabot.unit.spec.tsx
index 95ef811d13f..be331d5962d 100644
--- a/enterprise/frontend/src/metabase-enterprise/metabot/metabot.unit.spec.tsx
+++ b/enterprise/frontend/src/metabase-enterprise/metabot/metabot.unit.spec.tsx
@@ -1,3 +1,4 @@
+/* eslint-disable jest/expect-expect */
import { combineReducers } from "@reduxjs/toolkit";
import userEvent from "@testing-library/user-event";
import fetchMock from "fetch-mock";
@@ -9,6 +10,7 @@ import { setupDatabaseListEndpoint } from "__support__/server-mocks";
import { mockSettings } from "__support__/settings";
import {
act,
+ fireEvent,
renderWithProviders,
screen,
waitFor,
@@ -106,9 +108,24 @@ function setup(
const chat = () => screen.findByTestId("metabot-chat");
const chatMessages = () => screen.findAllByTestId("metabot-chat-message");
const lastChatMessage = async () => (await chatMessages()).at(-1);
-const input = () => screen.findByTestId("metabot-chat-input");
-const enterChatMessage = async (message: string, send = true) =>
- userEvent.type(await input(), `${message}${send ? "{Enter}" : ""}`);
+const input = async () => {
+ const chatInput = await screen.findByTestId("metabot-chat-input");
+ // get tiptap content editable node
+ // eslint-disable-next-line testing-library/no-node-access
+ return chatInput.querySelector('[contenteditable="true"]')!;
+};
+const enterChatMessage = async (message: string, send = true) => {
+ // using userEvent.type works locally but in CI characters are sometimes dropped
+ // so "Who is your favorite?" becomes something like "Woi or fvrite?"
+ const editor = await input();
+ editor.textContent = message;
+ fireEvent.input(editor, {
+ target: { textContent: message },
+ });
+ if (send) {
+ await userEvent.type(await input(), "{Enter}");
+ }
+};
const closeChatButton = () => screen.findByTestId("metabot-close-chat");
const responseLoader = () => screen.findByTestId("metabot-response-loader");
const resetChatButton = () => screen.findByTestId("metabot-reset-chat");
@@ -248,19 +265,7 @@ describe("metabot-streaming", () => {
}
});
- it("should not render markdown for user messages", async () => {
- setup();
- mockAgentEndpoint({ textChunks: whoIsYourFavoriteResponse });
-
- const msg = "# Who is your favorite?";
- await enterChatMessage(msg);
- expect(await screen.findByText(msg)).toBeInTheDocument();
- expect(
- screen.queryByRole("heading", { level: 1 }),
- ).not.toBeInTheDocument();
- });
-
- it("should render markdown for metabot's replies", async () => {
+ it("should render markdown for messages", async () => {
setup();
mockAgentEndpoint({
textChunks: [
@@ -269,11 +274,17 @@ describe("metabot-streaming", () => {
`d:{"finishReason":"stop","usage":{"promptTokens":4916,"completionTokens":8}}`,
],
});
- await enterChatMessage("Who is your favorite?");
- const heading = await screen.findByRole("heading", { level: 1 });
- expect(heading).toBeInTheDocument();
- expect(heading).toHaveTextContent(`You, but don't tell anyone.`);
+ await enterChatMessage("# Who is your favorite?");
+
+ await screen.findByRole("heading", {
+ level: 1,
+ name: `Who is your favorite?`,
+ });
+ await screen.findByRole("heading", {
+ level: 1,
+ name: `You, but don't tell anyone.`,
+ });
});
it("should present the user an option to provide feedback", async () => {
@@ -388,9 +399,9 @@ describe("metabot-streaming", () => {
),
});
- expect(await input()).toHaveValue("");
+ expect(await input()).toHaveTextContent("");
await userEvent.click(await screen.findByText("CLICK HERE"));
- expect(await input()).toHaveValue("TEST VAL");
+ expect(await input()).toHaveTextContent("TEST VAL");
});
describe("prompt-suggestions", () => {
@@ -493,7 +504,7 @@ describe("metabot-streaming", () => {
);
await enterChatMessage("Who is your favorite?", false);
- expect(await input()).toHaveValue("Who is your favorite?");
+ expect(await input()).toHaveTextContent("Who is your favorite?");
await enterChatMessage("Who is your favorite?");
expect(await responseLoader()).toBeInTheDocument();
@@ -502,7 +513,7 @@ describe("metabot-streaming", () => {
).toBeInTheDocument();
// should auto-clear input + refocus
- expect(await input()).toHaveValue("");
+ expect(await input()).toHaveTextContent("");
expect(await input()).toHaveFocus();
});
@@ -682,7 +693,7 @@ describe("metabot-streaming", () => {
["user", "Who is your favorite?"],
["agent", METABOT_ERR_MSG.agentOffline],
]);
- expect(await input()).toHaveValue("Who is your favorite?");
+ expect(await input()).toHaveTextContent("Who is your favorite?");
});
it("should handle non-successful responses", async () => {
@@ -695,7 +706,7 @@ describe("metabot-streaming", () => {
["user", "Who is your favorite?"],
["agent", METABOT_ERR_MSG.default],
]);
- expect(await input()).toHaveValue("Who is your favorite?");
+ expect(await input()).toHaveTextContent("Who is your favorite?");
});
it("should handle show error if data error part is in response", async () => {
@@ -708,7 +719,7 @@ describe("metabot-streaming", () => {
["user", "Who is your favorite?"],
["agent", METABOT_ERR_MSG.default],
]);
- expect(await input()).toHaveValue("Who is your favorite?");
+ expect(await input()).toHaveTextContent("Who is your favorite?");
});
it("should not show a user error when an AbortError is triggered", async () => {
@@ -725,7 +736,7 @@ describe("metabot-streaming", () => {
await userEvent.click(await resetChatButton());
await assertConversation([]);
- expect(await input()).toHaveValue("");
+ expect(await input()).toHaveTextContent("");
});
it("should remove previous error messages and prompt when submiting next prompt", async () => {
@@ -738,7 +749,7 @@ describe("metabot-streaming", () => {
["user", "Who is your favorite?"],
["agent", METABOT_ERR_MSG.agentOffline],
]);
- expect(await input()).toHaveValue("Who is your favorite?");
+ expect(await input()).toHaveTextContent("Who is your favorite?");
mockAgentEndpoint({
textChunks: whoIsYourFavoriteResponse,
@@ -958,10 +969,12 @@ describe("metabot-streaming", () => {
expect(beforeResetState.conversationId).not.toBe(null);
expect(_.omit(beforeResetState.messages[0], "id")).toStrictEqual({
role: "user",
+ type: "text",
message: "Who is your favorite?",
});
expect(_.omit(beforeResetState.messages[1], "id")).toStrictEqual({
role: "agent",
+ type: "text",
message: "You, but don't tell anyone.",
});
@@ -980,7 +993,9 @@ describe("metabot-streaming", () => {
// adding messages this long via the ui's input makes the test hang
act(() => {
- store.dispatch(addUserMessage({ id: "1", message: longMsg }));
+ store.dispatch(
+ addUserMessage({ id: "1", type: "text", message: longMsg }),
+ );
});
expect(await screen.findByText(/xxxxxxx/)).toBeInTheDocument();
expect(
@@ -988,7 +1003,9 @@ describe("metabot-streaming", () => {
).not.toBeInTheDocument();
act(() => {
- store.dispatch(addUserMessage({ id: "2", message: longMsg }));
+ store.dispatch(
+ addUserMessage({ id: "2", type: "text", message: longMsg }),
+ );
});
expect(
await screen.findByText(/This chat is getting long/),
diff --git a/enterprise/frontend/src/metabase-enterprise/metabot/reactions/errors.ts b/enterprise/frontend/src/metabase-enterprise/metabot/reactions/errors.ts
deleted file mode 100644
index 6d978531ce5..00000000000
--- a/enterprise/frontend/src/metabase-enterprise/metabot/reactions/errors.ts
+++ /dev/null
@@ -1,22 +0,0 @@
-import { t } from "ttag";
-
-import { addAgentErrorMessage, stopProcessing } from "../state";
-
-import type { ReactionHandler } from "./types";
-
-type UnknownReaction = { type: string } & Record<string, unknown>;
-
-export const notifyUnknownReaction: ReactionHandler<UnknownReaction> = (
- reaction,
-) => {
- return ({ dispatch }) => {
- console.error("Unknown reaction recieved", reaction);
- dispatch(
- addAgentErrorMessage({
- type: "message",
- message: t`Whoops, I actually can’t do this. Sorry.`,
- }),
- );
- dispatch(stopProcessing());
- };
-};
diff --git a/enterprise/frontend/src/metabase-enterprise/metabot/reactions/index.ts b/enterprise/frontend/src/metabase-enterprise/metabot/reactions/index.ts
deleted file mode 100644
index 10e8b198218..00000000000
--- a/enterprise/frontend/src/metabase-enterprise/metabot/reactions/index.ts
+++ /dev/null
@@ -1,18 +0,0 @@
-import type { MetabotReaction } from "metabase-types/api";
-
-import { showMessage } from "./messages";
-import { redirect } from "./metabot";
-import type { ReactionHandler } from "./types";
-
-export * from "./errors";
-
-type ReactionHandlers = {
- [key in MetabotReaction["type"]]: ReactionHandler<
- Extract<MetabotReaction, { type: key }>
- >;
-};
-
-export const reactionHandlers: ReactionHandlers = {
- "metabot.reaction/message": showMessage,
- "metabot.reaction/redirect": redirect,
-};
diff --git a/enterprise/frontend/src/metabase-enterprise/metabot/reactions/messages.ts b/enterprise/frontend/src/metabase-enterprise/metabot/reactions/messages.ts
deleted file mode 100644
index b8697166163..00000000000
--- a/enterprise/frontend/src/metabase-enterprise/metabot/reactions/messages.ts
+++ /dev/null
@@ -1,13 +0,0 @@
-import type { MetabotMessageReaction } from "metabase-types/api";
-
-import { addAgentMessage } from "../state";
-
-import type { ReactionHandler } from "./types";
-
-export const showMessage: ReactionHandler<MetabotMessageReaction> = (
- reaction,
-) => {
- return ({ dispatch }) => {
- dispatch(addAgentMessage({ message: reaction.message }));
- };
-};
diff --git a/enterprise/frontend/src/metabase-enterprise/metabot/reactions/metabot.ts b/enterprise/frontend/src/metabase-enterprise/metabot/reactions/metabot.ts
deleted file mode 100644
index 2d285c71f36..00000000000
--- a/enterprise/frontend/src/metabase-enterprise/metabot/reactions/metabot.ts
+++ /dev/null
@@ -1,21 +0,0 @@
-import { push } from "react-router-redux";
-
-import type { MetabotRedirectReaction } from "metabase-types/api";
-
-import type { ReactionHandler } from "./types";
-
-export const redirect: ReactionHandler<MetabotRedirectReaction> = (
- reaction,
-) => {
- const redirectUrl = new URL(`${window.location.origin}${reaction.url}`);
-
- return async ({ dispatch }) => {
- await dispatch(
- push({
- pathname: redirectUrl.pathname,
- hash: redirectUrl.hash,
- search: redirectUrl.search,
- }),
- );
- };
-};
diff --git a/enterprise/frontend/src/metabase-enterprise/metabot/reactions/types.ts b/enterprise/frontend/src/metabase-enterprise/metabot/reactions/types.ts
deleted file mode 100644
index ae668711100..00000000000
--- a/enterprise/frontend/src/metabase-enterprise/metabot/reactions/types.ts
+++ /dev/null
@@ -1,8 +0,0 @@
-import type { Dispatch, GetState } from "metabase-types/store";
-
-export type ReactionHandler<Reaction> = (
- reaction: Reaction,
-) => (reduxApis: {
- dispatch: Dispatch;
- getState: GetState;
-}) => void | Promise<void>;
diff --git a/enterprise/frontend/src/metabase-enterprise/metabot/state/actions.ts b/enterprise/frontend/src/metabase-enterprise/metabot/state/actions.ts
index f688eedff97..cbb5506e914 100644
--- a/enterprise/frontend/src/metabase-enterprise/metabot/state/actions.ts
+++ b/enterprise/frontend/src/metabase-enterprise/metabot/state/actions.ts
@@ -1,6 +1,7 @@
-import { type UnknownAction, isRejected } from "@reduxjs/toolkit";
+import { type UnknownAction, isRejected, nanoid } from "@reduxjs/toolkit";
import { push } from "react-router-redux";
import { P, match } from "ts-pattern";
+import _ from "underscore";
import { createAsyncThunk } from "metabase/lib/redux";
import { addUndo } from "metabase/redux/undo";
@@ -16,14 +17,19 @@ import type {
MetabotAgentRequest,
MetabotAgentResponse,
MetabotChatContext,
- MetabotReaction,
+ MetabotTransformInfo,
} from "metabase-types/api";
import type { Dispatch } from "metabase-types/store";
import { METABOT_ERR_MSG } from "../constants";
-import { notifyUnknownReaction, reactionHandlers } from "../reactions";
-import { type MetabotErrorMessage, metabot } from "./reducer";
+import {
+ type MetabotAgentEditSuggestionChatMessage,
+ type MetabotAgentTodoListChatMessage,
+ type MetabotErrorMessage,
+ type MetabotUserChatMessage,
+ metabot,
+} from "./reducer";
import {
getAgentErrorMessages,
getAgentRequestMetadata,
@@ -48,6 +54,9 @@ export const {
toolCallEnd,
setProfileOverride,
setMetabotReqIdOverride,
+ addSuggestedTransform,
+ activateSuggestedTransform,
+ deactivateSuggestedTransform,
} = metabot.actions;
type PromptErrorOutcome = {
@@ -125,8 +134,7 @@ export type MetabotPromptSubmissionResult =
export const submitInput = createAsyncThunk<
MetabotPromptSubmissionResult,
- {
- message: string;
+ Omit<MetabotUserChatMessage, "id" | "role"> & {
context: MetabotChatContext;
metabot_id?: string;
}
@@ -158,7 +166,12 @@ export const submitInput = createAsyncThunk<
// altering it by adding the current message the user is wanting to send
const agentMetadata = getAgentRequestMetadata(getState() as any);
const messageId = createMessageId();
- dispatch(addUserMessage({ id: messageId, message: data.message }));
+ dispatch(
+ addUserMessage({
+ id: messageId,
+ ..._.omit(data, ["context", "metabot_id"]),
+ }),
+ );
const sendMessageRequestPromise = dispatch(
sendAgentRequest({
@@ -229,10 +242,21 @@ export const sendAgentRequest = createAsyncThunk<
signal,
},
{
- onDataPart: (part) => {
+ onDataPart: function handleDataPart(part) {
match(part)
// only update the convo state if the request is successful
.with({ type: "state" }, (part) => (state = part.value))
+ .with({ type: "todo_list" }, (part) => {
+ const message: Omit<
+ MetabotAgentTodoListChatMessage,
+ "id" | "role"
+ > = {
+ type: "todo_list",
+ payload: part.value,
+ };
+
+ dispatch(addAgentMessage(message));
+ })
.with({ type: "navigate_to" }, (part) => {
dispatch(setNavigateToPath(part.value));
@@ -240,14 +264,47 @@ export const sendAgentRequest = createAsyncThunk<
dispatch(push(part.value) as UnknownAction);
}
})
+ .with({ type: "transform_suggestion" }, ({ value }) => {
+ const suggestedTransform = {
+ ...value,
+ id: value.id || undefined,
+ active: true,
+ suggestionId: nanoid(),
+ };
+ dispatch(addSuggestedTransform(suggestedTransform));
+
+ const transform = req.context.user_is_viewing
+ .filter(
+ (t): t is MetabotTransformInfo => t.type === "transform",
+ )
+ .find((t) => t.id === suggestedTransform.id);
+ const message: Omit<
+ MetabotAgentEditSuggestionChatMessage,
+ "id" | "role"
+ > = {
+ type: "edit_suggestion",
+ model: "transform",
+ payload: {
+ editorTransform: transform,
+ suggestedTransform,
+ },
+ };
+ dispatch(addAgentMessage(message));
+ })
.exhaustive();
},
- onTextPart: (part) => {
+ onTextPart: function handleTextPart(part) {
dispatch(addAgentTextDelta(String(part)));
},
- onToolCallPart: (part) => dispatch(toolCallStart(part)),
- onToolResultPart: (part) => dispatch(toolCallEnd(part)),
- onError: (part) => (error = part),
+ onToolCallPart: function handleToolCallPart(part) {
+ dispatch(toolCallStart(part));
+ },
+ onToolResultPart: function handleToolResultPart(part) {
+ dispatch(toolCallEnd(part));
+ },
+ onError: function handleError(part) {
+ error = part;
+ },
},
);
@@ -309,7 +366,12 @@ export const retryPrompt = createAsyncThunk<
dispatch(metabot.actions.rewindStateToMessageId(messageId));
return await dispatch(
- submitInput({ message: prompt.message, context, metabot_id }),
+ submitInput({
+ type: "text",
+ message: prompt.message,
+ context,
+ metabot_id,
+ }),
).unwrap();
},
);
@@ -326,37 +388,6 @@ export const resetConversation = createAsyncThunk(
},
);
-export const processMetabotReactions = createAsyncThunk(
- "metabase-enterprise/metabot/processMetabotReactions",
- async (reactions: MetabotReaction[], { dispatch, getState }) => {
- dispatch(setIsProcessing(true));
-
- for (const reaction of reactions) {
- try {
- const reactionHandler =
- reactionHandlers[reaction.type] ?? notifyUnknownReaction;
- // TS isn't smart enough to know the reaction matches the handler
- await reactionHandler(reaction as any)({ dispatch, getState });
- } catch (error: any) {
- console.error("Halting processing of reactions.", error);
- dispatch(stopProcessingAndNotify());
- break;
- }
-
- // TODO: make an EnterpriseStore
- const isProcessing = getIsProcessing(getState() as any);
- if (!isProcessing) {
- console.warn(
- "A handler has stopped further procesing of metabot reactions",
- );
- break;
- }
- }
-
- dispatch(setIsProcessing(false));
- },
-);
-
export const stopProcessing = () => (dispatch: Dispatch) => {
dispatch(setIsProcessing(false));
};
diff --git a/enterprise/frontend/src/metabase-enterprise/metabot/state/reducer.ts b/enterprise/frontend/src/metabase-enterprise/metabot/state/reducer.ts
index c3781d3643d..e15a2e9a8c6 100644
--- a/enterprise/frontend/src/metabase-enterprise/metabot/state/reducer.ts
+++ b/enterprise/frontend/src/metabase-enterprise/metabot/state/reducer.ts
@@ -3,19 +3,71 @@ import _ from "underscore";
import { logout } from "metabase/auth/actions";
import { uuid } from "metabase/lib/uuid";
-import type { MetabotHistory } from "metabase-types/api";
+import type {
+ MetabotHistory,
+ MetabotTodoItem,
+ MetabotTransformInfo,
+ SuggestedTransform,
+} from "metabase-types/api";
import { TOOL_CALL_MESSAGES } from "../constants";
import { sendAgentRequest } from "./actions";
import { createMessageId } from "./utils";
-export type MetabotChatMessage = {
+export type MetabotUserTextChatMessage = {
id: string;
- role: "user" | "agent";
+ role: "user";
+ type: "text";
message: string;
};
+export type MetabotUserActionChatMessage = {
+ id: string;
+ role: "user";
+ type: "action";
+ message: string;
+ userMessage: string;
+};
+
+export type MetabotAgentTextChatMessage = {
+ id: string;
+ role: "agent";
+ type: "text";
+ message: string;
+};
+
+export type MetabotAgentTodoListChatMessage = {
+ id: string;
+ role: "agent";
+ type: "todo_list";
+ payload: MetabotTodoItem[];
+};
+
+export type MetabotAgentEditSuggestionChatMessage = {
+ id: string;
+ role: "agent";
+ type: "edit_suggestion";
+ model: "transform";
+ payload: {
+ editorTransform: MetabotTransformInfo | undefined;
+ suggestedTransform: MetabotSuggestedTransform;
+ };
+};
+
+export type MetabotAgentChatMessage =
+ | MetabotAgentTextChatMessage
+ | MetabotAgentTodoListChatMessage
+ | MetabotAgentEditSuggestionChatMessage;
+
+export type MetabotUserChatMessage =
+ | MetabotUserTextChatMessage
+ | MetabotUserActionChatMessage;
+
+export type MetabotChatMessage =
+ | MetabotUserChatMessage
+ | MetabotAgentChatMessage;
+
export type MetabotErrorMessage = {
type: "message" | "alert";
message: string;
@@ -28,8 +80,14 @@ export type MetabotToolCall = {
status: "started" | "ended";
};
+export type MetabotSuggestedTransform = SuggestedTransform & {
+ active: boolean;
+ suggestionId: string; // internal unique identifier for marking active/inactive
+};
+
export type MetabotReactionsState = {
navigateToPath: string | null;
+ suggestedTransforms: MetabotSuggestedTransform[];
};
export interface MetabotState {
@@ -58,6 +116,7 @@ export const getMetabotInitialState = (): MetabotState => ({
state: {},
reactions: {
navigateToPath: null,
+ suggestedTransforms: [],
},
toolCalls: [],
experimental: {
@@ -72,24 +131,27 @@ export const metabot = createSlice({
reducers: {
addUserMessage: (
state,
- action: PayloadAction<Omit<MetabotChatMessage, "role">>,
+ action: PayloadAction<Omit<MetabotUserChatMessage, "role">>,
) => {
- const { id, message } = action.payload;
+ const { id, message, ...rest } = action.payload;
state.errorMessages = [];
- state.messages.push({ id, role: "user", message });
+ state.messages.push({ id, role: "user", message, ...rest } as any);
state.history.push({ id, role: "user", content: message });
},
addAgentMessage: (
state,
- action: PayloadAction<Omit<MetabotChatMessage, "id" | "role">>,
+ action: PayloadAction<Omit<MetabotAgentChatMessage, "id" | "role">>,
) => {
state.toolCalls = [];
state.messages.push({
id: createMessageId(),
role: "agent",
- message: action.payload.message,
- });
+ ...action.payload,
+ // transforms in message is making this flakily produce possibly infinite
+ // typescript errors. since unused ts-expect-error directives produces
+ // errors, casting this as any to avoid having to add / remove constantly.
+ } as any);
},
addAgentErrorMessage: (
state,
@@ -100,14 +162,18 @@ export const metabot = createSlice({
addAgentTextDelta: (state, action: PayloadAction<string>) => {
const hasToolCalls = state.toolCalls.length > 0;
const lastMessage = _.last(state.messages);
- const canAppend = !hasToolCalls && lastMessage?.role === "agent";
+ const canAppend =
+ !hasToolCalls &&
+ lastMessage?.role === "agent" &&
+ lastMessage.type === "text";
if (canAppend) {
- lastMessage!.message = lastMessage!.message + action.payload;
+ lastMessage.message = lastMessage.message + action.payload;
} else {
state.messages.push({
id: createMessageId(),
role: "agent",
+ type: "text",
message: action.payload,
});
}
@@ -156,6 +222,7 @@ export const metabot = createSlice({
state.isProcessing = false;
state.toolCalls = [];
state.conversationId = uuid();
+ state.reactions.suggestedTransforms = [];
state.experimental.metabotReqIdOverride = undefined;
},
resetConversationId: (state) => {
@@ -179,6 +246,45 @@ export const metabot = createSlice({
setProfileOverride: (state, action: PayloadAction<string | undefined>) => {
state.experimental.profileOverride = action.payload;
},
+ addSuggestedTransform: (
+ state,
+ { payload: transform }: PayloadAction<MetabotSuggestedTransform>,
+ ) => {
+ // mark all other transform w/ same id as inactive before adding new one
+ state.reactions.suggestedTransforms.forEach((t) => {
+ if (t.id === transform.id) {
+ t.active = false;
+ }
+ });
+ // transform type caused flaky "possible infinite type definition" errorj
+ // ts-expect-error fails when it doesn't fail, so casting to any
+ state.reactions.suggestedTransforms.push(transform as any);
+ },
+ activateSuggestedTransform: (
+ state,
+ action: PayloadAction<{
+ id?: SuggestedTransform["id"];
+ suggestionId: string;
+ }>,
+ ) => {
+ const { id, suggestionId } = action.payload;
+
+ state.reactions.suggestedTransforms.forEach((t) => {
+ if (t.id === id) {
+ t.active = t.suggestionId === suggestionId;
+ }
+ });
+ },
+ deactivateSuggestedTransform: (
+ state,
+ action: PayloadAction<SuggestedTransform["id"] | undefined>,
+ ) => {
+ state.reactions.suggestedTransforms.forEach((t) => {
+ if (t.id === action.payload) {
+ t.active = false;
+ }
+ });
+ },
},
extraReducers: (builder) => {
builder
diff --git a/enterprise/frontend/src/metabase-enterprise/metabot/state/reducer.unit.spec.ts b/enterprise/frontend/src/metabase-enterprise/metabot/state/reducer.unit.spec.ts
new file mode 100644
index 00000000000..4ac3dad3ae5
--- /dev/null
+++ b/enterprise/frontend/src/metabase-enterprise/metabot/state/reducer.unit.spec.ts
@@ -0,0 +1,226 @@
+import { configureStore } from "@reduxjs/toolkit";
+
+import {
+ type MetabotState,
+ type MetabotSuggestedTransform,
+ activateSuggestedTransform,
+ addSuggestedTransform,
+ deactivateSuggestedTransform,
+ getMetabotInitialState,
+ metabotReducer,
+} from "metabase-enterprise/metabot/state";
+import { createMockTransform } from "metabase-types/api/mocks/transform";
+
+const createMockSuggestedTransform = (
+ overrides: Partial<MetabotSuggestedTransform>,
+): MetabotSuggestedTransform => ({
+ ...createMockTransform(),
+ active: false,
+ suggestionId: "suggestion-123",
+ ...overrides,
+});
+
+const createTestStore = (initialState?: Partial<MetabotState>) =>
+ configureStore({
+ reducer: {
+ metabot: metabotReducer,
+ },
+ preloadedState: {
+ metabot: { ...getMetabotInitialState(), ...initialState },
+ },
+ });
+
+describe("metabot reducer", () => {
+ describe("transforms", () => {
+ describe("addSuggestedTransform", () => {
+ it("should add a new suggested transform to the state", () => {
+ const store = createTestStore();
+ const transform = createMockSuggestedTransform({
+ id: 1,
+ active: true,
+ });
+
+ store.dispatch(addSuggestedTransform(transform));
+
+ const state = store.getState().metabot;
+ expect(state.reactions.suggestedTransforms).toHaveLength(1);
+ expect(state.reactions.suggestedTransforms).toContain(transform);
+ });
+
+ it("should mark existing transforms with same ID as inactive when adding new one", () => {
+ const existingTransform = createMockSuggestedTransform({
+ id: 1,
+ active: true,
+ suggestionId: "old-suggestion",
+ });
+ const store = createTestStore({
+ reactions: {
+ navigateToPath: null,
+ suggestedTransforms: [existingTransform],
+ },
+ });
+
+ const newTransform = createMockSuggestedTransform({
+ id: 1,
+ active: true,
+ suggestionId: "new-suggestion",
+ });
+
+ store.dispatch(addSuggestedTransform(newTransform));
+ const state = store.getState().metabot;
+
+ expect(state.reactions.suggestedTransforms).toEqual([
+ expect.objectContaining({
+ suggestionId: "old-suggestion",
+ active: false,
+ }),
+ expect.objectContaining({
+ suggestionId: "new-suggestion",
+ active: true,
+ }),
+ ]);
+ });
+ });
+
+ describe("activateSuggestedTransform", () => {
+ it("should activate only the transform with matching suggestionId and deactivate others with same ID", () => {
+ const transform1 = createMockSuggestedTransform({
+ id: 1,
+ active: false,
+ suggestionId: "suggestion-1",
+ });
+ const transform2 = createMockSuggestedTransform({
+ id: 1,
+ active: true,
+ suggestionId: "suggestion-2",
+ });
+ const transform3 = createMockSuggestedTransform({
+ id: 2,
+ active: true,
+ suggestionId: "suggestion-3",
+ });
+ const store = createTestStore({
+ reactions: {
+ navigateToPath: null,
+ suggestedTransforms: [transform1, transform2, transform3],
+ },
+ });
+
+ store.dispatch(
+ activateSuggestedTransform({
+ id: 1,
+ suggestionId: "suggestion-1",
+ }),
+ );
+ expect(store.getState().metabot.reactions.suggestedTransforms).toEqual([
+ expect.objectContaining({
+ suggestionId: "suggestion-1",
+ active: true,
+ }),
+ expect.objectContaining({
+ suggestionId: "suggestion-2",
+ active: false,
+ }),
+ expect.objectContaining({
+ suggestionId: "suggestion-3",
+ active: true,
+ }),
+ ]);
+ });
+
+ it("should handle new transforms gracefully", () => {
+ const newTransform = createMockSuggestedTransform({
+ id: undefined,
+ active: false,
+ suggestionId: "new-suggestion",
+ });
+ const store = createTestStore({
+ reactions: {
+ navigateToPath: null,
+ suggestedTransforms: [newTransform],
+ },
+ });
+
+ store.dispatch(
+ activateSuggestedTransform({
+ id: undefined,
+ suggestionId: "new-suggestion",
+ }),
+ );
+ expect(store.getState().metabot.reactions.suggestedTransforms).toEqual([
+ expect.objectContaining({
+ suggestionId: "new-suggestion",
+ active: true,
+ }),
+ ]);
+ });
+ });
+
+ describe("deactivateSuggestedTransform", () => {
+ it("should deactivate all transforms with matching ID without affecting others", () => {
+ const transform1 = createMockSuggestedTransform({
+ id: 1,
+ active: true,
+ suggestionId: "suggestion-1",
+ });
+ const transform2 = createMockSuggestedTransform({
+ id: 1,
+ active: true,
+ suggestionId: "suggestion-2",
+ });
+ const transform3 = createMockSuggestedTransform({
+ id: 2,
+ active: true,
+ suggestionId: "suggestion-3",
+ });
+ const store = createTestStore({
+ reactions: {
+ navigateToPath: null,
+ suggestedTransforms: [transform1, transform2, transform3],
+ },
+ });
+
+ store.dispatch(deactivateSuggestedTransform(1));
+ const state = store.getState().metabot;
+
+ expect(state.reactions.suggestedTransforms).toEqual([
+ expect.objectContaining({
+ suggestionId: "suggestion-1",
+ active: false,
+ }),
+ expect.objectContaining({
+ suggestionId: "suggestion-2",
+ active: false,
+ }),
+ expect.objectContaining({
+ suggestionId: "suggestion-3",
+ active: true,
+ }),
+ ]);
+ });
+
+ it("should handle new transforms gracefully", () => {
+ const newTransform = createMockSuggestedTransform({
+ id: undefined,
+ active: true,
+ suggestionId: "new-suggestion",
+ });
+ const store = createTestStore({
+ reactions: {
+ navigateToPath: null,
+ suggestedTransforms: [newTransform],
+ },
+ });
+
+ store.dispatch(deactivateSuggestedTransform(undefined));
+
+ expect(store.getState().metabot.reactions.suggestedTransforms).toEqual([
+ expect.objectContaining({
+ suggestionId: "new-suggestion",
+ active: false,
+ }),
+ ]);
+ });
+ });
+ });
+});
diff --git a/enterprise/frontend/src/metabase-enterprise/metabot/state/selectors.ts b/enterprise/frontend/src/metabase-enterprise/metabot/state/selectors.ts
index c3847c46cc4..0f6a9369046 100644
--- a/enterprise/frontend/src/metabase-enterprise/metabot/state/selectors.ts
+++ b/enterprise/frontend/src/metabase-enterprise/metabot/state/selectors.ts
@@ -1,7 +1,10 @@
import { createSelector } from "@reduxjs/toolkit";
import _ from "underscore";
+import * as Urls from "metabase/lib/urls";
import { getIsEmbedding } from "metabase/selectors/embed";
+import { getLocation } from "metabase/selectors/routing";
+import type { TransformId } from "metabase-types/api";
import {
FIXED_METABOT_IDS,
@@ -9,6 +12,7 @@ import {
METABOT_REQUEST_IDS,
} from "../constants";
+import type { MetabotUserChatMessage } from "./reducer";
import type { MetabotStoreState } from "./types";
export const getMetabot = (state: MetabotStoreState) => {
@@ -16,7 +20,7 @@ export const getMetabot = (state: MetabotStoreState) => {
};
export const getMetabotVisible = createSelector(
- getMetabot,
+ [getMetabot],
(metabot) => metabot.visible,
);
@@ -44,7 +48,7 @@ export const getAgentErrorMessages = createSelector(
// that exact message will be returned.
export const getUserPromptForMessageId = createSelector(
[getMessages, (_, messageId: string) => messageId],
- (messages, messageId) => {
+ (messages, messageId): MetabotUserChatMessage | undefined => {
const messageIndex = messages.findLastIndex((m) => m.id === messageId);
const message = messages[messageIndex];
if (!message) {
@@ -54,20 +58,10 @@ export const getUserPromptForMessageId = createSelector(
if (message.role === "user") {
return message;
} else {
- return messages.slice(0, messageIndex).findLast((m) => m.role === "user");
- }
- },
-);
-
-export const getLastAgentMessagesByType = createSelector(
- [getMessages, getAgentErrorMessages],
- (messages, errorMessages) => {
- if (errorMessages.length > 0) {
- return errorMessages.map(({ message }) => message);
+ return messages
+ .slice(0, messageIndex)
+ .findLast<MetabotUserChatMessage>((m) => m.role === "user");
}
-
- const start = messages.findLastIndex((msg) => msg.role !== "agent") + 1;
- return messages.slice(start).map(({ message }) => message);
},
);
@@ -100,7 +94,7 @@ export const getIsLongMetabotConversation = createSelector(
getMessages,
(messages) => {
const totalMessageLength = messages.reduce((sum, msg) => {
- return sum + msg.message.length;
+ return sum + ("message" in msg ? msg.message.length : 0);
}, 0);
return totalMessageLength >= LONG_CONVO_MSG_LENGTH_THRESHOLD;
},
@@ -128,17 +122,31 @@ export const getProfileOverride = createSelector(
(metabot) => metabot.experimental.profileOverride,
);
+export const getProfile = createSelector(
+ getProfileOverride,
+ getLocation,
+ (profileOverride, location) => {
+ if (profileOverride) {
+ return profileOverride;
+ }
+
+ return location.pathname.startsWith(Urls.transformList())
+ ? "transforms_codegen"
+ : undefined;
+ },
+);
+
export const getAgentRequestMetadata = createSelector(
getHistory,
getMetabotState,
- getProfileOverride,
- (history, state, profileId) => ({
+ getProfile,
+ (history, state, profile) => ({
state,
// NOTE: need end to end support for ids on messages as BE will error if ids are present
history: history.map((h) =>
h.id && h.id.startsWith(`msg_`) ? _.omit(h, "id") : h,
),
- ...(profileId ? { profile_id: profileId } : {}),
+ ...(profile ? { profile_id: profile } : {}),
}),
);
@@ -146,3 +154,30 @@ export const getNavigateToPath = createSelector(
getMetabotReactionsState,
(reactionsState) => reactionsState.navigateToPath,
);
+
+export const getMetabotSuggestedTransforms = createSelector(
+ getMetabotReactionsState,
+ (reactionsState) => reactionsState.suggestedTransforms,
+);
+
+export const getMetabotSuggestedTransform = createSelector(
+ [
+ getMetabotSuggestedTransforms,
+ (_, transformId?: TransformId) => transformId,
+ ],
+ (suggestedTransforms, transformId) => {
+ return suggestedTransforms.findLast(
+ (t) => t.id === transformId && t.active,
+ );
+ },
+);
+
+export const getIsSuggestedTransformActive = createSelector(
+ [getMetabotSuggestedTransforms, (_, suggestionId: string) => suggestionId],
+ (suggestedTransforms, suggestionId) => {
+ const suggestion = suggestedTransforms.find(
+ (t) => t.suggestionId === suggestionId,
+ );
+ return suggestion?.active ?? false;
+ },
+);
diff --git a/enterprise/frontend/src/metabase-enterprise/metabot/state/selectors.unit.spec.ts b/enterprise/frontend/src/metabase-enterprise/metabot/state/selectors.unit.spec.ts
index 8e614334e39..a5e9fa38073 100644
--- a/enterprise/frontend/src/metabase-enterprise/metabot/state/selectors.unit.spec.ts
+++ b/enterprise/frontend/src/metabase-enterprise/metabot/state/selectors.unit.spec.ts
@@ -3,7 +3,6 @@ import { createMockState } from "metabase-types/store/mocks";
import {
type MetabotState,
- getLastAgentMessagesByType,
getMetabotInitialState,
getUserPromptForMessageId,
} from "./index";
@@ -23,71 +22,46 @@ function setup(metabotState: Partial<MetabotState>) {
}
describe("metabot selectors", () => {
- describe("getLastAgentMessagesByType", () => {
- it("should not return any messages if there are none", () => {
- const state = setup({ messages: [] });
- const messages = getLastAgentMessagesByType(state as any);
- expect(messages).toEqual([]);
- });
-
- it("should not return any messages if latest message is from a user", () => {
- const state = setup({
- messages: [{ id: "1", role: "user", message: "bleh" }],
- });
- const messages = getLastAgentMessagesByType(state as any);
- expect(messages).toEqual([]);
- });
-
- it("should return latest agent reply messages only", () => {
- const state = setup({
- messages: [
- { id: "1", role: "user", message: "bleh" },
- { id: "2", role: "agent", message: "blah" },
- { id: "3", role: "agent", message: "blah" },
- ],
- });
- const messages = getLastAgentMessagesByType(state as any);
- expect(messages).toEqual(["blah", "blah"]);
- });
-
- it("should return latest agent error messages only", () => {
- const state = setup({
- messages: [{ id: "1", role: "agent", message: "blah" }],
- errorMessages: [
- { type: "message", message: "BLAH" },
- { type: "message", message: "BLAH" },
- ],
- });
- const messages = getLastAgentMessagesByType(state as any);
- expect(messages).toEqual(["BLAH", "BLAH"]);
- });
- });
-
describe("getUserPromptForMessageId", () => {
it("should return the message with the matching id if id is for a user message", () => {
const state = setup({
messages: [
- { id: "1", role: "user", message: "bleh" },
- { id: "2", role: "agent", message: "blah" },
+ { id: "1", role: "user", type: "text", message: "bleh" },
+ { id: "2", role: "agent", type: "text", message: "blah" },
],
});
const message = getUserPromptForMessageId(state as any, "1");
- expect(message).toEqual({ id: "1", role: "user", message: "bleh" });
+ expect(message).toEqual({
+ id: "1",
+ role: "user",
+ type: "text",
+ message: "bleh",
+ });
});
it("should return the message with the matching id if id is for an agent message", () => {
const state = setup({
messages: [
- { id: "1", role: "user", message: "bleh" },
- { id: "2", role: "agent", message: "blah" },
- { id: "3", role: "user", message: "bleh bleh" },
- { id: "4", role: "agent", message: "blah blah" },
+ { id: "1", type: "text", role: "user", message: "bleh" },
+ { id: "2", type: "text", role: "agent", message: "blah" },
+ { id: "3", type: "text", role: "user", message: "bleh bleh" },
+ { id: "4", type: "text", role: "agent", message: "blah blah" },
],
});
const message1 = getUserPromptForMessageId(state as any, "2");
- expect(message1).toEqual({ id: "1", role: "user", message: "bleh" });
+ expect(message1).toEqual({
+ id: "1",
+ role: "user",
+ type: "text",
+ message: "bleh",
+ });
const message2 = getUserPromptForMessageId(state as any, "4");
- expect(message2).toEqual({ id: "3", role: "user", message: "bleh bleh" });
+ expect(message2).toEqual({
+ id: "3",
+ role: "user",
+ type: "text",
+ message: "bleh bleh",
+ });
});
});
});
diff --git a/enterprise/frontend/src/metabase-enterprise/metabot/utils/links.ts b/enterprise/frontend/src/metabase-enterprise/metabot/utils/links.ts
new file mode 100644
index 00000000000..9a3830e9f41
--- /dev/null
+++ b/enterprise/frontend/src/metabase-enterprise/metabot/utils/links.ts
@@ -0,0 +1,75 @@
+export const METABSE_PROTOCOL_LINK =
+ /metabase:\/\/(?<model>[^\/]+)\/(?<id>\d+)/;
+
+export const METABSE_PROTOCOL_MD_LINK =
+ /\[(?<name>[^\]]+)\]\(metabase:\/\/(?<model>[^\/]+)\/(?<id>\d+)\)/;
+
+export const METABASE_PROTOCOL_ENTITY_MODELS = [
+ "question",
+ "dashboard",
+ "collection",
+ "document",
+ "model",
+ "database",
+ "table",
+ "transform",
+] as const;
+
+export type MetabaseProtocolEntityModel =
+ (typeof METABASE_PROTOCOL_ENTITY_MODELS)[number];
+
+const isMetabaseProtocolEntityModel = (
+ model: string,
+): model is MetabaseProtocolEntityModel => {
+ return (METABASE_PROTOCOL_ENTITY_MODELS as readonly string[]).includes(model);
+};
+
+export interface MetabaseProtocolEntity {
+ id: number;
+ model: MetabaseProtocolEntityModel;
+ name: string;
+}
+
+export const parseMetabaseProtocolLink = (
+ href: string,
+): Pick<MetabaseProtocolEntity, "id" | "model"> | undefined => {
+ const match = href.match(METABSE_PROTOCOL_LINK);
+
+ if (!match?.groups) {
+ return undefined;
+ }
+
+ const { id, model } = match?.groups;
+
+ if (!isMetabaseProtocolEntityModel(model)) {
+ return undefined;
+ }
+
+ return { id: parseInt(id, 10), model };
+};
+
+export const parseMetabaseProtocolMarkdownLink = (
+ href: string,
+): MetabaseProtocolEntity | undefined => {
+ const match = href.match(METABSE_PROTOCOL_MD_LINK);
+
+ if (!match?.groups) {
+ return undefined;
+ }
+
+ const { id, model, name } = match?.groups;
+
+ if (!isMetabaseProtocolEntityModel(model)) {
+ return undefined;
+ }
+
+ return { id: parseInt(id, 10), model, name };
+};
+
+export const createMetabaseProtocolLink = ({
+ id,
+ name,
+ model,
+}: MetabaseProtocolEntity): string => {
+ return `[${name}](metabase://${model}/${id})`;
+};
diff --git a/enterprise/frontend/src/metabase-enterprise/metabot/utils/links.unit.spec.ts b/enterprise/frontend/src/metabase-enterprise/metabot/utils/links.unit.spec.ts
new file mode 100644
index 00000000000..96239aa3757
--- /dev/null
+++ b/enterprise/frontend/src/metabase-enterprise/metabot/utils/links.unit.spec.ts
@@ -0,0 +1,164 @@
+import type { MetabaseProtocolEntity } from "./links";
+import {
+ createMetabaseProtocolLink,
+ parseMetabaseProtocolLink,
+ parseMetabaseProtocolMarkdownLink,
+} from "./links";
+
+describe("parseMetabaseProtocolLink", () => {
+ it("should parse metabase://model/id for various entities", () => {
+ expect(parseMetabaseProtocolLink("metabase://question/123")).toEqual({
+ id: 123,
+ model: "question",
+ });
+ expect(parseMetabaseProtocolLink("metabase://dashboard/456")).toEqual({
+ id: 456,
+ model: "dashboard",
+ });
+ expect(parseMetabaseProtocolLink("metabase://collection/789")).toEqual({
+ id: 789,
+ model: "collection",
+ });
+ expect(parseMetabaseProtocolLink("metabase://model/111")).toEqual({
+ id: 111,
+ model: "model",
+ });
+ });
+
+ it("should return undefined for invalid protocol", () => {
+ expect(parseMetabaseProtocolLink("blah://")).toBeUndefined();
+ });
+
+ it("should return undefined for unsupported entity models", () => {
+ expect(
+ parseMetabaseProtocolLink("metabase://unsupported/123"),
+ ).toBeUndefined();
+ });
+
+ it("should return undefined for non-numeric IDs", () => {
+ expect(
+ parseMetabaseProtocolLink("metabase://question/abc"),
+ ).toBeUndefined();
+ });
+});
+
+describe("parseMetabaseProtocolMarkdownLink", () => {
+ it("should parse markdown format [Name](metabase://model/id)", () => {
+ expect(
+ parseMetabaseProtocolMarkdownLink(
+ "[My Question](metabase://question/123)",
+ ),
+ ).toEqual({
+ id: 123,
+ model: "question",
+ name: "My Question",
+ });
+ });
+
+ it("should parse different entity models with names", () => {
+ expect(
+ parseMetabaseProtocolMarkdownLink(
+ "[Sales Dashboard](metabase://dashboard/456)",
+ ),
+ ).toEqual({
+ id: 456,
+ model: "dashboard",
+ name: "Sales Dashboard",
+ });
+
+ expect(
+ parseMetabaseProtocolMarkdownLink(
+ "[Reports Collection](metabase://collection/789)",
+ ),
+ ).toEqual({
+ id: 789,
+ model: "collection",
+ name: "Reports Collection",
+ });
+ });
+
+ it("should handle names with special characters", () => {
+ expect(
+ parseMetabaseProtocolMarkdownLink(
+ "[Data & Analytics: Q1 Report](metabase://question/123)",
+ ),
+ ).toEqual({
+ id: 123,
+ model: "question",
+ name: "Data & Analytics: Q1 Report",
+ });
+ });
+
+ it("should return undefined for invalid markdown format", () => {
+ expect(
+ parseMetabaseProtocolMarkdownLink(
+ "My Question](metabase://question/123)",
+ ),
+ ).toBeUndefined();
+ expect(
+ parseMetabaseProtocolMarkdownLink(
+ "[My Question(metabase://question/123)",
+ ),
+ ).toBeUndefined();
+ expect(
+ parseMetabaseProtocolMarkdownLink("[My Question](http://example.com)"),
+ ).toBeUndefined();
+ });
+
+ it("should return undefined for unsupported entity models", () => {
+ expect(
+ parseMetabaseProtocolMarkdownLink("[Test](metabase://unsupported/123)"),
+ ).toBeUndefined();
+ });
+});
+
+describe("createMetabaseProtocolLink", () => {
+ it("should create a valid metabase protocol link", () => {
+ const entity: MetabaseProtocolEntity = {
+ id: 123,
+ model: "question",
+ name: "My Question",
+ };
+
+ const result = createMetabaseProtocolLink(entity);
+ expect(result).toBe("[My Question](metabase://question/123)");
+ });
+
+ it("should create links for different entity models", () => {
+ expect(
+ createMetabaseProtocolLink({
+ id: 456,
+ model: "dashboard",
+ name: "Sales Dashboard",
+ }),
+ ).toBe("[Sales Dashboard](metabase://dashboard/456)");
+
+ expect(
+ createMetabaseProtocolLink({
+ id: 789,
+ model: "collection",
+ name: "Reports",
+ }),
+ ).toBe("[Reports](metabase://collection/789)");
+ });
+
+ it("should handle names with special characters", () => {
+ expect(
+ createMetabaseProtocolLink({
+ id: 123,
+ model: "question",
+ name: "Data & Analytics: Q1 Report",
+ }),
+ ).toBe("[Data & Analytics: Q1 Report](metabase://question/123)");
+ });
+
+ it("should handle empty name", () => {
+ expect(
+ createMetabaseProtocolLink({
+ id: 123,
+ model: "question",
+ name: "",
+ }),
+ ).toBe("[](metabase://question/123)");
+ });
+});
diff --git a/enterprise/frontend/src/metabase-enterprise/rich_text_editing/tiptap/extensions/Command/CommandSuggestion.tsx b/enterprise/frontend/src/metabase-enterprise/rich_text_editing/tiptap/extensions/Command/CommandSuggestion.tsx
index bad08051ed5..abbaed80bd0 100644
--- a/enterprise/frontend/src/metabase-enterprise/rich_text_editing/tiptap/extensions/Command/CommandSuggestion.tsx
+++ b/enterprise/frontend/src/metabase-enterprise/rich_text_editing/tiptap/extensions/Command/CommandSuggestion.tsx
@@ -231,6 +231,8 @@ export const CommandSuggestion = forwardRef<
onSelectEntity: onSelectLinkEntity,
enabled: true,
searchModels: showLinkSearch ? LINK_SEARCH_MODELS : EMBED_SEARCH_MODELS,
+ canFilterSearchModels: false,
+ canBrowseAll: true,
});
const {
@@ -397,6 +399,7 @@ export const CommandSuggestion = forwardRef<
modal={entityModal}
onModalSelect={entityHandlers.handleModalSelect}
onModalClose={entityHandlers.handleModalClose}
+ canBrowseAll
/>
) : (
<>
diff --git a/enterprise/frontend/src/metabase-enterprise/rich_text_editing/tiptap/extensions/Mention/MentionSuggestion.tsx b/enterprise/frontend/src/metabase-enterprise/rich_text_editing/tiptap/extensions/Mention/MentionSuggestion.tsx
index 1e3e331c4fd..53ee2d2909d 100644
--- a/enterprise/frontend/src/metabase-enterprise/rich_text_editing/tiptap/extensions/Mention/MentionSuggestion.tsx
+++ b/enterprise/frontend/src/metabase-enterprise/rich_text_editing/tiptap/extensions/Mention/MentionSuggestion.tsx
@@ -7,22 +7,24 @@ import {
LoadingSuggestionPaper,
SuggestionPaper,
} from "metabase-enterprise/documents/components/Editor/shared/SuggestionPaper";
-import type { SuggestionModel } from "metabase-enterprise/documents/components/Editor/types";
import { getCurrentDocument } from "metabase-enterprise/documents/selectors";
import type { SearchResult } from "metabase-types/api";
import { EntitySearchSection } from "../shared/EntitySearchSection";
+import type { SuggestionModel } from "../shared/types";
import { useEntitySuggestions } from "../shared/useEntitySuggestions";
import type { MentionCommandProps } from "./MentionExtension";
-interface MentionSuggestionProps {
+export interface MentionSuggestionProps {
items: SearchResult[];
command: (item: MentionCommandProps) => void;
editor: Editor;
range: Range;
query: string;
searchModels?: SuggestionModel[];
+ canFilterSearchModels?: boolean;
+ canBrowseAll?: boolean;
}
interface SuggestionRef {
@@ -33,7 +35,16 @@ const MentionSuggestionComponent = forwardRef<
SuggestionRef,
MentionSuggestionProps
>(function MentionSuggestionComponent(
- { items: _items, command, editor, range: _range, query, searchModels },
+ {
+ items: _items,
+ command,
+ editor,
+ range,
+ query,
+ searchModels,
+ canFilterSearchModels = false,
+ canBrowseAll = true,
+ },
ref,
) {
const document = useSelector(getCurrentDocument);
@@ -49,7 +60,7 @@ const MentionSuggestionComponent = forwardRef<
model: item.model,
label: item.label,
href: item.href,
- document,
+ document, // currently only used for analytics tracking purposes
});
},
[command, document],
@@ -61,12 +72,16 @@ const MentionSuggestionComponent = forwardRef<
searchResults,
selectedIndex,
modal,
+ selectedSearchModelName,
handlers,
} = useEntitySuggestions({
query,
editor,
+ range,
searchModels,
onSelectEntity,
+ canFilterSearchModels,
+ canBrowseAll,
});
useImperativeHandle(ref, () => ({
@@ -78,7 +93,10 @@ const MentionSuggestionComponent = forwardRef<
}
return (
- <SuggestionPaper aria-label={t`Mention Dialog`}>
+ <SuggestionPaper
+ aria-label={t`Mention Dialog`}
+ key={selectedSearchModelName}
+ >
<EntitySearchSection
menuItems={menuItems}
selectedIndex={selectedIndex}
@@ -90,6 +108,8 @@ const MentionSuggestionComponent = forwardRef<
onModalSelect={handlers.handleModalSelect}
onModalClose={handlers.handleModalClose}
onItemHover={handlers.hoverHandler}
+ selectedSearchModelName={selectedSearchModelName}
+ canBrowseAll={canBrowseAll}
/>
</SuggestionPaper>
);
@@ -99,15 +119,25 @@ export const MentionSuggestion = MentionSuggestionComponent;
export const createMentionSuggestion = ({
searchModels,
+ canFilterSearchModels,
+ canBrowseAll,
}: {
searchModels: SuggestionModel[];
+ canFilterSearchModels?: boolean;
+ canBrowseAll?: boolean;
}) => {
return forwardRef<
SuggestionRef,
Omit<MentionSuggestionProps, "searchModels">
>(function MentionSuggestionWrapper(props, ref) {
return (
- <MentionSuggestion {...props} ref={ref} searchModels={searchModels} />
+ <MentionSuggestion
+ {...props}
+ ref={ref}
+ searchModels={searchModels}
+ canFilterSearchModels={canFilterSearchModels}
+ canBrowseAll={canBrowseAll}
+ />
);
});
};
diff --git a/enterprise/frontend/src/metabase-enterprise/rich_text_editing/tiptap/extensions/Mention/MentionSuggestion.unit.spec.tsx b/enterprise/frontend/src/metabase-enterprise/rich_text_editing/tiptap/extensions/Mention/MentionSuggestion.unit.spec.tsx
new file mode 100644
index 00000000000..c2cad42ee7a
--- /dev/null
+++ b/enterprise/frontend/src/metabase-enterprise/rich_text_editing/tiptap/extensions/Mention/MentionSuggestion.unit.spec.tsx
@@ -0,0 +1,209 @@
+import userEvent from "@testing-library/user-event";
+import type { Editor } from "@tiptap/core";
+import fetchMock from "fetch-mock";
+
+import {
+ setupRecentViewsEndpoints,
+ setupSearchEndpoints,
+} from "__support__/server-mocks";
+import { renderWithProviders, screen } from "__support__/ui";
+import { checkNotNull } from "metabase/lib/types";
+import {
+ createMockRecentCollectionItem,
+ createMockSearchResult,
+} from "metabase-types/api/mocks";
+import { createMockState } from "metabase-types/store/mocks";
+
+import type { MentionSuggestionProps } from "./MentionSuggestion";
+import { MentionSuggestion } from "./MentionSuggestion";
+
+const expectOptionToBePresent = async (name: string | RegExp) => {
+ expect(await screen.findByRole("option", { name })).toBeInTheDocument();
+};
+
+const expectOptionNotToBePresent = (name: string | RegExp) => {
+ expect(screen.queryByRole("option", { name })).not.toBeInTheDocument();
+};
+
+const SEARCH_ITEMS = [
+ createMockSearchResult({
+ name: "Orders question",
+ model: "card",
+ id: 1,
+ }),
+];
+
+const RECENT_ITEMS = [
+ createMockRecentCollectionItem({
+ id: 4,
+ name: "Recent Card",
+ model: "card",
+ }),
+];
+
+interface SetupProps extends Partial<MentionSuggestionProps> {
+ query?: string;
+ searchItems?: typeof SEARCH_ITEMS;
+ recentItems?: typeof RECENT_ITEMS;
+}
+
+const setup = (props: SetupProps = {}) => {
+ const command = jest.fn();
+
+ const mockChain = {
+ focus: jest.fn().mockReturnThis(),
+ deleteRange: jest.fn().mockReturnThis(),
+ insertContent: jest.fn().mockReturnThis(),
+ run: jest.fn().mockReturnThis(),
+ };
+
+ const editor = {
+ commands: {
+ focus: jest.fn(),
+ deleteRange: jest.fn().mockReturnThis(),
+ insertContent: jest.fn().mockReturnThis(),
+ run: jest.fn(),
+ },
+ chain: jest.fn().mockReturnValue(mockChain),
+ } as unknown as Editor;
+
+ setupSearchEndpoints(props.searchItems ?? SEARCH_ITEMS);
+ setupRecentViewsEndpoints(props.recentItems ?? RECENT_ITEMS);
+
+ const defaultProps: MentionSuggestionProps = {
+ items: [],
+ command,
+ editor,
+ range: { from: 0, to: 0 },
+ query: props.query || "",
+ ...props,
+ };
+
+ renderWithProviders(<MentionSuggestion {...defaultProps} />, {
+ storeInitialState: createMockState({}),
+ });
+
+ return { command, editor };
+};
+
+describe("MentionSuggestion", () => {
+ it("shows recent items for empty query", async () => {
+ setup({ query: "" });
+ await expectOptionToBePresent(/Recent Card/);
+ });
+
+ it("shows 'Browse all' when canBrowseAll=true", async () => {
+ setup({ query: "", canBrowseAll: true });
+ await expectOptionToBePresent(/Recent Card/);
+ expect(screen.getByText("Browse all")).toBeInTheDocument();
+ });
+
+ it("hides 'Browse all' when canBrowseAll=false", async () => {
+ setup({ query: "", canBrowseAll: false });
+ await expectOptionToBePresent(/Recent Card/);
+ expect(screen.queryByText("Browse all")).not.toBeInTheDocument();
+ });
+
+ it("searches without model filtering when none provided", async () => {
+ setup({ query: "ord" });
+ await expectOptionToBePresent(/Orders question/);
+ expectOptionNotToBePresent(/Recent Card/);
+ });
+
+ it("shows model selector for empty query with searchModels", async () => {
+ setup({
+ query: "",
+ searchModels: ["card", "dashboard", "table"],
+ canFilterSearchModels: true,
+ canBrowseAll: true,
+ });
+ await expectOptionToBePresent(/Question/);
+ await expectOptionToBePresent(/Dashboard/);
+ await expectOptionToBePresent(/Table/);
+ });
+
+ it("filters search by selected model and shows model name", async () => {
+ const { editor } = setup({
+ query: "",
+ searchModels: ["card", "dashboard", "table"],
+ searchItems: [
+ createMockSearchResult({
+ name: "Sales Dashboard",
+ model: "dashboard",
+ id: 10,
+ }),
+ ],
+ canFilterSearchModels: true,
+ canBrowseAll: true,
+ });
+
+ await userEvent.click(
+ await screen.findByRole("option", {
+ name: /Dashboard/,
+ }),
+ );
+ expect(editor.chain).toHaveBeenCalled();
+ const chainMethods = editor.chain();
+ expect(chainMethods.focus).toHaveBeenCalled();
+ expect(chainMethods.deleteRange).toHaveBeenCalled();
+ expect(chainMethods.insertContent).toHaveBeenCalledWith("@");
+ expect(chainMethods.run).toHaveBeenCalled();
+
+ expect(await screen.findByText("Dashboard")).toBeInTheDocument();
+ await expectOptionToBePresent(/Sales Dashboard/);
+
+ const call = fetchMock.callHistory.lastCall("path:/api/search");
+ const urlObject = new URL(checkNotNull(call?.request?.url));
+ expect(urlObject.searchParams.get("models")).toEqual("dashboard");
+ });
+
+ it("filters model selector by query text", async () => {
+ setup({
+ query: "que",
+ searchModels: ["card", "dashboard", "table"],
+ canFilterSearchModels: true,
+ canBrowseAll: true,
+ });
+
+ await expectOptionToBePresent(/Question/);
+ expectOptionNotToBePresent(/Dashboard/);
+ expectOptionNotToBePresent(/Table/);
+ });
+
+ it("behaves as standard mention without searchModels", async () => {
+ setup({ query: "" });
+
+ await expectOptionToBePresent(/Recent Card/);
+ expect(screen.getByText("Browse all")).toBeInTheDocument();
+ expectOptionNotToBePresent(/Question/);
+ expectOptionNotToBePresent(/Dashboard/);
+ });
+
+ it("searches all models when query doesn't match any model name", async () => {
+ setup({
+ query: "Sales", // Doesn't match any model name
+ searchModels: ["card", "dashboard", "table"],
+ searchItems: [
+ createMockSearchResult({ name: "Sales Card", model: "card", id: 11 }),
+ createMockSearchResult({
+ name: "Sales Dashboard",
+ model: "dashboard",
+ id: 12,
+ }),
+ createMockSearchResult({
+ name: "Sales Table",
+ model: "table",
+ id: 13,
+ }),
+ ],
+ });
+
+ expect(
+ await screen.findAllByRole("option", { name: /Sales/ }),
+ ).toHaveLength(3);
+ const call = fetchMock.callHistory.lastCall("path:/api/search");
+ const urlObject = new URL(checkNotNull(call?.request?.url));
+ const models = urlObject.searchParams.getAll("models").sort();
+ expect(models).toEqual(["card", "dashboard", "table"]);
+ });
+});
diff --git a/enterprise/frontend/src/metabase-enterprise/rich_text_editing/tiptap/extensions/MetabotMention/MetabotMentionExtension.tsx b/enterprise/frontend/src/metabase-enterprise/rich_text_editing/tiptap/extensions/MetabotMention/MetabotMentionExtension.tsx
index 94eb5901587..d398c7aabf0 100644
--- a/enterprise/frontend/src/metabase-enterprise/rich_text_editing/tiptap/extensions/MetabotMention/MetabotMentionExtension.tsx
+++ b/enterprise/frontend/src/metabase-enterprise/rich_text_editing/tiptap/extensions/MetabotMention/MetabotMentionExtension.tsx
@@ -16,6 +16,7 @@ interface MentionProps {
type?: string;
id?: number | string;
model?: string;
+ label?: string;
}
export const MetabotMentionPluginKey = new PluginKey("metabot-mention");
@@ -53,8 +54,10 @@ export const MetabotMentionExtension = Extension.create<MentionOptions>({
attrs: {
entityId: props.id,
model: props.model,
+ label: props.label,
},
})
+ .insertContent(" ") // Add space after mention
.run();
}
},
diff --git a/enterprise/frontend/src/metabase-enterprise/rich_text_editing/tiptap/extensions/SmartLink/SmartLinkNode.tsx b/enterprise/frontend/src/metabase-enterprise/rich_text_editing/tiptap/extensions/SmartLink/SmartLinkNode.tsx
index f8b53d523fc..deac0ca9e29 100644
--- a/enterprise/frontend/src/metabase-enterprise/rich_text_editing/tiptap/extensions/SmartLink/SmartLinkNode.tsx
+++ b/enterprise/frontend/src/metabase-enterprise/rich_text_editing/tiptap/extensions/SmartLink/SmartLinkNode.tsx
@@ -27,8 +27,11 @@ import {
useGetDocumentQuery,
useListMentionsQuery,
} from "metabase-enterprise/api";
-import type { SuggestionModel } from "metabase-enterprise/documents/components/Editor/types";
import { updateMentionsCache } from "metabase-enterprise/documents/documents.slice";
+import {
+ METABSE_PROTOCOL_MD_LINK,
+ parseMetabaseProtocolMarkdownLink,
+} from "metabase-enterprise/metabot/utils/links";
import type {
Card,
CardDisplayType,
@@ -38,12 +41,14 @@ import type {
Document,
MentionableUser,
Table,
+ Transform,
} from "metabase-types/api";
import {
entityToUrlableModel,
isMentionableUser,
} from "../shared/suggestionUtils";
+import type { SuggestionModel } from "../shared/types";
import styles from "./SmartLinkNode.module.css";
@@ -52,6 +57,7 @@ export type SmartLinkEntity =
| Dashboard
| Collection
| Table
+ | Transform
| Database
| Document
| MentionableUser;
@@ -222,6 +228,24 @@ export const SmartLink = Node.create<{
};
}
+ return null; // Return null to prevent node creation
+ },
+ }),
+ nodePasteRule({
+ find: new RegExp(METABSE_PROTOCOL_MD_LINK, "g"),
+ type: this.type,
+ getAttributes: (match) => {
+ const url = match[0];
+ const parsedEntity = parseMetabaseProtocolMarkdownLink(url);
+
+ if (parsedEntity) {
+ return {
+ entityId: parsedEntity.id,
+ model: parsedEntity.model,
+ label: parsedEntity.name,
+ };
+ }
+
return null; // Return null to prevent node creation
},
}),
@@ -229,7 +253,7 @@ export const SmartLink = Node.create<{
},
});
-const useEntityData = (
+export const useEntityData = (
entityId: number | null,
model: SuggestionModel | null,
) => {
@@ -335,17 +359,27 @@ const useEntityData = (
export const SmartLinkComponent = memo(
({ node }: NodeViewProps) => {
- const { entityId, model } = node.attrs;
- const { entity, isLoading, error } = useEntityData(entityId, model);
+ const { entityId, model, label } = node.attrs;
+
+ const {
+ entity: networkEntity,
+ isLoading,
+ error,
+ } = useEntityData(entityId, model);
+ const cachedEntity = { id: parseInt(entityId, 10), model, name: label };
+ const entity = networkEntity || cachedEntity;
const dispatch = useDispatch();
useEffect(() => {
- if (entity?.name) {
- dispatch(updateMentionsCache({ entityId, model, name: entity.name }));
+ if (entity) {
+ const name =
+ "display_name" in entity ? entity.display_name : entity?.name;
+ dispatch(updateMentionsCache({ entityId, model, name }));
}
- }, [dispatch, entity?.name, entityId, model]);
+ }, [dispatch, entity, entityId, model]);
- if (isLoading) {
+ const showLoading = isLoading && !entity;
+ if (showLoading) {
return (
<NodeViewWrapper as="span">
<span className={styles.smartLink}>
@@ -382,7 +416,15 @@ export const SmartLinkComponent = memo(
const entityUrlableModel = entityToUrlableModel(entity, model);
const entityUrl = modelToUrl(entityUrlableModel);
- const iconData = getIcon(entityToObjectWithModel(entity, model));
+ const iconData =
+ entity === cachedEntity
+ ? getIcon(cachedEntity)
+ : getIcon(
+ entityToObjectWithModel(
+ entity as NonNullable<typeof networkEntity>,
+ model,
+ ),
+ );
return (
<NodeViewWrapper as="span">
@@ -428,7 +470,7 @@ function entityToObjectWithModel(
};
}
-function getName(entity: SmartLinkEntity) {
+function getName(entity: { name?: string; display_name?: string }) {
if ("display_name" in entity && entity.display_name !== "") {
return entity.display_name;
}
diff --git a/enterprise/frontend/src/metabase-enterprise/rich_text_editing/tiptap/extensions/SmartLink/SmartLinkNode.unit.spec.tsx b/enterprise/frontend/src/metabase-enterprise/rich_text_editing/tiptap/extensions/SmartLink/SmartLinkNode.unit.spec.tsx
index 2b0105b1fd2..c91d3ea341b 100644
--- a/enterprise/frontend/src/metabase-enterprise/rich_text_editing/tiptap/extensions/SmartLink/SmartLinkNode.unit.spec.tsx
+++ b/enterprise/frontend/src/metabase-enterprise/rich_text_editing/tiptap/extensions/SmartLink/SmartLinkNode.unit.spec.tsx
@@ -9,7 +9,6 @@ import {
setupTableEndpoints,
} from "__support__/server-mocks";
import { renderWithProviders, screen, waitFor } from "__support__/ui";
-import type { SuggestionModel } from "metabase-enterprise/documents/components/Editor/types";
import {
createMockCard,
createMockCollection,
@@ -19,25 +18,49 @@ import {
createMockTable,
} from "metabase-types/api/mocks";
+import type { SuggestionModel } from "../shared/types";
+
import { SmartLinkComponent, type SmartLinkEntity } from "./SmartLinkNode";
-function createProps(model: SuggestionModel, entity: SmartLinkEntity) {
- const node = { attrs: { entityId: entity.id, model } };
+function createProps(
+ model: SuggestionModel,
+ entity: SmartLinkEntity | { id: number; label?: string },
+ label?: string,
+) {
+ const node = { attrs: { entityId: entity.id, model, label } };
return { node } as unknown as NodeViewProps;
}
function setup({
entity,
model,
+ label,
}: {
model: SuggestionModel;
entity: SmartLinkEntity;
+ label?: string;
}) {
- const props = createProps(model, entity);
+ const props = createProps(model, entity, label);
renderWithProviders(<SmartLinkComponent {...props} />);
}
describe("SmartLink", () => {
+ describe("general", () => {
+ it("renders cached label immediately while loading network data", async () => {
+ const card = createMockCard({ name: "Network Card Name" });
+ setupCardEndpoints(card);
+ setup({ model: "card", entity: card, label: "Cached Card Name" });
+
+ expect(screen.getByText("Cached Card Name")).toBeInTheDocument();
+ expect(
+ screen.queryByRole("img", { name: /hourglass/ }),
+ ).not.toBeInTheDocument();
+ // Eventually updates to network data
+ expect(await screen.findByText("Network Card Name")).toBeInTheDocument();
+ expect(screen.queryByText("Cached Card Name")).not.toBeInTheDocument();
+ });
+ });
+
describe("for Card", () => {
it("should render the name of a card", async () => {
const card = createMockCard({
diff --git a/enterprise/frontend/src/metabase-enterprise/rich_text_editing/tiptap/extensions/shared/EntitySearchSection.tsx b/enterprise/frontend/src/metabase-enterprise/rich_text_editing/tiptap/extensions/shared/EntitySearchSection.tsx
index d7cecc359f7..0b3a56876e5 100644
--- a/enterprise/frontend/src/metabase-enterprise/rich_text_editing/tiptap/extensions/shared/EntitySearchSection.tsx
+++ b/enterprise/frontend/src/metabase-enterprise/rich_text_editing/tiptap/extensions/shared/EntitySearchSection.tsx
@@ -21,6 +21,8 @@ interface EntitySearchSectionProps {
onModalSelect: (item: QuestionPickerValueItem) => void;
onModalClose: () => void;
onItemHover: (index: number) => void;
+ canBrowseAll?: boolean;
+ selectedSearchModelName?: string;
}
export function EntitySearchSection({
@@ -34,9 +36,18 @@ export function EntitySearchSection({
onModalSelect,
onModalClose,
onItemHover,
+ selectedSearchModelName,
+ canBrowseAll,
}: EntitySearchSectionProps) {
return (
<>
+ {selectedSearchModelName && (
+ <Box py="xs">
+ <Text size="sm" c="text-light" fw="bold">
+ {selectedSearchModelName}
+ </Text>
+ </Box>
+ )}
{menuItems.map((item, index) => (
<MenuItemComponent
key={index}
@@ -46,20 +57,29 @@ export function EntitySearchSection({
onMouseEnter={() => onItemHover(index)}
/>
))}
- {query.length > 0 && searchResults.length === 0 ? (
+ {query.length > 0 &&
+ menuItems.length === 0 &&
+ searchResults.length === 0 ? (
<Box p="sm" ta="center">
<Text size="md" c="text-medium">{t`No results found`}</Text>
</Box>
) : null}
- {menuItems.length > 0 && <Divider my="sm" mx="sm" />}
- <SearchResultsFooter
- isSelected={selectedIndex === menuItems.length}
- onClick={onFooterClick}
- onMouseEnter={() => onItemHover(menuItems.length)}
- />
+ {canBrowseAll && (
+ <>
+ {menuItems.length > 0 && <Divider my="sm" mx="sm" />}
+ <SearchResultsFooter
+ isSelected={selectedIndex === menuItems.length}
+ onClick={onFooterClick}
+ onMouseEnter={() => onItemHover(menuItems.length)}
+ />
- {modal === "question-picker" && (
- <QuestionPickerModal onChange={onModalSelect} onClose={onModalClose} />
+ {modal === "question-picker" && (
+ <QuestionPickerModal
+ onChange={onModalSelect}
+ onClose={onModalClose}
+ />
+ )}
+ </>
)}
</>
);
diff --git a/enterprise/frontend/src/metabase-enterprise/rich_text_editing/tiptap/extensions/shared/constants.ts b/enterprise/frontend/src/metabase-enterprise/rich_text_editing/tiptap/extensions/shared/constants.ts
index d4f8819870d..080b6613e73 100644
--- a/enterprise/frontend/src/metabase-enterprise/rich_text_editing/tiptap/extensions/shared/constants.ts
+++ b/enterprise/frontend/src/metabase-enterprise/rich_text_editing/tiptap/extensions/shared/constants.ts
@@ -1,4 +1,4 @@
-import type { SuggestionModel } from "metabase-enterprise/documents/components/Editor/types";
+import type { SuggestionModel } from "./types";
export const LINK_SEARCH_MODELS: SuggestionModel[] = [
"card",
diff --git a/enterprise/frontend/src/metabase-enterprise/rich_text_editing/tiptap/extensions/shared/suggestionUtils.ts b/enterprise/frontend/src/metabase-enterprise/rich_text_editing/tiptap/extensions/shared/suggestionUtils.ts
index cdeb3e5b112..510b3999e94 100644
--- a/enterprise/frontend/src/metabase-enterprise/rich_text_editing/tiptap/extensions/shared/suggestionUtils.ts
+++ b/enterprise/frontend/src/metabase-enterprise/rich_text_editing/tiptap/extensions/shared/suggestionUtils.ts
@@ -1,8 +1,8 @@
+import { getTranslatedEntityName } from "metabase/common/utils/model-names";
import { getIcon } from "metabase/lib/icon";
import { getName } from "metabase/lib/name";
import type { UrlableModel } from "metabase/lib/urls/modelToUrl";
import type { MenuItem } from "metabase-enterprise/documents/components/Editor/shared/MenuComponents";
-import type { SuggestionModel } from "metabase-enterprise/documents/components/Editor/types";
import type {
Database,
MentionableUser,
@@ -11,6 +11,8 @@ import type {
} from "metabase-types/api";
import { isObject } from "metabase-types/guards";
+import type { SuggestionModel } from "./types";
+
export const filterRecents = (item: RecentItem, models: SuggestionModel[]) =>
models.includes(item.model);
@@ -80,6 +82,21 @@ export function buildUserMenuItems(
});
}
+export function buildSearchModelMenuItems(
+ searchModels: SuggestionModel[],
+ onSelect: (model: SuggestionModel) => void,
+): MenuItem[] {
+ return searchModels.map((model) => {
+ return {
+ icon: getIcon({ model }).name,
+ label: getTranslatedEntityName(model) || model,
+ model,
+ action: () => onSelect(model),
+ hasSubmenu: true,
+ };
+ });
+}
+
export function entityToUrlableModel<
T extends {
id: string | number;
diff --git a/enterprise/frontend/src/metabase-enterprise/rich_text_editing/tiptap/extensions/shared/types.ts b/enterprise/frontend/src/metabase-enterprise/rich_text_editing/tiptap/extensions/shared/types.ts
new file mode 100644
index 00000000000..f5a29ce8c0c
--- /dev/null
+++ b/enterprise/frontend/src/metabase-enterprise/rich_text_editing/tiptap/extensions/shared/types.ts
@@ -0,0 +1,3 @@
+import type { SearchModel } from "metabase-types/api";
+
+export type SuggestionModel = SearchModel | "transform" | "user";
diff --git a/enterprise/frontend/src/metabase-enterprise/rich_text_editing/tiptap/extensions/shared/useEntitySearch.ts b/enterprise/frontend/src/metabase-enterprise/rich_text_editing/tiptap/extensions/shared/useEntitySearch.ts
index bd438f74538..4f013bc3211 100644
--- a/enterprise/frontend/src/metabase-enterprise/rich_text_editing/tiptap/extensions/shared/useEntitySearch.ts
+++ b/enterprise/frontend/src/metabase-enterprise/rich_text_editing/tiptap/extensions/shared/useEntitySearch.ts
@@ -3,7 +3,6 @@ import { useMemo } from "react";
import { useListRecentsQuery, useSearchQuery } from "metabase/api";
import { useListMentionsQuery } from "metabase-enterprise/api";
import type { MenuItem } from "metabase-enterprise/documents/components/Editor/shared/MenuComponents";
-import type { SuggestionModel } from "metabase-enterprise/documents/components/Editor/types";
import type {
MentionableUser,
RecentItem,
@@ -11,6 +10,8 @@ import type {
SearchResult,
} from "metabase-types/api";
+import type { SuggestionModel } from "../shared/types";
+
import {
LINK_SEARCH_LIMIT,
LINK_SEARCH_MODELS,
@@ -29,6 +30,7 @@ interface UseEntitySearchOptions {
onSelectSearchResult: (item: SearchResult) => void;
onSelectUser: (item: MentionableUser) => void;
enabled?: boolean;
+ shouldFetchRecents?: boolean;
searchModels?: SuggestionModel[];
}
@@ -44,10 +46,9 @@ export function useEntitySearch({
onSelectSearchResult,
onSelectUser,
enabled = true,
+ shouldFetchRecents = true,
searchModels = LINK_SEARCH_MODELS,
}: UseEntitySearchOptions): UseEntitySearchResult {
- const shouldFetchRecents = enabled && query.length === 0;
-
const { data: recents = [], isLoading: isRecentsLoading } =
useListRecentsQuery(undefined, {
refetchOnMountOrArgChange: 10, // only refetch if the cache is more than 10 seconds stale
@@ -73,7 +74,7 @@ export function useEntitySearch({
limit: LINK_SEARCH_LIMIT,
},
{
- skip: !enabled || !query || query.length === 0,
+ skip: !enabled || shouldFetchRecents,
},
);
@@ -98,7 +99,7 @@ export function useEntitySearch({
const menuItems = useMemo(() => {
const items: MenuItem[] = [];
- if (query.length > 0) {
+ if (!shouldFetchRecents) {
if (!isUsersLoading) {
items.push(...buildUserMenuItems(users, onSelectUser));
}
@@ -116,7 +117,7 @@ export function useEntitySearch({
return items;
}, [
- query,
+ shouldFetchRecents,
searchResults,
users,
isSearchLoading,
@@ -128,13 +129,9 @@ export function useEntitySearch({
onSelectUser,
]);
- const isLoading =
- (shouldFetchRecents && isRecentsLoading) ||
- (query.length > 0 && isSearchLoading);
-
return {
menuItems,
- isLoading,
+ isLoading: shouldFetchRecents ? isRecentsLoading : isSearchLoading,
searchResults,
};
}
diff --git a/enterprise/frontend/src/metabase-enterprise/rich_text_editing/tiptap/extensions/shared/useEntitySuggestions.ts b/enterprise/frontend/src/metabase-enterprise/rich_text_editing/tiptap/extensions/shared/useEntitySuggestions.ts
index 488bddcd157..a8b99a9cc17 100644
--- a/enterprise/frontend/src/metabase-enterprise/rich_text_editing/tiptap/extensions/shared/useEntitySuggestions.ts
+++ b/enterprise/frontend/src/metabase-enterprise/rich_text_editing/tiptap/extensions/shared/useEntitySuggestions.ts
@@ -1,21 +1,26 @@
-import type { Editor } from "@tiptap/core";
-import { useCallback, useEffect, useState } from "react";
+import type { Editor, Range } from "@tiptap/core";
+import { useCallback, useEffect, useMemo, useState } from "react";
import type { QuestionPickerValueItem } from "metabase/common/components/Pickers/QuestionPicker/types";
+import { getTranslatedEntityName } from "metabase/common/utils/model-names";
import { modelToUrl } from "metabase/lib/urls/modelToUrl";
-import type { SuggestionModel } from "metabase-enterprise/documents/components/Editor/types";
import type {
MentionableUser,
RecentItem,
SearchResult,
} from "metabase-types/api";
-import { entityToUrlableModel } from "./suggestionUtils";
+import {
+ buildSearchModelMenuItems,
+ entityToUrlableModel,
+} from "./suggestionUtils";
+import type { SuggestionModel } from "./types";
import { useEntitySearch } from "./useEntitySearch";
interface UseEntitySuggestionsOptions {
query: string;
editor: Editor;
+ range?: Range;
onSelectEntity: (item: {
id: number | string;
model: string;
@@ -24,6 +29,8 @@ interface UseEntitySuggestionsOptions {
}) => void;
enabled?: boolean;
searchModels?: SuggestionModel[];
+ canFilterSearchModels: boolean;
+ canBrowseAll: boolean;
}
interface UseEntitySuggestionsResult {
@@ -33,6 +40,7 @@ interface UseEntitySuggestionsResult {
selectedIndex: number;
modal: "question-picker" | null;
totalItems: number;
+ selectedSearchModelName?: string;
handlers: {
selectItem: (index: number) => void;
upHandler: () => void;
@@ -49,12 +57,17 @@ interface UseEntitySuggestionsResult {
export function useEntitySuggestions({
query,
editor,
+ range,
onSelectEntity,
enabled = true,
searchModels,
+ canFilterSearchModels,
+ canBrowseAll,
}: UseEntitySuggestionsOptions): UseEntitySuggestionsResult {
const [selectedIndex, setSelectedIndex] = useState(0);
const [modal, setModal] = useState<"question-picker" | null>(null);
+ const [selectedSearchModel, setSelectedSearchModel] =
+ useState<SuggestionModel | null>(null);
const handleRecentSelect = useCallback(
(item: RecentItem) => {
@@ -92,16 +105,83 @@ export function useEntitySuggestions({
[onSelectEntity],
);
- const { menuItems, isLoading, searchResults } = useEntitySearch({
+ const handleSearchModelSelect = useCallback(
+ (model: SuggestionModel) => {
+ // clear any input the user made to filter search models
+ if (range) {
+ editor.chain().focus().deleteRange(range).insertContent("@").run();
+ }
+ setSelectedSearchModel(model);
+ setSelectedIndex(0);
+ },
+ [editor, range],
+ );
+
+ const filteredSearchModels = useMemo(() => {
+ if (!searchModels || !canFilterSearchModels) {
+ return undefined;
+ }
+ return searchModels.filter((model) => {
+ const modelName = getTranslatedEntityName(model) ?? "";
+ return modelName.toLowerCase().startsWith(query.toLowerCase());
+ });
+ }, [searchModels, query, canFilterSearchModels]);
+
+ // Use selected model if available, otherwise use filtered models
+ // If no models match the filter but searchModels was provided, fall back to all searchModels
+ const effectiveSearchModels = useMemo(() => {
+ if (selectedSearchModel) {
+ return [selectedSearchModel];
+ }
+ if (
+ searchModels &&
+ (!filteredSearchModels || filteredSearchModels?.length === 0)
+ ) {
+ return searchModels;
+ }
+ return filteredSearchModels;
+ }, [selectedSearchModel, filteredSearchModels, searchModels]);
+
+ const searchModelMenuItems = useMemo(() => {
+ return selectedSearchModel || filteredSearchModels === undefined
+ ? []
+ : buildSearchModelMenuItems(
+ filteredSearchModels,
+ handleSearchModelSelect,
+ );
+ }, [filteredSearchModels, selectedSearchModel, handleSearchModelSelect]);
+
+ const hasSearchModels = (searchModels?.length ?? 0) > 0;
+ const hasMatchingFilteredModels = (filteredSearchModels?.length ?? 0) > 0;
+ const isInModelSelectionMode =
+ !selectedSearchModel && hasSearchModels && hasMatchingFilteredModels;
+
+ const {
+ menuItems: entityMenuItems,
+ isLoading,
+ searchResults,
+ } = useEntitySearch({
query,
onSelectRecent: handleRecentSelect,
onSelectSearchResult: handleSearchResultSelect,
onSelectUser: handleUserSelect,
- enabled,
- searchModels,
+ enabled: enabled && !isInModelSelectionMode,
+ shouldFetchRecents:
+ enabled &&
+ query.length === 0 &&
+ !isInModelSelectionMode &&
+ !selectedSearchModel,
+ searchModels: effectiveSearchModels,
});
- const totalItems = menuItems.length + 1;
+ const menuItems = useMemo(() => {
+ if (isInModelSelectionMode) {
+ return searchModelMenuItems;
+ }
+ return entityMenuItems;
+ }, [isInModelSelectionMode, searchModelMenuItems, entityMenuItems]);
+
+ const totalItems = menuItems.length + Number(canBrowseAll);
const selectItem = useCallback(
(index: number) => {
@@ -182,13 +262,19 @@ export function useEntitySuggestions({
setSelectedIndex(0);
}, [menuItems.length]);
+ // Get the translated name for the selected search model
+ const selectedSearchModelName = selectedSearchModel
+ ? getTranslatedEntityName(selectedSearchModel) || selectedSearchModel
+ : undefined;
+
return {
menuItems,
- isLoading,
+ isLoading: isInModelSelectionMode ? false : isLoading,
searchResults,
selectedIndex,
modal,
totalItems,
+ selectedSearchModelName,
handlers: {
selectItem,
upHandler,
diff --git a/enterprise/frontend/src/metabase-enterprise/rich_text_editing/tiptap/extensions/suggestionRenderer.tsx b/enterprise/frontend/src/metabase-enterprise/rich_text_editing/tiptap/extensions/suggestionRenderer.tsx
index 25bac1e060b..44e4cc0f244 100644
--- a/enterprise/frontend/src/metabase-enterprise/rich_text_editing/tiptap/extensions/suggestionRenderer.tsx
+++ b/enterprise/frontend/src/metabase-enterprise/rich_text_editing/tiptap/extensions/suggestionRenderer.tsx
@@ -1,4 +1,5 @@
import {
+ type Placement,
type VirtualElement,
autoUpdate,
computePosition,
@@ -11,11 +12,33 @@ import type {
SuggestionKeyDownProps,
SuggestionProps,
} from "@tiptap/suggestion";
+import { merge } from "icepick";
import type React from "react";
+type DeepPartial<T> = {
+ [K in keyof T]?: T[K] extends object ? DeepPartial<T[K]> : T[K];
+};
+
+interface SuggestionRendererOptions {
+ positionOptions: {
+ placement: Placement;
+ fallbackPlacements: Placement[];
+ };
+}
+
+const defaultRendererOptions: SuggestionRendererOptions = {
+ positionOptions: {
+ placement: "bottom-start",
+ fallbackPlacements: ["top-start", "bottom-end", "top-end"],
+ },
+};
+
export const createSuggestionRenderer = <I = unknown, TSelected = unknown>(
SuggestionComponent: React.ComponentType<SuggestionProps<I, TSelected>>,
+ options?: DeepPartial<SuggestionRendererOptions>,
) => {
+ const config = merge(defaultRendererOptions, options);
+
return () => {
let component: ReactRenderer | undefined;
let currentClientRect: (() => DOMRect | null) | null | undefined;
@@ -42,11 +65,11 @@ export const createSuggestionRenderer = <I = unknown, TSelected = unknown>(
};
computePosition(virtualElement, element, {
- placement: "bottom-start",
+ placement: config.positionOptions.placement,
strategy: "fixed",
middleware: [
flip({
- fallbackPlacements: ["top-start", "bottom-end", "top-end"],
+ fallbackPlacements: config.positionOptions.fallbackPlacements,
padding: 4,
}),
shift({
diff --git a/enterprise/frontend/src/metabase-enterprise/transforms-python/components/PythonEditor/PythonEditor.tsx b/enterprise/frontend/src/metabase-enterprise/transforms-python/components/PythonEditor/PythonEditor.tsx
index bfa7b07b872..350b42c0f7e 100644
--- a/enterprise/frontend/src/metabase-enterprise/transforms-python/components/PythonEditor/PythonEditor.tsx
+++ b/enterprise/frontend/src/metabase-enterprise/transforms-python/components/PythonEditor/PythonEditor.tsx
@@ -7,6 +7,7 @@ import { completion } from "./utils";
export function PythonEditor({
value,
+ proposedValue,
onChange,
withPandasCompletions,
className,
@@ -14,6 +15,8 @@ export function PythonEditor({
...rest
}: {
value: string;
+ proposedValue?: string;
+
onChange?: (value: string) => void;
withPandasCompletions?: boolean;
className?: string;
@@ -23,6 +26,7 @@ export function PythonEditor({
<CodeEditor
className={cx(S.editor, className)}
value={value}
+ proposedValue={proposedValue}
onChange={onChange}
language="python"
extensions={withPandasCompletions ? completion : undefined}
diff --git a/enterprise/frontend/src/metabase-enterprise/transforms-python/components/PythonTransformEditor/PythonDataPicker/PythonDataPicker.tsx b/enterprise/frontend/src/metabase-enterprise/transforms-python/components/PythonTransformEditor/PythonDataPicker/PythonDataPicker.tsx
index 7d5595e44bc..53f6ef31094 100644
--- a/enterprise/frontend/src/metabase-enterprise/transforms-python/components/PythonTransformEditor/PythonDataPicker/PythonDataPicker.tsx
+++ b/enterprise/frontend/src/metabase-enterprise/transforms-python/components/PythonTransformEditor/PythonDataPicker/PythonDataPicker.tsx
@@ -1,4 +1,4 @@
-import { useState } from "react";
+import { useEffect, useState } from "react";
import { t } from "ttag";
import { hasFeature } from "metabase/admin/databases/utils";
@@ -47,6 +47,10 @@ export function PythonDataPicker({
getInitialTableSelections(tables),
);
+ useEffect(() => {
+ setTableSelections(getInitialTableSelections(tables));
+ }, [tables]);
+
const {
data: databases,
isLoading: isLoadingDatabases,
diff --git a/enterprise/frontend/src/metabase-enterprise/transforms-python/components/PythonTransformEditor/PythonEditorBody/PythonEditorBody.tsx b/enterprise/frontend/src/metabase-enterprise/transforms-python/components/PythonTransformEditor/PythonEditorBody/PythonEditorBody.tsx
index cc5675009d4..4176f8761e9 100644
--- a/enterprise/frontend/src/metabase-enterprise/transforms-python/components/PythonTransformEditor/PythonEditorBody/PythonEditorBody.tsx
+++ b/enterprise/frontend/src/metabase-enterprise/transforms-python/components/PythonTransformEditor/PythonEditorBody/PythonEditorBody.tsx
@@ -5,7 +5,7 @@ import { t } from "ttag";
import Link from "metabase/common/components/Link";
import * as Urls from "metabase/lib/urls";
import RunButtonWithTooltip from "metabase/query_builder/components/RunButtonWithTooltip";
-import { Box, Checkbox, Flex, Icon, Stack } from "metabase/ui";
+import { Box, Button, Checkbox, Flex, Icon, Stack, Tooltip } from "metabase/ui";
import { SHARED_LIB_IMPORT_PATH } from "metabase-enterprise/transforms-python/constants";
import { PythonEditor } from "../../PythonEditor";
@@ -16,6 +16,7 @@ import { hasImport, insertImport, removeImport } from "./utils";
type PythonEditorBodyProps = {
source: string;
+ proposedSource?: string;
isRunnable: boolean;
onChange: (source: string) => void;
onRun?: () => void;
@@ -24,12 +25,15 @@ type PythonEditorBodyProps = {
isDirty?: boolean;
tables?: Record<string, number>;
withDebugger?: boolean;
+ onAcceptProposed?: () => void;
+ onRejectProposed?: () => void;
};
const EDITOR_HEIGHT = 400;
export function PythonEditorBody({
source,
+ proposedSource,
onChange,
isRunnable,
onRun,
@@ -37,29 +41,62 @@ export function PythonEditorBody({
isRunning,
isDirty,
withDebugger,
+ onAcceptProposed,
+ onRejectProposed,
}: PythonEditorBodyProps) {
return (
<MaybeResizableBox resizable={withDebugger}>
<Flex h="100%" align="end" bg="bg-light" pos="relative">
<PythonEditor
value={source}
+ proposedValue={proposedSource}
onChange={onChange}
withPandasCompletions
data-testid="python-editor"
/>
- {withDebugger && (
- <Box p="md">
- <RunButtonWithTooltip
- disabled={!isRunnable}
- isRunning={isRunning}
- isDirty={isDirty}
- onRun={onRun}
- onCancel={onCancel}
- getTooltip={() => t`Run Python script`}
- />
- </Box>
- )}
+ <Stack m="1rem" gap="md" mt="auto">
+ {proposedSource && onRejectProposed && onAcceptProposed && (
+ <>
+ <Tooltip label={t`Accept proposed changes`} position="left">
+ <Button
+ data-testid="accept-proposed-changes-button"
+ variant="filled"
+ bg="success"
+ px="0"
+ w="2.5rem"
+ onClick={onAcceptProposed}
+ >
+ <Icon name="check" />
+ </Button>
+ </Tooltip>
+ <Tooltip label={t`Reject proposed changes`} position="left">
+ <Button
+ data-testid="reject-proposed-changes-button"
+ w="2.5rem"
+ px="0"
+ variant="filled"
+ bg="danger"
+ onClick={onRejectProposed}
+ >
+ <Icon name="close" />
+ </Button>
+ </Tooltip>
+ </>
+ )}
+ {withDebugger && (
+ <Box p="md">
+ <RunButtonWithTooltip
+ disabled={!isRunnable}
+ isRunning={isRunning}
+ isDirty={isDirty}
+ onRun={onRun}
+ onCancel={onCancel}
+ getTooltip={() => t`Run Python script`}
+ />
+ </Box>
+ )}
+ </Stack>
<SharedLibraryActions source={source} onChange={onChange} />
</Flex>
</MaybeResizableBox>
diff --git a/enterprise/frontend/src/metabase-enterprise/transforms-python/components/PythonTransformEditor/PythonTransformEditor.tsx b/enterprise/frontend/src/metabase-enterprise/transforms-python/components/PythonTransformEditor/PythonTransformEditor.tsx
index 567229fea9f..7b51e03bcee 100644
--- a/enterprise/frontend/src/metabase-enterprise/transforms-python/components/PythonTransformEditor/PythonTransformEditor.tsx
+++ b/enterprise/frontend/src/metabase-enterprise/transforms-python/components/PythonTransformEditor/PythonTransformEditor.tsx
@@ -3,11 +3,13 @@ import { useState } from "react";
import { Flex, Stack } from "metabase/ui";
import { EditorHeader } from "metabase-enterprise/transforms/components/QueryEditor/EditorHeader";
+import { useRegisterMetabotTransformContext } from "metabase-enterprise/transforms/hooks/use-register-transform-metabot-context";
import type {
- DatabaseId,
PythonTransformSource,
+ PythonTransformSourceDraft,
PythonTransformTableAliases,
Table,
+ Transform,
} from "metabase-types/api";
import { PythonDataPicker } from "./PythonDataPicker";
@@ -21,33 +23,39 @@ import {
useTestPythonTransform,
} from "./utils";
-export type PythonTransformSourceDraft = {
- type: "python";
- body: string;
- "source-database": DatabaseId | undefined;
- "source-tables": PythonTransformTableAliases;
-};
-
export type PythonTransformEditorProps = {
+ transform?: Transform | undefined;
initialSource: PythonTransformSourceDraft;
+ proposedSource?: PythonTransformSource;
isNew?: boolean;
isSaving?: boolean;
isRunnable?: boolean;
+ onChange?: (newSource: PythonTransformSourceDraft) => void;
onSave: (newSource: PythonTransformSource) => void;
onCancel: () => void;
+ onRejectProposed?: () => void;
+ onAcceptProposed?: (query: PythonTransformSource) => void;
};
export function PythonTransformEditor({
+ transform,
initialSource,
+ proposedSource,
isNew = true,
isSaving = false,
isRunnable = true,
+ onChange,
onSave,
onCancel,
+ onRejectProposed,
+ onAcceptProposed,
}: PythonTransformEditorProps) {
const [source, setSource] = useState(initialSource);
+ const saveSource = proposedSource ?? source;
const [isSourceDirty, setIsSourceDirty] = useState(false);
+ useRegisterMetabotTransformContext(transform, proposedSource ?? source);
+
const { isRunning, isDirty, cancel, run, executionResult } =
useTestPythonTransform(source);
@@ -58,6 +66,7 @@ export function PythonTransformEditor({
};
setSource(newSource);
setIsSourceDirty(true);
+ onChange?.(newSource);
};
const handleDataChange = (
@@ -82,11 +91,20 @@ export function PythonTransformEditor({
};
const handleSave = () => {
- if (isPythonTransformSource(source)) {
- onSave(source);
+ if (isPythonTransformSource(saveSource)) {
+ onSave(saveSource);
}
};
+ const handleAcceptProposed =
+ proposedSource && onAcceptProposed
+ ? () => {
+ setSource(proposedSource);
+ setIsSourceDirty(true);
+ onAcceptProposed(proposedSource);
+ }
+ : undefined;
+
const showDebugger = useShouldShowPythonDebugger();
const handleCmdEnter = () => {
@@ -95,14 +113,14 @@ export function PythonTransformEditor({
}
if (isRunning) {
cancel();
- } else if (isRunnable && isPythonTransformSource(source)) {
+ } else if (isRunnable && isPythonTransformSource(saveSource)) {
run();
}
};
useHotkeys([["mod+Enter", handleCmdEnter]], []);
- const validationResult = getValidationResult(source);
+ const validationResult = getValidationResult(saveSource);
return (
<Stack
@@ -115,6 +133,7 @@ export function PythonTransformEditor({
<EditorHeader
isNew={isNew}
isSaving={isSaving}
+ hasProposedQuery={!!proposedSource}
onSave={handleSave}
onCancel={onCancel}
validationResult={validationResult}
@@ -122,8 +141,8 @@ export function PythonTransformEditor({
/>
<Flex h="100%" w="100%">
<PythonDataPicker
- database={source["source-database"]}
- tables={source["source-tables"]}
+ database={saveSource["source-database"]}
+ tables={saveSource["source-tables"]}
onChange={handleDataChange}
/>
<Stack w="100%" h="100%" gap={0}>
@@ -134,8 +153,11 @@ export function PythonTransformEditor({
onRun={run}
onCancel={cancel}
source={source.body}
+ proposedSource={proposedSource?.body}
onChange={handleScriptChange}
withDebugger={showDebugger}
+ onAcceptProposed={handleAcceptProposed}
+ onRejectProposed={onRejectProposed}
/>
{showDebugger && (
<PythonEditorResults
diff --git a/enterprise/frontend/src/metabase-enterprise/transforms-python/components/PythonTransformEditor/utils.ts b/enterprise/frontend/src/metabase-enterprise/transforms-python/components/PythonTransformEditor/utils.ts
index 95ebe40a3f5..1340277d1ad 100644
--- a/enterprise/frontend/src/metabase-enterprise/transforms-python/components/PythonTransformEditor/utils.ts
+++ b/enterprise/frontend/src/metabase-enterprise/transforms-python/components/PythonTransformEditor/utils.ts
@@ -7,13 +7,12 @@ import { useExecutePythonMutation } from "metabase-enterprise/api/transform-pyth
import type {
ExecutePythonTransformResponse,
PythonTransformSource,
+ PythonTransformSourceDraft,
PythonTransformTableAliases,
Table,
TableId,
} from "metabase-types/api";
-import type { PythonTransformSourceDraft } from "./PythonTransformEditor";
-
export function updateTransformSignature(
script: string,
tables: PythonTransformTableAliases,
diff --git a/enterprise/frontend/src/metabase-enterprise/transforms/components/QueryEditor/EditorBody/EditorBody.tsx b/enterprise/frontend/src/metabase-enterprise/transforms/components/QueryEditor/EditorBody/EditorBody.tsx
index 16f7793fb77..8d681b5cd90 100644
--- a/enterprise/frontend/src/metabase-enterprise/transforms/components/QueryEditor/EditorBody/EditorBody.tsx
+++ b/enterprise/frontend/src/metabase-enterprise/transforms/components/QueryEditor/EditorBody/EditorBody.tsx
@@ -17,6 +17,7 @@ import type Database from "metabase-lib/v1/metadata/Database";
import type NativeQuery from "metabase-lib/v1/queries/NativeQuery";
import type {
Database as ApiDatabase,
+ DatasetQuery,
NativeQuerySnippet,
RecentItem,
} from "metabase-types/api";
@@ -60,6 +61,9 @@ type EditorBodyProps = {
nativeEditorSelectedText?: string | null;
databases: ApiDatabase[];
+ proposedQuestion?: Question;
+ onRejectProposed?: () => void;
+ onAcceptProposed?: (query: DatasetQuery) => void;
};
export function EditorBody({
@@ -82,6 +86,9 @@ export function EditorBody({
onChangeNativeEditorSelection,
nativeEditorSelectedText,
onOpenModal,
+ proposedQuestion,
+ onRejectProposed,
+ onAcceptProposed,
}: EditorBodyProps) {
const [isResizing, setIsResizing] = useState(false);
const reportTimezone = useSetting("report-timezone-long");
@@ -149,6 +156,9 @@ export function EditorBody({
setNativeEditorSelectedRange={onChangeNativeEditorSelection}
nativeEditorSelectedText={nativeEditorSelectedText}
onOpenModal={onOpenModal}
+ proposedQuestion={proposedQuestion}
+ onRejectProposed={onRejectProposed}
+ onAcceptProposed={onAcceptProposed}
/>
) : (
<ResizableBox
diff --git a/enterprise/frontend/src/metabase-enterprise/transforms/components/QueryEditor/EditorHeader/EditorHeader.tsx b/enterprise/frontend/src/metabase-enterprise/transforms/components/QueryEditor/EditorHeader/EditorHeader.tsx
index ebb83b57361..b224302f2c7 100644
--- a/enterprise/frontend/src/metabase-enterprise/transforms/components/QueryEditor/EditorHeader/EditorHeader.tsx
+++ b/enterprise/frontend/src/metabase-enterprise/transforms/components/QueryEditor/EditorHeader/EditorHeader.tsx
@@ -8,27 +8,33 @@ import type { QueryValidationResult } from "../types";
type EditorHeaderProps = {
validationResult: QueryValidationResult;
+ name?: string;
isNew: boolean;
isQueryDirty: boolean;
isSaving: boolean;
+ hasProposedQuery: boolean;
onSave: () => void;
onCancel: () => void;
};
export function EditorHeader({
validationResult,
+ name,
isNew,
isQueryDirty,
isSaving,
+ hasProposedQuery,
onSave,
onCancel,
}: EditorHeaderProps) {
const canSave =
- (isNew || isQueryDirty) && validationResult.isValid && !isSaving;
+ (isNew || isQueryDirty || hasProposedQuery) &&
+ validationResult.isValid &&
+ !isSaving;
return (
<EditBar
- title={getTitle(isNew)}
+ title={getTitle(isNew, name)}
admin
buttons={[
<Button key="cancel" small onClick={onCancel}>{t`Cancel`}</Button>,
@@ -46,11 +52,11 @@ export function EditorHeader({
);
}
-function getTitle(isNew: boolean) {
+function getTitle(isNew: boolean, name?: string) {
if (isNew) {
return t`You’re creating a new transform`;
} else {
- return t`You’re editing a transform`;
+ return t`You’re editing the "${name}" transform`;
}
}
diff --git a/enterprise/frontend/src/metabase-enterprise/transforms/components/QueryEditor/QueryEditor.tsx b/enterprise/frontend/src/metabase-enterprise/transforms/components/QueryEditor/QueryEditor.tsx
index 9a23794e27f..beb6f713fb8 100644
--- a/enterprise/frontend/src/metabase-enterprise/transforms/components/QueryEditor/QueryEditor.tsx
+++ b/enterprise/frontend/src/metabase-enterprise/transforms/components/QueryEditor/QueryEditor.tsx
@@ -1,5 +1,5 @@
import { useDisclosure, useHotkeys, useToggle } from "@mantine/hooks";
-import { useState } from "react";
+import { useMemo, useState } from "react";
import { t } from "ttag";
import { useListDatabasesQuery } from "metabase/api";
@@ -7,11 +7,13 @@ import type { SelectionRange } from "metabase/query_builder/components/NativeQue
import type { QueryModalType } from "metabase/query_builder/constants";
import { NativeQueryPreview } from "metabase/querying/notebook/components/NativeQueryPreview";
import { Center, Flex, Loader, Modal, Stack } from "metabase/ui";
+import { useRegisterMetabotTransformContext } from "metabase-enterprise/transforms/hooks/use-register-transform-metabot-context";
import * as Lib from "metabase-lib";
import type Question from "metabase-lib/v1/Question";
import type {
NativeQuerySnippet,
QueryTransformSource,
+ Transform,
} from "metabase-types/api";
import { useQueryMetadata } from "../../hooks/use-query-metadata";
@@ -35,23 +37,32 @@ import {
} from "./utils";
type QueryEditorProps = {
+ transform?: Transform | undefined;
initialSource: QueryTransformSource;
+ proposedSource?: QueryTransformSource;
isNew?: boolean;
isSaving?: boolean;
onSave: (source: QueryTransformSource) => void;
+ onChange?: (source: QueryTransformSource) => void;
onCancel: () => void;
+ onRejectProposed?: () => void;
+ onAcceptProposed?: (query: QueryTransformSource) => void;
};
export function QueryEditor({
+ transform,
initialSource,
+ proposedSource,
isNew = true,
isSaving = false,
onSave,
+ onChange,
onCancel,
+ onRejectProposed,
+ onAcceptProposed,
}: QueryEditorProps) {
- const { question, isQueryDirty, setQuestion } = useQueryState(
- initialSource.query,
- );
+ const { question, proposedQuestion, isQueryDirty, setQuestion } =
+ useQueryState(initialSource.query, proposedSource?.query);
const { isInitiallyLoaded } = useQueryMetadata(question);
const {
result,
@@ -61,18 +72,28 @@ export function QueryEditor({
isResultDirty,
runQuery,
cancelQuery,
- } = useQueryResults(question);
+ } = useQueryResults(question, proposedQuestion);
const { isNative } = Lib.queryDisplayInfo(question.query());
const [isShowingNativeQueryPreview, toggleNativeQueryPreview] = useToggle();
const [isPreviewQueryModalOpen, togglePreviewQueryModal] = useToggle();
const validationResult = getValidationResult(question.query());
+ const source = useMemo(() => {
+ const query = proposedSource?.query ?? question.datasetQuery();
+ return { type: "query" as const, query };
+ }, [proposedSource, question]);
+ useRegisterMetabotTransformContext(transform, source);
+
const handleChange = async (newQuestion: Question) => {
setQuestion(newQuestion);
+ onChange?.({ type: "query", query: newQuestion.datasetQuery() });
};
const handleSave = () => {
- onSave({ type: "query", query: question.datasetQuery() });
+ onSave({
+ type: "query",
+ query: proposedQuestion?.datasetQuery() ?? question.datasetQuery(),
+ });
};
const handleCmdEnter = () => {
@@ -147,8 +168,10 @@ export function QueryEditor({
>
<EditorHeader
validationResult={validationResult}
+ name={transform?.name}
isNew={isNew}
isSaving={isSaving}
+ hasProposedQuery={!!proposedSource}
isQueryDirty={isQueryDirty}
onSave={handleSave}
onCancel={onCancel}
@@ -157,6 +180,7 @@ export function QueryEditor({
<Stack flex="2 1 100%" pos="relative">
<EditorBody
question={question}
+ proposedQuestion={proposedQuestion}
isNative={isNative}
isRunnable={isRunnable}
isRunning={isRunning}
@@ -166,6 +190,12 @@ export function QueryEditor({
onChange={handleChange}
onRunQuery={runQuery}
onCancelQuery={cancelQuery}
+ onRejectProposed={onRejectProposed}
+ onAcceptProposed={
+ proposedSource
+ ? () => onAcceptProposed?.(proposedSource)
+ : undefined
+ }
databases={databases?.data ?? []}
onToggleDataReference={handleToggleDataReference}
onToggleSnippetSidebar={handleToggleSnippetSidebar}
@@ -187,7 +217,6 @@ export function QueryEditor({
onRunQuery={runQuery}
onCancelQuery={() => undefined}
/>
-
{!isNative && (
<NativeQuerySidebarToggle
isShowingNativeQueryPreview={isShowingNativeQueryPreview}
diff --git a/enterprise/frontend/src/metabase-enterprise/transforms/hooks/use-query-results/use-query-results.ts b/enterprise/frontend/src/metabase-enterprise/transforms/hooks/use-query-results/use-query-results.ts
index f75e518a5f7..71d7e8f4ad4 100644
--- a/enterprise/frontend/src/metabase-enterprise/transforms/hooks/use-query-results/use-query-results.ts
+++ b/enterprise/frontend/src/metabase-enterprise/transforms/hooks/use-query-results/use-query-results.ts
@@ -9,7 +9,10 @@ import * as Lib from "metabase-lib";
import Question from "metabase-lib/v1/Question";
import type { DatasetQuery } from "metabase-types/api";
-export function useQueryResults(question: Question) {
+export function useQueryResults(
+ question: Question,
+ proposedQuestion?: Question,
+) {
const metadata = useSelector(getMetadata);
const [lastRunQuery, setLastRunQuery] = useState<DatasetQuery | null>(null);
const deferredRef = useRef<Deferred>();
@@ -22,12 +25,14 @@ export function useQueryResults(question: Question) {
return deferredRef.current;
}
+ const currentQuestion = proposedQuestion ?? question;
+
const [{ value: results = null, loading: isRunning }, runQuery] = useAsyncFn(
() =>
- runQuestionQuery(question, {
+ runQuestionQuery(currentQuestion, {
cancelDeferred: deferred(),
}),
- [question],
+ [currentQuestion],
);
const { result, rawSeries, isRunnable, isResultDirty } = useMemo(() => {
@@ -35,7 +40,7 @@ export function useQueryResults(question: Question) {
? Question.create({
dataset_query: lastRunQuery,
metadata,
- visualization_settings: question.settings(),
+ visualization_settings: currentQuestion.settings(),
})
: null;
const result = results ? results[0] : null;
@@ -43,9 +48,13 @@ export function useQueryResults(question: Question) {
lastRunQuestion && result
? [{ card: lastRunQuestion.card(), data: result.data }]
: null;
- const isRunnable = Lib.canRun(question.query(), question.type());
+ const isRunnable = Lib.canRun(
+ currentQuestion.query(),
+ currentQuestion.type(),
+ );
const isResultDirty =
- lastRunQuestion == null || question.isDirtyComparedTo(lastRunQuestion);
+ lastRunQuestion == null ||
+ currentQuestion.isDirtyComparedTo(lastRunQuestion);
return {
result,
@@ -53,12 +62,12 @@ export function useQueryResults(question: Question) {
isRunnable,
isResultDirty,
};
- }, [question, results, metadata, lastRunQuery]);
+ }, [currentQuestion, results, metadata, lastRunQuery]);
const handleRunQuery = useCallback(async () => {
await runQuery();
- setLastRunQuery(question.datasetQuery());
- }, [question, runQuery]);
+ setLastRunQuery(currentQuestion.datasetQuery());
+ }, [currentQuestion, runQuery]);
const handleCancelQuery = useCallback(() => {
return deferredRef.current?.resolve();
diff --git a/enterprise/frontend/src/metabase-enterprise/transforms/hooks/use-query-state/use-query-state.ts b/enterprise/frontend/src/metabase-enterprise/transforms/hooks/use-query-state/use-query-state.ts
index c2a5aa357b0..48c0a890fe6 100644
--- a/enterprise/frontend/src/metabase-enterprise/transforms/hooks/use-query-state/use-query-state.ts
+++ b/enterprise/frontend/src/metabase-enterprise/transforms/hooks/use-query-state/use-query-state.ts
@@ -10,7 +10,10 @@ const DEFAULT_VIZ_SETTINGS: VisualizationSettings = {
"table.pivot": false,
};
-export function useQueryState(initialQuery: DatasetQuery) {
+export function useQueryState(
+ initialQuery: DatasetQuery,
+ proposedQuery?: DatasetQuery,
+) {
const [query, setQuery] = useState(initialQuery);
const metadata = useSelector(getMetadata);
@@ -24,6 +27,30 @@ export function useQueryState(initialQuery: DatasetQuery) {
[query, metadata],
);
+ const proposedQuestion = useMemo(() => {
+ if (!proposedQuery) {
+ return undefined;
+ }
+
+ const question = Question.create({
+ dataset_query: proposedQuery,
+ metadata,
+ });
+ const { isNative } = Lib.queryDisplayInfo(question.query());
+
+ if (isNative) {
+ const nativeQuery = question.legacyNativeQuery();
+ if (nativeQuery) {
+ const queryText = nativeQuery.queryText();
+ // For native queries, ensure template tags are processed
+ const updatedQuery = nativeQuery.setQueryText(queryText);
+ return updatedQuery.question();
+ }
+ }
+
+ return question;
+ }, [proposedQuery, metadata]);
+
const isQueryDirty = useMemo(
() => !Lib.areLegacyQueriesEqual(query, initialQuery),
[query, initialQuery],
@@ -33,5 +60,5 @@ export function useQueryState(initialQuery: DatasetQuery) {
setQuery(newQuestion.datasetQuery());
};
- return { question, isQueryDirty, setQuestion };
+ return { question, proposedQuestion, isQueryDirty, setQuestion };
}
diff --git a/enterprise/frontend/src/metabase-enterprise/transforms/hooks/use-register-transform-metabot-context.ts b/enterprise/frontend/src/metabase-enterprise/transforms/hooks/use-register-transform-metabot-context.ts
new file mode 100644
index 00000000000..9ecd8397e26
--- /dev/null
+++ b/enterprise/frontend/src/metabase-enterprise/transforms/hooks/use-register-transform-metabot-context.ts
@@ -0,0 +1,18 @@
+import { useRegisterMetabotContextProvider } from "metabase/metabot";
+import type {
+ PythonTransformSourceDraft,
+ SuggestedTransform,
+ Transform,
+ TransformSource,
+} from "metabase-types/api";
+
+export const useRegisterMetabotTransformContext = (
+ transform: Transform | SuggestedTransform | undefined,
+ source: TransformSource | PythonTransformSourceDraft,
+) => {
+ useRegisterMetabotContextProvider(async () => {
+ return {
+ user_is_viewing: [{ type: "transform", ...(transform || {}), source }],
+ };
+ }, [transform, source]);
+};
diff --git a/enterprise/frontend/src/metabase-enterprise/transforms/hooks/use-source-state.ts b/enterprise/frontend/src/metabase-enterprise/transforms/hooks/use-source-state.ts
new file mode 100644
index 00000000000..24d35b504c2
--- /dev/null
+++ b/enterprise/frontend/src/metabase-enterprise/transforms/hooks/use-source-state.ts
@@ -0,0 +1,75 @@
+import { useCallback, useMemo, useState } from "react";
+import _ from "underscore";
+
+import { useDispatch, useSelector } from "metabase/lib/redux";
+import {
+ type MetabotSuggestedTransform,
+ deactivateSuggestedTransform,
+ getMetabotSuggestedTransform,
+} from "metabase-enterprise/metabot/state";
+import type { Transform, TransformSource } from "metabase-types/api";
+
+interface UseSourceStateResult<SourceType> {
+ source: SourceType | TransformSource;
+ setSource: (source: SourceType) => void;
+ suggestedTransform: MetabotSuggestedTransform | undefined;
+ proposedSource: TransformSource | undefined;
+ clearProposed: () => void;
+ acceptProposed: (source: TransformSource) => void;
+ isDirty: boolean;
+}
+
+export const useSourceState = <SourceType>(
+ transformId: Transform["id"] | undefined,
+ initialSource: SourceType,
+): UseSourceStateResult<SourceType> => {
+ const dispatch = useDispatch();
+
+ const [source, setSource] = useState<SourceType | TransformSource>(
+ initialSource,
+ );
+
+ const suggestedTransform = useSelector(
+ (state) => getMetabotSuggestedTransform(state, transformId) as any,
+ ) as ReturnType<typeof getMetabotSuggestedTransform>;
+
+ const isPropsedSame = useMemo(
+ () => _.isEqual(suggestedTransform?.source, source),
+ [suggestedTransform?.source, source],
+ );
+ const proposedSource = isPropsedSame ? undefined : suggestedTransform?.source;
+
+ const isDirty = useMemo(() => {
+ return !_.isEqual(initialSource, source) || !!proposedSource;
+ }, [initialSource, source, proposedSource]);
+
+ const handleSetSource = useCallback(
+ (source: SourceType) => {
+ dispatch(deactivateSuggestedTransform(suggestedTransform?.id));
+ setSource(source);
+ },
+ [dispatch, suggestedTransform],
+ );
+
+ const clearProposed = useCallback(() => {
+ dispatch(deactivateSuggestedTransform(suggestedTransform?.id));
+ }, [dispatch, suggestedTransform]);
+
+ const acceptProposed = useCallback(
+ async (source: TransformSource) => {
+ setSource(source);
+ dispatch(deactivateSuggestedTransform(suggestedTransform?.id));
+ },
+ [dispatch, suggestedTransform],
+ );
+
+ return {
+ source,
+ setSource: handleSetSource,
+ isDirty,
+ suggestedTransform,
+ proposedSource,
+ clearProposed,
+ acceptProposed,
+ };
+};
diff --git a/enterprise/frontend/src/metabase-enterprise/transforms/pages/NewTransformPage/CreateTransformModal/CreateTransformModal.tsx b/enterprise/frontend/src/metabase-enterprise/transforms/pages/NewTransformPage/CreateTransformModal/CreateTransformModal.tsx
index a1b9fbfa259..1f473d5cccf 100644
--- a/enterprise/frontend/src/metabase-enterprise/transforms/pages/NewTransformPage/CreateTransformModal/CreateTransformModal.tsx
+++ b/enterprise/frontend/src/metabase-enterprise/transforms/pages/NewTransformPage/CreateTransformModal/CreateTransformModal.tsx
@@ -28,14 +28,25 @@ import type {
TransformSource,
} from "metabase-types/api";
+const NEW_TRANSFORM_SCHEMA = Yup.object({
+ name: Yup.string().required(Errors.required),
+ description: Yup.string().nullable(),
+ targetName: Yup.string().required(Errors.required),
+ targetSchema: Yup.string().nullable(),
+});
+
+export type NewTransformValues = Yup.InferType<typeof NEW_TRANSFORM_SCHEMA>;
+
type CreateTransformModalProps = {
source: TransformSource;
+ initValues?: Partial<NewTransformValues>;
onCreate: (transform: Transform) => void;
onClose: () => void;
};
export function CreateTransformModal({
source,
+ initValues,
onCreate,
onClose,
}: CreateTransformModalProps) {
@@ -44,6 +55,7 @@ export function CreateTransformModal({
<FocusTrap.InitialFocus />
<CreateTransformForm
source={source}
+ initValues={initValues}
onCreate={onCreate}
onClose={onClose}
/>
@@ -53,26 +65,14 @@ export function CreateTransformModal({
type CreateTransformFormProps = {
source: TransformSource;
+ initValues?: Partial<NewTransformValues>;
onCreate: (transform: Transform) => void;
onClose: () => void;
};
-type NewTransformValues = {
- name: string;
- description: string | null;
- targetName: string;
- targetSchema: string | null;
-};
-
-const NEW_TRANSFORM_SCHEMA = Yup.object({
- name: Yup.string().required(Errors.required),
- description: Yup.string().nullable(),
- targetName: Yup.string().required(Errors.required),
- targetSchema: Yup.string().nullable(),
-});
-
function CreateTransformForm({
source,
+ initValues,
onCreate,
onClose,
}: CreateTransformFormProps) {
@@ -100,8 +100,8 @@ function CreateTransformForm({
const supportsSchemas = database && hasFeature(database, "schemas");
const initialValues: NewTransformValues = useMemo(
- () => getInitialValues(schemas),
- [schemas],
+ () => getInitialValues(schemas, initValues),
+ [schemas, initValues],
);
if (isLoading || error != null) {
@@ -165,12 +165,16 @@ function CreateTransformForm({
);
}
-function getInitialValues(schemas: string[]): NewTransformValues {
+function getInitialValues(
+ schemas: string[],
+ initValues?: Partial<NewTransformValues>,
+): NewTransformValues {
return {
name: "",
description: null,
targetName: "",
targetSchema: schemas?.[0] || null,
+ ...initValues,
};
}
@@ -186,7 +190,7 @@ function getCreateRequest(
target: {
type: "table",
name: targetName,
- schema: targetSchema,
+ schema: targetSchema ?? null,
database: databaseId,
},
};
diff --git a/enterprise/frontend/src/metabase-enterprise/transforms/pages/NewTransformPage/NewTransformPage.tsx b/enterprise/frontend/src/metabase-enterprise/transforms/pages/NewTransformPage/NewTransformPage.tsx
index 240b59b0a3f..9f57259205c 100644
--- a/enterprise/frontend/src/metabase-enterprise/transforms/pages/NewTransformPage/NewTransformPage.tsx
+++ b/enterprise/frontend/src/metabase-enterprise/transforms/pages/NewTransformPage/NewTransformPage.tsx
@@ -1,14 +1,22 @@
import { useDisclosure } from "@mantine/hooks";
+import type { Location } from "history";
import { useState } from "react";
+import type { Route } from "react-router";
import { push } from "react-router-redux";
import { skipToken, useGetCardQuery } from "metabase/api";
+import { AdminSettingsLayout } from "metabase/common/components/AdminLayout/AdminSettingsLayout";
+import { LeaveRouteConfirmModal } from "metabase/common/components/LeaveConfirmModal";
import { LoadingAndErrorWrapper } from "metabase/common/components/LoadingAndErrorWrapper";
-import { useDispatch } from "metabase/lib/redux";
+import { useDispatch, useSelector } from "metabase/lib/redux";
import * as Urls from "metabase/lib/urls";
import { PLUGIN_TRANSFORMS_PYTHON } from "metabase/plugins";
+import { getMetabotSuggestedTransform } from "metabase-enterprise/metabot/state";
+import { useSourceState } from "metabase-enterprise/transforms/hooks/use-source-state";
import type {
CardId,
+ DraftTransform,
+ DraftTransformSource,
LegacyDatasetQuery,
Transform,
TransformSource,
@@ -16,10 +24,13 @@ import type {
import { QueryEditor } from "../../components/QueryEditor";
-import { CreateTransformModal } from "./CreateTransformModal";
import {
- getInitialPythonTransformSource,
- getInitialQueryTransformSource,
+ CreateTransformModal,
+ type NewTransformValues,
+} from "./CreateTransformModal";
+import {
+ type InitialTransformSource,
+ getInitialTransformSource,
} from "./utils";
type NewTransformPageParams = {
@@ -33,13 +44,69 @@ type NewTransformPageParsedParams = {
};
type NewTransformPageProps = {
+ location: Location;
params: NewTransformPageParams;
+ route: Route;
};
-export function NewTransformPage({ params }: NewTransformPageProps) {
+export function NewTransformPage({
+ location,
+ route,
+ params,
+}: NewTransformPageProps) {
const { type, cardId } = getParsedParams(params);
- const [source, setSource] = useState<TransformSource | null>(null);
+ const {
+ data: card,
+ isLoading,
+ error,
+ } = useGetCardQuery(cardId ? { id: cardId } : skipToken);
+
+ const suggestedTransform = useSelector(
+ getMetabotSuggestedTransform as any,
+ ) as ReturnType<typeof getMetabotSuggestedTransform>;
+
+ if (isLoading || error) {
+ return <LoadingAndErrorWrapper loading={isLoading} error={error} />;
+ }
+
+ return (
+ <AdminSettingsLayout fullWidth>
+ <NewTransformPageInner
+ route={route}
+ location={location}
+ initialSource={getInitialTransformSource(
+ card,
+ type,
+ suggestedTransform,
+ )}
+ />
+ </AdminSettingsLayout>
+ );
+}
+
+export function NewTransformPageInner({
+ initialSource,
+ location,
+ route,
+}: {
+ initialSource: InitialTransformSource;
+ location: Location;
+ route: Route;
+}) {
+ const {
+ source,
+ setSource,
+ suggestedTransform,
+ proposedSource,
+ acceptProposed,
+ clearProposed,
+ isDirty,
+ } = useSourceState<TransformSource | DraftTransformSource>(
+ undefined,
+ initialSource,
+ );
+
const [isModalOpened, { open: openModal, close: closeModal }] =
useDisclosure();
const dispatch = useDispatch();
@@ -54,76 +121,103 @@ export function NewTransformPage({ params }: NewTransformPageProps) {
};
const handleCancel = () => {
+ setSource(initialSource);
dispatch(push(Urls.transformList()));
+ clearProposed();
+ };
+
+ const [createTransformInitValues, setCreateTransformInitValues] = useState<
+ Partial<NewTransformValues> | undefined
+ >(undefined);
+
+ const handleAcceptProposed = (source: TransformSource) => {
+ if (suggestedTransform) {
+ setCreateTransformInitValues({
+ name: suggestedTransform.name,
+ description: suggestedTransform.description,
+ targetName: suggestedTransform.target.name,
+ });
+ }
+ acceptProposed(source);
};
return (
<>
<NewTransformEditorBody
- type={type}
- cardId={cardId}
+ initialSource={initialSource}
+ proposedSource={proposedSource}
+ onChange={setSource}
onSave={handleSave}
onCancel={handleCancel}
+ onRejectProposed={clearProposed}
+ onAcceptProposed={handleAcceptProposed}
/>
- {isModalOpened && source !== null && (
+ {isModalOpened && source && (
<CreateTransformModal
- source={source}
+ source={source as TransformSource}
+ initValues={createTransformInitValues}
onCreate={handleCreate}
onClose={closeModal}
/>
)}
+ <LeaveRouteConfirmModal
+ key={location.key}
+ isEnabled={isDirty && !isModalOpened}
+ route={route}
+ onConfirm={clearProposed}
+ />
</>
);
}
-function NewTransformEditorBody(props: {
- type: LegacyDatasetQuery["type"] | "python";
- cardId?: CardId;
+interface NewTransformEditorBody {
+ initialSource: InitialTransformSource;
+ proposedSource?: TransformSource;
+ onChange: (source: DraftTransform["source"]) => void;
onSave: (source: TransformSource) => void;
onCancel: () => void;
-}) {
- const { type, ...rest } = props;
- if (type === "python") {
+ onRejectProposed?: () => void;
+ onAcceptProposed?: (query: TransformSource) => void;
+}
+
+function NewTransformEditorBody({
+ initialSource,
+ proposedSource,
+ onChange,
+ onSave,
+ onCancel,
+ onRejectProposed,
+ onAcceptProposed,
+}: NewTransformEditorBody) {
+ if (initialSource.type === "python") {
return (
<PLUGIN_TRANSFORMS_PYTHON.TransformEditor
- initialSource={getInitialPythonTransformSource()}
+ initialSource={initialSource}
+ proposedSource={
+ proposedSource?.type === "python" ? proposedSource : undefined
+ }
isNew
- onSave={props.onSave}
- onCancel={props.onCancel}
+ onSave={onSave}
+ onCancel={onCancel}
+ onChange={onChange}
+ onRejectProposed={onRejectProposed}
+ onAcceptProposed={onAcceptProposed}
/>
);
}
- return <NewQueryTransformEditorBody {...rest} type={type} />;
-}
-
-function NewQueryTransformEditorBody({
- type,
- cardId,
- onSave,
- onCancel,
-}: {
- type: LegacyDatasetQuery["type"];
- cardId?: CardId;
- onSave: (source: TransformSource) => void;
- onCancel: () => void;
-}) {
- const {
- data: card,
- isLoading,
- error,
- } = useGetCardQuery(cardId ? { id: cardId } : skipToken);
-
- if (isLoading || error) {
- return <LoadingAndErrorWrapper loading={isLoading} error={error} />;
- }
-
return (
<QueryEditor
- initialSource={getInitialQueryTransformSource(card, type)}
+ initialSource={initialSource}
+ proposedSource={
+ proposedSource?.type === "query" ? proposedSource : undefined
+ }
isNew
onSave={onSave}
onCancel={onCancel}
+ onChange={onChange}
+ onRejectProposed={onRejectProposed}
+ onAcceptProposed={onAcceptProposed}
/>
);
}
diff --git a/enterprise/frontend/src/metabase-enterprise/transforms/pages/NewTransformPage/utils.ts b/enterprise/frontend/src/metabase-enterprise/transforms/pages/NewTransformPage/utils.ts
index d4f0da959b6..81a928ef234 100644
--- a/enterprise/frontend/src/metabase-enterprise/transforms/pages/NewTransformPage/utils.ts
+++ b/enterprise/frontend/src/metabase-enterprise/transforms/pages/NewTransformPage/utils.ts
@@ -1,10 +1,46 @@
+import { match } from "ts-pattern";
+
import Question from "metabase-lib/v1/Question";
-import type { Card, LegacyDatasetQuery } from "metabase-types/api";
+import type {
+ Card,
+ LegacyDatasetQuery,
+ PythonTransformSourceDraft,
+ QueryTransformSource,
+ SuggestedTransform,
+} from "metabase-types/api";
+
+export type InitialTransformSource =
+ | QueryTransformSource
+ | PythonTransformSourceDraft;
+
+export function getInitialTransformSource(
+ card: Card | undefined,
+ type: LegacyDatasetQuery["type"] | "python",
+ suggestedTransform: SuggestedTransform | undefined,
+): InitialTransformSource {
+ const canUseSuggestedTransform = match({
+ type,
+ suggestionSourceType: suggestedTransform?.source.type,
+ })
+ .with({ type: "native", suggestionSourceType: "query" }, () => true)
+ .with({ type: "python", suggestionSourceType: "python" }, () => true)
+ .otherwise(() => false);
+
+ if (!card?.id && suggestedTransform && canUseSuggestedTransform) {
+ return suggestedTransform.source;
+ }
+
+ if (type === "python") {
+ return getInitialPythonTransformSource();
+ }
+
+ return getInitialQueryTransformSource(card, type);
+}
export function getInitialQueryTransformSource(
card: Card | undefined,
type: LegacyDatasetQuery["type"] | undefined,
-) {
+): QueryTransformSource {
const query =
card != null
? card.dataset_query
@@ -13,7 +49,7 @@ export function getInitialQueryTransformSource(
return { type: "query" as const, query };
}
-export function getInitialPythonTransformSource() {
+export function getInitialPythonTransformSource(): PythonTransformSourceDraft {
return {
type: "python" as const,
"source-database": undefined,
diff --git a/enterprise/frontend/src/metabase-enterprise/transforms/pages/TransformPage/TransformPage.tsx b/enterprise/frontend/src/metabase-enterprise/transforms/pages/TransformPage/TransformPage.tsx
index 88c00236223..0793ba706d4 100644
--- a/enterprise/frontend/src/metabase-enterprise/transforms/pages/TransformPage/TransformPage.tsx
+++ b/enterprise/frontend/src/metabase-enterprise/transforms/pages/TransformPage/TransformPage.tsx
@@ -4,6 +4,7 @@ import { t } from "ttag";
import { skipToken } from "metabase/api";
import { LoadingAndErrorWrapper } from "metabase/common/components/LoadingAndErrorWrapper";
import * as Urls from "metabase/lib/urls";
+import { useRegisterMetabotContextProvider } from "metabase/metabot";
import { PLUGIN_TRANSFORMS_PYTHON } from "metabase/plugins";
import { Stack } from "metabase/ui";
import { useGetTransformQuery } from "metabase-enterprise/api";
@@ -50,6 +51,12 @@ export function TransformPage({ params }: TransformPageProps) {
setIsPolling(isPollingNeeded(transform));
}
+ useRegisterMetabotContextProvider(async () => {
+ return transform
+ ? { user_is_viewing: [{ type: "transform", ...transform }] }
+ : {};
+ }, [transform]);
+
if (isLoading || error != null) {
return <LoadingAndErrorWrapper loading={isLoading} error={error} />;
}
diff --git a/enterprise/frontend/src/metabase-enterprise/transforms/pages/TransformQueryPage/TransformQueryPage.tsx b/enterprise/frontend/src/metabase-enterprise/transforms/pages/TransformQueryPage/TransformQueryPage.tsx
index 9d5fdab6fd2..72c2cdce7e2 100644
--- a/enterprise/frontend/src/metabase-enterprise/transforms/pages/TransformQueryPage/TransformQueryPage.tsx
+++ b/enterprise/frontend/src/metabase-enterprise/transforms/pages/TransformQueryPage/TransformQueryPage.tsx
@@ -1,7 +1,11 @@
+import type { Location } from "history";
+import type { Route } from "react-router";
import { push } from "react-router-redux";
import { t } from "ttag";
import { skipToken } from "metabase/api";
+import { AdminSettingsLayout } from "metabase/common/components/AdminLayout/AdminSettingsLayout";
+import { LeaveRouteConfirmModal } from "metabase/common/components/LeaveConfirmModal";
import { LoadingAndErrorWrapper } from "metabase/common/components/LoadingAndErrorWrapper";
import { useDispatch } from "metabase/lib/redux";
import * as Urls from "metabase/lib/urls";
@@ -14,7 +18,12 @@ import {
useGetTransformQuery,
useUpdateTransformMutation,
} from "metabase-enterprise/api";
-import type { Transform, TransformSource } from "metabase-types/api";
+import { useSourceState } from "metabase-enterprise/transforms/hooks/use-source-state";
+import type {
+ DraftTransformSource,
+ Transform,
+ TransformSource,
+} from "metabase-types/api";
import { QueryEditor } from "../../components/QueryEditor";
@@ -24,9 +33,15 @@ type TransformQueryPageParams = {
type TransformQueryPageProps = {
params: TransformQueryPageParams;
+ location: Location;
+ route: Route;
};
-export function TransformQueryPage({ params }: TransformQueryPageProps) {
+export function TransformQueryPage({
+ params,
+ location,
+ route,
+}: TransformQueryPageProps) {
const transformId = Urls.extractEntityId(params.transformId);
const {
data: transform,
@@ -42,21 +57,34 @@ export function TransformQueryPage({ params }: TransformQueryPageProps) {
return <LoadingAndErrorWrapper error={t`Transform not found.`} />;
}
- return <TransformQueryPageBody transform={transform} />;
+ return (
+ <TransformQueryPageBody
+ transform={transform}
+ location={location}
+ route={route}
+ />
+ );
}
type TransformQueryPageBodyProps = {
transform: Transform;
+ location: Location;
+ route: Route;
};
export function TransformQueryPageBody({
transform,
+ location,
+ route,
}: TransformQueryPageBodyProps) {
const [updateTransform, { isLoading: isSaving }] =
useUpdateTransformMutation();
const dispatch = useDispatch();
const { sendSuccessToast, sendErrorToast } = useMetadataToasts();
+ const { setSource, proposedSource, acceptProposed, clearProposed, isDirty } =
+ useSourceState<DraftTransformSource>(transform.id, transform.source);
+
const {
checkData,
isCheckingDependencies,
@@ -71,6 +99,7 @@ export function TransformQueryPageBody({
sendErrorToast(t`Failed to update transform query`);
} else {
sendSuccessToast(t`Transform query updated`);
+ clearProposed();
dispatch(push(Urls.transform(transform.id)));
}
},
@@ -84,28 +113,24 @@ export function TransformQueryPageBody({
};
const handleCancel = () => {
+ // set to initial source to fix isDirty calc on route leave
+ setSource(transform.source);
+ clearProposed();
dispatch(push(Urls.transform(transform.id)));
};
- if (transform.source.type === "python") {
- return (
- <PLUGIN_TRANSFORMS_PYTHON.TransformEditor
- initialSource={transform.source}
- isNew={false}
- isSaving={isSaving}
- onSave={handleSaveSource}
- onCancel={handleCancel}
- />
- );
- }
return (
- <>
- <QueryEditor
+ <AdminSettingsLayout fullWidth key={transform.id}>
+ <TransformEditorBody
+ transform={transform}
initialSource={transform.source}
- isNew={false}
+ proposedSource={proposedSource}
isSaving={isSaving || isCheckingDependencies}
+ onChange={setSource}
onSave={handleSaveSource}
onCancel={handleCancel}
+ onRejectProposed={clearProposed}
+ onAcceptProposed={acceptProposed}
/>
{isConfirmationShown && checkData != null && (
<PLUGIN_DEPENDENCIES.CheckDependenciesModal
@@ -115,6 +140,72 @@ export function TransformQueryPageBody({
onClose={handleCloseConfirmation}
/>
)}
- </>
+ <LeaveRouteConfirmModal
+ key={location.key}
+ isEnabled={isDirty && !isConfirmationShown && !isSaving}
+ route={route}
+ onConfirm={clearProposed}
+ />
+ </AdminSettingsLayout>
+ );
+}
+
+interface TransformEditorBodyProps {
+ transform: Transform;
+ initialSource: TransformSource;
+ proposedSource?: TransformSource;
+ isSaving?: boolean;
+ onChange?: (source: DraftTransformSource) => void;
+ onSave: (source: TransformSource) => void;
+ onCancel: () => void;
+ onRejectProposed?: () => void;
+ onAcceptProposed?: (source: TransformSource) => void;
+}
+
+function TransformEditorBody({
+ transform,
+ initialSource,
+ proposedSource,
+ isSaving,
+ onChange,
+ onSave,
+ onCancel,
+ onRejectProposed,
+ onAcceptProposed,
+}: TransformEditorBodyProps) {
+ if (initialSource.type === "python") {
+ return (
+ <PLUGIN_TRANSFORMS_PYTHON.TransformEditor
+ transform={transform}
+ initialSource={initialSource}
+ proposedSource={
+ proposedSource?.type === "python" ? proposedSource : undefined
+ }
+ isNew={false}
+ isSaving={isSaving}
+ onChange={onChange}
+ onSave={onSave}
+ onCancel={onCancel}
+ onRejectProposed={onRejectProposed}
+ onAcceptProposed={onAcceptProposed}
+ />
+ );
+ }
+
+ return (
+ <QueryEditor
+ initialSource={initialSource}
+ transform={transform}
+ isNew={false}
+ isSaving={isSaving}
+ onSave={onSave}
+ onChange={onChange}
+ onCancel={onCancel}
+ proposedSource={
+ proposedSource?.type === "query" ? proposedSource : undefined
+ }
+ onRejectProposed={onRejectProposed}
+ onAcceptProposed={onAcceptProposed}
+ />
);
}
diff --git a/frontend/src/metabase-types/api/metabot.ts b/frontend/src/metabase-types/api/metabot.ts
index 92bc6a2bc42..00de7c70814 100644
--- a/frontend/src/metabase-types/api/metabot.ts
+++ b/frontend/src/metabase-types/api/metabot.ts
@@ -4,8 +4,11 @@ import type {
CardType,
DashboardId,
DatasetQuery,
+ DraftTransform,
PaginationResponse,
RowValue,
+ SuggestedTransform,
+ Transform,
UnsavedCard,
Version,
} from ".";
@@ -55,18 +58,6 @@ export type MetabotHistory = any[];
export type MetabotStateContext = Record<string, any>;
-export type MetabotMessageReaction = {
- type: "metabot.reaction/message";
- message: string;
-};
-
-export type MetabotRedirectReaction = {
- type: "metabot.reaction/redirect";
- url: string;
-};
-
-export type MetabotReaction = MetabotMessageReaction | MetabotRedirectReaction;
-
export type MetabotColumnType =
| "number"
| "string"
@@ -133,11 +124,17 @@ export type MetabotDocumentInfo = {
id: number;
};
+export type MetabotTransformInfo =
+ | ({ type: "transform" } & Transform) // edit
+ | ({ type: "transform" } & SuggestedTransform) // edit saved suggested
+ | ({ type: "transform" } & DraftTransform); // edit unsaved suggested
+
export type MetabotEntityInfo =
| MetabotCardInfo
| MetabotDashboardInfo
| MetabotAdhocQueryInfo
- | MetabotDocumentInfo;
+ | MetabotDocumentInfo
+ | MetabotTransformInfo;
/* Metabot v3 - API Request Types */
@@ -152,7 +149,6 @@ export type MetabotAgentRequest = {
};
export type MetabotAgentResponse = {
- reactions: MetabotReaction[];
history: MetabotHistory[];
conversation_id: string;
state: any;
@@ -238,3 +234,12 @@ export interface MetabotGenerateContentResponse {
description: string;
error: string | null;
}
+
+/* Metabot v3 - Data Part Types */
+
+export type MetabotTodoItem = {
+ id: string;
+ content: string;
+ status: "pending" | "in_progress" | "completed" | "cancelled";
+ priority: "high" | "medium" | "low";
+};
diff --git a/frontend/src/metabase-types/api/transform.ts b/frontend/src/metabase-types/api/transform.ts
index 17eb3329e94..ace4df4ff1f 100644
--- a/frontend/src/metabase-types/api/transform.ts
+++ b/frontend/src/metabase-types/api/transform.ts
@@ -24,14 +24,25 @@ export type Transform = {
last_run?: TransformRun | null;
};
+export type SuggestedTransform = Partial<Pick<Transform, "id">> &
+ Pick<Transform, "name" | "description" | "source" | "target">;
+
export type PythonTransformTableAliases = Record<string, ConcreteTableId>;
+export type PythonTransformSourceDraft = {
+ type: "python";
+ body: string;
+ "source-database": DatabaseId | undefined;
+ "source-tables": PythonTransformTableAliases;
+};
+
export type PythonTransformSource = {
type: "python";
body: string;
"source-database": DatabaseId;
"source-tables": PythonTransformTableAliases;
};
+
export type QueryTransformSource = {
type: "query";
query: DatasetQuery;
@@ -39,6 +50,14 @@ export type QueryTransformSource = {
export type TransformSource = QueryTransformSource | PythonTransformSource;
+export type DraftTransformSource =
+ | Transform["source"]
+ | PythonTransformSourceDraft;
+
+export type DraftTransform = Partial<
+ Pick<Transform, "id" | "name" | "description" | "target">
+> & { source: DraftTransformSource };
+
export type TransformTargetType = "table";
export type TransformTarget = {
diff --git a/frontend/src/metabase/api/tags/constants.ts b/frontend/src/metabase/api/tags/constants.ts
index eefc1fdff10..60eb5b7b93e 100644
--- a/frontend/src/metabase/api/tags/constants.ts
+++ b/frontend/src/metabase/api/tags/constants.ts
@@ -33,6 +33,7 @@ export const TAG_TYPES = [
"snippet",
"subscription",
"subscription-channel",
+ "transform",
"table",
"task",
"timeline",
diff --git a/frontend/src/metabase/common/components/AdminLayout/AdminSettingsLayout.tsx b/frontend/src/metabase/common/components/AdminLayout/AdminSettingsLayout.tsx
index 4d06c526281..178ffbeb1a0 100644
--- a/frontend/src/metabase/common/components/AdminLayout/AdminSettingsLayout.tsx
+++ b/frontend/src/metabase/common/components/AdminLayout/AdminSettingsLayout.tsx
@@ -1,6 +1,10 @@
import type React from "react";
+import { t } from "ttag";
import ErrorBoundary from "metabase/ErrorBoundary";
+import { useSelector } from "metabase/lib/redux";
+import { PLUGIN_METABOT } from "metabase/plugins";
+import { getLocation } from "metabase/selectors/routing";
import { Box } from "metabase/ui";
import { NotFound } from "../ErrorPages";
@@ -15,9 +19,13 @@ export const AdminSettingsLayout = ({
}: {
sidebar?: React.ReactNode;
children?: React.ReactNode;
- maw?: string;
fullWidth?: boolean;
+ maw?: string;
}) => {
+ const location = useSelector(getLocation);
+ const isMetabotEnabledForRoute =
+ location.pathname.startsWith("/admin/transforms");
+
return (
<Box className={S.Wrapper}>
<Box className={S.Main}>
@@ -32,11 +40,26 @@ export const AdminSettingsLayout = ({
p={fullWidth ? 0 : "2rem"}
>
<Box maw={fullWidth ? undefined : maw} w="100%">
- <Box pb={fullWidth ? 0 : "2rem"}>
+ <Box {...(fullWidth ? { h: "100%" } : { pb: "2rem" })}>
<ErrorBoundary>{children ?? <NotFound />}</ErrorBoundary>
</Box>
</Box>
</Box>
+
+ <PLUGIN_METABOT.Metabot
+ hide={!isMetabotEnabledForRoute}
+ config={{
+ // we don't save snapshots of the metabot conversation "state" value and do not
+ // revert it to the point in time of a message was sent. this will cause values
+ // like the todo list to confuse the agent as there may no longer be any conversation
+ // history but an in progress/complete todo list.
+ preventRetryMessage: true,
+ preventClose: true,
+ hideSuggestedPrompts: true,
+ emptyText: t`Let's transform your data together!`,
+ suggestionModels: ["dataset", "transform", "table", "database"],
+ }}
+ />
</Box>
</Box>
);
diff --git a/frontend/src/metabase/common/components/CodeEditor/CodeEditor.tsx b/frontend/src/metabase/common/components/CodeEditor/CodeEditor.tsx
index 5741f9fb397..96eb6d97d8c 100644
--- a/frontend/src/metabase/common/components/CodeEditor/CodeEditor.tsx
+++ b/frontend/src/metabase/common/components/CodeEditor/CodeEditor.tsx
@@ -13,6 +13,7 @@ type Props = {
lineNumbers?: boolean;
readOnly?: boolean;
value: string;
+ proposedValue?: string;
onChange?: (value: string) => void;
extensions?: Extension[];
"data-testid"?: string;
@@ -26,6 +27,7 @@ export function CodeEditor({
lineNumbers = true,
readOnly,
value,
+ proposedValue,
onChange,
extensions: externalExtensions,
...rest
@@ -33,6 +35,8 @@ export function CodeEditor({
const extensions = useExtensions({
language,
extensions: externalExtensions,
+ originalValue: proposedValue ? value : undefined,
+ proposedValue,
});
return (
@@ -47,7 +51,7 @@ export function CodeEditor({
extensions={extensions}
id={id}
readOnly={readOnly}
- value={value}
+ value={proposedValue ?? value}
onChange={onChange}
highlightRanges={highlightRanges}
{...rest}
diff --git a/frontend/src/metabase/common/components/CodeEditor/utils.ts b/frontend/src/metabase/common/components/CodeEditor/utils.ts
index 6de3a92be40..148c4531a12 100644
--- a/frontend/src/metabase/common/components/CodeEditor/utils.ts
+++ b/frontend/src/metabase/common/components/CodeEditor/utils.ts
@@ -7,26 +7,38 @@ import { StreamLanguage, indentUnit } from "@codemirror/language";
import { clojure } from "@codemirror/legacy-modes/mode/clojure";
import { pug } from "@codemirror/legacy-modes/mode/pug";
import { ruby } from "@codemirror/legacy-modes/mode/ruby";
+import { unifiedMergeView } from "@codemirror/merge";
import type { Extension } from "@codemirror/state";
import { handlebarsLanguage as handlebars } from "@xiechao/codemirror-lang-handlebars";
import { useMemo } from "react";
+import _ from "underscore";
import type { CodeLanguage } from "./types";
export function useExtensions({
language,
extensions,
+ originalValue,
+ proposedValue,
}: {
language?: CodeLanguage | Extension;
extensions?: Extension[];
+ originalValue?: string;
+ proposedValue?: string;
}) {
- return useMemo(
- () => [
+ return useMemo(() => {
+ const hasProposed = !!originalValue && !!proposedValue;
+
+ return _.compact([
...(extensions ?? []),
- ...(language ? [getLanguageExtension(language)] : []),
- ],
- [language, extensions],
- );
+ language && getLanguageExtension(language),
+ hasProposed &&
+ unifiedMergeView({
+ original: originalValue,
+ mergeControls: false,
+ }),
+ ]);
+ }, [language, extensions, originalValue, proposedValue]);
}
export function getLanguageExtension(language: CodeLanguage | Extension) {
diff --git a/frontend/src/metabase/common/components/LeaveConfirmModal/LeaveRouteConfirmModal.tsx b/frontend/src/metabase/common/components/LeaveConfirmModal/LeaveRouteConfirmModal.tsx
index a68d3e60b23..a0f802b3ef5 100644
--- a/frontend/src/metabase/common/components/LeaveConfirmModal/LeaveRouteConfirmModal.tsx
+++ b/frontend/src/metabase/common/components/LeaveConfirmModal/LeaveRouteConfirmModal.tsx
@@ -11,6 +11,7 @@ interface LeaveRouteConfirmModalProps {
isLocationAllowed?: (location?: Location) => boolean;
route: Route;
router: InjectedRouter;
+ onConfirm?: () => void;
}
const _LeaveRouteConfirmModal = ({
@@ -18,6 +19,7 @@ const _LeaveRouteConfirmModal = ({
isLocationAllowed,
route,
router,
+ onConfirm,
}: LeaveRouteConfirmModalProps) => {
const { opened, close, confirm } = useConfirmRouteLeaveModal({
isEnabled,
@@ -26,8 +28,17 @@ const _LeaveRouteConfirmModal = ({
router,
});
+ const handleConfirm = () => {
+ confirm();
+ onConfirm?.();
+ };
+
return (
- <LeaveConfirmModal onConfirm={confirm} onClose={close} opened={opened} />
+ <LeaveConfirmModal
+ onConfirm={handleConfirm}
+ onClose={close}
+ opened={opened}
+ />
);
};
diff --git a/frontend/src/metabase/common/utils/model-names.ts b/frontend/src/metabase/common/utils/model-names.ts
index fa24bd66198..42e99b61c92 100644
--- a/frontend/src/metabase/common/utils/model-names.ts
+++ b/frontend/src/metabase/common/utils/model-names.ts
@@ -2,7 +2,9 @@ import { t } from "ttag";
import type { SearchModel } from "metabase-types/api";
-const TRANSLATED_NAME_BY_MODEL_TYPE: Record<SearchModel, string> = {
+type ModelNames = SearchModel | "user";
+
+const TRANSLATED_NAME_BY_MODEL_TYPE: Record<ModelNames, string> = {
get action() {
return t`Action`;
},
@@ -39,7 +41,10 @@ const TRANSLATED_NAME_BY_MODEL_TYPE: Record<SearchModel, string> = {
get transform() {
return t`Transform`;
},
+ get user() {
+ return t`User`;
+ },
};
-export const getTranslatedEntityName = (type: SearchModel) =>
+export const getTranslatedEntityName = (type: ModelNames) =>
TRANSLATED_NAME_BY_MODEL_TYPE[type] || null;
diff --git a/frontend/src/metabase/dashboard/actions/tabs.ts b/frontend/src/metabase/dashboard/actions/tabs.ts
index 320f694e4e4..8433246cb72 100644
--- a/frontend/src/metabase/dashboard/actions/tabs.ts
+++ b/frontend/src/metabase/dashboard/actions/tabs.ts
@@ -219,8 +219,9 @@ export function getPrevDashAndTabs({
filterRemovedTabs?: boolean;
}) {
const dashId = state.dashboardId;
- // @ts-expect-error - possibly infinite type error
- const prevDash = dashId ? state.dashboards[dashId] : null;
+ const prevDash =
+ // @ts-expect-error - possibly infinite type error
+ dashId ? state.dashboards[dashId] : null;
const prevTabs =
prevDash?.tabs?.filter((t) => !filterRemovedTabs || !t.isRemoved) ?? [];
diff --git a/frontend/src/metabase/lib/icon.ts b/frontend/src/metabase/lib/icon.ts
index 223d8a6e54d..93426916650 100644
--- a/frontend/src/metabase/lib/icon.ts
+++ b/frontend/src/metabase/lib/icon.ts
@@ -11,7 +11,12 @@ import type {
import type { ColorName } from "./colors/types";
-export type IconModel = SearchModel | CollectionItemModel | "schema";
+export type IconModel =
+ | SearchModel
+ | CollectionItemModel
+ | "schema"
+ | "transform"
+ | "user";
export type ObjectWithModel = {
id?: unknown;
@@ -39,6 +44,7 @@ export const modelIconMap: Record<IconModel, IconName> = {
snippet: "unknown",
document: "document",
transform: "refresh_downstream",
+ user: "person",
};
export type IconData = {
diff --git a/frontend/src/metabase/lib/urls/modelToUrl.ts b/frontend/src/metabase/lib/urls/modelToUrl.ts
index 09b8f199352..2df45d5c334 100644
--- a/frontend/src/metabase/lib/urls/modelToUrl.ts
+++ b/frontend/src/metabase/lib/urls/modelToUrl.ts
@@ -4,6 +4,7 @@ import { dashboard } from "./dashboards";
import { document } from "./documents";
import { metric, model } from "./models";
import { question, tableRowsQuery } from "./questions";
+import { transform } from "./transforms";
export type UrlableModel = {
id: number;
@@ -40,6 +41,8 @@ export function modelToUrl(item: UrlableModel) {
return document(item);
case "user":
return null;
+ case "transform":
+ return transform(item.id);
default:
return null;
}
diff --git a/frontend/src/metabase/metabot/context.ts b/frontend/src/metabase/metabot/context.ts
index 61b12f27494..ebd8c18a303 100644
--- a/frontend/src/metabase/metabot/context.ts
+++ b/frontend/src/metabase/metabot/context.ts
@@ -10,10 +10,17 @@ export type ChatContextProviderFn = (
export type DeregisterChatContextProviderFn = () => void;
+// internal type so we can support tiptap editor and textarea as inputs
+export type MetabotChatInputRef = {
+ focus: () => void;
+ scrollHeight: number;
+ scrollTop: number;
+};
+
export interface MetabotContext {
prompt: string;
setPrompt: (prompt: string) => void;
- promptInputRef: RefObject<HTMLTextAreaElement> | undefined;
+ promptInputRef: RefObject<MetabotChatInputRef> | undefined;
getChatContext: () => Promise<MetabotChatContext>;
registerChatContextProvider: (
diff --git a/frontend/src/metabase/nav/components/AdminNavbar/AdminNavbar.styled.tsx b/frontend/src/metabase/nav/components/AdminNavbar/AdminNavbar.styled.tsx
index c1b21442b2f..48db97179a3 100644
--- a/frontend/src/metabase/nav/components/AdminNavbar/AdminNavbar.styled.tsx
+++ b/frontend/src/metabase/nav/components/AdminNavbar/AdminNavbar.styled.tsx
@@ -67,6 +67,42 @@ export const AdminMobileNavBarItems = styled.ul`
overflow-y: auto;
`;
+export const AdminButtons = styled.div`
+ margin-inline-start: auto;
+ display: flex;
+ gap: 0.5rem;
+`;
+
+export const AdminActionButton = styled.button`
+ border: 1px solid ${() => alpha("bg-white", 0.2)};
+ height: 2.625rem;
+ width: 2.625rem;
+ display: flex;
+ justify-content: center;
+ align-items: center;
+ border-radius: 5px;
+ font-weight: 700;
+ font-size: 13px;
+ transition: all 200ms;
+ color: var(--mb-color-text-white);
+ white-space: nowrap;
+ text-align: center;
+
+ &:disabled {
+ color: ${() => alpha("bg-white", 0.2)};
+ }
+
+ &:hover {
+ color: var(--mb-color-text-white);
+ background-color: ${() => darken("admin-navbar")};
+ border-color: ${() => darken("admin-navbar")};
+
+ &:disabled {
+ color: ${() => alpha("bg-white", 0.2)};
+ }
+ }
+`;
+
export const AdminExitLink = styled(Link)`
border: 1px solid ${() => alpha("bg-white", 0.2)};
padding: 12px 18px;
@@ -77,7 +113,6 @@ export const AdminExitLink = styled(Link)`
color: var(--mb-color-text-white);
white-space: nowrap;
text-align: center;
- margin-inline-start: auto;
&:hover {
color: var(--mb-color-text-white);
diff --git a/frontend/src/metabase/nav/components/AdminNavbar/AdminNavbar.tsx b/frontend/src/metabase/nav/components/AdminNavbar/AdminNavbar.tsx
index a7c76c753d7..0773405366d 100644
--- a/frontend/src/metabase/nav/components/AdminNavbar/AdminNavbar.tsx
+++ b/frontend/src/metabase/nav/components/AdminNavbar/AdminNavbar.tsx
@@ -8,6 +8,7 @@ import LogoIcon from "metabase/common/components/LogoIcon";
import CS from "metabase/css/core/index.css";
import { useDispatch, useSelector } from "metabase/lib/redux";
import { useRegisterShortcut } from "metabase/palette/hooks/useRegisterShortcut";
+import { PLUGIN_METABOT } from "metabase/plugins";
import { getIsPaidPlan } from "metabase/selectors/settings";
import { getUserIsAdmin } from "metabase/selectors/user";
import { Button, Icon } from "metabase/ui";
@@ -19,6 +20,7 @@ import { AdminNavItem } from "./AdminNavItem";
import { AdminNavLink } from "./AdminNavItem.styled";
import AdminNavCS from "./AdminNavbar.module.css";
import {
+ AdminButtons,
AdminExitLink,
AdminLogoContainer,
AdminLogoLink,
@@ -92,10 +94,15 @@ export const AdminNavbar = ({
</AdminNavbarItems>
{!isPaidPlan && isAdmin && <StoreLink />}
- <AdminExitLink
- to="/"
- data-testid="exit-admin"
- >{t`Exit admin`}</AdminExitLink>
+
+ <AdminButtons>
+ <PLUGIN_METABOT.MetabotAdminAppBarButton />
+
+ <AdminExitLink
+ to="/"
+ data-testid="exit-admin"
+ >{t`Exit admin`}</AdminExitLink>
+ </AdminButtons>
</MobileHide>
</AdminNavbarRoot>
);
diff --git a/frontend/src/metabase/plugins/index.ts b/frontend/src/metabase/plugins/index.ts
index f0936b542da..12cfb938647 100644
--- a/frontend/src/metabase/plugins/index.ts
+++ b/frontend/src/metabase/plugins/index.ts
@@ -80,6 +80,7 @@ import type {
PythonTransformSource,
PythonTransformTableAliases,
Revision,
+ SearchModel,
Series,
TableId,
Timeline,
@@ -703,9 +704,20 @@ export const PLUGIN_AI_ENTITY_ANALYSIS: PluginAIEntityAnalysis = {
chartAnalysisRenderFormats: {},
};
-type PLUGIN_METABOT_TYPE = {
+type PluginMetabotConfig = {
+ emptyText?: string;
+ hideSuggestedPrompts?: boolean;
+ preventClose?: boolean;
+ preventRetryMessage?: boolean;
+ suggestionModels: (SearchModel | "transform" | "user")[];
+};
+
+type PluginMetabotType = {
isEnabled: () => boolean;
- Metabot: (props: { hide?: boolean }) => React.ReactElement | null;
+ Metabot: (props: {
+ hide?: boolean;
+ config?: PluginMetabotConfig;
+ }) => React.ReactElement | null;
defaultMetabotContextValue: MetabotContext;
MetabotContext: React.Context<MetabotContext>;
getMetabotProvider: () => ComponentType<{ children: React.ReactNode }>;
@@ -716,11 +728,13 @@ type PLUGIN_METABOT_TYPE = {
getMetabotVisible: (state: State) => boolean;
MetabotToggleButton: ComponentType<{ className?: string }>;
MetabotAppBarButton: ComponentType;
+ MetabotAdminAppBarButton: ComponentType;
};
-export const PLUGIN_METABOT: PLUGIN_METABOT_TYPE = {
+export const PLUGIN_METABOT: PluginMetabotType = {
isEnabled: () => false,
- Metabot: () => null,
+ Metabot: (_props: { hide?: boolean; config?: PluginMetabotConfig }) =>
+ null as React.ReactElement | null,
defaultMetabotContextValue,
MetabotContext: React.createContext(defaultMetabotContextValue),
getMetabotProvider: () => {
@@ -738,6 +752,7 @@ export const PLUGIN_METABOT: PLUGIN_METABOT_TYPE = {
getMetabotVisible: () => false,
MetabotToggleButton: PluginPlaceholder,
MetabotAppBarButton: PluginPlaceholder,
+ MetabotAdminAppBarButton: PluginPlaceholder,
};
type DashCardMenuItemGetter = (
@@ -874,17 +889,27 @@ export type PythonTransformsPlugin = {
PythonRunnerSettingsPage: ComponentType;
SourceSection: ComponentType<{ transform: Transform }>;
TransformEditor: ComponentType<{
+ transform?: Transform | undefined;
initialSource: {
type: "python";
body: string;
"source-database": DatabaseId | undefined;
"source-tables": PythonTransformTableAliases;
};
+ proposedSource?: PythonTransformSource;
isNew?: boolean;
isSaving?: boolean;
isRunnable?: boolean;
+ onChange?: (newSource: {
+ type: "python";
+ body: string;
+ "source-database": DatabaseId | undefined;
+ "source-tables": PythonTransformTableAliases;
+ }) => void;
onSave: (newSource: PythonTransformSource) => void;
onCancel: () => void;
+ onRejectProposed?: () => void;
+ onAcceptProposed?: (query: PythonTransformSource) => void;
}>;
getAdminRoutes: () => ReactNode;
getTransformsNavLinks: () => ReactNode;
diff --git a/frontend/src/metabase/query_builder/components/NativeQueryEditor/CodeMirrorEditor/CodeMirrorEditor.module.css b/frontend/src/metabase/query_builder/components/NativeQueryEditor/CodeMirrorEditor/CodeMirrorEditor.module.css
index 0c28c0ba96e..eb36ad7cad2 100644
--- a/frontend/src/metabase/query_builder/components/NativeQueryEditor/CodeMirrorEditor/CodeMirrorEditor.module.css
+++ b/frontend/src/metabase/query_builder/components/NativeQueryEditor/CodeMirrorEditor/CodeMirrorEditor.module.css
@@ -1,4 +1,10 @@
.editor {
+ --change: var(--mb-color-success);
+ --change-light: color-mix(in srgb, var(--change) 11%, transparent);
+ --remove: var(--mb-color-danger);
+ --remove-mid: color-mix(in srgb, var(--remove) 25%, transparent);
+ --remove-light: color-mix(in srgb, var(--remove) 11%, transparent);
+
width: 100%;
min-width: 0;
max-width: 100%;
@@ -6,6 +12,47 @@
height: 100%;
color: var(--mb-color-text-dark);
background-color: var(--mb-color-bg-light);
+
+ :global {
+ /* merge view styles */
+ .cm-collapsedLines {
+ background: var(--mb-color-bg-light) !important;
+ color: var(--mb-color-text-light);
+
+ &:before,
+ &:after {
+ content: "-";
+ color: var(--mb-color-text-light);
+ }
+ }
+
+ .cm-merge-b .cm-changedLineGutter {
+ background: var(--change);
+ }
+
+ .cm-deletedLineGutter {
+ background: var(--remove);
+ }
+
+ .cm-deletedChunk {
+ background: var(--remove-light);
+ }
+
+ .cm-deletedText {
+ background: var(--remove-mid);
+ }
+
+ .cm-merge-b {
+ .cm-changedText {
+ background: linear-gradient(var(--change), var(--change)) bottom / 100%
+ 2px no-repeat;
+ }
+
+ .cm-changedLine {
+ background: var(--change-light);
+ }
+ }
+ }
}
.tag {
diff --git a/frontend/src/metabase/query_builder/components/NativeQueryEditor/CodeMirrorEditor/CodeMirrorEditor.tsx b/frontend/src/metabase/query_builder/components/NativeQueryEditor/CodeMirrorEditor/CodeMirrorEditor.tsx
index 8f8222db8c0..823c4dab542 100644
--- a/frontend/src/metabase/query_builder/components/NativeQueryEditor/CodeMirrorEditor/CodeMirrorEditor.tsx
+++ b/frontend/src/metabase/query_builder/components/NativeQueryEditor/CodeMirrorEditor/CodeMirrorEditor.tsx
@@ -21,6 +21,7 @@ import type { SelectionRange } from "../types";
export type CodeMirrorEditorProps = {
query: Lib.Query;
+ proposedQuery?: Lib.Query;
highlightedLineNumbers?: number[];
placeholder?: string;
readOnly?: boolean;
@@ -51,6 +52,7 @@ export const CodeMirrorEditor = forwardRef<
>(function CodeMirrorEditor(
{
query,
+ proposedQuery,
highlightedLineNumbers,
placeholder = getPlaceholderText(Lib.engine(query)),
readOnly,
@@ -64,7 +66,11 @@ export const CodeMirrorEditor = forwardRef<
ref,
) {
const editorRef = useRef<CodeMirrorRef>(null);
- const extensions = useExtensions({ query, onRunQuery });
+ const extensions = useExtensions({
+ query,
+ diff: !!proposedQuery,
+ onRunQuery,
+ });
useImperativeHandle(ref, () => {
return {
@@ -128,13 +134,17 @@ export const CodeMirrorEditor = forwardRef<
[highlightedLineNumbers],
);
+ const value = useMemo(() => {
+ return Lib.rawNativeQuery(proposedQuery ?? query);
+ }, [proposedQuery, query]);
+
return (
<CodeMirror
ref={editorRef}
data-testid="native-query-editor"
className={S.editor}
extensions={extensions}
- value={Lib.rawNativeQuery(query)}
+ value={value}
readOnly={readOnly}
onChange={onChange}
height="100%"
diff --git a/frontend/src/metabase/query_builder/components/NativeQueryEditor/CodeMirrorEditor/extensions.tsx b/frontend/src/metabase/query_builder/components/NativeQueryEditor/CodeMirrorEditor/extensions.tsx
index 890751480b1..4e02357f30a 100644
--- a/frontend/src/metabase/query_builder/components/NativeQueryEditor/CodeMirrorEditor/extensions.tsx
+++ b/frontend/src/metabase/query_builder/components/NativeQueryEditor/CodeMirrorEditor/extensions.tsx
@@ -1,4 +1,5 @@
import { autocompletion } from "@codemirror/autocomplete";
+import { unifiedMergeView } from "@codemirror/merge";
import { type Extension, Prec } from "@codemirror/state";
import {
Decoration,
@@ -26,10 +27,15 @@ import { getReferencedCardIds } from "./util";
type Options = {
query: Lib.Query;
+ diff: boolean;
onRunQuery?: () => void;
};
-export function useExtensions({ query, onRunQuery }: Options): Extension[] {
+export function useExtensions({
+ query,
+ diff,
+ onRunQuery,
+}: Options): Extension[] {
const { databaseId, engine, referencedCardIds } = useMemo(
() => ({
databaseId: Lib.databaseID(query),
@@ -78,10 +84,18 @@ export function useExtensions({ query, onRunQuery }: Options): Extension[] {
},
]),
),
+ diff
+ ? unifiedMergeView({
+ original: Lib.rawNativeQuery(query),
+ mergeControls: false,
+ })
+ : null,
]
.flat()
.filter(isNotNull);
}, [
+ query,
+ diff,
engine,
schemaCompletion,
snippetCompletion,
diff --git a/frontend/src/metabase/query_builder/components/NativeQueryEditor/NativeQueryEditor.tsx b/frontend/src/metabase/query_builder/components/NativeQueryEditor/NativeQueryEditor.tsx
index 970e8213331..0bf28117c23 100644
--- a/frontend/src/metabase/query_builder/components/NativeQueryEditor/NativeQueryEditor.tsx
+++ b/frontend/src/metabase/query_builder/components/NativeQueryEditor/NativeQueryEditor.tsx
@@ -7,6 +7,7 @@ import {
useCallback,
} from "react";
import { ResizableBox, type ResizableBoxProps } from "react-resizable";
+import { t } from "ttag";
import _ from "underscore";
import ExplicitSize from "metabase/common/components/ExplicitSize";
@@ -22,7 +23,7 @@ import {
import { SnippetFormModal } from "metabase/query_builder/components/template_tags/SnippetFormModal";
import type { QueryModalType } from "metabase/query_builder/constants";
import { useNotebookScreenSize } from "metabase/query_builder/hooks/use-notebook-screen-size";
-import { Flex } from "metabase/ui";
+import { Button, Flex, Icon, Stack, Tooltip } from "metabase/ui";
import * as Lib from "metabase-lib";
import type Question from "metabase-lib/v1/Question";
import type Database from "metabase-lib/v1/metadata/Database";
@@ -31,6 +32,7 @@ import type {
CardId,
Collection,
DatabaseId,
+ DatasetQuery,
NativeQuerySnippet,
ParameterId,
} from "metabase-types/api";
@@ -59,6 +61,10 @@ type OwnProps = {
question: Question;
query: NativeQuery;
+ proposedQuestion?: Question | undefined;
+ onRejectProposed?: () => void;
+ onAcceptProposed?: (query: DatasetQuery) => void;
+
nativeEditorSelectedText?: string;
modalSnippet?: NativeQuerySnippet;
viewHeight: number;
@@ -239,6 +245,9 @@ class NativeQueryEditor extends Component<Props, NativeQueryEditorState> {
resizableBoxProps = {},
snippetCollections = [],
question,
+ proposedQuestion,
+ onRejectProposed,
+ onAcceptProposed,
query,
readOnly,
isNativeEditorOpen,
@@ -336,6 +345,7 @@ class NativeQueryEditor extends Component<Props, NativeQueryEditorState> {
<CodeMirrorEditor
ref={this.editor}
query={question.query()}
+ proposedQuery={proposedQuestion?.query()}
readOnly={readOnly}
placeholder={placeholder}
highlightedLineNumbers={highlightedLineNumbers}
@@ -349,16 +359,55 @@ class NativeQueryEditor extends Component<Props, NativeQueryEditorState> {
}
/>
- {hasRunButton && !readOnly && (
- <NativeQueryEditorRunButton
- cancelQuery={this.props.cancelQuery}
- isResultDirty={this.props.isResultDirty}
- isRunnable={this.props.isRunnable}
- isRunning={this.props.isRunning}
- nativeEditorSelectedText={this.props.nativeEditorSelectedText}
- runQuery={this.props.runQuery}
- />
- )}
+ <Stack m="1rem" gap="md" mt="auto">
+ {proposedQuestion && onRejectProposed && onAcceptProposed && (
+ <>
+ <Tooltip label={t`Accept proposed changes`} position="top">
+ <Button
+ data-testid="accept-proposed-changes-button"
+ variant="filled"
+ bg="success"
+ px="0"
+ w="2.5rem"
+ onClick={() => {
+ const proposedQuery =
+ proposedQuestion.legacyNativeQuery();
+ if (proposedQuery) {
+ this.onChange(proposedQuery.queryText());
+ onAcceptProposed(proposedQuery.datasetQuery());
+ }
+ }}
+ >
+ <Icon name="check" />
+ </Button>
+ </Tooltip>
+ <Tooltip label={t`Reject proposed changes`} position="top">
+ <Button
+ data-testid="reject-proposed-changes-button"
+ w="2.5rem"
+ px="0"
+ variant="filled"
+ bg="danger"
+ onClick={onRejectProposed}
+ >
+ <Icon name="close" />
+ </Button>
+ </Tooltip>
+ </>
+ )}
+ {hasRunButton && !readOnly && (
+ <NativeQueryEditorRunButton
+ cancelQuery={this.props.cancelQuery}
+ isResultDirty={this.props.isResultDirty}
+ isRunnable={this.props.isRunnable}
+ isRunning={this.props.isRunning}
+ nativeEditorSelectedText={
+ this.props.nativeEditorSelectedText
+ }
+ runQuery={this.props.runQuery}
+ />
+ )}
+ </Stack>
</Flex>
</ResizableBox>
</div>
diff --git a/frontend/src/metabase/query_builder/components/NativeQueryEditor/NativeQueryEditorRunButton/NativeQueryEditorRunButton.module.css b/frontend/src/metabase/query_builder/components/NativeQueryEditor/NativeQueryEditorRunButton/NativeQueryEditorRunButton.module.css
index 88ed00b3945..b89beac1065 100644
--- a/frontend/src/metabase/query_builder/components/NativeQueryEditor/NativeQueryEditorRunButton/NativeQueryEditorRunButton.module.css
+++ b/frontend/src/metabase/query_builder/components/NativeQueryEditor/NativeQueryEditorRunButton/NativeQueryEditorRunButton.module.css
@@ -1,6 +1,4 @@
.RunButtonWithTooltipStyled {
- margin: 1rem;
- margin-top: auto;
height: 40px;
width: 40px;
}
diff --git a/frontend/src/metabase/ui/components/icons/Icon/icons/arrow_right.svg b/frontend/src/metabase/ui/components/icons/Icon/icons/arrow_right.svg
index 4929c941f8f..a94154b5588 100644
--- a/frontend/src/metabase/ui/components/icons/Icon/icons/arrow_right.svg
+++ b/frontend/src/metabase/ui/components/icons/Icon/icons/arrow_right.svg
@@ -1,3 +1,3 @@
-<svg viewBox="0 0 16 16" fill="currentcolor" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" style="transform: rotate(-180deg)">
- <path d="M8.53 2.53a.75.75 0 0 0-1.06-1.06l-6 6a.748.748 0 0 0-.22.528v.004a.748.748 0 0 0 .22.528l6 6a.75.75 0 0 0 1.06-1.06L3.81 8.75H14a.75.75 0 0 0 0-1.5H3.81l4.72-4.72z" />
+<svg viewBox="0 0 16 16" fill="currentColor" xmlns="http://www.w3.org/2000/svg">
+ <path d="M7.47 2.53C7.33752 2.38782 7.2654 2.19978 7.26882 2.00548C7.27225 1.81118 7.35097 1.62579 7.48838 1.48838C7.62579 1.35096 7.81118 1.27225 8.00548 1.26882C8.19978 1.2654 8.38783 1.33752 8.53 1.47L14.53 7.47C14.6704 7.6099 14.7495 7.7998 14.75 7.998V8.002C14.7495 8.20019 14.6704 8.3901 14.53 8.53L8.53 14.53C8.38783 14.6625 8.19978 14.7346 8.00548 14.7312C7.81118 14.7277 7.62579 14.649 7.48838 14.5116C7.35097 14.3742 7.27225 14.1888 7.26882 13.9945C7.2654 13.8002 7.33752 13.6122 7.47 13.47L12.19 8.75H2C1.80109 8.75 1.61032 8.67098 1.46967 8.53033C1.32902 8.38968 1.25 8.19891 1.25 8C1.25 7.80109 1.32902 7.61032 1.46967 7.46967C1.61032 7.32902 1.80109 7.25 2 7.25H12.19L7.47 2.53Z" />
</svg>
diff --git a/frontend/test/jest-setup.js b/frontend/test/jest-setup.js
index aeb6cb9a0ad..ab77c6bed94 100644
--- a/frontend/test/jest-setup.js
+++ b/frontend/test/jest-setup.js
@@ -60,3 +60,43 @@ Range.prototype.getBoundingClientRect = () => ({
top: 0,
width: 0,
});
+
+// Mock getClientRects for ProseMirror/TipTap compatibility in tests
+Range.prototype.getClientRects = () => ({
+ 0: {
+ bottom: 0,
+ height: 0,
+ left: 0,
+ right: 0,
+ top: 0,
+ width: 0,
+ },
+ length: 1,
+ item: () => null,
+ [Symbol.iterator]: function* () {
+ yield this[0];
+ },
+});
+
+// Also mock for Elements which ProseMirror might try to call getClientRects on
+Element.prototype.getClientRects =
+ Element.prototype.getClientRects ||
+ (() => ({
+ 0: {
+ bottom: 0,
+ height: 0,
+ left: 0,
+ right: 0,
+ top: 0,
+ width: 0,
+ },
+ length: 1,
+ item: () => null,
+ [Symbol.iterator]: function* () {
+ yield this[0];
+ },
+ }));
+
+// Mock elementFromPoint for ProseMirror/TipTap compatibility in tests
+document.elementFromPoint = document.elementFromPoint || (() => null);
+document.elementsFromPoint = document.elementsFromPoint || (() => []);
diff --git a/package.json b/package.json
index 882be464013..8d36ee651c8 100644
--- a/package.json
+++ b/package.json
@@ -17,6 +17,7 @@
"@codemirror/lang-python": "^6.1.7",
"@codemirror/lang-sql": "^6.8.0",
"@codemirror/legacy-modes": "^6.4.2",
+ "@codemirror/merge": "^6.10.2",
"@dagrejs/dagre": "^1.1.5",
"@dnd-kit/core": "^6.0.8",
"@dnd-kit/modifiers": "^6.0.1",
diff --git a/src/metabase/native_query_snippets/api.clj b/src/metabase/native_query_snippets/api.clj
index 35ecc6fbd2b..8f24c1af4f3 100644
--- a/src/metabase/native_query_snippets/api.clj
+++ b/src/metabase/native_query_snippets/api.clj
@@ -14,26 +14,34 @@
(set! *warn-on-reflection* true)
-(mu/defn- hydrated-native-query-snippet :- [:maybe (ms/InstanceOf :model/NativeQuerySnippet)]
- [id :- ms/PositiveInt]
- (-> (api/read-check (t2/select-one :model/NativeQuerySnippet :id id))
- (t2/hydrate :creator)))
+(mu/defn list-native-query-snippets :- [:sequential (ms/InstanceOf :model/NativeQuerySnippet)]
+ "List all native query snippets the current user has read access to."
+ ([]
+ (list-native-query-snippets false))
+ ([archived :- ms/BooleanValue]
+ (let [snippets (t2/select :model/NativeQuerySnippet
+ :archived archived
+ {:order-by [[:%lower.name :asc]]})]
+ (t2/hydrate (filter mi/can-read? snippets) :creator))))
(api.macros/defendpoint :get "/"
"Fetch all snippets"
[_route-params
{:keys [archived]} :- [:map
[:archived {:default false} [:maybe ms/BooleanValue]]]]
- (let [snippets (t2/select :model/NativeQuerySnippet
- :archived archived
- {:order-by [[:%lower.name :asc]]})]
- (t2/hydrate (filter mi/can-read? snippets) :creator)))
+ (list-native-query-snippets (boolean archived)))
+
+(mu/defn get-native-query-snippet :- [:maybe (ms/InstanceOf :model/NativeQuerySnippet)]
+ "Fetch native query snippet with ID and hydrate creator."
+ [id :- ms/PositiveInt]
+ (-> (api/read-check (t2/select-one :model/NativeQuerySnippet :id id))
+ (t2/hydrate :creator)))
(api.macros/defendpoint :get "/:id"
"Fetch native query snippet with ID."
[{:keys [id]} :- [:map
[:id ms/PositiveInt]]]
- (hydrated-native-query-snippet id))
+ (get-native-query-snippet id))
(defn- check-snippet-name-is-unique [snippet-name]
(when (t2/exists? :model/NativeQuerySnippet :name snippet-name)
@@ -72,7 +80,7 @@
(when-let [new-name (:name changes)]
(check-snippet-name-is-unique new-name))
(t2/update! :model/NativeQuerySnippet id changes))
- (hydrated-native-query-snippet id)))
+ (get-native-query-snippet id)))
(api.macros/defendpoint :put "/:id"
"Update an existing `NativeQuerySnippet`."
diff --git a/src/metabase/native_query_snippets/core.clj b/src/metabase/native_query_snippets/core.clj
index 0bc73e177e6..dd63ca12601 100644
--- a/src/metabase/native_query_snippets/core.clj
+++ b/src/metabase/native_query_snippets/core.clj
@@ -1,14 +1,19 @@
(ns metabase.native-query-snippets.core
(:require
+ [metabase.native-query-snippets.api]
[metabase.native-query-snippets.models.native-query-snippet]
[metabase.native-query-snippets.models.native-query-snippet.permissions]
[potemkin :as p]))
(comment
+ metabase.native-query-snippets.api/keep-me
metabase.native-query-snippets.models.native-query-snippet.permissions/keep-me
metabase.native-query-snippets.models.native-query-snippet/keep-me)
(p/import-vars
+ [metabase.native-query-snippets.api
+ list-native-query-snippets
+ get-native-query-snippet]
[metabase.native-query-snippets.models.native-query-snippet
add-template-tags
NativeQuerySnippetName]
diff --git a/src/metabase/search/api.clj b/src/metabase/search/api.clj
index 4c477a7cdf2..bd3aa64ae18 100644
--- a/src/metabase/search/api.clj
+++ b/src/metabase/search/api.clj
@@ -184,7 +184,7 @@
[:last_edited_by {:optional true} [:maybe (ms/QueryVectorOf ms/PositiveInt)]]
[:model_ancestors {:default false} [:maybe :boolean]]
[:search_engine {:optional true} [:maybe string?]]
- [:search_native_query {:optional true} [:maybe true?]]
+ [:search_native_query {:optional true} [:maybe :boolean]]
[:verified {:optional true} [:maybe true?]]
[:ids {:optional true} [:maybe (ms/QueryVectorOf ms/PositiveInt)]]
[:calculate_available_models {:optional true} [:maybe true?]]
diff --git a/src/metabase/search/config.clj b/src/metabase/search/config.clj
index af6798f23b0..93c86ae5598 100644
--- a/src/metabase/search/config.clj
+++ b/src/metabase/search/config.clj
@@ -43,8 +43,8 @@
(def model->db-model
"Mapping of model name to :db_model and :alias"
(cond-> api/model->db-model
- config/ee-available? (assoc "document" {:db-model :model/Document :alias :document})
- config/ee-available? (assoc "transform" {:db-model :model/Transform :alias :transform})))
+ config/ee-available? (assoc "document" {:db-model :model/Document :alias :document}
+ "transform" {:db-model :model/Transform :alias :transform})))
;; We won't need this once fully migrated to specs, but kept for now in case legacy cod falls out of sync
(def excluded-models
@@ -75,8 +75,7 @@
"The order of this list influences the order of the results: items earlier in the
list will be ranked higher."
(cond-> ["dashboard" "metric" "segment" "indexed-entity" "card" "dataset" "collection" "table" "action"]
- config/ee-available? (conj "document")
- config/ee-available? (conj "transform")
+ config/ee-available? (concat ["document" "transform"])
:always (conj "database")))
(assert (= all-models (set models-search-order)) "The models search order has to include all models")
@@ -261,7 +260,7 @@
[:last-edited-by {:optional true} [:set {:min 1} ms/PositiveInt]]
[:limit-int {:optional true} ms/Int]
[:offset-int {:optional true} ms/Int]
- [:search-native-query {:optional true} true?]
+ [:search-native-query {:optional true} :boolean]
[:table-db-id {:optional true} ms/PositiveInt]
;; true to search for verified items only, nil will return all items
[:verified {:optional true} true?]
diff --git a/src/metabase/search/core.clj b/src/metabase/search/core.clj
index 65365d99b67..0622d63d6ad 100644
--- a/src/metabase/search/core.clj
+++ b/src/metabase/search/core.clj
@@ -3,13 +3,10 @@
(:require
[metabase.analytics.core :as analytics]
[metabase.analytics.prometheus :as prometheus]
- [metabase.search.appdb.core :as search.engines.appdb]
[metabase.search.config :as search.config]
[metabase.search.engine :as search.engine]
[metabase.search.impl :as search.impl]
- [metabase.search.in-place.legacy :as search.legacy]
[metabase.search.ingestion :as search.ingestion]
- [metabase.search.semantic.core :as search.engines.semantic]
[metabase.search.spec :as search.spec]
[metabase.search.util :as search.util]
[metabase.util :as u]
@@ -19,14 +16,7 @@
(set! *warn-on-reflection* true)
(comment
- ;; Make sure to import all the engine implementations. In future this can happen automatically, as per drivers.
- ;;
- ;; TODO -- maybe engine loading should be moved to [[metabase.search.init]] instead
search.engine/keep-me
- search.engines.appdb/keep-me
- search.engines.semantic/keep-me
- search.legacy/keep-me
-
search.config/keep-me
search.impl/keep-me)
diff --git a/src/metabase/search/filter.clj b/src/metabase/search/filter.clj
index 4adc28c089e..b349c97f520 100644
--- a/src/metabase/search/filter.clj
+++ b/src/metabase/search/filter.clj
@@ -40,7 +40,8 @@
(remove nil?)
(for [search-model (:models search-ctx)
:let [spec (search.spec/spec search-model)]]
- (when (and (visible-to? search-ctx spec) (every? (:attrs spec) required))
+ (when (and (visible-to? search-ctx spec)
+ (every? (:attrs spec) required))
(:name spec))))))
(defn models-without-collection
diff --git a/src/metabase/search/impl.clj b/src/metabase/search/impl.clj
index 77a255eb9f9..f0ffe9a2a8c 100644
--- a/src/metabase/search/impl.clj
+++ b/src/metabase/search/impl.clj
@@ -205,7 +205,9 @@
:collection_type
:archived_directly
:display_name
- :effective_parent))))
+ :effective_parent)
+ (cond-> (= model "transform")
+ (dissoc :source :target)))))
(defn- bit->boolean
"Coerce a bit returned by some MySQL/MariaDB versions in some situations to Boolean."
@@ -275,7 +277,7 @@
[:offset {:optional true} [:maybe ms/Int]]
[:table-db-id {:optional true} [:maybe ms/PositiveInt]]
[:search-engine {:optional true} [:maybe string?]]
- [:search-native-query {:optional true} [:maybe true?]]
+ [:search-native-query {:optional true} [:maybe boolean?]]
[:model-ancestors? {:optional true} [:maybe boolean?]]
[:verified {:optional true} [:maybe true?]]
[:ids {:optional true} [:maybe [:set ms/PositiveInt]]]
diff --git a/src/metabase/search/in_place/filter.clj b/src/metabase/search/in_place/filter.clj
index 31d12003aee..32a2f4ddf33 100644
--- a/src/metabase/search/in_place/filter.clj
+++ b/src/metabase/search/in_place/filter.clj
@@ -307,15 +307,15 @@
display-type]} search-context
feature->supported-models (feature->supported-models)]
(cond-> models
- (some? created-at) (set/intersection (:created-at feature->supported-models))
- (some? created-by) (set/intersection (:created-by feature->supported-models))
- (some? last-edited-at) (set/intersection (:last-edited-at feature->supported-models))
- (some? last-edited-by) (set/intersection (:last-edited-by feature->supported-models))
- (true? search-native-query) (set/intersection (:search-native-query feature->supported-models))
- (true? verified) (set/intersection (:verified feature->supported-models))
- (some? non-temporal-dim-ids) (set/intersection (:non-temporal-dim-ids feature->supported-models))
- (some? has-temporal-dim) (set/intersection (:has-temporal-dim feature->supported-models))
- (seq display-type) (set/intersection (:display-type feature->supported-models)))))
+ (some? created-at) (set/intersection (:created-at feature->supported-models))
+ (some? created-by) (set/intersection (:created-by feature->supported-models))
+ (some? last-edited-at) (set/intersection (:last-edited-at feature->supported-models))
+ (some? last-edited-by) (set/intersection (:last-edited-by feature->supported-models))
+ (true? search-native-query) (set/intersection (:search-native-query feature->supported-models))
+ (true? verified) (set/intersection (:verified feature->supported-models))
+ (some? non-temporal-dim-ids) (set/intersection (:non-temporal-dim-ids feature->supported-models))
+ (some? has-temporal-dim) (set/intersection (:has-temporal-dim feature->supported-models))
+ (seq display-type) (set/intersection (:display-type feature->supported-models)))))
(mu/defn build-filters :- :map
"Build the search filters for a model."
diff --git a/src/metabase/search/in_place/legacy.clj b/src/metabase/search/in_place/legacy.clj
index fae15ae4516..2b6e6d6c171 100644
--- a/src/metabase/search/in_place/legacy.clj
+++ b/src/metabase/search/in_place/legacy.clj
@@ -310,6 +310,13 @@
:display_name
:description])
+(defmethod searchable-columns "transform"
+ [_ search-native-query]
+ (cond-> [:name
+ :description]
+ search-native-query
+ (conj :source)))
+
(defmethod searchable-columns "indexed-entity"
[_ _]
[:name])
@@ -433,6 +440,10 @@
[:table.description :table_description]
[:metabase_database.name :database_name]])
+(defmethod columns-for-model "transform"
+ [_]
+ [:id :name :description :created_at :updated_at])
+
(mu/defn- select-clause-for-model :- [:sequential HoneySQLColumn]
"The search query uses a `union-all` which requires that there be the same number of columns in each of the segments
of the query. This function will take the columns for `model` and will inject constant `nil` values for any column
@@ -538,6 +549,10 @@
(-> (base-query-for-model model search-ctx)
(sql.helpers/where [:= :router_database_id nil])))
+(defmethod search-query-for-model "transform"
+ [model search-ctx]
+ (base-query-for-model model search-ctx))
+
(defmethod search-query-for-model "dashboard"
[model search-ctx]
(-> (base-query-for-model model search-ctx)
diff --git a/src/metabase/search/init.clj b/src/metabase/search/init.clj
index 18aa35ecf04..43b66a66d0a 100644
--- a/src/metabase/search/init.clj
+++ b/src/metabase/search/init.clj
@@ -1,6 +1,9 @@
(ns metabase.search.init
"This is loaded for side effects on system launch."
(:require
+ [metabase.search.appdb.core]
+ [metabase.search.in-place.legacy]
[metabase.search.models]
+ [metabase.search.semantic.core]
[metabase.search.settings]
[metabase.search.task.search-index]))
diff --git a/src/metabase/search/models.clj b/src/metabase/search/models.clj
index 9d0d0c87f24..4c69b901880 100644
--- a/src/metabase/search/models.clj
+++ b/src/metabase/search/models.clj
@@ -15,7 +15,6 @@
(t2/define-after-update :hook/search-index
[instance]
-
(search/update! instance)
nil)
diff --git a/src/metabase/search/scoring.clj b/src/metabase/search/scoring.clj
index 17760c978f3..e0042a90ff3 100644
--- a/src/metabase/search/scoring.clj
+++ b/src/metabase/search/scoring.clj
@@ -3,6 +3,7 @@
[clojure.string :as str]
[honey.sql.helpers :as sql.helpers]
[metabase.app-db.core :as mdb]
+ [metabase.driver.sql.query-processor :as sql.qp]
[metabase.search.config :as search.config]))
(def ^:private seconds-in-a-day 86400)
@@ -65,16 +66,23 @@
(defn user-recency-expr
"Expression to select the `:user-recency` timestamp for the `current-user-id`."
[{:keys [current-user-id]}]
- {:select [[[:max :recent_views.timestamp] :last_viewed_at]]
- :from [:recent_views]
- :where [:and
- [:= :recent_views.user_id current-user-id]
- [:= (cast-to-text :recent_views.model_id) :search_index.model_id]
- [:= :recent_views.model
- [:case
- [:= :search_index.model [:inline "dataset"]] [:inline "card"]
- [:= :search_index.model [:inline "metric"]] [:inline "card"]
- :else :search_index.model]]]})
+ (let [one-day-ago (sql.qp/add-interval-honeysql-form (mdb/db-type) :%now -1 :day)]
+ {:select [[[:case
+ ;; Transforms get a hardcoded 1-day last_viewed_at because we don't track views on them
+ [:= :search_index.model [:inline "transform"]]
+ one-day-ago
+ :else
+ [:max :recent_views.timestamp]]
+ :last_viewed_at]]
+ :from [:recent_views]
+ :where [:and
+ [:= :recent_views.user_id current-user-id]
+ [:= (cast-to-text :recent_views.model_id) :search_index.model_id]
+ [:= :recent_views.model
+ [:case
+ [:= :search_index.model [:inline "dataset"]] [:inline "card"]
+ [:= :search_index.model [:inline "metric"]] [:inline "card"]
+ :else :search_index.model]]]}))
(defn model-rank-expr
"Score an item based on its :model type."
diff --git a/src/metabase/search/spec.clj b/src/metabase/search/spec.clj
index 94bf75756a9..0681cf52aab 100644
--- a/src/metabase/search/spec.clj
+++ b/src/metabase/search/spec.clj
@@ -14,8 +14,7 @@
(def search-models
"Set of search model string names. Sorted by order to index based on importance and amount of time to index"
(cond-> ["collection" "dashboard" "segment" "database" "action"]
- config/ee-available? (conj "document")
- config/ee-available? (conj "transform")
+ config/ee-available? (conj "document" "transform")
;; metric/card/dataset moved to the end because they take a long time due to computing has_temporal_dim etc.
;; table and indexed-entity moved to the end because there can be a large number of them
true (conj "table" "indexed-entity" "metric" "card" "dataset")))
diff --git a/test/metabase/search/in_place/filter_test.clj b/test/metabase/search/in_place/filter_test.clj
index f392ca9155d..d051f9d2579 100644
--- a/test/metabase/search/in_place/filter_test.clj
+++ b/test/metabase/search/in_place/filter_test.clj
@@ -100,7 +100,8 @@
:last-edited-at "past3days"})))))
(testing "search native query"
- (is (= #{"dataset" "action" "card" "metric"}
+ (is (= (cond-> #{"dataset" "action" "card" "metric"}
+ config/ee-available? (conj "transform"))
(search.filter/search-context->applicable-models
(merge default-search-ctx
{:search-native-query true})))))))
diff --git a/yarn.lock b/yarn.lock
index 37a81d76ce5..27fade42978 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -1243,6 +1243,17 @@
"@codemirror/view" "^6.35.0"
crelt "^1.0.5"
+"@codemirror/merge@^6.10.2":
+ version "6.10.2"
+ resolved "https://registry.yarnpkg.com/@codemirror/merge/-/merge-6.10.2.tgz#b87b27fff45f38c3e3c7a463d8a0c2f2e81c4263"
+ integrity sha512-rmHzVkt5FnCtsi0IgvDIDjh/J4LmbfOboB7FMvVl21IHO0p1QM6jSwjkBjBD3D+c+T79OabEqoduCqvJCBV8Yg==
+ dependencies:
+ "@codemirror/language" "^6.0.0"
+ "@codemirror/state" "^6.0.0"
+ "@codemirror/view" "^6.17.0"
+ "@lezer/highlight" "^1.0.0"
+ style-mod "^4.1.0"
+
"@codemirror/search@^6.0.0":
version "6.5.9"
resolved "https://registry.yarnpkg.com/@codemirror/search/-/search-6.5.9.tgz#08829cf1db9d093dd4822bb22ece93da3ebffefc"