Skip to content

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

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.ts
index 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.ts
index 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.ts
index 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.ts
index 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.ts
index 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.ts
index 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.ts
index 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.ts
index 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.ts
index 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.ts
index 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.ts
index 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.ts
index 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.ts
deleted file mode 100644
index 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.ts
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
index 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.ts
index 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 source
diff --git a/frontend/src/metabase/store.ts b/frontend/src/metabase/store.ts
index 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.ts
index 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,
});
}