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
Write the metadata mirror from one listener, not 33 endpoint hookups (#81147)
Romeo Van Snicke6e11ee3620c
diff --git a/frontend/src/metabase/api/automagic-dashboards.ts b/frontend/src/metabase/api/automagic-dashboards.tsindex e1fa186cfbe..abebd8b0c77 100644--- a/frontend/src/metabase/api/automagic-dashboards.ts+++ b/frontend/src/metabase/api/automagic-dashboards.ts@@ -1,5 +1,3 @@-import { updateMetadata } from "metabase/redux/metadata";-import { QueryMetadataSchema } from "metabase/schema";import type {Dashboard,DashboardQueryMetadata,@@ -14,7 +12,6 @@ import {provideDashboardQueryMetadataTags,provideDatabaseCandidateListTags,} from "./tags";-import { handleQueryFulfilled } from "./utils/lifecycle";// `subPath` is embedded raw into the request URL (its slashes are real path// separators) and originates from the `/auto/dashboard/*` route — i.e. it is@@ -62,10 +59,6 @@ export const automagicDashboardsApi = Api.injectEndpoints({}),providesTags: (metadata) =>metadata ? provideDashboardQueryMetadataTags(metadata) : [],- onQueryStarted: (_, { queryFulfilled, dispatch }) =>- handleQueryFulfilled(queryFulfilled, (data) =>- dispatch(updateMetadata(data, QueryMetadataSchema)),- ),}),listDatabaseXrays: builder.query<DatabaseXray[], DatabaseId>({query: (id) => `/api/automagic-dashboards/database/${id}/candidates`,@@ -84,10 +77,6 @@ export const automagicDashboardsApi = Api.injectEndpoints({params,};},- onQueryStarted: (_, { queryFulfilled, dispatch }) =>- handleQueryFulfilled(queryFulfilled, (data) =>- dispatch(updateMetadata(data, QueryMetadataSchema)),- ),}),}),});diff --git a/frontend/src/metabase/api/card.ts b/frontend/src/metabase/api/card.tsindex 2636f1e8cf5..a81a849b7a5 100644--- a/frontend/src/metabase/api/card.ts+++ b/frontend/src/metabase/api/card.ts@@ -1,4 +1,3 @@-import { QueryMetadataSchema, QuestionSchema } from "metabase/schema";import type {Card,CardId,@@ -33,7 +32,6 @@ import {provideCardTags,provideParameterValuesTags,} from "./tags";-import { hydrateMetadataStore } from "./utils/hydrate-metadata-store";const PERSISTED_MODEL_REFRESH_DELAY = 200;@@ -77,7 +75,6 @@ export const cardApi = Api.injectEndpoints({params,}),providesTags: (cards = []) => provideCardListTags(cards),- onQueryStarted: hydrateMetadataStore([QuestionSchema]),}),getCard: builder.query<Card, GetCardRequest>({query: ({ id, ignore_error, ...params }) => ({@@ -87,7 +84,6 @@ export const cardApi = Api.injectEndpoints({noEvent: ignore_error,}),providesTags: (card) => (card ? provideCardTags(card) : []),- onQueryStarted: hydrateMetadataStore(QuestionSchema),}),getCardQueryMetadata: builder.query<CardQueryMetadata, CardId>({query: (id) => ({@@ -96,7 +92,6 @@ export const cardApi = Api.injectEndpoints({}),providesTags: (metadata, _error, id) =>metadata ? provideCardQueryMetadataTags(id, metadata) : [],- onQueryStarted: hydrateMetadataStore(QueryMetadataSchema),}),getCardQuery: builder.query<Dataset, CardQueryRequest & RtkCacheKeyed>({query: ({ cardId, dashboardId, ...body }) => ({@@ -172,7 +167,6 @@ export const cardApi = Api.injectEndpoints({body,}),invalidatesTags: (_, error) => invalidateTags(error, [listTag("card")]),- onQueryStarted: hydrateMetadataStore(QuestionSchema),}),createCardFromCsv: builder.mutation<Card, CreateCardFromCsvRequest>({query: ({ file, collection_id }) => {@@ -223,7 +217,6 @@ export const cardApi = Api.injectEndpoints({return invalidateTags(error, tags);},- onQueryStarted: hydrateMetadataStore(QuestionSchema),}),deleteCard: builder.mutation<void, CardId>({query: (id) => ({diff --git a/frontend/src/metabase/api/collection.ts b/frontend/src/metabase/api/collection.tsindex 4d4bdede484..e6c9a2172a9 100644--- a/frontend/src/metabase/api/collection.ts+++ b/frontend/src/metabase/api/collection.ts@@ -1,4 +1,3 @@-import { ObjectUnionSchema } from "metabase/schema";import type {Collection,CollectionItemModel,@@ -27,7 +26,6 @@ import {provideCollectionListTags,provideCollectionTags,} from "./tags";-import { hydrateMetadataStore } from "./utils/hydrate-metadata-store";const getCollectionItemTagModels = (models: ListCollectionItemsRequest["models"],@@ -83,10 +81,6 @@ export const collectionApi = Api.injectEndpoints({),{ type: "collection", id: `${id}-items` },],- onQueryStarted: hydrateMetadataStore<ListCollectionItemsResponse>(- [ObjectUnionSchema],- (response) => response.data,- ),}),getCollection: builder.query<Collection, getCollectionRequest>({query: ({ id, ignore_error, ...params }) => {diff --git a/frontend/src/metabase/api/dashboard.ts b/frontend/src/metabase/api/dashboard.tsindex 52d08781064..1d305b79edc 100644--- a/frontend/src/metabase/api/dashboard.ts+++ b/frontend/src/metabase/api/dashboard.ts@@ -1,4 +1,3 @@-import { QueryMetadataSchema } from "metabase/schema";import type {CopyDashboardRequest,CreateDashboardRequest,@@ -40,7 +39,6 @@ import {provideValidDashboardFilterFieldTags,tag,} from "./tags";-import { hydrateMetadataStore } from "./utils/hydrate-metadata-store";export const dashboardApi = Api.injectEndpoints({endpoints: (builder) => {@@ -97,7 +95,6 @@ export const dashboardApi = Api.injectEndpoints({}),providesTags: (metadata) =>metadata ? provideDashboardQueryMetadataTags(metadata) : [],- onQueryStarted: hydrateMetadataStore(QueryMetadataSchema),}),getDashboardCardQuery: builder.query<Dataset,diff --git a/frontend/src/metabase/api/database.ts b/frontend/src/metabase/api/database.tsindex c18e1474718..c3a26028134 100644--- a/frontend/src/metabase/api/database.ts+++ b/frontend/src/metabase/api/database.ts@@ -1,11 +1,3 @@-import { updateMetadata } from "metabase/redux/metadata";-import {- DatabaseSchema,- FieldSchema,- SchemaSchema,- TableSchema,-} from "metabase/schema";-import { generateSchemaId } from "metabase-lib/v1/metadata/utils/schema";import type {AutocompleteRequest,AutocompleteSuggestion,@@ -43,7 +35,6 @@ import {provideDatabaseTags,tag,} from "./tags";-import { handleQueryFulfilled } from "./utils/lifecycle";/*** schema names containing slashes, backslashes, or percent signs are rejected@@ -53,13 +44,6 @@ import { handleQueryFulfilled } from "./utils/lifecycle";export const shouldSchemaBePassedAsQueryParam = (schema: SchemaName) =>/[/\\%]/.test(schema);-const toNormalizedSchemas = (dbId: DatabaseId, schemaNames: SchemaName[]) =>- schemaNames.map((schemaName) => ({- id: generateSchemaId(dbId, schemaName),- name: schemaName,- database: { id: dbId },- }));-export const databaseApi = Api.injectEndpoints({endpoints: (builder) => ({listDatabases: builder.query<@@ -72,10 +56,6 @@ export const databaseApi = Api.injectEndpoints({params,}),providesTags: (response) => provideDatabaseListTags(response?.data ?? []),- onQueryStarted: (_, { queryFulfilled, dispatch }) =>- handleQueryFulfilled(queryFulfilled, (data) =>- dispatch(updateMetadata(data.data, [DatabaseSchema])),- ),}),getDatabase: builder.query<Database, GetDatabaseRequest>({query: ({ id, ...params }) => ({@@ -85,10 +65,6 @@ export const databaseApi = Api.injectEndpoints({}),providesTags: (database) =>database ? provideDatabaseTags(database) : [],- onQueryStarted: (_, { queryFulfilled, dispatch }) =>- handleQueryFulfilled(queryFulfilled, (data) =>- dispatch(updateMetadata(data, DatabaseSchema)),- ),}),getDatabaseHealth: builder.query<GetDatabaseHealthResponse,@@ -110,10 +86,6 @@ export const databaseApi = Api.injectEndpoints({}),providesTags: (database) =>database ? provideDatabaseTags(database) : [],- onQueryStarted: (_, { queryFulfilled, dispatch }) =>- handleQueryFulfilled(queryFulfilled, (data) =>- dispatch(updateMetadata(data, DatabaseSchema)),- ),}),getDatabaseUsageInfo: builder.query<DatabaseUsageInfo, DatabaseId>({query: (id) => ({@@ -145,14 +117,6 @@ export const databaseApi = Api.injectEndpoints({listTag("schema"),...schemas.map((schema) => idTag("schema", schema)),],- onQueryStarted: ({ id }, { queryFulfilled, dispatch }) =>- handleQueryFulfilled(queryFulfilled, (schemaNames) =>- dispatch(- updateMetadata(toNormalizedSchemas(id, schemaNames), [- SchemaSchema,- ]),- ),- ),}),listSyncableDatabaseSchemas: builder.query<SchemaName[], DatabaseId>({query: (id) => ({@@ -163,14 +127,6 @@ export const databaseApi = Api.injectEndpoints({listTag("schema"),...schemas.map((schema) => idTag("schema", schema)),],- onQueryStarted: (id, { queryFulfilled, dispatch }) =>- handleQueryFulfilled(queryFulfilled, (schemaNames) =>- dispatch(- updateMetadata(toNormalizedSchemas(id, schemaNames), [- SchemaSchema,- ]),- ),- ),}),listDatabaseSchemaTables: builder.query<Table[],@@ -191,10 +147,6 @@ export const databaseApi = Api.injectEndpoints({listTag("table"),...tables.map((table) => idTag("table", table.id)),],- onQueryStarted: (_, { queryFulfilled, dispatch }) =>- handleQueryFulfilled(queryFulfilled, (data) =>- dispatch(updateMetadata(data, [TableSchema])),- ),}),listVirtualDatabaseTables: builder.query<Table[],@@ -209,10 +161,6 @@ export const databaseApi = Api.injectEndpoints({listTag("table"),...tables.map((table) => idTag("table", table.id)),],- onQueryStarted: (_, { queryFulfilled, dispatch }) =>- handleQueryFulfilled(queryFulfilled, (data) =>- dispatch(updateMetadata(data, [TableSchema])),- ),}),listDatabaseIdFields: builder.query<Field[], ListDatabaseIdFieldsRequest>({query: ({ id, ...params }) => ({@@ -221,10 +169,6 @@ export const databaseApi = Api.injectEndpoints({params,}),providesTags: [listTag("field")],- onQueryStarted: (_, { queryFulfilled, dispatch }) =>- handleQueryFulfilled(queryFulfilled, (data) =>- dispatch(updateMetadata(data, [FieldSchema])),- ),}),createDatabase: builder.mutation<Database, CreateDatabaseRequest>({query: (body) => ({diff --git a/frontend/src/metabase/api/dataset.ts b/frontend/src/metabase/api/dataset.tsindex 53acefddd4e..eb2a1362ea4 100644--- a/frontend/src/metabase/api/dataset.ts+++ b/frontend/src/metabase/api/dataset.ts@@ -1,5 +1,3 @@-import { updateMetadata } from "metabase/redux/metadata";-import { QueryMetadataSchema } from "metabase/schema";import type {CardQueryMetadata,Dataset,@@ -16,7 +14,6 @@ import {provideAdhocQueryMetadataTags,provideParameterValuesTags,} from "./tags";-import { handleQueryFulfilled } from "./utils/lifecycle";interface IgnorableError {ignore_error?: boolean;@@ -98,10 +95,6 @@ export const datasetApi = Api.injectEndpoints({}),providesTags: (metadata) =>metadata ? provideAdhocQueryMetadataTags(metadata) : [],- onQueryStarted: (_, { queryFulfilled, dispatch }) =>- handleQueryFulfilled(queryFulfilled, (data) =>- dispatch(updateMetadata(data, QueryMetadataSchema)),- ),}),getNativeDataset: builder.query<NativeDatasetResponse, DatasetQuery>({query: (body) => ({diff --git a/frontend/src/metabase/api/field.ts b/frontend/src/metabase/api/field.tsindex 0e560e2c964..2f9b9380f59 100644--- a/frontend/src/metabase/api/field.ts+++ b/frontend/src/metabase/api/field.ts@@ -1,5 +1,3 @@-import { updateMetadata } from "metabase/redux/metadata";-import { FieldSchema } from "metabase/schema";import type {CreateFieldDimensionRequest,Field,@@ -26,7 +24,6 @@ import {provideRemappedFieldValuesTags,tag,} from "./tags";-import { handleQueryFulfilled } from "./utils/lifecycle";export const fieldApi = Api.injectEndpoints({endpoints: (builder) => ({@@ -37,10 +34,6 @@ export const fieldApi = Api.injectEndpoints({params,}),providesTags: (field) => (field ? provideFieldTags(field) : []),- onQueryStarted: (_, { queryFulfilled, dispatch }) =>- handleQueryFulfilled(queryFulfilled, (data) =>- dispatch(updateMetadata(data, FieldSchema)),- ),}),getFieldTableIds: builder.query<GetFieldTableIdsResponse,diff --git a/frontend/src/metabase/api/measure.ts b/frontend/src/metabase/api/measure.tsindex 588ba7aef43..10d38280465 100644--- a/frontend/src/metabase/api/measure.ts+++ b/frontend/src/metabase/api/measure.ts@@ -1,4 +1,3 @@-import { MeasureSchema } from "metabase/schema";import type {CreateMeasureRequest,FieldValue,@@ -21,7 +20,6 @@ import {provideMeasureTags,tag,} from "./tags";-import { hydrateMetadataStore } from "./utils/hydrate-metadata-store";export const measureApi = Api.injectEndpoints({endpoints: (builder) => ({@@ -31,7 +29,6 @@ export const measureApi = Api.injectEndpoints({url: "/api/measure",}),providesTags: (measures = []) => provideMeasureListTags(measures),- onQueryStarted: hydrateMetadataStore([MeasureSchema]),}),getMeasure: builder.query<Measure, MeasureId>({query: (id) => ({@@ -39,7 +36,6 @@ export const measureApi = Api.injectEndpoints({url: `/api/measure/${id}`,}),providesTags: (measure) => (measure ? provideMeasureTags(measure) : []),- onQueryStarted: hydrateMetadataStore(MeasureSchema),}),getMeasureDimensionValues: builder.query<GetMeasureDimensionValuesResponse,diff --git a/frontend/src/metabase/api/metric.ts b/frontend/src/metabase/api/metric.tsindex d1cc4335127..09991bc84cb 100644--- a/frontend/src/metabase/api/metric.ts+++ b/frontend/src/metabase/api/metric.ts@@ -1,4 +1,3 @@-import { MetricSchema } from "metabase/schema";import type {AddMetricDimensionsRequest,Dataset,@@ -32,7 +31,6 @@ import {provideMetricTags,} from "./tags/utils";import { getMetricDatasetCacheKey } from "./utils/get-metric-dataset-cache-key";-import { hydrateMetadataStore } from "./utils/hydrate-metadata-store";/*** Curation edits change the dimensions embedded in the metric card itself,@@ -54,10 +52,6 @@ export const metricApi = Api.injectEndpoints({url: "/api/metric",}),providesTags: (response) => provideMetricListTags(response?.data ?? []),- onQueryStarted: hydrateMetadataStore<GetMetricListResponse>(- [MetricSchema],- (response) => response.data,- ),}),getMetric: builder.query<Metric, MetricId>({query: (id) => ({@@ -65,7 +59,6 @@ export const metricApi = Api.injectEndpoints({url: `/api/metric/${id}`,}),providesTags: (metric) => (metric ? provideMetricTags(metric) : []),- onQueryStarted: hydrateMetadataStore(MetricSchema),}),getMetricDimensionValues: builder.query<GetMetricDimensionValuesResponse,diff --git a/frontend/src/metabase/api/segment.ts b/frontend/src/metabase/api/segment.tsindex b1be4f7df6a..4ca66670795 100644--- a/frontend/src/metabase/api/segment.ts+++ b/frontend/src/metabase/api/segment.ts@@ -1,4 +1,3 @@-import { SegmentSchema } from "metabase/schema";import type {CreateSegmentRequest,Segment,@@ -15,7 +14,6 @@ import {provideSegmentTags,tag,} from "./tags";-import { hydrateMetadataStore } from "./utils/hydrate-metadata-store";export const segmentApi = Api.injectEndpoints({endpoints: (builder) => ({@@ -25,7 +23,6 @@ export const segmentApi = Api.injectEndpoints({url: "/api/segment",}),providesTags: (segments = []) => provideSegmentListTags(segments),- onQueryStarted: hydrateMetadataStore([SegmentSchema]),}),getSegment: builder.query<Segment, SegmentId>({query: (id) => ({@@ -33,7 +30,6 @@ export const segmentApi = Api.injectEndpoints({url: `/api/segment/${id}`,}),providesTags: (segment) => (segment ? provideSegmentTags(segment) : []),- onQueryStarted: hydrateMetadataStore(SegmentSchema),}),createSegment: builder.mutation<Segment, CreateSegmentRequest>({query: (body) => ({diff --git a/frontend/src/metabase/api/snippet.ts b/frontend/src/metabase/api/snippet.tsindex 40870c607e3..d4d8b031441 100644--- a/frontend/src/metabase/api/snippet.ts+++ b/frontend/src/metabase/api/snippet.ts@@ -1,4 +1,3 @@-import { SnippetSchema } from "metabase/schema";import type {CreateSnippetRequest,ListSnippetsParams,@@ -15,7 +14,6 @@ import {provideSnippetListTags,provideSnippetTags,} from "./tags";-import { hydrateMetadataStore } from "./utils/hydrate-metadata-store";export const snippetApi = Api.injectEndpoints({endpoints: (builder) => ({@@ -29,7 +27,6 @@ export const snippetApi = Api.injectEndpoints({params,}),providesTags: (snippets = []) => provideSnippetListTags(snippets),- onQueryStarted: hydrateMetadataStore([SnippetSchema]),}),getSnippet: builder.query<NativeQuerySnippet, NativeQuerySnippetId>({query: (id) => ({@@ -37,7 +34,6 @@ export const snippetApi = Api.injectEndpoints({url: `/api/native-query-snippet/${id}`,}),providesTags: (snippet) => (snippet ? provideSnippetTags(snippet) : []),- onQueryStarted: hydrateMetadataStore(SnippetSchema),}),createSnippet: builder.mutation<NativeQuerySnippet, CreateSnippetRequest>({query: (body) => ({@@ -47,7 +43,6 @@ export const snippetApi = Api.injectEndpoints({}),invalidatesTags: (_, error) =>invalidateTags(error, [listTag("snippet")]),- onQueryStarted: hydrateMetadataStore(SnippetSchema),}),updateSnippet: builder.mutation<NativeQuerySnippet, UpdateSnippetRequest>({query: ({ id, ...body }) => ({@@ -57,7 +52,6 @@ export const snippetApi = Api.injectEndpoints({}),invalidatesTags: (_, error, { id }) =>invalidateTags(error, [listTag("snippet"), idTag("snippet", id)]),- onQueryStarted: hydrateMetadataStore(SnippetSchema),}),}),});diff --git a/frontend/src/metabase/api/table.ts b/frontend/src/metabase/api/table.tsindex ef37013e308..8aa14dfd14e 100644--- a/frontend/src/metabase/api/table.ts+++ b/frontend/src/metabase/api/table.ts@@ -1,5 +1,3 @@-import { updateMetadata } from "metabase/redux/metadata";-import { ForeignKeySchema, TableSchema } from "metabase/schema";import type {BulkTableRequest,BulkTableSelectionInfo,@@ -30,7 +28,6 @@ import {provideTableTags,tag,} from "./tags";-import { handleQueryFulfilled } from "./utils/lifecycle";export const tableApi = Api.injectEndpoints({endpoints: (builder) => ({@@ -41,10 +38,6 @@ export const tableApi = Api.injectEndpoints({params,}),providesTags: (tables = []) => provideTableListTags(tables),- onQueryStarted: (_, { queryFulfilled, dispatch }) =>- handleQueryFulfilled(queryFulfilled, (data) =>- dispatch(updateMetadata(data, [TableSchema])),- ),}),getTable: builder.query<Table, GetTableRequest>({query: ({ id }) => ({@@ -52,10 +45,6 @@ export const tableApi = Api.injectEndpoints({url: `/api/table/${id}`,}),providesTags: (table) => (table ? provideTableTags(table) : []),- onQueryStarted: (_, { queryFulfilled, dispatch }) =>- handleQueryFulfilled(queryFulfilled, (data) =>- dispatch(updateMetadata(data, TableSchema)),- ),}),getTableQueryMetadata: builder.query<Table, GetTableQueryMetadataRequest>({query: ({ id, ...params }) => ({@@ -64,10 +53,6 @@ export const tableApi = Api.injectEndpoints({params,}),providesTags: (table) => (table ? provideTableTags(table) : []),- onQueryStarted: (_, { queryFulfilled, dispatch }) =>- handleQueryFulfilled(queryFulfilled, (data) =>- dispatch(updateMetadata(data, TableSchema)),- ),}),getTableData: builder.query<TableData, GetTableDataRequest>({query: ({ tableId }) => ({@@ -81,10 +66,6 @@ export const tableApi = Api.injectEndpoints({url: `/api/table/${id}/fks`,}),providesTags: [listTag("field")],- onQueryStarted: (_, { queryFulfilled, dispatch }) =>- handleQueryFulfilled(queryFulfilled, (data) =>- dispatch(updateMetadata(data, [ForeignKeySchema])),- ),}),updateTable: builder.mutation<Table, UpdateTableRequest>({query: ({ id, ...body }) => ({diff --git a/frontend/src/metabase/api/utils/hydrate-metadata-store.ts b/frontend/src/metabase/api/utils/hydrate-metadata-store.tsdeleted file mode 100644index d2c4690c6d7..00000000000--- a/frontend/src/metabase/api/utils/hydrate-metadata-store.ts+++ /dev/null@@ -1,34 +0,0 @@-import type { Schema } from "normalizr";--import { updateMetadata } from "metabase/redux/metadata";--import { handleQueryFulfilled } from "./lifecycle";--/**- * `onQueryStarted` helper that mirrors an RTK Query response into the- * normalized `state.entities.<slice>` store via `metabase/entities/UPDATE`.- *- * Why this exists: `getMetadata` in `metabase/selectors/metadata.ts` (and the- * `Metadata`/`Database`/`Table`/… wrappers it builds) read directly from- * `state.entities.*`, stitching one logical object together from several- * endpoints' payloads. Every endpoint whose payload should flow into- * `getMetadata` therefore needs to hydrate the slices on each successful fetch.- */-export const hydrateMetadataStore =- <Response>(- schema: Schema,- pick: (response: Response) => unknown = (response) => response,- ) =>- (- _arg: unknown,- {- queryFulfilled,- dispatch,- }: {- queryFulfilled: Promise<{ data: Response }>;- dispatch: (action: ReturnType<typeof updateMetadata>) => unknown;- },- ) =>- handleQueryFulfilled(queryFulfilled, (data) =>- dispatch(updateMetadata(pick(data), schema)),- );diff --git a/frontend/src/metabase/api/utils/index.ts b/frontend/src/metabase/api/utils/index.tsindex 285d528a179..64edda3fa09 100644--- a/frontend/src/metabase/api/utils/index.ts+++ b/frontend/src/metabase/api/utils/index.ts@@ -1,4 +1,3 @@export * from "./errors";-export * from "./hydrate-metadata-store";export * from "./run-rtk-endpoint";export * from "./use-token-refresh";diff --git a/frontend/src/metabase/redux/entities/hydration.ts b/frontend/src/metabase/redux/entities/hydration.tsnew file mode 100644index 00000000000..648418ddd36--- /dev/null+++ b/frontend/src/metabase/redux/entities/hydration.ts@@ -0,0 +1,261 @@+import { type Middleware, isFulfilled } from "@reduxjs/toolkit";+import type { Schema } from "normalizr";++import {+ automagicDashboardsApi,+ cardApi,+ collectionApi,+ dashboardApi,+ databaseApi,+ datasetApi,+ fieldApi,+ measureApi,+ metricApi,+ segmentApi,+ snippetApi,+ tableApi,+} from "metabase/api";+import { updateMetadata } from "metabase/redux/metadata";+import {+ DatabaseSchema,+ FieldSchema,+ ForeignKeySchema,+ MeasureSchema,+ MetricSchema,+ ObjectUnionSchema,+ QueryMetadataSchema,+ QuestionSchema,+ SchemaSchema,+ SegmentSchema,+ SnippetSchema,+ TableSchema,+} from "metabase/schema";+import { generateSchemaId } from "metabase-lib/v1/metadata/utils/schema";+import type { DatabaseId, SchemaName } from "metabase-types/api";++/**+ * The part of an RTK Query endpoint a rule needs. Structural, so a real+ * endpoint satisfies it and infers both type parameters.+ */+type HydratingEndpoint<Response, Arg> = {+ name: string;+ Types: { ResultType: Response; QueryArg: Arg };+};++type HydrationRule = {+ endpointName: string;+ schema: Schema;+ toEntities: (response: unknown, arg: unknown) => unknown;+};++function hydrates<Response, Arg>(+ endpoint: HydratingEndpoint<Response, Arg>,+ schema: Schema,+ select: (response: Response, arg: Arg) => unknown = (response) => response,+): HydrationRule {+ return {+ endpointName: endpoint.name,+ schema,+ // The middleware finds this rule by the endpoint name the action carries,+ // so the payload and original args are always this endpoint's types.+ toEntities: (response, arg) => select(response as Response, arg as Arg),+ };+}++/**+ * No endpoint returns schema records. The schema list endpoints return bare+ * names, so the id has to be rebuilt from the database the caller asked about.+ */+const toNormalizedSchemas = (+ databaseId: DatabaseId,+ schemaNames: SchemaName[],+) =>+ schemaNames.map((schemaName) => ({+ id: generateSchemaId(databaseId, schemaName),+ name: schemaName,+ database: { id: databaseId },+ }));++/**+ * Every endpoint whose payload flows into `getMetadata`.+ *+ * `getMetadata` in `metabase/selectors/metadata.ts` stitches one logical object+ * together from several endpoints' payloads, so each of these has to reach+ * `state.entities` on success. This table is the only place that happens.+ *+ * Adding an endpoint here starts hydrating every one of its callers, which is a+ * behaviour change. `hydration.unit.spec.ts` fails on any edit to the set.+ */+const HYDRATION_RULES: HydrationRule[] = [+ hydrates(+ databaseApi.endpoints.listDatabases,+ [DatabaseSchema],+ (response) => response.data,+ ),+ hydrates(databaseApi.endpoints.getDatabase, DatabaseSchema),+ hydrates(databaseApi.endpoints.getDatabaseMetadata, DatabaseSchema),+ hydrates(+ databaseApi.endpoints.listDatabaseSchemas,+ [SchemaSchema],+ (schemaNames, { id }) => toNormalizedSchemas(id, schemaNames),+ ),+ hydrates(+ databaseApi.endpoints.listSyncableDatabaseSchemas,+ [SchemaSchema],+ (schemaNames, databaseId) => toNormalizedSchemas(databaseId, schemaNames),+ ),+ hydrates(databaseApi.endpoints.listDatabaseSchemaTables, [TableSchema]),+ hydrates(databaseApi.endpoints.listVirtualDatabaseTables, [TableSchema]),+ hydrates(databaseApi.endpoints.listDatabaseIdFields, [FieldSchema]),++ hydrates(tableApi.endpoints.listTables, [TableSchema]),+ hydrates(tableApi.endpoints.getTable, TableSchema),+ hydrates(tableApi.endpoints.getTableQueryMetadata, TableSchema),+ hydrates(tableApi.endpoints.listTableForeignKeys, [ForeignKeySchema]),++ hydrates(fieldApi.endpoints.getField, FieldSchema),++ hydrates(cardApi.endpoints.listCards, [QuestionSchema]),+ hydrates(cardApi.endpoints.getCard, QuestionSchema),+ hydrates(cardApi.endpoints.getCardQueryMetadata, QueryMetadataSchema),+ hydrates(cardApi.endpoints.createCard, QuestionSchema),+ hydrates(cardApi.endpoints.updateCard, QuestionSchema),++ hydrates(+ dashboardApi.endpoints.getDashboardQueryMetadata,+ QueryMetadataSchema,+ ),++ hydrates(datasetApi.endpoints.getAdhocQueryMetadata, QueryMetadataSchema),++ hydrates(+ automagicDashboardsApi.endpoints.getXrayDashboardQueryMetadata,+ QueryMetadataSchema,+ ),+ hydrates(+ automagicDashboardsApi.endpoints.getXrayDashboardForModel,+ QueryMetadataSchema,+ ),++ hydrates(segmentApi.endpoints.listSegments, [SegmentSchema]),+ hydrates(segmentApi.endpoints.getSegment, SegmentSchema),++ hydrates(+ metricApi.endpoints.listMetrics,+ [MetricSchema],+ (response) => response.data,+ ),+ hydrates(metricApi.endpoints.getMetric, MetricSchema),++ hydrates(measureApi.endpoints.listMeasures, [MeasureSchema]),+ hydrates(measureApi.endpoints.getMeasure, MeasureSchema),++ hydrates(snippetApi.endpoints.listSnippets, [SnippetSchema]),+ hydrates(snippetApi.endpoints.getSnippet, SnippetSchema),+ hydrates(snippetApi.endpoints.createSnippet, SnippetSchema),+ hydrates(snippetApi.endpoints.updateSnippet, SnippetSchema),++ hydrates(+ collectionApi.endpoints.listCollectionItems,+ [ObjectUnionSchema],+ (response) => response.data,+ ),+];++export const HYDRATED_ENDPOINT_NAMES = HYDRATION_RULES.map(+ (rule) => rule.endpointName,+);++const RULES_BY_ENDPOINT = new Map(+ HYDRATION_RULES.map((rule) => [rule.endpointName, rule]),+);++type FulfilledQuery = {+ endpointName: string;+ originalArgs: unknown;+ payload: unknown;+};++// `isFulfilled` matches every async thunk in the app, so the type prefix pins+// this to the shared Api's own actions. Read off an injected slice rather than+// the base Api: every slice is the same enhanced object, so `reducerPath` is+// identical on all of them, and a rename cannot silently break the guard.+const API_ACTION_PREFIX = `${databaseApi.reducerPath}/`;++function getFulfilledQuery(action: unknown): FulfilledQuery | undefined {+ if (!isFulfilled(action) || !action.type.startsWith(API_ACTION_PREFIX)) {+ return undefined;+ }+ const { arg } = action.meta;+ if (+ arg != null &&+ typeof arg === "object" &&+ "endpointName" in arg &&+ typeof arg.endpointName === "string"+ ) {+ return {+ endpointName: arg.endpointName,+ originalArgs: "originalArgs" in arg ? arg.originalArgs : undefined,+ payload: action.payload,+ };+ }+ return undefined;+}++/**+ * The single writer into `state.entities`. Runs after the RTK cache has taken+ * the response.+ *+ * It lives here rather than in each endpoint's `onQueryStarted` so that+ * `metabase/api` needs no import from `metabase/redux`, which is an upward+ * edge: `shared/api` is U1 and `shared/redux` is U2.+ */+export const metadataHydrationMiddleware: Middleware =+ ({ dispatch }) =>+ (next) =>+ (action) => {+ const result = next(action);++ const query = getFulfilledQuery(action);+ const rule = query && RULES_BY_ENDPOINT.get(query.endpointName);+ if (!query || !rule) {+ return result;+ }++ const { payload } = query;+ if (payload == null) {+ return result;+ }++ // `normalize` throws on anything that is not an object, and two responses+ // reach here that are not one: a redirect resolves the request with a+ // string body, and a list response that omits its rows selects `undefined`.+ // Skipped explicitly, so that a genuine fault still throws.+ const entities = rule.toEntities(payload, query.originalArgs);+ if (entities == null || typeof entities !== "object") {+ return result;+ }++ // Deferred so the write cannot re-enter the action that triggered it.+ // Writing synchronously lands while the fulfilled action is still+ // unwinding through RTK Query's middleware, and reorders that work against+ // the render it triggers. `AddCardSidebar.unit.spec.tsx` catches it.+ //+ // A promise and not `queueMicrotask`: Jest's fake timers replace+ // `queueMicrotask`, so a spec that drives polling by hand would never+ // flush the write.+ // Caught so a failed write cannot surface as an unhandled rejection, which+ // would be detached from the endpoint that caused it. Logged and not+ // swallowed: the write is a mirror of a response the cache already holds,+ // so losing one leaves stale metadata rather than a broken request.+ Promise.resolve()+ .then(() => dispatch(updateMetadata(entities, rule.schema)))+ .catch((error) => {+ console.error(+ `Failed to mirror the ${query.endpointName} response into state.entities`,+ error,+ );+ });++ return result;+ };diff --git a/frontend/src/metabase/redux/entities/hydration.unit.spec.ts b/frontend/src/metabase/redux/entities/hydration.unit.spec.tsnew file mode 100644index 00000000000..4de855e27e0--- /dev/null+++ b/frontend/src/metabase/redux/entities/hydration.unit.spec.ts@@ -0,0 +1,236 @@+import type { Dispatch, MiddlewareAPI } from "@reduxjs/toolkit";++import { generateSchemaId } from "metabase-lib/v1/metadata/utils/schema";++import {+ HYDRATED_ENDPOINT_NAMES,+ metadataHydrationMiddleware,+} from "./hydration";++/**+ * Every endpoint whose response reaches `state.entities`.+ *+ * Keep this list literal. Dropping an endpoint stops its data reaching+ * `getMetadata` and throws nothing, and adding one starts hydrating every+ * caller of an endpoint that does not hydrate today. Both are behaviour+ * changes that have to be argued in review, not absorbed by a snapshot.+ */+const HYDRATING_ENDPOINTS = [+ "createCard",+ "createSnippet",+ "getAdhocQueryMetadata",+ "getCard",+ "getCardQueryMetadata",+ "getDashboardQueryMetadata",+ "getDatabase",+ "getDatabaseMetadata",+ "getField",+ "getMeasure",+ "getMetric",+ "getSegment",+ "getSnippet",+ "getTable",+ "getTableQueryMetadata",+ "getXrayDashboardForModel",+ "getXrayDashboardQueryMetadata",+ "listCards",+ "listCollectionItems",+ "listDatabaseIdFields",+ "listDatabaseSchemaTables",+ "listDatabaseSchemas",+ "listDatabases",+ "listMeasures",+ "listMetrics",+ "listSegments",+ "listSnippets",+ "listSyncableDatabaseSchemas",+ "listTableForeignKeys",+ "listTables",+ "listVirtualDatabaseTables",+ "updateCard",+ "updateSnippet",+];++type UpdateAction = {+ type: string;+ payload: { entities: Record<string, Record<string, unknown>> };+};++async function runMiddleware(action: unknown): Promise<UpdateAction[]> {+ const dispatched: UpdateAction[] = [];+ // The middleware only ever dispatches `updateMetadata`, so the recorder takes+ // that one shape. Redux types `dispatch` to accept any action.+ const store = {+ dispatch: (dispatchedAction: UpdateAction) => {+ dispatched.push(dispatchedAction);+ return dispatchedAction;+ },+ getState: () => ({}),+ } as unknown as MiddlewareAPI<Dispatch, unknown>;++ metadataHydrationMiddleware(store)((nextAction) => nextAction)(action);+ // The write is deferred by a microtask, so let it run.+ await Promise.resolve();++ return dispatched;+}++function fulfilled(+ endpointName: string,+ payload: unknown,+ originalArgs?: unknown,+) {+ return {+ type: "metabase-api/executeQuery/fulfilled",+ payload,+ meta: {+ requestId: "test-request",+ requestStatus: "fulfilled" as const,+ arg: { endpointName, originalArgs, type: "query" },+ },+ };+}++describe("metadataHydrationMiddleware", () => {+ it("hydrates exactly the endpoints in the list, and no others", () => {+ expect([...HYDRATED_ENDPOINT_NAMES].sort()).toEqual(+ [...HYDRATING_ENDPOINTS].sort(),+ );+ });++ it("registers each endpoint once", () => {+ expect(new Set(HYDRATED_ENDPOINT_NAMES).size).toBe(+ HYDRATED_ENDPOINT_NAMES.length,+ );+ });++ it("defers the write instead of re-entering the action that triggered it", () => {+ const dispatched: UpdateAction[] = [];+ // Same narrowing as `runMiddleware`: the middleware only dispatches+ // `updateMetadata`, while Redux types `dispatch` to accept any action.+ const store = {+ dispatch: (action: UpdateAction) => dispatched.push(action),+ getState: () => ({}),+ } as unknown as MiddlewareAPI<Dispatch, unknown>;++ metadataHydrationMiddleware(store)((nextAction) => nextAction)(+ fulfilled("getTable", { id: 7, name: "Orders" }, { id: 7 }),+ );++ // Writing here would land while the fulfilled action is still unwinding+ // through RTK Query's middleware, which reorders its post-processing.+ expect(dispatched).toEqual([]);+ });++ it("normalizes a response into its slice", async () => {+ const [action] = await runMiddleware(+ fulfilled("getTable", { id: 7, name: "Orders" }, { id: 7 }),+ );++ expect(action.payload.entities.tables["7"]).toEqual(+ expect.objectContaining({ id: 7, name: "Orders" }),+ );+ });++ it("unwraps a list response that nests its rows under `data`", async () => {+ const [action] = await runMiddleware(+ fulfilled("listDatabases", {+ data: [{ id: 1, name: "Sample" }],+ total: 1,+ }),+ );++ expect(action.payload.entities.databases["1"]).toEqual(+ expect.objectContaining({ id: 1, name: "Sample" }),+ );+ });++ it("ignores a list response that omits its rows", async () => {+ // `normalize(undefined)` throws, so the rule's selection is guarded.+ expect(+ await runMiddleware(fulfilled("listDatabases", { total: 0 })),+ ).toEqual([]);+ });++ it("ignores an endpoint that does not hydrate", async () => {+ expect(+ await runMiddleware(fulfilled("getTableData", { rows: [] })),+ ).toEqual([]);+ });++ it("ignores a non-endpoint action", async () => {+ expect(await runMiddleware({ type: "metabase/some/thing" })).toEqual([]);+ });++ it("reports a failed write instead of rejecting", async () => {+ const consoleError = jest+ .spyOn(console, "error")+ .mockImplementation(() => undefined);+ // The write is deferred, so a throw here would otherwise surface as an+ // unhandled rejection, detached from the endpoint that caused it.+ const store = {+ dispatch: () => {+ throw new Error("reducer blew up");+ },+ getState: () => ({}),+ } as unknown as MiddlewareAPI<Dispatch, unknown>;++ metadataHydrationMiddleware(store)((nextAction) => nextAction)(+ fulfilled("getTable", { id: 7, name: "Orders" }, { id: 7 }),+ );+ await Promise.resolve();+ await Promise.resolve();++ expect(consoleError).toHaveBeenCalledWith(+ expect.stringContaining("getTable"),+ expect.any(Error),+ );+ consoleError.mockRestore();+ });++ it("ignores a fulfilled thunk that is not an Api query", async () => {+ // `isFulfilled` matches every async thunk in the app, so a thunk of another+ // slice carrying an `endpointName` must not reach the mirror.+ const foreignThunk = {+ type: "some-other-slice/executeQuery/fulfilled",+ payload: { id: 7, name: "Orders" },+ meta: {+ requestId: "test-request",+ requestStatus: "fulfilled" as const,+ arg: { endpointName: "getTable", originalArgs: { id: 7 } },+ },+ };++ expect(await runMiddleware(foreignThunk)).toEqual([]);+ });++ it("ignores a redirect, which resolves the request with a string body", async () => {+ expect(+ await runMiddleware(fulfilled("getTable", "<html>", { id: 7 })),+ ).toEqual([]);+ });++ describe("schema records, which no endpoint returns", () => {+ it("builds them from an object arg for listDatabaseSchemas", async () => {+ const [action] = await runMiddleware(+ fulfilled("listDatabaseSchemas", ["public"], { id: 3 }),+ );++ const id = generateSchemaId(3, "public");+ expect(action.payload.entities.schemas[id]).toEqual(+ expect.objectContaining({ id, name: "public" }),+ );+ });++ it("builds them from a bare id arg for listSyncableDatabaseSchemas", async () => {+ const [action] = await runMiddleware(+ fulfilled("listSyncableDatabaseSchemas", ["public"], 3),+ );++ const id = generateSchemaId(3, "public");+ expect(action.payload.entities.schemas[id]).toEqual(+ expect.objectContaining({ id, name: "public" }),+ );+ });+ });+});diff --git a/frontend/src/metabase/redux/entities/index.ts b/frontend/src/metabase/redux/entities/index.tsindex e3a23ce81b2..2131438b1e5 100644--- a/frontend/src/metabase/redux/entities/index.ts+++ b/frontend/src/metabase/redux/entities/index.ts@@ -13,8 +13,8 @@ type SliceReducer = Reducer<SliceState>;* Slices held under `state.entities.<name>`. These used to be wired up by the* (now-removed) entity framework via `createEntity`; the slices themselves* still exist because `getMetadata` in `metabase/selectors/metadata.ts` reads- * directly from them. RTK Query endpoints populate the slices by dispatching- * `metabase/entities/UPDATE` (see `hydrateMetadataStore`).+ * directly from them. `metadataHydrationMiddleware` in `./hydration` is the+ * only writer, and populates them by dispatching `metabase/entities/UPDATE`.*/const ENTITY_SLICE_NAMES = ["databases",diff --git a/frontend/src/metabase/redux/entities/tables-reducer.ts b/frontend/src/metabase/redux/entities/tables-reducer.tsindex db837dbee0f..ac382c0d59c 100644--- a/frontend/src/metabase/redux/entities/tables-reducer.ts+++ b/frontend/src/metabase/redux/entities/tables-reducer.ts@@ -84,10 +84,10 @@ export function tablesReducer(};}- // Keep `original_fields` in sync when something dispatches- // `updateMetadata(field, FieldSchema)` (e.g. RTK Query's getField- // onQueryStarted). Without this, edits land in state.entities.fields but- // hydrateTableFields keeps reading stale data from original_fields.+ // Keep `original_fields` in sync when a field reaches the mirror, which the+ // hydration listener does for every endpoint carrying one. Without this,+ // edits land in state.entities.fields but hydrateTableFields keeps reading+ // stale data from original_fields.//// Virtual card tables can have multiple `original_fields` entries with the// same `id` (a model with two columns both mapped to the same sourcediff --git a/frontend/src/metabase/store.ts b/frontend/src/metabase/store.tsindex 0fe2bbfce3b..0a30f0459e0 100644--- a/frontend/src/metabase/store.ts+++ b/frontend/src/metabase/store.ts@@ -8,6 +8,7 @@ import {import { Api } from "metabase/api";import { PLUGIN_REDUX_MIDDLEWARES } from "metabase/plugins";+import { metadataHydrationMiddleware } from "metabase/redux/entities/hydration";import type { State } from "metabase/redux/store";// Each app passes its own reducer map, so per-slice types can't be known here.@@ -27,6 +28,7 @@ export function getStore(const middlewares: Middleware[] = [Api.middleware,+ metadataHydrationMiddleware,...PLUGIN_REDUX_MIDDLEWARES,...extraMiddlewares,];diff --git a/frontend/test/__support__/entities-store.ts b/frontend/test/__support__/entities-store.tsindex dc2539dabb0..45f98479014 100644--- a/frontend/test/__support__/entities-store.ts+++ b/frontend/test/__support__/entities-store.ts@@ -7,6 +7,7 @@ import { commonReducers } from "metabase/reducers-common";import { mainReducers } from "metabase/reducers-main";import { publicReducers } from "metabase/reducers-public";import { reducer as entitiesReducer } from "metabase/redux/entities";+import { metadataHydrationMiddleware } from "metabase/redux/entities/hydration";import type { State } from "metabase/redux/store";import {type StoreSeedState,@@ -57,7 +58,10 @@ export function getStore(getDefaultMiddleware({immutableCheck: false,serializableCheck: false,- }).concat(middleware)) as never,+ // Appended rather than defaulted: callers pass their own `middleware`+ // list, and dropping the mirror's only writer would stop hydration in+ // that spec with nothing failing.+ }).concat(middleware, metadataHydrationMiddleware)) as never,});}