Skip to content

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

Convert `metabase/redux/metadata.js` to TypeScript and remove some deprecated handlers (#76048)

Romeo Van Snickdfecbd6799a7
diff --git a/frontend/src/metabase/admin/databases/database.ts b/frontend/src/metabase/admin/databases/database.ts
index 95e99eec610..1c42bbf9a1b 100644
--- a/frontend/src/metabase/admin/databases/database.ts
+++ b/frontend/src/metabase/admin/databases/database.ts
@@ -5,7 +5,7 @@ import { databaseApi } from "metabase/api";
import { runRtkEndpoint } from "metabase/api/utils/run-rtk-endpoint";
import { combineReducers } from "metabase/redux";
import { createDatabase } from "metabase/redux/databases";
-import { updateMetadata } from "metabase/redux/metadata-typed";
+import { updateMetadata } from "metabase/redux/metadata";
import type { Dispatch } from "metabase/redux/store";
import { DatabaseSchema } from "metabase/schema";
import type { DatabaseData, DatabaseId } from "metabase-types/api";
diff --git a/frontend/src/metabase/api/utils/hydrate-metadata-store.ts b/frontend/src/metabase/api/utils/hydrate-metadata-store.ts
index 11ae7eed5bf..d2c4690c6d7 100644
--- a/frontend/src/metabase/api/utils/hydrate-metadata-store.ts
+++ b/frontend/src/metabase/api/utils/hydrate-metadata-store.ts
@@ -1,6 +1,6 @@
import type { Schema } from "normalizr";
-import { updateMetadata } from "metabase/redux/metadata-typed";
+import { updateMetadata } from "metabase/redux/metadata";
import { handleQueryFulfilled } from "./lifecycle";
diff --git a/frontend/src/metabase/hoc/Remapped.tsx b/frontend/src/metabase/hoc/Remapped.tsx
index e1785c3e7dc..39492d71afd 100644
--- a/frontend/src/metabase/hoc/Remapped.tsx
+++ b/frontend/src/metabase/hoc/Remapped.tsx
@@ -1,7 +1,7 @@
import { Component, type ComponentType } from "react";
import { connect } from "metabase/redux";
-import { fetchRemapping } from "metabase/redux/metadata";
+import { fetchRemapping } from "metabase/redux/remappings";
import type { State } from "metabase/redux/store";
import { getMetadata } from "metabase/selectors/metadata";
import type Field from "metabase-lib/v1/metadata/Field";
diff --git a/frontend/src/metabase/parameters/components/widgets/ParameterFieldWidget/FieldValuesWidget/FieldValuesWidget.tsx b/frontend/src/metabase/parameters/components/widgets/ParameterFieldWidget/FieldValuesWidget/FieldValuesWidget.tsx
index d61ce0d3069..af0e9a50b11 100644
--- a/frontend/src/metabase/parameters/components/widgets/ParameterFieldWidget/FieldValuesWidget/FieldValuesWidget.tsx
+++ b/frontend/src/metabase/parameters/components/widgets/ParameterFieldWidget/FieldValuesWidget/FieldValuesWidget.tsx
@@ -35,7 +35,7 @@ import {
fetchParameterValues,
} from "metabase/parameters/actions";
import { connect, useDispatch } from "metabase/redux";
-import { addRemappings } from "metabase/redux/metadata";
+import { addRemappings } from "metabase/redux/remappings";
import type { State } from "metabase/redux/store";
import { getMetadata } from "metabase/selectors/metadata";
import {
@@ -277,7 +277,11 @@ export const FieldValuesWidgetInner = forwardRef<
// ? this may rely on field mutations
const updateRemappings = (options: FieldValue[]) => {
if (Field.remappedField(fields) != null) {
- fields.forEach((field) => dispatch(addRemappings(field.id, options)));
+ fields.forEach((field) => {
+ if (typeof field.id === "number") {
+ dispatch(addRemappings(field.id, options));
+ }
+ });
}
};
diff --git a/frontend/src/metabase/query_builder/actions/core/initializeQB.ts b/frontend/src/metabase/query_builder/actions/core/initializeQB.ts
index 57826570662..8bf27a4f1af 100644
--- a/frontend/src/metabase/query_builder/actions/core/initializeQB.ts
+++ b/frontend/src/metabase/query_builder/actions/core/initializeQB.ts
@@ -15,17 +15,14 @@ import {
import { loadMetadataForCard } from "metabase/questions/actions";
import { setErrorPage } from "metabase/redux/app";
import type { DispatchFn } from "metabase/redux/hooks";
-import {
- fetchDatabaseMetadata,
- fetchTableMetadata,
- updateMetadata,
-} from "metabase/redux/metadata";
+import { fetchDatabaseMetadata, updateMetadata } from "metabase/redux/metadata";
import { INITIALIZE_QB, resetQB } from "metabase/redux/query-builder";
import type {
Dispatch,
GetState,
QueryBuilderUIControls,
} from "metabase/redux/store";
+import { fetchTableMetadataAndForeignKeys } from "metabase/redux/tables";
import { FieldSchema } from "metabase/schema";
import { getMetadata } from "metabase/selectors/metadata";
import { canUserCreateQueries, getUser } from "metabase/selectors/user";
@@ -314,7 +311,7 @@ async function handleQBInit(
const currentUser = getUser(getState());
if (isTableRoute && slugEntityId != null) {
- await dispatch(fetchTableMetadata(slugEntityId));
+ await dispatch(fetchTableMetadataAndForeignKeys({ id: slugEntityId }));
if (isStale()) {
return;
}
diff --git a/frontend/src/metabase/redux/databases.ts b/frontend/src/metabase/redux/databases.ts
index 83e57559783..1014183f68d 100644
--- a/frontend/src/metabase/redux/databases.ts
+++ b/frontend/src/metabase/redux/databases.ts
@@ -2,7 +2,7 @@ import _ from "underscore";
import { databaseApi } from "metabase/api";
import { runRtkEndpoint } from "metabase/api/utils/run-rtk-endpoint";
-import { updateMetadata } from "metabase/redux/metadata-typed";
+import { updateMetadata } from "metabase/redux/metadata";
import type { Dispatch } from "metabase/redux/store";
import { DatabaseSchema } from "metabase/schema";
import type { DatabaseData } from "metabase-types/api";
diff --git a/frontend/src/metabase/redux/entities/tables-reducer.ts b/frontend/src/metabase/redux/entities/tables-reducer.ts
index e4d80c2675c..5aa90f17e8d 100644
--- a/frontend/src/metabase/redux/entities/tables-reducer.ts
+++ b/frontend/src/metabase/redux/entities/tables-reducer.ts
@@ -86,9 +86,8 @@ export function tablesReducer(
// Keep `original_fields` in sync when something dispatches
// `updateMetadata(field, FieldSchema)` (e.g. RTK Query's getField
- // onQueryStarted, or the deprecated redux/metadata wrappers). Without this,
- // edits land in state.entities.fields but hydrateTableFields keeps reading
- // stale data from original_fields.
+ // onQueryStarted). 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/redux/metadata-typed.ts b/frontend/src/metabase/redux/metadata-typed.ts
deleted file mode 100644
index b7c7684b8c8..00000000000
--- a/frontend/src/metabase/redux/metadata-typed.ts
+++ /dev/null
@@ -1,11 +0,0 @@
-import { type Schema, normalize } from "normalizr";
-
-// Handled by the per-slice reducers in `metabase/redux/entities` — see
-// `makeSliceReducer` there, which merges `payload.entities.<name>` into the
-// matching `state.entities.<name>` slice so `getMetadata` picks up the change.
-const UPDATE = "metabase/entities/UPDATE";
-
-export function updateMetadata(data: unknown, schema: Schema) {
- const payload = normalize(data, schema);
- return { type: UPDATE, payload };
-}
diff --git a/frontend/src/metabase/redux/metadata.js b/frontend/src/metabase/redux/metadata.js
deleted file mode 100644
index 1cafdb541f1..00000000000
--- a/frontend/src/metabase/redux/metadata.js
+++ /dev/null
@@ -1,283 +0,0 @@
-import { getIn } from "icepick";
-import _ from "underscore";
-
-import {
- cardApi,
- dashboardApi,
- databaseApi,
- datasetApi,
- fieldApi,
- revisionApi,
- segmentApi,
- tableApi,
-} from "metabase/api";
-import { runRtkEndpoint } from "metabase/api/utils/run-rtk-endpoint";
-import { isProduction } from "metabase/env";
-import { createThunkAction } from "metabase/redux";
-import { fetchTableMetadataAndForeignKeys } from "metabase/redux/tables";
-import { DatabaseSchema, FieldSchema, TableSchema } from "metabase/schema";
-import { hasRemappedParameterValues } from "metabase-lib/v1/parameters/utils/parameter-source";
-import { normalizeParameter } from "metabase-lib/v1/parameters/utils/parameter-values";
-
-import { updateMetadata } from "./metadata-typed";
-
-export * from "metabase/redux/metadata-typed";
-
-// NOTE: All of these actions are deprecated. Use metadata entities directly.
-
-const deprecated = (message) => {
- if (!isProduction) {
- console.warn("DEPRECATED: " + message);
- }
-};
-
-export const fetchSegments = () => (dispatch) => {
- deprecated("metabase/redux/metadata fetchSegments");
- return runRtkEndpoint(undefined, dispatch, segmentApi.endpoints.listSegments);
-};
-
-export const updateSegment = (segment) => (dispatch) => {
- deprecated("metabase/redux/metadata updateSegment");
- return runRtkEndpoint(segment, dispatch, segmentApi.endpoints.updateSegment);
-};
-
-export const fetchRealDatabases =
- (reload = false) =>
- (dispatch) => {
- deprecated("metabase/redux/metadata fetchRealDatabases");
- return runRtkEndpoint(
- { include: "tables" },
- dispatch,
- databaseApi.endpoints.listDatabases,
- { forceRefetch: reload },
- );
- };
-
-export const fetchDatabaseMetadata =
- (dbId, reload = false) =>
- (dispatch) => {
- deprecated("metabase/redux/metadata fetchDatabaseMetadata");
- return runRtkEndpoint(
- { id: dbId },
- dispatch,
- databaseApi.endpoints.getDatabaseMetadata,
- { forceRefetch: reload },
- );
- };
-
-export const updateDatabase = (database) => async (dispatch) => {
- deprecated("metabase/redux/metadata updateDatabase");
- const slimDatabase = _.omit(database, "tables", "tables_lookup");
- const result = await runRtkEndpoint(
- slimDatabase,
- dispatch,
- databaseApi.endpoints.updateDatabase,
- );
- dispatch(updateMetadata(result, DatabaseSchema));
- return result;
-};
-
-export const updateTable = (table) => async (dispatch) => {
- deprecated("metabase/redux/metadata updateTable");
- const slimTable = _.omit(
- table,
- "fields",
- "fields_lookup",
- "aggregation_operators",
- "segments",
- );
- const result = await runRtkEndpoint(
- slimTable,
- dispatch,
- tableApi.endpoints.updateTable,
- );
- dispatch(updateMetadata(result, TableSchema));
- return result;
-};
-
-export const fetchTableMetadata = (id, reload = false) => {
- deprecated("metabase/redux/metadata fetchTableMetadata");
- return fetchTableMetadataAndForeignKeys({ id }, { reload });
-};
-
-export const updateFieldValues = (fieldId, fieldValuePairs) => (dispatch) => {
- deprecated("metabase/redux/metadata updateFieldValues");
- return runRtkEndpoint(
- { id: fieldId, values: fieldValuePairs },
- dispatch,
- fieldApi.endpoints.updateFieldValues,
- );
-};
-
-export const updateField = (field) => async (dispatch) => {
- deprecated("metabase/redux/metadata updateField");
- const slimField = _.omit(field, "filter_operators_lookup");
- const result = await runRtkEndpoint(
- slimField,
- dispatch,
- fieldApi.endpoints.updateField,
- );
- dispatch(updateMetadata(result, FieldSchema));
- return result;
-};
-
-export const deleteFieldDimension = (fieldId) => async (dispatch) => {
- deprecated("metabase/redux/metadata deleteFieldDimension");
- const result = await runRtkEndpoint(
- fieldId,
- dispatch,
- fieldApi.endpoints.deleteFieldDimension,
- );
- dispatch(updateMetadata({ id: fieldId, dimensions: [] }, FieldSchema));
- return result;
-};
-
-export const updateFieldDimension =
- (fieldId, dimension) => async (dispatch) => {
- deprecated("metabase/redux/metadata updateFieldDimension");
- const result = await runRtkEndpoint(
- { id: fieldId, ...dimension },
- dispatch,
- fieldApi.endpoints.createFieldDimension,
- );
- dispatch(
- updateMetadata({ id: fieldId, dimensions: [result] }, FieldSchema),
- );
- return result;
- };
-
-export const FETCH_REVISIONS = "metabase/metadata/FETCH_REVISIONS";
-export const fetchRevisions = createThunkAction(FETCH_REVISIONS, (type, id) => {
- return async (dispatch) => {
- const revisions = await runRtkEndpoint(
- { id, entity: type === "metric" ? "legacy-metric" : type },
- dispatch,
- revisionApi.endpoints.listRevisions,
- );
- return { type, id, revisions };
- };
-});
-
-export const FETCH_SEGMENT_FIELDS = "metabase/metadata/FETCH_SEGMENT_FIELDS";
-export const fetchSegmentFields = createThunkAction(
- FETCH_SEGMENT_FIELDS,
- (segmentId, reload = false) => {
- return async (dispatch, getState) => {
- await dispatch(fetchSegments()); // FIXME: fetchSegment?
- const segment = getIn(getState(), ["entities", "segments", segmentId]);
- const tableId = segment.table_id;
- await dispatch(fetchTableMetadata(tableId));
- const table = getIn(getState(), ["entities", "tables", tableId]);
- const databaseId = table.db_id;
- await dispatch(fetchDatabaseMetadata(databaseId));
- };
- },
-);
-
-export const FETCH_SEGMENT_TABLE = "metabase/metadata/FETCH_SEGMENT_TABLE";
-export const fetchSegmentTable = createThunkAction(
- FETCH_SEGMENT_TABLE,
- (segmentId, reload = false) => {
- return async (dispatch, getState) => {
- await dispatch(fetchSegments()); // FIXME: fetchSegment?
- const segment = getIn(getState(), ["entities", "segments", segmentId]);
- const tableId = segment.table_id;
- await dispatch(fetchTableMetadata(tableId));
- };
- },
-);
-
-export const FETCH_SEGMENT_REVISIONS =
- "metabase/metadata/FETCH_SEGMENT_REVISIONS";
-export const fetchSegmentRevisions = createThunkAction(
- FETCH_SEGMENT_REVISIONS,
- (segmentId, reload = false) => {
- return async (dispatch, getState) => {
- await Promise.all([
- dispatch(fetchRevisions("segment", segmentId)),
- dispatch(fetchSegments()),
- ]);
- const segment = getIn(getState(), ["entities", "segments", segmentId]);
- const tableId = segment.table_id;
- await dispatch(fetchTableMetadata(tableId));
- };
- },
-);
-
-export const addRemappings = (fieldId, remappings) => (dispatch, getState) => {
- deprecated("metabase/redux/metadata addRemappings");
- const existing = getState().entities.fields?.[fieldId]?.remappings ?? [];
- const merged = Array.from(new Map(existing.concat(remappings)));
- return dispatch(
- updateMetadata({ id: fieldId, remappings: merged }, FieldSchema),
- );
-};
-
-const FETCH_REMAPPING = "metabase/metadata/FETCH_REMAPPING";
-export const fetchRemapping = createThunkAction(
- FETCH_REMAPPING,
- ({ parameter, value, field, cardId, dashboardId, uuid, token }) =>
- async (dispatch, getState) => {
- if (field != null && field.hasRemappedValue(value)) {
- return;
- }
-
- if (
- parameter == null ||
- !hasRemappedParameterValues(parameter, field ? [field] : [])
- ) {
- return;
- }
-
- const entityIdentifier = uuid ?? token ?? null;
- let remapping;
- if (dashboardId != null) {
- remapping = await runRtkEndpoint(
- {
- ...(entityIdentifier
- ? { entityIdentifier }
- : { dashboard_id: dashboardId }),
- parameter_id: parameter.id,
- value,
- },
- dispatch,
- dashboardApi.endpoints.getRemappedDashboardParameterValue,
- { forceRefetch: false },
- );
- } else if (cardId != null) {
- remapping = await runRtkEndpoint(
- {
- ...(entityIdentifier ? { entityIdentifier } : { card_id: cardId }),
- parameter_id: parameter.id,
- value,
- },
- dispatch,
- cardApi.endpoints.getRemappedCardParameterValue,
- { forceRefetch: false },
- );
- } else if (field != null) {
- // Field-based remapping (e.g. FK display fields). Static-list sources
- // carry their [value, label] pairs inline and need no network call.
- remapping = await runRtkEndpoint(
- {
- parameter: normalizeParameter(parameter),
- field_ids: [field.id],
- value,
- },
- dispatch,
- datasetApi.endpoints.getRemappedParameterValue,
- { forceRefetch: false },
- );
- }
-
- if (remapping == null) {
- return;
- }
-
- if (field != null) {
- dispatch(addRemappings(field.id, [remapping]));
- }
-
- return remapping;
- },
-);
diff --git a/frontend/src/metabase/redux/metadata.ts b/frontend/src/metabase/redux/metadata.ts
new file mode 100644
index 00000000000..dacac96c520
--- /dev/null
+++ b/frontend/src/metabase/redux/metadata.ts
@@ -0,0 +1,145 @@
+import { type Schema, normalize } from "normalizr";
+import _ from "underscore";
+
+import { databaseApi, fieldApi, segmentApi, tableApi } from "metabase/api";
+import { runRtkEndpoint } from "metabase/api/utils/run-rtk-endpoint";
+import { createThunkAction } from "metabase/redux";
+import { fetchRevisions } from "metabase/redux/revisions";
+import type { Dispatch } from "metabase/redux/store";
+import { fetchTableMetadataAndForeignKeys } from "metabase/redux/tables";
+import { DatabaseSchema, FieldSchema, TableSchema } from "metabase/schema";
+import type {
+ Database,
+ DatabaseId,
+ Field,
+ Segment,
+ SegmentId,
+ Table,
+} from "metabase-types/api";
+
+const UPDATE = "metabase/entities/UPDATE";
+
+// Normalizes an entity (or list) and dispatches it into `state.entities`.
+// Handled by the per-slice reducers in `metabase/redux/entities` — see
+// `makeSliceReducer` there, which merges `payload.entities.<name>` into the
+// matching `state.entities.<name>` slice so `getMetadata` picks up the change.
+export function updateMetadata(data: unknown, schema: Schema) {
+ const payload = normalize(data, schema);
+ return { type: UPDATE, payload };
+}
+
+export const fetchSegments =
+ () =>
+ (dispatch: Dispatch): Promise<unknown> =>
+ runRtkEndpoint(undefined, dispatch, segmentApi.endpoints.listSegments);
+
+export const updateSegment =
+ (segment: Segment) =>
+ (dispatch: Dispatch): Promise<unknown> =>
+ runRtkEndpoint(segment, dispatch, segmentApi.endpoints.updateSegment);
+
+export const fetchRealDatabases =
+ (reload = false) =>
+ (dispatch: Dispatch): Promise<unknown> =>
+ runRtkEndpoint(
+ { include: "tables" },
+ dispatch,
+ databaseApi.endpoints.listDatabases,
+ { forceRefetch: reload },
+ );
+
+export const fetchDatabaseMetadata =
+ (id: DatabaseId, options: { reload?: boolean } = {}) =>
+ (dispatch: Dispatch): Promise<unknown> =>
+ runRtkEndpoint(
+ { id },
+ dispatch,
+ databaseApi.endpoints.getDatabaseMetadata,
+ { forceRefetch: options.reload ?? false },
+ );
+
+export const updateDatabase =
+ (database: Database) =>
+ async (dispatch: Dispatch): Promise<unknown> => {
+ const slimDatabase = _.omit(database, "tables", "tables_lookup");
+ const result: unknown = await runRtkEndpoint(
+ slimDatabase,
+ dispatch,
+ databaseApi.endpoints.updateDatabase,
+ );
+ dispatch(updateMetadata(result, DatabaseSchema));
+ return result;
+ };
+
+export const updateTable =
+ (table: Table) =>
+ async (dispatch: Dispatch): Promise<unknown> => {
+ const slimTable = _.omit(
+ table,
+ "fields",
+ "fields_lookup",
+ "aggregation_operators",
+ "segments",
+ );
+ const result: unknown = await runRtkEndpoint(
+ slimTable,
+ dispatch,
+ tableApi.endpoints.updateTable,
+ );
+ dispatch(updateMetadata(result, TableSchema));
+ return result;
+ };
+
+export const updateField =
+ (field: Field) =>
+ async (dispatch: Dispatch): Promise<unknown> => {
+ const slimField = _.omit(field, "filter_operators_lookup");
+ const result: unknown = await runRtkEndpoint(
+ slimField,
+ dispatch,
+ fieldApi.endpoints.updateField,
+ );
+ dispatch(updateMetadata(result, FieldSchema));
+ return result;
+ };
+
+const FETCH_SEGMENT_FIELDS = "metabase/metadata/FETCH_SEGMENT_FIELDS";
+export const fetchSegmentFields = createThunkAction(
+ FETCH_SEGMENT_FIELDS,
+ (segmentId: SegmentId) => {
+ return async (dispatch, getState) => {
+ await dispatch(fetchSegments());
+ const tableId = getState().entities.segments[segmentId].table_id;
+ await dispatch(fetchTableMetadataAndForeignKeys({ id: tableId }));
+ const databaseId = getState().entities.tables[tableId].db_id;
+ await dispatch(fetchDatabaseMetadata(databaseId));
+ };
+ },
+);
+
+const FETCH_SEGMENT_TABLE = "metabase/metadata/FETCH_SEGMENT_TABLE";
+export const fetchSegmentTable = createThunkAction(
+ FETCH_SEGMENT_TABLE,
+ (segmentId: SegmentId) => {
+ return async (dispatch, getState) => {
+ await dispatch(fetchSegments());
+ const tableId = getState().entities.segments[segmentId].table_id;
+ await dispatch(fetchTableMetadataAndForeignKeys({ id: tableId }));
+ };
+ },
+);
+
+const FETCH_SEGMENT_REVISIONS = "metabase/metadata/FETCH_SEGMENT_REVISIONS";
+export const fetchSegmentRevisions = createThunkAction(
+ FETCH_SEGMENT_REVISIONS,
+ (segmentId: SegmentId) => {
+ return async (dispatch, getState) => {
+ await Promise.all([
+ dispatch(fetchRevisions("segment", segmentId)),
+ dispatch(fetchSegments()),
+ ]);
+ const tableId = getState().entities.segments[segmentId].table_id;
+ await dispatch(fetchTableMetadataAndForeignKeys({ id: tableId }));
+ };
+ },
+);
diff --git a/frontend/src/metabase/redux/remappings.ts b/frontend/src/metabase/redux/remappings.ts
new file mode 100644
index 00000000000..bd9bff67936
--- /dev/null
+++ b/frontend/src/metabase/redux/remappings.ts
@@ -0,0 +1,125 @@
+import { cardApi, dashboardApi, datasetApi } from "metabase/api";
+import { runRtkEndpoint } from "metabase/api/utils/run-rtk-endpoint";
+import { createThunkAction } from "metabase/redux";
+import type { Dispatch, GetState } from "metabase/redux/store";
+import { FieldSchema } from "metabase/schema";
+import type Field from "metabase-lib/v1/metadata/Field";
+import { hasRemappedParameterValues } from "metabase-lib/v1/parameters/utils/parameter-source";
+import { normalizeParameter } from "metabase-lib/v1/parameters/utils/parameter-values";
+import type {
+ CardId,
+ DashboardId,
+ FieldId,
+ FieldValue,
+ Parameter,
+ RowValue,
+} from "metabase-types/api";
+
+import { updateMetadata } from "./metadata";
+
+export const addRemappings =
+ (fieldId: FieldId, remappings: FieldValue[]) =>
+ (dispatch: Dispatch, getState: GetState) => {
+ const existing = getState().entities.fields?.[fieldId]?.remappings ?? [];
+ const merged = Array.from(
+ new Map(
+ existing
+ .concat(remappings)
+ .map((remapping): [RowValue, FieldValue] => [
+ remapping[0],
+ remapping,
+ ]),
+ ).values(),
+ );
+ return dispatch(
+ updateMetadata({ id: fieldId, remappings: merged }, FieldSchema),
+ );
+ };
+
+type FetchRemappingOptions = {
+ parameter?: Parameter | null;
+ value: RowValue;
+ field?: Field | null;
+ cardId?: CardId | null;
+ dashboardId?: DashboardId | null;
+ uuid?: string | null;
+ token?: string | null;
+};
+
+const FETCH_REMAPPING = "metabase/remappings/FETCH_REMAPPING";
+export const fetchRemapping = createThunkAction(
+ FETCH_REMAPPING,
+ ({
+ parameter,
+ value,
+ field,
+ cardId,
+ dashboardId,
+ uuid,
+ token,
+ }: FetchRemappingOptions) =>
+ async (dispatch: Dispatch) => {
+ if (field != null && field.hasRemappedValue(value)) {
+ return;
+ }
+
+ if (
+ parameter == null ||
+ !hasRemappedParameterValues(parameter, field ? [field] : [])
+ ) {
+ return;
+ }
+
+ const entityIdentifier = uuid ?? token ?? null;
+ let remapping: FieldValue | undefined;
+ if (dashboardId != null) {
+ remapping = await runRtkEndpoint(
+ {
+ ...(entityIdentifier
+ ? { entityIdentifier }
+ : { dashboard_id: dashboardId }),
+ parameter_id: parameter.id,
+ value,
+ },
+ dispatch,
+ dashboardApi.endpoints.getRemappedDashboardParameterValue,
+ { forceRefetch: false },
+ );
+ } else if (cardId != null) {
+ remapping = await runRtkEndpoint(
+ {
+ ...(entityIdentifier ? { entityIdentifier } : { card_id: cardId }),
+ parameter_id: parameter.id,
+ value,
+ },
+ dispatch,
+ cardApi.endpoints.getRemappedCardParameterValue,
+ { forceRefetch: false },
+ );
+ } else if (field != null) {
+ // Field-based remapping (e.g. FK display fields). Static-list sources
+ // carry their [value, label] pairs inline and need no network call.
+ remapping = await runRtkEndpoint(
+ {
+ parameter: normalizeParameter(parameter),
+ field_ids: [field.id],
+ value,
+ },
+ dispatch,
+ datasetApi.endpoints.getRemappedParameterValue,
+ { forceRefetch: false },
+ );
+ }
+
+ if (remapping == null) {
+ return;
+ }
+
+ const fieldId = field?.id;
+ if (typeof fieldId === "number") {
+ dispatch(addRemappings(fieldId, [remapping]));
+ }
+
+ return remapping;
+ },
+);
diff --git a/frontend/src/metabase/redux/revisions.js b/frontend/src/metabase/redux/revisions.js
deleted file mode 100644
index b4a131bbfcc..00000000000
--- a/frontend/src/metabase/redux/revisions.js
+++ /dev/null
@@ -1,16 +0,0 @@
-import { assocIn } from "icepick";
-import _ from "underscore";
-
-import { FETCH_REVISIONS } from "./metadata";
-
-// NOTE: actions are still in metabase/redux/metadata
-
-// eslint-disable-next-line import/no-default-export -- deprecated usage
-export default (state = {}, action) => {
- if (action.type === FETCH_REVISIONS && !action.error) {
- const { type, id, revisions } = action.payload;
- return assocIn(state, [type, id], _.indexBy(revisions, "id"));
- } else {
- return state;
- }
-};
diff --git a/frontend/src/metabase/redux/revisions.ts b/frontend/src/metabase/redux/revisions.ts
new file mode 100644
index 00000000000..ac6a1f453cc
--- /dev/null
+++ b/frontend/src/metabase/redux/revisions.ts
@@ -0,0 +1,67 @@
+import type { UnknownAction } from "@reduxjs/toolkit";
+import { assocIn } from "icepick";
+import _ from "underscore";
+
+import { revisionApi } from "metabase/api";
+import { runRtkEndpoint } from "metabase/api/utils/run-rtk-endpoint";
+import { createThunkAction } from "metabase/redux";
+import type {
+ Revision,
+ RevisionEntityType,
+ RevisionId,
+} from "metabase-types/api";
+
+type RevisionTargetType = RevisionEntityType | "metric";
+
+export const FETCH_REVISIONS = "metabase/revisions/FETCH_REVISIONS";
+export const fetchRevisions = createThunkAction(
+ FETCH_REVISIONS,
+ (entityType: RevisionTargetType, id: number | string) => {
+ return async (dispatch) => {
+ const revisions: Revision[] = await runRtkEndpoint(
+ {
+ id,
+ entity: entityType === "metric" ? "legacy-metric" : entityType,
+ },
+ dispatch,
+ revisionApi.endpoints.listRevisions,
+ );
+ return { type: entityType, id, revisions };
+ };
+ },
+);
+
+type RevisionsState = Record<
+ string,
+ Record<string | number, Record<RevisionId, Revision>>
+>;
+
+type FetchRevisionsPayload = {
+ type: RevisionTargetType;
+ id: number | string;
+ revisions: Revision[];
+};
+
+function isFetchRevisionsPayload(
+ payload: unknown,
+): payload is FetchRevisionsPayload {
+ return (
+ typeof payload === "object" && payload !== null && "revisions" in payload
+ );
+}
+
+// eslint-disable-next-line import/no-default-export -- deprecated usage
+export default function revisions(
+ state: RevisionsState = {},
+ action: UnknownAction,
+): RevisionsState {
+ if (
+ action.type === FETCH_REVISIONS &&
+ !action.error &&
+ isFetchRevisionsPayload(action.payload)
+ ) {
+ const { type, id, revisions } = action.payload;
+ return assocIn(state, [type, id], _.indexBy(revisions, "id"));
+ }
+ return state;
+}
diff --git a/frontend/src/metabase/redux/tables.ts b/frontend/src/metabase/redux/tables.ts
index 066aee3a144..0906f52bf41 100644
--- a/frontend/src/metabase/redux/tables.ts
+++ b/frontend/src/metabase/redux/tables.ts
@@ -1,6 +1,6 @@
import { fieldApi, tableApi } from "metabase/api";
import { runRtkEndpoint } from "metabase/api/utils/run-rtk-endpoint";
-import { updateMetadata } from "metabase/redux/metadata-typed";
+import { updateMetadata } from "metabase/redux/metadata";
import type { Dispatch, GetState } from "metabase/redux/store";
import { TableSchema } from "metabase/schema";
import { getMetadataUnfiltered } from "metabase/selectors/metadata";