The easy-to-use open source Business Intelligence and Embedded Analytics tool that lets everyone work with data :bar_chart:
TypeScript analyticsbibusiness-intelligencebusinessintelligenceclojuredashboarddatadata-analysisdata-visualizationdatabasemetabasemysqlpostgrespostgresqlreportingslacksql-editorvisualization
test(sdk-package): split useMetabaseQuery hook tests into smaller test suites (#78109)
Phoomparin Mano6569bc127169
diff --git a/enterprise/frontend/src/embedding-sdk-package/hooks/public/use-metabase-query/tests/fixtures.ts b/enterprise/frontend/src/embedding-sdk-package/hooks/public/use-metabase-query/tests/fixtures.tsnew file mode 100644index 00000000000..153dc31411f--- /dev/null+++ b/enterprise/frontend/src/embedding-sdk-package/hooks/public/use-metabase-query/tests/fixtures.ts@@ -0,0 +1,231 @@+/* eslint-disable metabase/no-external-references-for-sdk-package-code */++import { createMockCard } from "metabase-types/api/mocks";++const column = <+ TFieldId extends number,+ TTableId extends number,+ TName extends string,+ TDisplayName extends string,+ TJsType extends string,+ TOptions extends object = object,+>(+ fieldId: TFieldId,+ tableId: TTableId,+ name: TName,+ displayName: TDisplayName,+ jsType: TJsType,+ // The empty default has the caller's inferred override shape.+ options = {} as TOptions,+) => ({+ type: "column" as const,+ fieldId,+ tableId,+ name,+ displayName,+ jsType,+ ...options,+});++const joinedColumn = <+ TFieldId extends number,+ TName extends string,+ TDisplayName extends string,+ TJsType extends string,+>(+ fieldId: TFieldId,+ sourceFieldId: number,+ name: TName,+ displayName: TDisplayName,+ jsType: TJsType,+) => ({+ type: "column" as const,+ fieldId,+ sourceFieldId,+ name,+ displayName,+ jsType,+});++const metadataField = (+ id: number,+ tableId: number,+ name: string,+ displayName: string,+ baseType: string,+ options: object = {},+) => ({+ id,+ table_id: tableId,+ name,+ display_name: displayName,+ base_type: baseType,+ effective_type: baseType,+ ...options,+});++const cardMetadata = (+ id: number,+ name: string,+ sourceTable: number,+ aggregation?: [["sum", ["field", number, null]]],+) =>+ createMockCard({+ id,+ name,+ ...(aggregation && { type: "metric" }),+ dataset_query: {+ type: "query",+ database: 1,+ query: {+ "source-table": sourceTable,+ ...(aggregation && { aggregation }),+ },+ },+ });++export const TEST_SCHEMA = {+ tables: {+ orders: {+ type: "table" as const,+ id: 1,+ fields: {+ id: column(100, 1, "ID", "ID", "number"),+ createdAt: column(103, 1, "CREATED_AT", "Created At", "Date", {+ baseType: "type/DateTime",+ }),+ amount: column(102, 1, "AMOUNT", "Amount", "number"),+ status: column(101, 1, "STATUS", "Status", "string"),+ },+ segments: {+ completed: { type: "segment" as const, id: 11, tableId: 1 },+ },+ measures: {+ revenue: {+ type: "measure" as const,+ id: 21,+ tableId: 1,+ columns: [{ name: "sum", displayName: "Sum", jsType: "number" }],+ },+ },+ },+ products: {+ type: "table" as const,+ id: 2,+ fields: {+ price: column(201, 2, "PRICE", "Price", "number"),+ },+ segments: {+ active: { type: "segment" as const, id: 12, tableId: 2 },+ },+ measures: {+ price: {+ type: "measure" as const,+ id: 22,+ tableId: 2,+ columns: [{ name: "price", displayName: "Price", jsType: "number" }],+ },+ },+ },+ },+ metrics: {+ revenue: {+ type: "metric" as const,+ id: 31,+ sourceTableId: 1,+ mappedTableIds: [1, 2],+ columns: [{ name: "sum", displayName: "Revenue", jsType: "number" }],+ dimensions: {+ orders: {+ amount: column(102, 1, "AMOUNT", "Amount", "number"),+ createdAt: column(103, 1, "CREATED_AT", "Created At", "Date", {+ baseType: "type/DateTime",+ }),+ status: column(101, 1, "STATUS", "Status", "string"),+ product: joinedColumn(202, 104, "NAME", "Name", "string"),+ },+ },+ },+ productRevenue: {+ type: "metric" as const,+ id: 32,+ sourceTableId: 2,+ mappedTableIds: [2],+ },+ questionRevenue: {+ type: "metric" as const,+ id: 33,+ sourceCardId: 41,+ },+ },+ questions: {+ ordersQuestion: {+ type: "card" as const,+ id: 41,+ columns: [+ {+ type: "column" as const,+ name: "STATUS",+ displayName: "Status",+ jsType: "string",+ },+ {+ type: "column" as const,+ name: "AMOUNT",+ displayName: "Amount",+ jsType: "number",+ },+ ],+ },+ },+} as const;++export const TEST_METADATA = {+ databases: {+ 1: {+ id: 1,+ name: "Test Database",+ features: ["basic-aggregations", "binning", "expressions"],+ },+ },+ tables: {+ 1: { id: 1, db_id: 1, name: "orders", display_name: "Orders" },+ 2: { id: 2, db_id: 1, name: "products", display_name: "Products" },+ },+ fields: {+ 100: metadataField(100, 1, "ID", "ID", "type/Integer"),+ 101: metadataField(101, 1, "STATUS", "Status", "type/Text"),+ 102: metadataField(102, 1, "AMOUNT", "Amount", "type/Float"),+ 103: metadataField(103, 1, "CREATED_AT", "Created At", "type/DateTime"),+ 104: metadataField(104, 1, "PRODUCT_ID", "Product ID", "type/Integer", {+ semantic_type: "type/FK",+ fk_target_field_id: 200,+ }),+ 200: metadataField(200, 2, "ID", "ID", "type/Integer", {+ semantic_type: "type/PK",+ }),+ 202: metadataField(202, 2, "NAME", "Name", "type/Text"),+ },+ segments: {+ 11: { id: 11, table_id: 1, name: "Completed" },+ },+ measures: {+ 21: {+ id: 21,+ name: "Revenue",+ table_id: 1,+ definition: {+ type: "query",+ database: 1,+ query: {+ "source-table": 1,+ aggregation: [["count"]],+ },+ },+ },+ },+ questions: {+ 41: cardMetadata(41, "Orders question", 1),+ 31: cardMetadata(31, "Revenue", 1, [["sum", ["field", 102, null]]]),+ },+};diff --git a/enterprise/frontend/src/embedding-sdk-package/hooks/public/use-metabase-query/tests/resolve-dataset-query-validation.unit.spec.tsx b/enterprise/frontend/src/embedding-sdk-package/hooks/public/use-metabase-query/tests/resolve-dataset-query-validation.unit.spec.tsxnew file mode 100644index 00000000000..f9cc558c2a7--- /dev/null+++ b/enterprise/frontend/src/embedding-sdk-package/hooks/public/use-metabase-query/tests/resolve-dataset-query-validation.unit.spec.tsx@@ -0,0 +1,170 @@+/* eslint-disable import/order */++import { createMockStore, resetTestState } from "./setup";+import { TEST_SCHEMA } from "./fixtures";++import { resolveDatasetQuery as resolveDatasetQueryInBundle } from "embedding-sdk-bundle/lib/create-metabase-query";++import { avg, breakout, filter, orderBy, sum } from "..";++beforeEach(resetTestState);++describe("resolveDatasetQuery validation", () => {+ it("rejects invalid limits with a clear error message", async () => {+ await expect(+ resolveDatasetQueryInBundle(createMockStore())({+ source: TEST_SCHEMA.tables.orders,+ limit: 0,+ }),+ ).rejects.toThrow("Table query limit must be a positive integer.");+ });++ it("rejects cross-table query clauses with clear error messages", async () => {+ await expect(+ resolveDatasetQueryInBundle(createMockStore())({+ source: TEST_SCHEMA.tables.orders,+ fields: [TEST_SCHEMA.tables.products.fields.price],+ }),+ ).rejects.toThrow(+ "Table query fields must belong to source table 1, but received table id 2.",+ );++ await expect(+ resolveDatasetQueryInBundle(createMockStore())({+ source: TEST_SCHEMA.tables.orders,+ filters: [filter(TEST_SCHEMA.tables.products.fields.price, "=", 10)],+ }),+ ).rejects.toThrow(+ "Table query filters must belong to source table 1, but received table id 2.",+ );++ await expect(+ resolveDatasetQueryInBundle(createMockStore())({+ source: TEST_SCHEMA.tables.orders,+ aggregations: [sum(TEST_SCHEMA.tables.products.fields.price)],+ }),+ ).rejects.toThrow(+ "Table query aggregations must belong to source table 1, but received table id 2.",+ );++ await expect(+ resolveDatasetQueryInBundle(createMockStore())({+ source: TEST_SCHEMA.tables.orders,+ breakouts: [TEST_SCHEMA.tables.products.fields.price],+ }),+ ).rejects.toThrow(+ "Table query breakouts must belong to source table 1, but received table id 2.",+ );++ await expect(+ resolveDatasetQueryInBundle(createMockStore())({+ source: TEST_SCHEMA.tables.orders,+ orderBys: [orderBy(TEST_SCHEMA.tables.products.fields.price, "desc")],+ }),+ ).rejects.toThrow(+ "Table query orderBys must belong to source table 1, but received table id 2.",+ );++ await expect(+ resolveDatasetQueryInBundle(createMockStore())({+ source: TEST_SCHEMA.tables.orders,+ aggregations: [avg(TEST_SCHEMA.tables.orders.fields.amount)],+ breakouts: [breakout(TEST_SCHEMA.tables.orders.fields.status)],+ orderBys: [orderBy(TEST_SCHEMA.tables.orders.fields.amount, "desc")],+ }),+ ).rejects.toThrow(+ "Table query orderBys for grouped queries must use query breakouts or aggregations included in the query.",+ );++ await expect(+ resolveDatasetQueryInBundle(createMockStore())({+ source: TEST_SCHEMA.tables.orders,+ breakouts: [+ breakout(TEST_SCHEMA.tables.orders.fields.createdAt, {+ unit: "month",+ }),+ ],+ orderBys: [+ orderBy(TEST_SCHEMA.tables.orders.fields.createdAt, "desc", {+ unit: "year",+ }),+ ],+ }),+ ).rejects.toThrow(+ "Table query orderBys for grouped queries must use query breakouts or aggregations included in the query.",+ );+ });++ it("rejects cross-table metric aggregations with clear error messages", async () => {+ await expect(+ resolveDatasetQueryInBundle(createMockStore())({+ source: TEST_SCHEMA.tables.orders,+ aggregations: [TEST_SCHEMA.metrics.productRevenue],+ }),+ ).rejects.toThrow(+ "Table query metric aggregations must belong to source table 1, but received mapped table ids 2.",+ );+ });++ it("rejects metric aggregations without source table metadata", async () => {+ await expect(+ resolveDatasetQueryInBundle(createMockStore())({+ source: TEST_SCHEMA.tables.orders,+ aggregations: [{ type: "metric", id: 31 }],+ }),+ ).rejects.toThrow(+ "Table query metric aggregations must include source table metadata.",+ );+ });++ it("rejects source-card metric aggregations under table sources", async () => {+ await expect(+ resolveDatasetQueryInBundle(createMockStore())({+ source: TEST_SCHEMA.tables.orders,+ aggregations: [TEST_SCHEMA.metrics.questionRevenue],+ }),+ ).rejects.toThrow(+ "Table query metric aggregations cannot use source-card Metrics. Use a saved question source for source-card Metrics.",+ );+ });++ it("rejects unsupported saved question query clauses with a clear error message", async () => {+ await expect(+ resolveDatasetQueryInBundle(createMockStore())({+ source: TEST_SCHEMA.questions.ordersQuestion,+ fields: [TEST_SCHEMA.questions.ordersQuestion.columns[0]],+ }),+ ).rejects.toThrow(+ "Saved question queries only support source and enabled, but received fields.",+ );++ await expect(+ resolveDatasetQueryInBundle(createMockStore())({+ source: TEST_SCHEMA.questions.ordersQuestion,+ limit: 10,+ }),+ ).rejects.toThrow(+ "Saved question queries only support source and enabled, but received limit.",+ );++ await expect(+ resolveDatasetQueryInBundle(createMockStore())({+ source: TEST_SCHEMA.questions.ordersQuestion,+ aggregations: [avg(TEST_SCHEMA.questions.ordersQuestion.columns[1])],+ }),+ ).rejects.toThrow(+ "Saved question queries only support source and enabled, but received aggregations.",+ );+ });++ it("rejects metric sources with a clear error message", async () => {+ await expect(+ resolveDatasetQueryInBundle(createMockStore())({+ // @ts-expect-error a metric is not a valid query source+ source: TEST_SCHEMA.metrics.revenue,+ }),+ ).rejects.toThrow(+ 'Query object creation requires a source reference like `{ type: "table", id }` or `{ type: "card", id }`.',+ );+ });+});diff --git a/enterprise/frontend/src/embedding-sdk-package/hooks/public/use-metabase-query/tests/resolve-dataset-query.unit.spec.tsx b/enterprise/frontend/src/embedding-sdk-package/hooks/public/use-metabase-query/tests/resolve-dataset-query.unit.spec.tsxnew file mode 100644index 00000000000..f997a4bbd89--- /dev/null+++ b/enterprise/frontend/src/embedding-sdk-package/hooks/public/use-metabase-query/tests/resolve-dataset-query.unit.spec.tsx@@ -0,0 +1,402 @@+/* eslint-disable import/order */++import {+ createMockStore,+ mockFetchTableMetadata,+ mockGetMetadataUnfiltered,+ mockRunRtkEndpoint,+ resetTestState,+ stagesOf,+} from "./setup";+import { TEST_SCHEMA } from "./fixtures";++import { resolveDatasetQuery as resolveDatasetQueryInBundle } from "embedding-sdk-bundle/lib/create-metabase-query";+import { cardApi } from "metabase/api";++import { avg, breakout, count, filter, orderBy, sum } from "..";++beforeEach(resetTestState);++describe("resolveDatasetQuery", () => {+ it("loads table metadata and passes the public source DSL through Lib.createTestQuery", async () => {+ const store = createMockStore();++ const datasetQuery = await resolveDatasetQueryInBundle(store)({+ source: TEST_SCHEMA.tables.orders,+ fields: [+ TEST_SCHEMA.tables.orders.fields.id,+ TEST_SCHEMA.tables.orders.fields.status,+ ],+ filters: [+ TEST_SCHEMA.tables.orders.segments.completed,+ filter(TEST_SCHEMA.tables.orders.fields.status, "=", "paid"),+ ],+ aggregations: [count(), sum(TEST_SCHEMA.tables.orders.fields.amount)],+ breakouts: [+ breakout(TEST_SCHEMA.tables.orders.fields.createdAt, { unit: "month" }),+ ],+ orderBys: [+ orderBy(TEST_SCHEMA.tables.orders.fields.createdAt, "desc", {+ unit: "month",+ }),+ ],+ limit: 100,+ });++ expect(mockFetchTableMetadata).toHaveBeenCalledWith({ id: 1 });++ expect(store.dispatch).toHaveBeenCalledWith({+ type: "fetchTableMetadata",+ payload: 1,+ });++ expect(mockGetMetadataUnfiltered).toHaveBeenCalledWith({});++ expect(datasetQuery).toMatchObject({+ "lib/type": "mbql/query",+ database: 1,+ stages: [+ {+ "lib/type": "mbql.stage/mbql",+ "source-table": 1,+ fields: [+ ["field", expect.anything(), 100],+ ["field", expect.anything(), 101],+ ],+ filters: [+ ["segment", expect.anything(), 11],+ ["=", expect.anything(), ["field", expect.anything(), 101], "paid"],+ ],+ aggregation: [+ ["count", expect.anything()],+ ["sum", expect.anything(), ["field", expect.anything(), 102]],+ ],+ breakout: [+ [+ "field",+ expect.objectContaining({ "temporal-unit": "month" }),+ 103,+ ],+ ],+ "order-by": [+ [+ "desc",+ expect.anything(),+ [+ "field",+ expect.objectContaining({ "temporal-unit": "month" }),+ 103,+ ],+ ],+ ],+ limit: 100,+ },+ ],+ });+ });++ it("passes generated table Measures to Lib.createTestQuery measure aggregations", async () => {+ const datasetQuery = await resolveDatasetQueryInBundle(createMockStore())({+ source: TEST_SCHEMA.tables.orders,+ aggregations: [TEST_SCHEMA.tables.orders.measures.revenue],+ });++ expect(stagesOf(datasetQuery)[0].aggregation).toEqual([+ ["measure", expect.anything(), 21],+ ]);+ });++ it("accepts id-only table source references", async () => {+ const datasetQuery = await resolveDatasetQueryInBundle(createMockStore())({+ source: { type: "table", id: 1 },+ fields: [TEST_SCHEMA.tables.orders.fields.id],+ });++ expect(datasetQuery).toMatchObject({+ database: 1,+ stages: [+ {+ "source-table": 1,+ fields: [["field", expect.anything(), 100]],+ },+ ],+ });+ });++ it("loads metric aggregation metadata and passes the public table source DSL through Lib.createTestQuery", async () => {+ const store = createMockStore();++ const datasetQuery = await resolveDatasetQueryInBundle(store)({+ source: TEST_SCHEMA.tables.orders,+ filters: [+ TEST_SCHEMA.tables.orders.segments.completed,+ filter(+ TEST_SCHEMA.metrics.revenue.dimensions.orders.status,+ "=",+ "paid",+ ),+ ],+ aggregations: [+ TEST_SCHEMA.metrics.revenue,+ count(),+ sum(TEST_SCHEMA.metrics.revenue.dimensions.orders.amount),+ TEST_SCHEMA.tables.orders.measures.revenue,+ ],+ breakouts: [+ breakout(TEST_SCHEMA.metrics.revenue.dimensions.orders.createdAt, {+ unit: "month",+ }),+ ],+ limit: 100,+ });++ expect(mockFetchTableMetadata).toHaveBeenCalledWith({ id: 1 });++ expect(mockRunRtkEndpoint).toHaveBeenNthCalledWith(+ 1,+ { id: 31 },+ store.dispatch,+ cardApi.endpoints.getCard,+ { forceRefetch: false },+ );++ expect(mockRunRtkEndpoint).toHaveBeenNthCalledWith(+ 2,+ 31,+ store.dispatch,+ cardApi.endpoints.getCardQueryMetadata,+ { forceRefetch: false },+ );++ expect(datasetQuery).toMatchObject({+ "lib/type": "mbql/query",+ database: 1,+ stages: [+ {+ "lib/type": "mbql.stage/mbql",+ "source-table": 1,+ filters: [+ ["segment", expect.anything(), 11],+ ["=", expect.anything(), ["field", expect.anything(), 101], "paid"],+ ],+ aggregation: [+ ["metric", expect.anything(), 31],+ ["count", expect.anything()],+ ["sum", expect.anything(), ["field", expect.anything(), 102]],+ ["measure", expect.anything(), 21],+ ],+ breakout: [+ [+ "field",+ expect.objectContaining({ "temporal-unit": "month" }),+ 103,+ ],+ ],+ limit: 100,+ },+ ],+ });+ });++ it("builds metric queries with FK-joined dimension breakouts", async () => {+ const datasetQuery = await resolveDatasetQueryInBundle(createMockStore())({+ source: TEST_SCHEMA.tables.orders,+ aggregations: [TEST_SCHEMA.metrics.revenue],+ breakouts: [+ breakout(TEST_SCHEMA.metrics.revenue.dimensions.orders.product),+ ],+ });++ expect(datasetQuery).toMatchObject({+ database: 1,+ stages: [+ {+ "source-table": 1,+ aggregation: [["metric", expect.anything(), 31]],+ breakout: [+ ["field", expect.objectContaining({ "source-field": 104 }), 202],+ ],+ },+ ],+ });+ });++ it("passes generated metric dimension orderBys through Lib.createTestQuery", async () => {+ const datasetQuery = await resolveDatasetQueryInBundle(createMockStore())({+ source: TEST_SCHEMA.tables.orders,+ aggregations: [TEST_SCHEMA.metrics.revenue],+ breakouts: [+ breakout(TEST_SCHEMA.metrics.revenue.dimensions.orders.createdAt, {+ unit: "month",+ }),+ ],+ orderBys: [+ orderBy(+ TEST_SCHEMA.metrics.revenue.dimensions.orders.createdAt,+ "desc",+ { unit: "month" },+ ),+ ],+ limit: 12,+ });++ expect(datasetQuery).toMatchObject({+ stages: [+ {+ "source-table": 1,+ aggregation: [["metric", expect.anything(), 31]],+ breakout: [+ [+ "field",+ expect.objectContaining({ "temporal-unit": "month" }),+ 103,+ ],+ ],+ "order-by": [+ [+ "desc",+ expect.anything(),+ [+ "field",+ expect.objectContaining({ "temporal-unit": "month" }),+ 103,+ ],+ ],+ ],+ limit: 12,+ },+ ],+ });+ });++ it("loads saved question metadata and passes the question source through Lib.createTestQuery", async () => {+ const store = createMockStore();++ const datasetQuery = await resolveDatasetQueryInBundle(store)({+ source: TEST_SCHEMA.questions.ordersQuestion,+ });++ expect(mockFetchTableMetadata).not.toHaveBeenCalled();++ expect(mockRunRtkEndpoint).toHaveBeenNthCalledWith(+ 1,+ { id: 41 },+ store.dispatch,+ cardApi.endpoints.getCard,+ { forceRefetch: false },+ );++ expect(mockRunRtkEndpoint).toHaveBeenNthCalledWith(+ 2,+ 41,+ store.dispatch,+ cardApi.endpoints.getCardQueryMetadata,+ { forceRefetch: false },+ );++ expect(datasetQuery).toMatchObject({+ "lib/type": "mbql/query",+ database: 1,+ stages: [+ {+ "lib/type": "mbql.stage/mbql",+ "source-card": 41,+ },+ ],+ });+ });++ it("passes aggregation result orderBys through Lib.createTestQuery", async () => {+ const avgAmount = avg(TEST_SCHEMA.tables.orders.fields.amount);++ const datasetQuery = await resolveDatasetQueryInBundle(createMockStore())({+ source: TEST_SCHEMA.tables.orders,+ aggregations: [avgAmount],+ breakouts: [breakout(TEST_SCHEMA.tables.orders.fields.status)],+ orderBys: [orderBy(avgAmount, "desc")],+ limit: 15,+ });++ expect(datasetQuery).toMatchObject({+ stages: [+ {+ aggregation: [+ ["avg", expect.anything(), ["field", expect.anything(), 102]],+ ],+ breakout: [["field", expect.anything(), 101]],+ "order-by": [+ [+ "desc",+ expect.anything(),+ ["aggregation", expect.anything(), expect.anything()],+ ],+ ],+ limit: 15,+ },+ ],+ });+ });++ it("passes metric aggregation result orderBys through Lib.createTestQuery", async () => {+ const avgAmount = avg(TEST_SCHEMA.metrics.revenue.dimensions.orders.amount);++ const datasetQuery = await resolveDatasetQueryInBundle(createMockStore())({+ source: TEST_SCHEMA.tables.orders,+ aggregations: [TEST_SCHEMA.metrics.revenue, avgAmount],+ breakouts: [+ breakout(TEST_SCHEMA.metrics.revenue.dimensions.orders.status),+ ],+ orderBys: [orderBy(avgAmount, "desc")],+ limit: 15,+ });++ expect(datasetQuery).toMatchObject({+ stages: [+ {+ aggregation: [+ ["metric", expect.anything(), 31],+ ["avg", expect.anything(), ["field", expect.anything(), 102]],+ ],+ breakout: [["field", expect.anything(), 101]],+ "order-by": [+ [+ "desc",+ expect.anything(),+ ["aggregation", expect.anything(), expect.anything()],+ ],+ ],+ limit: 15,+ },+ ],+ });+ });++ it("passes metric aggregation orderBys through Lib.createTestQuery", async () => {+ const datasetQuery = await resolveDatasetQueryInBundle(createMockStore())({+ source: TEST_SCHEMA.tables.orders,+ aggregations: [TEST_SCHEMA.metrics.revenue],+ breakouts: [+ breakout(TEST_SCHEMA.metrics.revenue.dimensions.orders.status),+ ],+ orderBys: [orderBy(TEST_SCHEMA.metrics.revenue, "desc")],+ limit: 15,+ });++ expect(datasetQuery).toMatchObject({+ stages: [+ {+ aggregation: [["metric", expect.anything(), 31]],+ breakout: [["field", expect.anything(), 101]],+ "order-by": [+ [+ "desc",+ expect.anything(),+ ["aggregation", expect.anything(), expect.anything()],+ ],+ ],+ limit: 15,+ },+ ],+ });+ });+});diff --git a/enterprise/frontend/src/embedding-sdk-package/hooks/public/use-metabase-query/tests/setup.tsx b/enterprise/frontend/src/embedding-sdk-package/hooks/public/use-metabase-query/tests/setup.tsxnew file mode 100644index 00000000000..e23ff62d159--- /dev/null+++ b/enterprise/frontend/src/embedding-sdk-package/hooks/public/use-metabase-query/tests/setup.tsx@@ -0,0 +1,140 @@+/* eslint-disable metabase/no-external-references-for-sdk-package-code */++import type { SdkStore } from "embedding-sdk-bundle/store/types";+import type { MetabaseEmbeddingSdkBundleExports } from "embedding-sdk-bundle/types/sdk-bundle";+import { useLazySelector } from "embedding-sdk-package/hooks/private/use-lazy-selector";+import { useMetabaseProviderPropsStore } from "embedding-sdk-shared/hooks/use-metabase-provider-props-store";+import { useSdkLoadingState } from "embedding-sdk-shared/hooks/use-sdk-loading-state";+import { ensureMetabaseProviderPropsStore } from "embedding-sdk-shared/lib/ensure-metabase-provider-props-store";+import { SdkLoadingState } from "embedding-sdk-shared/types/sdk-loading";+import { runRtkEndpoint } from "metabase/api/utils/run-rtk-endpoint";+import { fetchTableMetadata } from "metabase/redux/tables";+import { getMetadataUnfiltered } from "metabase/selectors/metadata";+import type { DatasetQuery } from "metabase-types/api";++import { TEST_METADATA } from "./fixtures";++jest.mock("embedding-sdk-package/hooks/private/use-lazy-selector", () => ({+ useLazySelector: jest.fn(() => ({ status: "success" })),+}));++jest.mock(+ "embedding-sdk-shared/hooks/use-metabase-provider-props-store",+ () => ({+ useMetabaseProviderPropsStore: jest.fn(),+ }),+);++jest.mock("embedding-sdk-shared/hooks/use-sdk-loading-state", () => ({+ useSdkLoadingState: jest.fn(() => ({ loadingState: "loaded" })),+}));++jest.mock("metabase/api", () => ({+ cardApi: {+ endpoints: {+ getCard: { name: "getCard" },+ getCardQueryMetadata: { name: "getCardQueryMetadata" },+ },+ },+}));++jest.mock("metabase/api/utils/run-rtk-endpoint", () => ({+ runRtkEndpoint: jest.fn(() => Promise.resolve(undefined)),+}));++jest.mock("metabase/redux/tables", () => ({+ fetchTableMetadata: jest.fn(({ id }) => ({+ type: "fetchTableMetadata",+ payload: id,+ })),+}));++jest.mock("metabase/selectors/metadata", () => ({+ getMetadataUnfiltered: jest.fn(),+}));++export const mockFetchTableMetadata = jest.mocked(fetchTableMetadata);+export const mockGetMetadataUnfiltered = jest.mocked(getMetadataUnfiltered);+export const mockRunRtkEndpoint = jest.mocked(runRtkEndpoint);+export const mockUseLazySelector = jest.mocked(useLazySelector);+export const mockUseMetabaseProviderPropsStore = jest.mocked(+ useMetabaseProviderPropsStore,+);+export const mockUseSdkLoadingState = jest.mocked(useSdkLoadingState);++export const createMockStore = (): SdkStore =>+ // A real `getSdkStore()` pulls in reducers this spec's API mock cannot satisfy.+ ({+ dispatch: jest.fn((action) => Promise.resolve(action)),+ getState: jest.fn(() => ({})),+ }) as unknown as SdkStore;++type MbqlStage = Record<string, unknown>;++export const createMockDatasetQuery = (stages: MbqlStage[]): DatasetQuery =>+ // `DatasetQuery` is opaque, so a test cannot construct it without type casts.+ ({+ "lib/type": "mbql/query",+ database: 1,+ stages,+ }) as unknown as DatasetQuery;++export const stagesOf = (query: DatasetQuery): MbqlStage[] =>+ // `DatasetQuery` does not expose its stages in its public type.+ (query as unknown as { stages: MbqlStage[] }).stages;++export const TEST_DATASET_QUERY = createMockDatasetQuery([+ { "source-table": 1 },+]);++export const mockPropsStore = (reduxStore: SdkStore) =>+ mockUseMetabaseProviderPropsStore.mockReturnValue({+ state: { internalProps: { reduxStore }, props: null },+ store: ensureMetabaseProviderPropsStore(),+ });++export const stubSdkBundle = (+ bundleExports: Partial<MetabaseEmbeddingSdkBundleExports>,+): void => {+ window.METABASE_EMBEDDING_SDK_BUNDLE =+ // The global is typed as the whole bundle; tests install only needed functions.+ bundleExports as MetabaseEmbeddingSdkBundleExports;+};++export const LOADED_SDK_STATE: ReturnType<typeof useSdkLoadingState> = {+ loadingState: SdkLoadingState.Loaded,+ loadingError: null,+ isInitial: false,+ isLoading: false,+ isLoaded: true,+ isInitialized: false,+ isError: false,+ isNotStartedLoading: false,+};++export function createDeferred<TValue>() {+ let resolve!: (value: TValue) => void;+ let reject!: (error: unknown) => void;++ const promise = new Promise<TValue>((resolvePromise, rejectPromise) => {+ resolve = resolvePromise;+ reject = rejectPromise;+ });++ return { promise, resolve, reject };+}++export const resetTestState = (): void => {+ jest.clearAllMocks();+ mockRunRtkEndpoint.mockResolvedValue(undefined);++ mockGetMetadataUnfiltered.mockReturnValue(+ // `Metadata` is a class; the fixture is the plain shape read out of it.+ TEST_METADATA as unknown as ReturnType<typeof getMetadataUnfiltered>,+ );++ mockUseLazySelector.mockReturnValue({ status: "success" });+ mockUseSdkLoadingState.mockReturnValue(LOADED_SDK_STATE);+ mockPropsStore(createMockStore());+ window.METABASE_EMBEDDING_SDK_BUNDLE = undefined;+};diff --git a/enterprise/frontend/src/embedding-sdk-package/hooks/public/use-metabase-query/tests/type-contract-invalid.ts b/enterprise/frontend/src/embedding-sdk-package/hooks/public/use-metabase-query/tests/type-contract-invalid.tsnew file mode 100644index 00000000000..0e5216d9af7--- /dev/null+++ b/enterprise/frontend/src/embedding-sdk-package/hooks/public/use-metabase-query/tests/type-contract-invalid.ts@@ -0,0 +1,128 @@+/* eslint-disable import/order */++import { TEST_SCHEMA } from "./fixtures";++import type { MetabaseCard } from "metabase/embedding-sdk/types/question";++import type { MetabaseQueryOptions, UseMetabaseQueryObjectResult } from "..";+import { breakout, sum, useMetabaseQuery } from "..";++type OrdersTable = (typeof TEST_SCHEMA)["tables"]["orders"];+type OrdersQuestion = (typeof TEST_SCHEMA)["questions"]["ordersQuestion"];++// --------+// Compile-time contracts that must **fail** type-checking.+//+// Enforced by the TypeScript compiler.+// These fixtures never run.+// --------++const _invalidCrossTableSegmentQuery = {+ source: TEST_SCHEMA.tables.orders,+ filters: [+ // @ts-expect-error segments must belong to the source table+ TEST_SCHEMA.tables.products.segments.active,+ ],+} satisfies MetabaseQueryOptions<OrdersTable>;++const _invalidCrossTableMeasureQuery = {+ source: TEST_SCHEMA.tables.orders,+ aggregations: [+ // @ts-expect-error measures must belong to the source table+ TEST_SCHEMA.tables.products.measures.price,+ ],+} satisfies MetabaseQueryOptions<OrdersTable>;++const _invalidCrossTableFieldQuery = {+ source: TEST_SCHEMA.tables.orders,+ fields: [+ // @ts-expect-error fields must belong to the source table+ TEST_SCHEMA.tables.products.fields.price,+ ],+} satisfies MetabaseQueryOptions<OrdersTable>;++const _invalidSavedQuestionClauseQuery = {+ source: TEST_SCHEMA.questions.ordersQuestion,++ // @ts-expect-error saved question queries only support source and enabled+ fields: [TEST_SCHEMA.questions.ordersQuestion.columns[0]],+} satisfies MetabaseQueryOptions<OrdersQuestion>;++// Only this value's type is used to reject passing the entire hook result to a card.+const hookResult = {} as UseMetabaseQueryObjectResult;+const _invalidHookResultCard = {+ // @ts-expect-error pass useMetabaseQueryObject(...).query, not the whole hook result+ query: hookResult,+} satisfies MetabaseCard;++const _invalidCrossTableMetricAggregationQuery = {+ source: TEST_SCHEMA.tables.orders,+ aggregations: [+ // @ts-expect-error metric aggregations must belong to the source table+ TEST_SCHEMA.metrics.productRevenue,+ ],+} satisfies MetabaseQueryOptions<OrdersTable>;++const _invalidIdOnlyMetricAggregationQuery = {+ source: TEST_SCHEMA.tables.orders,+ aggregations: [+ // @ts-expect-error metric aggregations must include source table metadata+ { type: "metric", id: 31 },+ ],+} satisfies MetabaseQueryOptions<OrdersTable>;++const _invalidSourceCardMetricAggregationQuery = {+ source: TEST_SCHEMA.tables.orders,+ aggregations: [+ // @ts-expect-error source-card metric aggregations need a saved question source+ TEST_SCHEMA.metrics.questionRevenue,+ ],+} satisfies MetabaseQueryOptions<OrdersTable>;++const _invalidMetricSourceQuery = {+ // @ts-expect-error Metrics must be used in aggregations, not as query sources+ source: TEST_SCHEMA.metrics.revenue,+} satisfies MetabaseQueryOptions;++function InvalidTypeFixtures() {+ const scalarAggregationResult = useMetabaseQuery({+ source: TEST_SCHEMA.tables.orders,+ aggregations: [sum(TEST_SCHEMA.tables.orders.fields.amount)],+ });++ // @ts-expect-error aggregation result rows should not include source fields+ void scalarAggregationResult.data?.rows[0]?.amount;++ const metricResult = useMetabaseQuery({+ source: TEST_SCHEMA.tables.orders,+ aggregations: [TEST_SCHEMA.metrics.revenue],+ });++ // @ts-expect-error aggregation result rows should not include source fields+ void metricResult.data?.rows[0]?.status;++ const groupedMetricResult = useMetabaseQuery<OrdersTable>({+ source: TEST_SCHEMA.tables.orders,+ aggregations: [TEST_SCHEMA.metrics.revenue],+ breakouts: [+ breakout(TEST_SCHEMA.metrics.revenue.dimensions.orders.createdAt, {+ unit: "month",+ }),+ ],+ });++ // @ts-expect-error result row keys use returned column names, not schema object keys+ void groupedMetricResult.data?.rows[0]?.createdAt;++ // @ts-expect-error grouped queries must include an explicit aggregation+ useMetabaseQuery<OrdersTable>({+ source: TEST_SCHEMA.tables.orders,+ breakouts: [+ breakout(TEST_SCHEMA.tables.orders.fields.createdAt, { unit: "month" }),+ ],+ });++ return null;+}++void InvalidTypeFixtures;diff --git a/enterprise/frontend/src/embedding-sdk-package/hooks/public/use-metabase-query/tests/type-contract-valid.ts b/enterprise/frontend/src/embedding-sdk-package/hooks/public/use-metabase-query/tests/type-contract-valid.tsnew file mode 100644index 00000000000..aad0519d789--- /dev/null+++ b/enterprise/frontend/src/embedding-sdk-package/hooks/public/use-metabase-query/tests/type-contract-valid.ts@@ -0,0 +1,107 @@+/* eslint-disable import/order */++import { TEST_SCHEMA } from "./fixtures";++import type { RowValue } from "../../data-schema";++import type { MetabaseCard } from "metabase/embedding-sdk/types/question";++import type { MetabaseQueryOptions, UseMetabaseQueryObjectResult } from "..";+import { breakout, orderBy, sum, useMetabaseQuery } from "..";++type OrdersTable = (typeof TEST_SCHEMA)["tables"]["orders"];++// --------+// Compile-time contracts that must pass type-checking.+//+// IMPORTANT: Only include type constructs that are not already covered by unit tests.+// If the usage pattern is already covered by a unit test, do not add it here.+//+// Enforced by the TypeScript compiler.+// These fixtures never run.+// --------++const _validCardQuery = {+ query: {+ "lib/type": "mbql/query",+ database: 1,+ stages: [],+ },+} satisfies MetabaseCard;++// Only this value's type is used to verify the hook result can populate a card.+const hookResult = {} as UseMetabaseQueryObjectResult;+const _validHookResultCard = {+ query: hookResult.query,+} satisfies MetabaseCard;++function ValidTypeFixtures() {+ const selectedFieldsResult = useMetabaseQuery({+ source: TEST_SCHEMA.tables.orders,+ fields: [TEST_SCHEMA.tables.orders.fields.id],+ });++ const selectedFieldValue: number | null | undefined =+ selectedFieldsResult.data?.rows[0]?.ID;++ void selectedFieldValue;++ const selectedFieldsQuery = {+ source: TEST_SCHEMA.tables.orders,+ fields: [+ TEST_SCHEMA.tables.orders.fields.id,+ TEST_SCHEMA.tables.orders.fields.status,+ ],+ } satisfies MetabaseQueryOptions<OrdersTable>;++ const selectedFieldsQueryResult = useMetabaseQuery(selectedFieldsQuery);++ const selectedQueryFieldValue: string | null | undefined =+ selectedFieldsQueryResult.data?.rows[0]?.STATUS;++ void selectedQueryFieldValue;++ const scalarAggregationResult = useMetabaseQuery({+ source: TEST_SCHEMA.tables.orders,+ aggregations: [sum(TEST_SCHEMA.tables.orders.fields.amount)],+ });++ const scalarAggregationValue: RowValue | undefined =+ scalarAggregationResult.data?.rows[0]?.sum;++ void scalarAggregationValue;++ const groupedMetricResult = useMetabaseQuery<OrdersTable>({+ source: TEST_SCHEMA.tables.orders,+ aggregations: [TEST_SCHEMA.metrics.revenue],+ breakouts: [+ breakout(TEST_SCHEMA.metrics.revenue.dimensions.orders.createdAt, {+ unit: "month",+ }),+ ],+ });++ const groupedMetricBreakoutValue: string | Date | null | undefined =+ groupedMetricResult.data?.rows[0]?.CREATED_AT;++ void groupedMetricBreakoutValue;++ const sortKey: "amount" | "createdAt" = "createdAt";++ type OrdersField =+ (typeof TEST_SCHEMA.tables.orders.fields)[keyof typeof TEST_SCHEMA.tables.orders.fields];++ const sortFields = {+ amount: TEST_SCHEMA.tables.orders.fields.amount,+ createdAt: TEST_SCHEMA.tables.orders.fields.createdAt,+ } satisfies Record<string, OrdersField>;++ useMetabaseQuery({+ source: TEST_SCHEMA.tables.orders,+ orderBys: [orderBy(sortFields[sortKey], "desc")],+ });++ return null;+}++void ValidTypeFixtures;diff --git a/enterprise/frontend/src/embedding-sdk-package/hooks/public/use-metabase-query/tests/use-metabase-query.unit.spec.tsx b/enterprise/frontend/src/embedding-sdk-package/hooks/public/use-metabase-query/tests/use-metabase-query.unit.spec.tsxnew file mode 100644index 00000000000..aa286340de9--- /dev/null+++ b/enterprise/frontend/src/embedding-sdk-package/hooks/public/use-metabase-query/tests/use-metabase-query.unit.spec.tsx@@ -0,0 +1,294 @@+/* eslint-disable import/order */++import {+ TEST_DATASET_QUERY,+ createDeferred,+ createMockDatasetQuery,+ mockUseLazySelector,+ resetTestState,+ stubSdkBundle,+} from "./setup";+import { TEST_SCHEMA } from "./fixtures";++import { act, renderHook, waitFor } from "@testing-library/react";++import type { QueryDatasetResult } from "embedding-sdk-bundle/lib/query-dataset";+import type { QueryInput } from "embedding-sdk-shared/lib/create-metabase-query/input-guards";+import type { DatasetQuery } from "metabase-types/api";++import { useMetabaseQuery, useMetabaseQueryObject } from "..";++beforeEach(resetTestState);++describe("useMetabaseQueryObject", () => {+ const query = {+ source: TEST_SCHEMA.tables.orders,+ limit: 10,+ };++ it("returns a loading state until async query creation resolves", async () => {+ const deferred = createDeferred<DatasetQuery>();+ const resolveDatasetQuery = jest.fn(() => jest.fn(() => deferred.promise));+ stubSdkBundle({ resolveDatasetQuery });++ const { result } = renderHook(() => useMetabaseQueryObject(query));++ expect(result.current).toEqual({+ query: null,+ error: null,+ isLoading: true,+ });++ deferred.resolve(TEST_DATASET_QUERY);++ await waitFor(() =>+ expect(result.current).toEqual({+ query: TEST_DATASET_QUERY,+ error: null,+ isLoading: false,+ }),+ );+ });++ it("returns query creation errors instead of swallowing them", async () => {+ const error = new Error("No column found");+ const resolveDatasetQuery = jest.fn(() =>+ jest.fn(() => Promise.reject(error)),+ );++ stubSdkBundle({ resolveDatasetQuery });++ const { result } = renderHook(() => useMetabaseQueryObject(query));++ await waitFor(() =>+ expect(result.current).toEqual({+ query: null,+ error,+ isLoading: false,+ }),+ );+ });++ it("waits for login before resolving the query", async () => {+ const resolveDatasetQuery = jest.fn(() =>+ jest.fn(() => Promise.resolve(TEST_DATASET_QUERY)),+ );++ stubSdkBundle({ resolveDatasetQuery });+ mockUseLazySelector.mockReturnValue({ status: "loading" });++ const { result, rerender } = renderHook(() =>+ useMetabaseQueryObject(query),+ );++ expect(result.current).toEqual({+ query: null,+ error: null,+ isLoading: true,+ });+ expect(resolveDatasetQuery).not.toHaveBeenCalled();++ mockUseLazySelector.mockReturnValue({ status: "success" });+ rerender();++ await waitFor(() => {+ expect(resolveDatasetQuery).toHaveBeenCalled();++ expect(result.current).toEqual({+ query: TEST_DATASET_QUERY,+ error: null,+ isLoading: false,+ });+ });+ });++ it("does not expose stale query results after the input changes", async () => {+ const firstDeferred = createDeferred<DatasetQuery>();+ const secondDeferred = createDeferred<DatasetQuery>();++ const firstQuery = {+ source: TEST_SCHEMA.tables.orders,+ limit: 10,+ };++ const secondQuery = {+ source: TEST_SCHEMA.tables.orders,+ limit: 20,+ };++ const secondDatasetQuery = createMockDatasetQuery([+ { "source-table": 1, limit: 20 },+ ]);++ // Which deferred a call gets is decided by the only field that differs.+ const resolveDatasetQuery = jest.fn(+ () => (input: QueryInput) =>+ "limit" in input && input.limit === 10+ ? firstDeferred.promise+ : secondDeferred.promise,+ );++ stubSdkBundle({ resolveDatasetQuery });++ const { result, rerender } = renderHook(+ ({ currentQuery }) => useMetabaseQueryObject(currentQuery),+ { initialProps: { currentQuery: firstQuery } },+ );++ rerender({ currentQuery: secondQuery });++ await waitFor(() => expect(resolveDatasetQuery).toHaveBeenCalledTimes(2));++ await act(async () => {+ secondDeferred.resolve(secondDatasetQuery);++ await secondDeferred.promise;+ });++ await waitFor(() =>+ expect(result.current).toEqual({+ query: secondDatasetQuery,+ error: null,+ isLoading: false,+ }),+ );++ await act(async () => {+ firstDeferred.resolve(TEST_DATASET_QUERY);++ await firstDeferred.promise;+ });++ expect(result.current).toEqual({+ query: secondDatasetQuery,+ error: null,+ isLoading: false,+ });+ });+});++describe("useMetabaseQuery", () => {+ it("ignores a stale response after the query changes", async () => {+ const firstQuery = {+ source: TEST_SCHEMA.tables.orders,+ limit: 10,+ };++ const secondQuery = {+ source: TEST_SCHEMA.tables.orders,+ limit: 20,+ };++ const firstDatasetQuery = createMockDatasetQuery([+ { "source-table": 1, limit: 10 },+ ]);++ const secondDatasetQuery = createMockDatasetQuery([+ { "source-table": 1, limit: 20 },+ ]);++ const firstResponse = createDeferred<QueryDatasetResult>();+ const secondResponse = createDeferred<QueryDatasetResult>();++ const runDatasetQuery = jest.fn(+ ({ datasetQuery }: { datasetQuery: DatasetQuery }) =>+ datasetQuery === firstDatasetQuery+ ? firstResponse.promise+ : secondResponse.promise,+ );++ const resolveDatasetQuery = jest.fn(+ () => (input: QueryInput) =>+ Promise.resolve(+ "limit" in input && input.limit === 10+ ? firstDatasetQuery+ : secondDatasetQuery,+ ),+ );++ stubSdkBundle({+ resolveDatasetQuery,+ queryDataset: jest.fn(() => runDatasetQuery),+ });++ const { result, rerender } = renderHook(+ ({ currentQuery }) => useMetabaseQuery(currentQuery),+ { initialProps: { currentQuery: firstQuery } },+ );++ await waitFor(() => expect(runDatasetQuery).toHaveBeenCalledTimes(1));+ rerender({ currentQuery: secondQuery });++ await waitFor(() => expect(runDatasetQuery).toHaveBeenCalledTimes(2));++ await act(async () => {+ firstResponse.resolve({+ rowCount: 1,+ runningTime: 1,+ columns: [],+ rows: [],+ });+ await firstResponse.promise;+ });++ expect(result.current).toMatchObject({+ data: null,+ error: null,+ isLoading: true,+ });++ await act(async () => {+ secondResponse.resolve({+ rowCount: 2,+ runningTime: 2,+ columns: [],+ rows: [],+ });++ await secondResponse.promise;+ });++ await waitFor(() =>+ expect(result.current).toMatchObject({+ data: expect.objectContaining({ rowCount: 2 }),+ error: null,+ isLoading: false,+ }),+ );+ });++ it("waits for async query creation before querying the dataset", async () => {+ const deferred = createDeferred<DatasetQuery>();++ const queryDataset = jest.fn(() =>+ Promise.resolve({+ rowCount: 1,+ runningTime: 1,+ columns: [],+ rows: [],+ }),+ );++ stubSdkBundle({+ resolveDatasetQuery: jest.fn(() => jest.fn(() => deferred.promise)),+ queryDataset: jest.fn(() => queryDataset),+ });++ renderHook(() =>+ useMetabaseQuery({+ source: TEST_SCHEMA.tables.orders,+ limit: 10,+ }),+ );++ expect(queryDataset).not.toHaveBeenCalled();++ deferred.resolve(TEST_DATASET_QUERY);++ await waitFor(() =>+ expect(queryDataset).toHaveBeenCalledWith({+ datasetQuery: TEST_DATASET_QUERY,+ }),+ );+ });+});diff --git a/enterprise/frontend/src/embedding-sdk-package/hooks/public/use-metabase-query/use-metabase-query.unit.spec.tsx b/enterprise/frontend/src/embedding-sdk-package/hooks/public/use-metabase-query/use-metabase-query.unit.spec.tsxdeleted file mode 100644index 95ec13dcd07..00000000000--- a/enterprise/frontend/src/embedding-sdk-package/hooks/public/use-metabase-query/use-metabase-query.unit.spec.tsx+++ /dev/null@@ -1,1651 +0,0 @@-import { act, renderHook, waitFor } from "@testing-library/react";--import { resolveDatasetQuery as resolveDatasetQueryInBundle } from "embedding-sdk-bundle/lib/create-metabase-query";-import type { QueryDatasetResult } from "embedding-sdk-bundle/lib/query-dataset";-import type { SdkStore } from "embedding-sdk-bundle/store/types";-import type { MetabaseEmbeddingSdkBundleExports } from "embedding-sdk-bundle/types/sdk-bundle";-import { useLazySelector } from "embedding-sdk-package/hooks/private/use-lazy-selector";-import { useMetabaseProviderPropsStore } from "embedding-sdk-shared/hooks/use-metabase-provider-props-store";-import { useSdkLoadingState } from "embedding-sdk-shared/hooks/use-sdk-loading-state";-import type { QueryInput } from "embedding-sdk-shared/lib/create-metabase-query/input-guards";-import { ensureMetabaseProviderPropsStore } from "embedding-sdk-shared/lib/ensure-metabase-provider-props-store";-import { SdkLoadingState } from "embedding-sdk-shared/types/sdk-loading";-import { cardApi } from "metabase/api";-import { runRtkEndpoint } from "metabase/api/utils/run-rtk-endpoint";-import type { MetabaseCard } from "metabase/embedding-sdk/types/question";-import { fetchTableMetadata } from "metabase/redux/tables";-import { getMetadataUnfiltered } from "metabase/selectors/metadata";-import type { DatasetQuery } from "metabase-types/api";-import { createMockCard } from "metabase-types/api/mocks";--import * as DataApp from "../../../data-app";-import type { RowValue } from "../data-schema";--import type { MetabaseQueryOptions, UseMetabaseQueryObjectResult } from ".";-import {- avg,- breakout,- count,- filter,- orderBy,- sum,- useMetabaseQuery,- useMetabaseQueryObject,-} from ".";--jest.mock("embedding-sdk-package/hooks/private/use-lazy-selector", () => ({- useLazySelector: jest.fn(() => ({ status: "success" })),-}));--jest.mock(- "embedding-sdk-shared/hooks/use-metabase-provider-props-store",- () => ({- useMetabaseProviderPropsStore: jest.fn(),- }),-);--jest.mock("embedding-sdk-shared/hooks/use-sdk-loading-state", () => ({- useSdkLoadingState: jest.fn(() => ({ loadingState: "loaded" })),-}));--jest.mock("metabase/api", () => ({- cardApi: {- endpoints: {- getCard: { name: "getCard" },- getCardQueryMetadata: { name: "getCardQueryMetadata" },- },- },-}));--jest.mock("metabase/api/utils/run-rtk-endpoint", () => ({- runRtkEndpoint: jest.fn(() => Promise.resolve(undefined)),-}));--jest.mock("metabase/redux/tables", () => ({- fetchTableMetadata: jest.fn(({ id }) => ({- type: "fetchTableMetadata",- payload: id,- })),-}));--jest.mock("metabase/selectors/metadata", () => ({- getMetadataUnfiltered: jest.fn(),-}));--const mockFetchTableMetadata = jest.mocked(fetchTableMetadata);-const mockGetMetadataUnfiltered = jest.mocked(getMetadataUnfiltered);-const mockRunRtkEndpoint = jest.mocked(runRtkEndpoint);-const mockUseLazySelector = jest.mocked(useLazySelector);-const mockUseMetabaseProviderPropsStore = jest.mocked(- useMetabaseProviderPropsStore,-);-const mockUseSdkLoadingState = jest.mocked(useSdkLoadingState);--const TEST_SCHEMA = {- tables: {- orders: {- type: "table",- id: 1,- fields: {- id: {- type: "column",- fieldId: 100,- tableId: 1,- name: "ID",- "source-name": "orders",- displayName: "ID",- jsType: "number",- },- createdAt: {- type: "column",- fieldId: 103,- tableId: 1,- name: "CREATED_AT",- "source-name": "orders",- displayName: "Created At",- jsType: "Date",- baseType: "type/DateTime",- },- amount: {- type: "column",- fieldId: 102,- tableId: 1,- name: "AMOUNT",- "source-name": "orders",- displayName: "Amount",- jsType: "number",- },- status: {- type: "column",- fieldId: 101,- tableId: 1,- name: "STATUS",- "source-name": "orders",- displayName: "Status",- jsType: "string",- },- productId: {- type: "column",- fieldId: 104,- tableId: 1,- name: "PRODUCT_ID",- displayName: "Product ID",- jsType: "number",- },- replacementProductId: {- type: "column",- fieldId: 105,- tableId: 1,- name: "REPLACEMENT_PRODUCT_ID",- displayName: "Replacement Product ID",- jsType: "number",- },- },- segments: {- completed: { type: "segment", id: 11, tableId: 1 },- },- measures: {- revenue: {- type: "measure",- id: 21,- tableId: 1,- columns: [{ name: "sum", displayName: "Sum", jsType: "number" }],- },- },- },- products: {- type: "table",- id: 2,- fields: {- price: {- type: "column",- fieldId: 201,- tableId: 2,- name: "PRICE",- "source-name": "products",- displayName: "Price",- jsType: "number",- },- name: {- type: "column",- fieldId: 202,- tableId: 2,- name: "NAME",- displayName: "Name",- jsType: "string",- },- },- segments: {- active: { type: "segment", id: 12, tableId: 2 },- },- measures: {- price: {- type: "measure",- id: 22,- tableId: 2,- columns: [{ name: "price", displayName: "Price", jsType: "number" }],- },- },- },- },- metrics: {- revenue: {- type: "metric",- id: 31,- name: "Revenue",- databaseId: 1,- sourceTableId: 1,- mappedTableIds: [1, 2],- columns: [{ name: "sum", displayName: "Revenue", jsType: "number" }],- dimensions: {- orders: {- amount: {- type: "column",- fieldId: 102,- tableId: 1,- name: "AMOUNT",- "source-name": "orders",- displayName: "Amount",- jsType: "number",- },- createdAt: {- type: "column",- fieldId: 103,- tableId: 1,- name: "CREATED_AT",- "source-name": "orders",- displayName: "Created At",- jsType: "Date",- baseType: "type/DateTime",- },- status: {- type: "column",- fieldId: 101,- tableId: 1,- name: "STATUS",- "source-name": "orders",- displayName: "Status",- jsType: "string",- },- product: {- type: "column",- fieldId: 202,- sourceFieldId: 104,- name: "NAME",- displayName: "Name",- jsType: "string",- },- },- },- },- sourceCardMetric: {- type: "metric",- id: 32,- name: "Stores with over 5 employees",- databaseId: 1,- sourceCardId: 1,- mappedTableIds: [1],- columns: [{ name: "count", displayName: "Count", jsType: "number" }],- dimensions: {- fields: {- count: {- type: "column",- name: "count",- displayName: "Count",- jsType: "number",- },- },- orders: {- status: {- type: "column",- fieldId: 101,- tableId: 1,- name: "STATUS",- "source-name": "orders",- displayName: "Status",- jsType: "string",- },- product: {- type: "column",- fieldId: 202,- sourceFieldId: 104,- name: "NAME",- displayName: "Name",- jsType: "string",- },- },- },- },- productRevenue: {- type: "metric",- id: 32,- name: "Product Revenue",- databaseId: 1,- sourceTableId: 2,- mappedTableIds: [2],- columns: [- {- name: "Product Revenue",- displayName: "Product Revenue",- jsType: "number",- },- ],- dimensions: {- products: {- price: {- type: "column",- fieldId: 201,- tableId: 2,- name: "PRICE",- displayName: "Price",- jsType: "number",- },- },- },- },- questionRevenue: {- type: "metric",- id: 33,- name: "Question Revenue",- databaseId: 1,- sourceCardId: 41,- mappedTableIds: [1],- columns: [- {- name: "Question Revenue",- displayName: "Question Revenue",- jsType: "number",- },- ],- dimensions: {- orders: {- createdAt: {- type: "column",- fieldId: 103,- tableId: 1,- name: "CREATED_AT",- displayName: "Created At",- jsType: "Date",- baseType: "type/DateTime",- },- },- },- },- },- questions: {- ordersQuestion: {- type: "card",- id: 41,- name: "Orders question",- columns: [- {- type: "column",- name: "STATUS",- displayName: "Status",- jsType: "string",- },- {- type: "column",- name: "AMOUNT",- displayName: "Amount",- jsType: "number",- },- {- type: "column",- name: "CREATED_AT",- displayName: "Created At",- jsType: "Date",- },- ],- },- },-} as const;--type OrdersTable = (typeof TEST_SCHEMA)["tables"]["orders"];-type OrdersQuestion = (typeof TEST_SCHEMA)["questions"]["ordersQuestion"];--const TEST_METADATA = {- databases: {- 1: {- id: 1,- name: "Test Database",- features: ["basic-aggregations", "binning", "expressions"],- },- },- tables: {- 1: { id: 1, db_id: 1, name: "orders", display_name: "Orders" },- 2: { id: 2, db_id: 1, name: "products", display_name: "Products" },- },- fields: {- 100: {- id: 100,- table_id: 1,- name: "ID",- display_name: "ID",- base_type: "type/Integer",- effective_type: "type/Integer",- },- 101: {- id: 101,- table_id: 1,- name: "STATUS",- display_name: "Status",- base_type: "type/Text",- effective_type: "type/Text",- },- 102: {- id: 102,- table_id: 1,- name: "AMOUNT",- display_name: "Amount",- base_type: "type/Float",- effective_type: "type/Float",- },- 103: {- id: 103,- table_id: 1,- name: "CREATED_AT",- display_name: "Created At",- base_type: "type/DateTime",- effective_type: "type/DateTime",- },- 104: {- id: 104,- table_id: 1,- name: "PRODUCT_ID",- display_name: "Product ID",- base_type: "type/Integer",- effective_type: "type/Integer",- semantic_type: "type/FK",- fk_target_field_id: 200,- },- 105: {- id: 105,- table_id: 1,- name: "REPLACEMENT_PRODUCT_ID",- display_name: "Replacement Product ID",- base_type: "type/Integer",- effective_type: "type/Integer",- semantic_type: "type/FK",- fk_target_field_id: 200,- },- 200: {- id: 200,- table_id: 2,- name: "ID",- display_name: "ID",- base_type: "type/Integer",- effective_type: "type/Integer",- semantic_type: "type/PK",- },- 201: {- id: 201,- table_id: 2,- name: "PRICE",- display_name: "Price",- base_type: "type/Float",- effective_type: "type/Float",- },- 202: {- id: 202,- table_id: 2,- name: "NAME",- display_name: "Name",- base_type: "type/Text",- effective_type: "type/Text",- },- },- segments: {- 11: { id: 11, table_id: 1, name: "Completed" },- 12: { id: 12, table_id: 2, name: "Active" },- },- measures: {- 21: {- id: 21,- name: "Revenue",- table_id: 1,- definition: {- type: "query",- database: 1,- query: {- "source-table": 1,- aggregation: [["count"]],- },- },- },- 22: {- id: 22,- name: "Price",- table_id: 2,- definition: {- type: "query",- database: 1,- query: {- "source-table": 2,- aggregation: [["count"]],- },- },- },- },- questions: {- 41: createMockCard({- id: 41,- name: "Orders question",- dataset_query: {- type: "query",- database: 1,- query: {- "source-table": 1,- },- },- }),- 31: createMockCard({- id: 31,- name: "Revenue",- type: "metric",- dataset_query: {- type: "query",- database: 1,- query: {- "source-table": 1,- aggregation: [["sum", ["field", 102, null]]],- },- },- }),- 32: createMockCard({- id: 32,- name: "Product Revenue",- type: "metric",- dataset_query: {- type: "query",- database: 1,- query: {- "source-table": 2,- aggregation: [["sum", ["field", 201, null]]],- },- },- }),- },-};--const createMockStore = (): SdkStore =>- // A real `getSdkStore()` pulls in reducers this spec's `metabase/api` mock can't- // satisfy; only `dispatch` and `getState` are reached, and both land in mocks.- ({- dispatch: jest.fn((action) => Promise.resolve(action)),- getState: jest.fn(() => ({})),- }) as unknown as SdkStore;--type MbqlStage = Record<string, unknown>;--const mbqlQuery = (stages: MbqlStage[]): DatasetQuery =>- // `DatasetQuery` is opaque, so one can't be written as a literal.- ({- "lib/type": "mbql/query",- database: 1,- stages,- }) as unknown as DatasetQuery;--const stagesOf = (query: DatasetQuery): MbqlStage[] =>- // ...nor its stages read.- (query as unknown as { stages: MbqlStage[] }).stages;--const TEST_DATASET_QUERY = mbqlQuery([{ "source-table": 1 }]);--const mockPropsStore = (reduxStore: SdkStore) =>- mockUseMetabaseProviderPropsStore.mockReturnValue({- state: { internalProps: { reduxStore }, props: null },- store: ensureMetabaseProviderPropsStore(),- });--const stubSdkBundle = (- exports: Partial<MetabaseEmbeddingSdkBundleExports>,-): void => {- window.METABASE_EMBEDDING_SDK_BUNDLE =- // The global is typed as the whole bundle; a test needs one or two functions.- exports as MetabaseEmbeddingSdkBundleExports;-};--const LOADED_SDK_STATE: ReturnType<typeof useSdkLoadingState> = {- loadingState: SdkLoadingState.Loaded,- loadingError: null,- isInitial: false,- isLoading: false,- isLoaded: true,- isInitialized: false,- isError: false,- isNotStartedLoading: false,-};--function createDeferred<TValue>() {- let resolve!: (value: TValue) => void;- let reject!: (error: unknown) => void;- const promise = new Promise<TValue>((resolvePromise, rejectPromise) => {- resolve = resolvePromise;- reject = rejectPromise;- });-- return { promise, resolve, reject };-}--const _validTableQuery = {- source: TEST_SCHEMA.tables.orders,- fields: [- TEST_SCHEMA.tables.orders.fields.id,- TEST_SCHEMA.tables.orders.fields.status,- ],- filters: [- TEST_SCHEMA.tables.orders.segments.completed,- filter(TEST_SCHEMA.tables.orders.fields.status, "=", "paid"),- ],- aggregations: [- TEST_SCHEMA.tables.orders.measures.revenue,- sum(TEST_SCHEMA.tables.orders.fields.amount),- ],- breakouts: [- breakout(TEST_SCHEMA.tables.orders.fields.createdAt, { unit: "month" }),- ],- orderBys: [- orderBy(TEST_SCHEMA.tables.orders.fields.createdAt, "desc", {- unit: "month",- }),- ],- limit: 100,-} satisfies MetabaseQueryOptions<OrdersTable>;--const _invalidCrossTableSegmentQuery = {- source: TEST_SCHEMA.tables.orders,- filters: [- // @ts-expect-error segments must belong to the source table- TEST_SCHEMA.tables.products.segments.active,- ],-} satisfies MetabaseQueryOptions<OrdersTable>;--const _invalidCrossTableMeasureQuery = {- source: TEST_SCHEMA.tables.orders,- aggregations: [- // @ts-expect-error measures must belong to the source table- TEST_SCHEMA.tables.products.measures.price,- ],-} satisfies MetabaseQueryOptions<OrdersTable>;--const _invalidCrossTableFieldQuery = {- source: TEST_SCHEMA.tables.orders,- fields: [- // @ts-expect-error fields must belong to the source table- TEST_SCHEMA.tables.products.fields.price,- ],-} satisfies MetabaseQueryOptions<OrdersTable>;--const _validTableQueryWithMetricAggregation = {- source: TEST_SCHEMA.tables.orders,- filters: [- TEST_SCHEMA.tables.orders.segments.completed,- filter(TEST_SCHEMA.metrics.revenue.dimensions.orders.status, "=", "paid"),- ],- aggregations: [- TEST_SCHEMA.metrics.revenue,- TEST_SCHEMA.tables.orders.measures.revenue,- sum(TEST_SCHEMA.metrics.revenue.dimensions.orders.amount),- ],- breakouts: [- breakout(TEST_SCHEMA.metrics.revenue.dimensions.orders.createdAt, {- unit: "month",- }),- ],- orderBys: [- orderBy(TEST_SCHEMA.metrics.revenue.dimensions.orders.createdAt, "desc", {- unit: "month",- }),- ],- limit: 100,-} satisfies MetabaseQueryOptions<OrdersTable>;--const _validTableQueryWithJoinedMetricBreakout = {- source: TEST_SCHEMA.tables.orders,- aggregations: [TEST_SCHEMA.metrics.revenue],- breakouts: [breakout(TEST_SCHEMA.metrics.revenue.dimensions.orders.product)],-} satisfies MetabaseQueryOptions<OrdersTable>;--const _validSavedQuestionQuery = {- source: TEST_SCHEMA.questions.ordersQuestion,-} satisfies MetabaseQueryOptions<OrdersQuestion>;--const _invalidSavedQuestionClauseQuery = {- source: TEST_SCHEMA.questions.ordersQuestion,-- // @ts-expect-error saved question queries only support source and enabled- fields: [TEST_SCHEMA.questions.ordersQuestion.columns[0]],-} satisfies MetabaseQueryOptions<OrdersQuestion>;--const _validCardQuery = {- query: {- "lib/type": "mbql/query",- database: 1,- stages: [],- },-} satisfies MetabaseCard;--// Only this value's *type* is used: the fixtures below typecheck, they never run.-const hookResult = {} as UseMetabaseQueryObjectResult;-const _validHookResultCard = {- query: hookResult.query,-} satisfies MetabaseCard;--const _invalidHookResultCard = {- // @ts-expect-error pass useMetabaseQueryObject(...).query, not the whole hook result- query: hookResult,-} satisfies MetabaseCard;--const _invalidCrossTableMetricAggregationQuery = {- source: TEST_SCHEMA.tables.orders,- aggregations: [- // @ts-expect-error metric aggregations must belong to the source table- TEST_SCHEMA.metrics.productRevenue,- ],-} satisfies MetabaseQueryOptions<OrdersTable>;--const _invalidIdOnlyMetricAggregationQuery = {- source: TEST_SCHEMA.tables.orders,- aggregations: [- // @ts-expect-error metric aggregations must include source table metadata- { type: "metric", id: 31 },- ],-} satisfies MetabaseQueryOptions<OrdersTable>;--const _invalidSourceCardMetricAggregationQuery = {- source: TEST_SCHEMA.tables.orders,- aggregations: [- // @ts-expect-error source-card metric aggregations need a saved question source- TEST_SCHEMA.metrics.questionRevenue,- ],-} satisfies MetabaseQueryOptions<OrdersTable>;--const _invalidMetricSourceQuery = {- // @ts-expect-error Metrics must be used in aggregations, not as query sources- source: TEST_SCHEMA.metrics.revenue,-} satisfies MetabaseQueryOptions;--function TypeFixtures() {- const selectedFieldsResult = useMetabaseQuery({- source: TEST_SCHEMA.tables.orders,- fields: [TEST_SCHEMA.tables.orders.fields.id],- });-- const selectedFieldValue: number | null | undefined =- selectedFieldsResult.data?.rows[0]?.ID;-- void selectedFieldValue;-- const selectedFieldsQuery = {- source: TEST_SCHEMA.tables.orders,- fields: [- TEST_SCHEMA.tables.orders.fields.id,- TEST_SCHEMA.tables.orders.fields.status,- ],- } satisfies MetabaseQueryOptions<OrdersTable>;-- const selectedFieldsQueryResult = useMetabaseQuery(selectedFieldsQuery);-- const selectedQueryFieldValue: string | null | undefined =- selectedFieldsQueryResult.data?.rows[0]?.STATUS;-- void selectedQueryFieldValue;-- const scalarAggregationResult = useMetabaseQuery({- source: TEST_SCHEMA.tables.orders,- aggregations: [sum(TEST_SCHEMA.tables.orders.fields.amount)],- });-- const scalarAggregationValue: RowValue | undefined =- scalarAggregationResult.data?.rows[0]?.sum;-- void scalarAggregationValue;-- // @ts-expect-error aggregation result rows should not include source fields- void scalarAggregationResult.data?.rows[0]?.amount;-- const metricResult = useMetabaseQuery({- source: TEST_SCHEMA.tables.orders,- aggregations: [TEST_SCHEMA.metrics.revenue],- });-- const metricAggregationValue = metricResult.data?.rows[0];-- void metricAggregationValue;-- // @ts-expect-error aggregation result rows should not include source fields- void metricResult.data?.rows[0]?.status;-- const groupedMetricResult = useMetabaseQuery<OrdersTable>({- source: TEST_SCHEMA.tables.orders,- aggregations: [TEST_SCHEMA.metrics.revenue],- breakouts: [- breakout(TEST_SCHEMA.metrics.revenue.dimensions.orders.createdAt, {- unit: "month",- }),- ],- });-- const groupedMetricBreakoutValue: string | Date | null | undefined =- groupedMetricResult.data?.rows[0]?.CREATED_AT;-- void groupedMetricBreakoutValue;-- // @ts-expect-error result row keys use returned column names, not schema object keys- void groupedMetricResult.data?.rows[0]?.createdAt;-- const sortKey: "amount" | "createdAt" = "createdAt";-- type OrdersField =- (typeof TEST_SCHEMA.tables.orders.fields)[keyof typeof TEST_SCHEMA.tables.orders.fields];-- const sortFields = {- amount: TEST_SCHEMA.tables.orders.fields.amount,- createdAt: TEST_SCHEMA.tables.orders.fields.createdAt,- } satisfies Record<string, OrdersField>;-- useMetabaseQuery({- source: TEST_SCHEMA.tables.orders,- orderBys: [orderBy(sortFields[sortKey], "desc")],- });-- // @ts-expect-error grouped queries must include an explicit aggregation- useMetabaseQuery<OrdersTable>({- source: TEST_SCHEMA.tables.orders,- breakouts: [- breakout(TEST_SCHEMA.tables.orders.fields.createdAt, { unit: "month" }),- ],- });-- return null;-}--void TypeFixtures;--describe("resolveDatasetQuery", () => {- beforeEach(() => {- jest.clearAllMocks();- mockRunRtkEndpoint.mockResolvedValue(undefined);- mockGetMetadataUnfiltered.mockReturnValue(- // `Metadata` is a class; the fixture is the plain shape read out of it.- TEST_METADATA as unknown as ReturnType<typeof getMetadataUnfiltered>,- );- mockUseLazySelector.mockReturnValue({ status: "success" });- mockUseSdkLoadingState.mockReturnValue(LOADED_SDK_STATE);- mockPropsStore(createMockStore());- window.METABASE_EMBEDDING_SDK_BUNDLE = undefined;- });-- it("exports the table query DSL from the data-app entrypoint", () => {- expect(DataApp).toMatchObject({- aggregations: {- avg: expect.any(Function),- count: expect.any(Function),- distinct: expect.any(Function),- max: expect.any(Function),- median: expect.any(Function),- min: expect.any(Function),- sum: expect.any(Function),- },- breakout: expect.any(Function),- filter: expect.any(Function),- orderBy: expect.any(Function),- useMetabaseQuery: expect.any(Function),- useMetabaseQueryObject: expect.any(Function),- });- expect(DataApp).not.toHaveProperty("count");- expect(DataApp).not.toHaveProperty("sum");- expect(DataApp).not.toHaveProperty("resolveDatasetQuery");- });-- it("loads table metadata and passes the public source DSL through Lib.createTestQuery", async () => {- const store = createMockStore();-- const datasetQuery = await resolveDatasetQueryInBundle(store)({- source: TEST_SCHEMA.tables.orders,- fields: [- TEST_SCHEMA.tables.orders.fields.id,- TEST_SCHEMA.tables.orders.fields.status,- ],- filters: [- TEST_SCHEMA.tables.orders.segments.completed,- filter(TEST_SCHEMA.tables.orders.fields.status, "=", "paid"),- ],- aggregations: [count(), sum(TEST_SCHEMA.tables.orders.fields.amount)],- breakouts: [- breakout(TEST_SCHEMA.tables.orders.fields.createdAt, { unit: "month" }),- ],- orderBys: [- orderBy(TEST_SCHEMA.tables.orders.fields.createdAt, "desc", {- unit: "month",- }),- ],- limit: 100,- });-- expect(mockFetchTableMetadata).toHaveBeenCalledWith({ id: 1 });-- expect(store.dispatch).toHaveBeenCalledWith({- type: "fetchTableMetadata",- payload: 1,- });-- expect(mockGetMetadataUnfiltered).toHaveBeenCalledWith({});-- expect(datasetQuery).toMatchObject({- "lib/type": "mbql/query",- database: 1,- stages: [- {- "lib/type": "mbql.stage/mbql",- "source-table": 1,- fields: [- ["field", expect.anything(), 100],- ["field", expect.anything(), 101],- ],- filters: [- ["segment", expect.anything(), 11],- ["=", expect.anything(), ["field", expect.anything(), 101], "paid"],- ],- aggregation: [- ["count", expect.anything()],- ["sum", expect.anything(), ["field", expect.anything(), 102]],- ],- breakout: [- [- "field",- expect.objectContaining({ "temporal-unit": "month" }),- 103,- ],- ],- "order-by": [- [- "desc",- expect.anything(),- [- "field",- expect.objectContaining({ "temporal-unit": "month" }),- 103,- ],- ],- ],- limit: 100,- },- ],- });- });-- it("passes generated table Measures to Lib.createTestQuery measure aggregations", async () => {- const datasetQuery = await resolveDatasetQueryInBundle(createMockStore())({- source: TEST_SCHEMA.tables.orders,- aggregations: [TEST_SCHEMA.tables.orders.measures.revenue],- });-- expect(stagesOf(datasetQuery)[0].aggregation).toEqual([- ["measure", expect.anything(), 21],- ]);- });-- it("accepts id-only table source references", async () => {- const datasetQuery = await resolveDatasetQueryInBundle(createMockStore())({- source: { type: "table", id: 1 },- fields: [TEST_SCHEMA.tables.orders.fields.id],- });-- expect(datasetQuery).toMatchObject({- database: 1,- stages: [- {- "source-table": 1,- fields: [["field", expect.anything(), 100]],- },- ],- });- });-- it("loads metric aggregation metadata and passes the public table source DSL through Lib.createTestQuery", async () => {- const store = createMockStore();-- const datasetQuery = await resolveDatasetQueryInBundle(store)({- source: TEST_SCHEMA.tables.orders,- filters: [- TEST_SCHEMA.tables.orders.segments.completed,- filter(- TEST_SCHEMA.metrics.revenue.dimensions.orders.status,- "=",- "paid",- ),- ],- aggregations: [- TEST_SCHEMA.metrics.revenue,- count(),- sum(TEST_SCHEMA.metrics.revenue.dimensions.orders.amount),- TEST_SCHEMA.tables.orders.measures.revenue,- ],- breakouts: [- breakout(TEST_SCHEMA.metrics.revenue.dimensions.orders.createdAt, {- unit: "month",- }),- ],- limit: 100,- });-- expect(mockFetchTableMetadata).toHaveBeenCalledWith({ id: 1 });-- expect(mockRunRtkEndpoint).toHaveBeenNthCalledWith(- 1,- { id: 31 },- store.dispatch,- cardApi.endpoints.getCard,- { forceRefetch: false },- );-- expect(mockRunRtkEndpoint).toHaveBeenNthCalledWith(- 2,- 31,- store.dispatch,- cardApi.endpoints.getCardQueryMetadata,- { forceRefetch: false },- );-- expect(datasetQuery).toMatchObject({- "lib/type": "mbql/query",- database: 1,- stages: [- {- "lib/type": "mbql.stage/mbql",- "source-table": 1,- filters: [- ["segment", expect.anything(), 11],- ["=", expect.anything(), ["field", expect.anything(), 101], "paid"],- ],- aggregation: [- ["metric", expect.anything(), 31],- ["count", expect.anything()],- ["sum", expect.anything(), ["field", expect.anything(), 102]],- ["measure", expect.anything(), 21],- ],- breakout: [- [- "field",- expect.objectContaining({ "temporal-unit": "month" }),- 103,- ],- ],- limit: 100,- },- ],- });- });-- it("builds metric queries with FK-joined dimension breakouts", async () => {- const datasetQuery = await resolveDatasetQueryInBundle(createMockStore())({- source: TEST_SCHEMA.tables.orders,- aggregations: [TEST_SCHEMA.metrics.revenue],- breakouts: [- breakout(TEST_SCHEMA.metrics.revenue.dimensions.orders.product),- ],- });-- expect(datasetQuery).toMatchObject({- database: 1,- stages: [- {- "source-table": 1,- aggregation: [["metric", expect.anything(), 31]],- breakout: [- ["field", expect.objectContaining({ "source-field": 104 }), 202],- ],- },- ],- });- });-- it("passes generated metric dimension orderBys through Lib.createTestQuery", async () => {- const datasetQuery = await resolveDatasetQueryInBundle(createMockStore())({- source: TEST_SCHEMA.tables.orders,- aggregations: [TEST_SCHEMA.metrics.revenue],- breakouts: [- breakout(TEST_SCHEMA.metrics.revenue.dimensions.orders.createdAt, {- unit: "month",- }),- ],- orderBys: [- orderBy(- TEST_SCHEMA.metrics.revenue.dimensions.orders.createdAt,- "desc",- { unit: "month" },- ),- ],- limit: 12,- });-- expect(datasetQuery).toMatchObject({- stages: [- {- "source-table": 1,- aggregation: [["metric", expect.anything(), 31]],- breakout: [- [- "field",- expect.objectContaining({ "temporal-unit": "month" }),- 103,- ],- ],- "order-by": [- [- "desc",- expect.anything(),- [- "field",- expect.objectContaining({ "temporal-unit": "month" }),- 103,- ],- ],- ],- limit: 12,- },- ],- });- });-- it("loads saved question metadata and passes the question source through Lib.createTestQuery", async () => {- const store = createMockStore();-- const datasetQuery = await resolveDatasetQueryInBundle(store)({- source: TEST_SCHEMA.questions.ordersQuestion,- });-- expect(mockFetchTableMetadata).not.toHaveBeenCalled();-- expect(mockRunRtkEndpoint).toHaveBeenNthCalledWith(- 1,- { id: 41 },- store.dispatch,- cardApi.endpoints.getCard,- { forceRefetch: false },- );-- expect(mockRunRtkEndpoint).toHaveBeenNthCalledWith(- 2,- 41,- store.dispatch,- cardApi.endpoints.getCardQueryMetadata,- { forceRefetch: false },- );-- expect(datasetQuery).toMatchObject({- "lib/type": "mbql/query",- database: 1,- stages: [- {- "lib/type": "mbql.stage/mbql",- "source-card": 41,- },- ],- });- });-- it("passes aggregation result orderBys through Lib.createTestQuery", async () => {- const avgAmount = avg(TEST_SCHEMA.tables.orders.fields.amount);-- const datasetQuery = await resolveDatasetQueryInBundle(createMockStore())({- source: TEST_SCHEMA.tables.orders,- aggregations: [avgAmount],- breakouts: [breakout(TEST_SCHEMA.tables.orders.fields.status)],- orderBys: [orderBy(avgAmount, "desc")],- limit: 15,- });-- expect(datasetQuery).toMatchObject({- stages: [- {- aggregation: [- ["avg", expect.anything(), ["field", expect.anything(), 102]],- ],- breakout: [["field", expect.anything(), 101]],- "order-by": [- [- "desc",- expect.anything(),- ["aggregation", expect.anything(), expect.anything()],- ],- ],- limit: 15,- },- ],- });- });-- it("passes metric aggregation result orderBys through Lib.createTestQuery", async () => {- const avgAmount = avg(TEST_SCHEMA.metrics.revenue.dimensions.orders.amount);-- const datasetQuery = await resolveDatasetQueryInBundle(createMockStore())({- source: TEST_SCHEMA.tables.orders,- aggregations: [TEST_SCHEMA.metrics.revenue, avgAmount],- breakouts: [- breakout(TEST_SCHEMA.metrics.revenue.dimensions.orders.status),- ],- orderBys: [orderBy(avgAmount, "desc")],- limit: 15,- });-- expect(datasetQuery).toMatchObject({- stages: [- {- aggregation: [- ["metric", expect.anything(), 31],- ["avg", expect.anything(), ["field", expect.anything(), 102]],- ],- breakout: [["field", expect.anything(), 101]],- "order-by": [- [- "desc",- expect.anything(),- ["aggregation", expect.anything(), expect.anything()],- ],- ],- limit: 15,- },- ],- });- });-- it("passes metric aggregation orderBys through Lib.createTestQuery", async () => {- const datasetQuery = await resolveDatasetQueryInBundle(createMockStore())({- source: TEST_SCHEMA.tables.orders,- aggregations: [TEST_SCHEMA.metrics.revenue],- breakouts: [- breakout(TEST_SCHEMA.metrics.revenue.dimensions.orders.status),- ],- orderBys: [orderBy(TEST_SCHEMA.metrics.revenue, "desc")],- limit: 15,- });-- expect(datasetQuery).toMatchObject({- stages: [- {- aggregation: [["metric", expect.anything(), 31]],- breakout: [["field", expect.anything(), 101]],- "order-by": [- [- "desc",- expect.anything(),- ["aggregation", expect.anything(), expect.anything()],- ],- ],- limit: 15,- },- ],- });- });-- it("rejects invalid limits with a clear error message", async () => {- await expect(- resolveDatasetQueryInBundle(createMockStore())({- source: TEST_SCHEMA.tables.orders,- limit: 0,- }),- ).rejects.toThrow("Table query limit must be a positive integer.");- });-- it("rejects cross-table query clauses with clear error messages", async () => {- await expect(- resolveDatasetQueryInBundle(createMockStore())({- source: TEST_SCHEMA.tables.orders,- fields: [TEST_SCHEMA.tables.products.fields.price],- }),- ).rejects.toThrow(- "Table query fields must belong to source table 1, but received table id 2.",- );-- await expect(- resolveDatasetQueryInBundle(createMockStore())({- source: TEST_SCHEMA.tables.orders,- filters: [filter(TEST_SCHEMA.tables.products.fields.price, "=", 10)],- }),- ).rejects.toThrow(- "Table query filters must belong to source table 1, but received table id 2.",- );-- await expect(- resolveDatasetQueryInBundle(createMockStore())({- source: TEST_SCHEMA.tables.orders,- aggregations: [sum(TEST_SCHEMA.tables.products.fields.price)],- }),- ).rejects.toThrow(- "Table query aggregations must belong to source table 1, but received table id 2.",- );-- await expect(- resolveDatasetQueryInBundle(createMockStore())({- source: TEST_SCHEMA.tables.orders,- breakouts: [TEST_SCHEMA.tables.products.fields.price],- }),- ).rejects.toThrow(- "Table query breakouts must belong to source table 1, but received table id 2.",- );-- await expect(- resolveDatasetQueryInBundle(createMockStore())({- source: TEST_SCHEMA.tables.orders,- orderBys: [orderBy(TEST_SCHEMA.tables.products.fields.price, "desc")],- }),- ).rejects.toThrow(- "Table query orderBys must belong to source table 1, but received table id 2.",- );-- await expect(- resolveDatasetQueryInBundle(createMockStore())({- source: TEST_SCHEMA.tables.orders,- aggregations: [avg(TEST_SCHEMA.tables.orders.fields.amount)],- breakouts: [breakout(TEST_SCHEMA.tables.orders.fields.status)],- orderBys: [orderBy(TEST_SCHEMA.tables.orders.fields.amount, "desc")],- }),- ).rejects.toThrow(- "Table query orderBys for grouped queries must use query breakouts or aggregations included in the query.",- );-- await expect(- resolveDatasetQueryInBundle(createMockStore())({- source: TEST_SCHEMA.tables.orders,- breakouts: [- breakout(TEST_SCHEMA.tables.orders.fields.createdAt, {- unit: "month",- }),- ],- orderBys: [- orderBy(TEST_SCHEMA.tables.orders.fields.createdAt, "desc", {- unit: "year",- }),- ],- }),- ).rejects.toThrow(- "Table query orderBys for grouped queries must use query breakouts or aggregations included in the query.",- );- });-- it("rejects cross-table metric aggregations with clear error messages", async () => {- await expect(- resolveDatasetQueryInBundle(createMockStore())({- source: TEST_SCHEMA.tables.orders,- aggregations: [TEST_SCHEMA.metrics.productRevenue],- }),- ).rejects.toThrow(- "Table query metric aggregations must belong to source table 1, but received mapped table ids 2.",- );- });-- it("rejects metric aggregations without source table metadata", async () => {- await expect(- resolveDatasetQueryInBundle(createMockStore())({- source: TEST_SCHEMA.tables.orders,- aggregations: [{ type: "metric", id: 31 }],- }),- ).rejects.toThrow(- "Table query metric aggregations must include source table metadata.",- );- });-- it("rejects source-card metric aggregations under table sources", async () => {- await expect(- resolveDatasetQueryInBundle(createMockStore())({- source: TEST_SCHEMA.tables.orders,- aggregations: [TEST_SCHEMA.metrics.questionRevenue],- }),- ).rejects.toThrow(- "Table query metric aggregations cannot use source-card Metrics. Use a saved question source for source-card Metrics.",- );- });-- it("rejects unsupported saved question query clauses with a clear error message", async () => {- await expect(- resolveDatasetQueryInBundle(createMockStore())({- source: TEST_SCHEMA.questions.ordersQuestion,- fields: [TEST_SCHEMA.questions.ordersQuestion.columns[0]],- }),- ).rejects.toThrow(- "Saved question queries only support source and enabled, but received fields.",- );-- await expect(- resolveDatasetQueryInBundle(createMockStore())({- source: TEST_SCHEMA.questions.ordersQuestion,- limit: 10,- }),- ).rejects.toThrow(- "Saved question queries only support source and enabled, but received limit.",- );-- await expect(- resolveDatasetQueryInBundle(createMockStore())({- source: TEST_SCHEMA.questions.ordersQuestion,- aggregations: [avg(TEST_SCHEMA.questions.ordersQuestion.columns[1])],- }),- ).rejects.toThrow(- "Saved question queries only support source and enabled, but received aggregations.",- );- });-- it("rejects metric sources with a clear error message", async () => {- await expect(- resolveDatasetQueryInBundle(createMockStore())({- // @ts-expect-error a metric is not a valid query source- source: TEST_SCHEMA.metrics.revenue,- }),- ).rejects.toThrow(- 'Query object creation requires a source reference like `{ type: "table", id }` or `{ type: "card", id }`.',- );- });-});--describe("useMetabaseQueryObject", () => {- const query = {- source: TEST_SCHEMA.tables.orders,- limit: 10,- };-- it("returns a loading state until async query creation resolves", async () => {- const deferred = createDeferred<DatasetQuery>();- const resolveDatasetQuery = jest.fn(() => jest.fn(() => deferred.promise));- stubSdkBundle({ resolveDatasetQuery });-- const { result } = renderHook(() => useMetabaseQueryObject(query));-- expect(result.current).toEqual({- query: null,- error: null,- isLoading: true,- });-- deferred.resolve(TEST_DATASET_QUERY);-- await waitFor(() =>- expect(result.current).toEqual({- query: TEST_DATASET_QUERY,- error: null,- isLoading: false,- }),- );- });-- it("returns query creation errors instead of swallowing them", async () => {- const error = new Error("No column found");- const resolveDatasetQuery = jest.fn(() =>- jest.fn(() => Promise.reject(error)),- );- stubSdkBundle({ resolveDatasetQuery });-- const { result } = renderHook(() => useMetabaseQueryObject(query));-- await waitFor(() =>- expect(result.current).toEqual({- query: null,- error,- isLoading: false,- }),- );- });-- it("waits for login before resolving the query", async () => {- const resolveDatasetQuery = jest.fn(() =>- jest.fn(() => Promise.resolve(TEST_DATASET_QUERY)),- );- stubSdkBundle({ resolveDatasetQuery });- mockUseLazySelector.mockReturnValue({ status: "loading" });-- const { result, rerender } = renderHook(() =>- useMetabaseQueryObject(query),- );-- expect(result.current).toEqual({- query: null,- error: null,- isLoading: true,- });- expect(resolveDatasetQuery).not.toHaveBeenCalled();-- mockUseLazySelector.mockReturnValue({ status: "success" });- rerender();-- await waitFor(() => {- expect(resolveDatasetQuery).toHaveBeenCalled();- expect(result.current).toEqual({- query: TEST_DATASET_QUERY,- error: null,- isLoading: false,- });- });- });-- it("does not expose stale query results after the input changes", async () => {- const firstDeferred = createDeferred<DatasetQuery>();- const secondDeferred = createDeferred<DatasetQuery>();-- const firstQuery = {- source: TEST_SCHEMA.tables.orders,- limit: 10,- };-- const secondQuery = {- source: TEST_SCHEMA.tables.orders,- limit: 20,- };-- const secondDatasetQuery = mbqlQuery([{ "source-table": 1, limit: 20 }]);-- // Which deferred a call gets is decided by the only field that differs.- const resolveDatasetQuery = jest.fn(- () => (input: QueryInput) =>- "limit" in input && input.limit === 10- ? firstDeferred.promise- : secondDeferred.promise,- );-- stubSdkBundle({ resolveDatasetQuery });-- const { result, rerender } = renderHook(- ({ currentQuery }) => useMetabaseQueryObject(currentQuery),- { initialProps: { currentQuery: firstQuery } },- );-- rerender({ currentQuery: secondQuery });- firstDeferred.resolve(TEST_DATASET_QUERY);-- expect(result.current).toEqual({- query: null,- error: null,- isLoading: true,- });-- secondDeferred.resolve(secondDatasetQuery);-- await waitFor(() =>- expect(result.current).toEqual({- query: secondDatasetQuery,- error: null,- isLoading: false,- }),- );- });-});--describe("useMetabaseQuery", () => {- it("ignores a stale response after the query changes", async () => {- const firstQuery = {- source: TEST_SCHEMA.tables.orders,- limit: 10,- };-- const secondQuery = {- source: TEST_SCHEMA.tables.orders,- limit: 20,- };-- const firstDatasetQuery = mbqlQuery([{ "source-table": 1, limit: 10 }]);- const secondDatasetQuery = mbqlQuery([{ "source-table": 1, limit: 20 }]);-- const firstResponse = createDeferred<QueryDatasetResult>();- const secondResponse = createDeferred<QueryDatasetResult>();-- const runDatasetQuery = jest.fn(- ({ datasetQuery }: { datasetQuery: DatasetQuery }) =>- datasetQuery === firstDatasetQuery- ? firstResponse.promise- : secondResponse.promise,- );-- const resolveDatasetQuery = jest.fn(- () => (input: QueryInput) =>- Promise.resolve(- "limit" in input && input.limit === 10- ? firstDatasetQuery- : secondDatasetQuery,- ),- );-- stubSdkBundle({- resolveDatasetQuery,- queryDataset: jest.fn(() => runDatasetQuery),- });-- const { result, rerender } = renderHook(- ({ currentQuery }) => useMetabaseQuery(currentQuery),- { initialProps: { currentQuery: firstQuery } },- );-- await waitFor(() => expect(runDatasetQuery).toHaveBeenCalledTimes(1));- rerender({ currentQuery: secondQuery });-- await waitFor(() => expect(runDatasetQuery).toHaveBeenCalledTimes(2));-- await act(async () => {- firstResponse.resolve({- rowCount: 1,- runningTime: 1,- columns: [],- rows: [],- });- await firstResponse.promise;- });-- expect(result.current).toMatchObject({- data: null,- error: null,- isLoading: true,- });-- await act(async () => {- secondResponse.resolve({- rowCount: 2,- runningTime: 2,- columns: [],- rows: [],- });-- await secondResponse.promise;- });-- await waitFor(() =>- expect(result.current).toMatchObject({- data: expect.objectContaining({ rowCount: 2 }),- error: null,- isLoading: false,- }),- );- });-- it("waits for async query creation before querying the dataset", async () => {- const deferred = createDeferred<DatasetQuery>();- const queryDataset = jest.fn(() =>- Promise.resolve({- rowCount: 1,- runningTime: 1,- columns: [],- rows: [],- }),- );- stubSdkBundle({- resolveDatasetQuery: jest.fn(() => jest.fn(() => deferred.promise)),- queryDataset: jest.fn(() => queryDataset),- });-- renderHook(() =>- useMetabaseQuery({- source: TEST_SCHEMA.tables.orders,- limit: 10,- }),- );-- expect(queryDataset).not.toHaveBeenCalled();-- deferred.resolve(TEST_DATASET_QUERY);-- await waitFor(() =>- expect(queryDataset).toHaveBeenCalledWith({- datasetQuery: TEST_DATASET_QUERY,- }),- );- });-});