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
Answer field remapping from the field, not the metadata store (#81932)
Romeo Van Snick28a72bb30ce2
diff --git a/frontend/src/metabase-lib/v1/metadata/Field.ts b/frontend/src/metabase-lib/v1/metadata/Field.tsindex af1311cf230..d21949d05fe 100644--- a/frontend/src/metabase-lib/v1/metadata/Field.ts+++ b/frontend/src/metabase-lib/v1/metadata/Field.ts@@ -25,6 +25,7 @@ import {} from "metabase-lib/v1/types/utils/isa";import type {Field as ApiField,+ FieldDimension,FieldFingerprint,FieldId,FieldReference,@@ -34,6 +35,24 @@ import type {import type Metadata from "./Metadata";import type Table from "./Table";import { getIconForField, getUniqueFieldId } from "./utils/fields";+import {+ getExternalRemappedField,+ getRemappedField,+ getSearchField,+ getSharedRemappedField,+ isSearchableField,+} from "./utils/remapping";++/**+ * A dimension whose remap target is hydrated into a `Field`, matching how the+ * API nests it.+ */+export type HydratedFieldDimension = Omit<+ FieldDimension,+ "human_readable_field"+> & {+ human_readable_field?: Field;+};// This interface is intentionally empty: a class cannot `extends` a type alias,// so merging an interface with the class is how instances inherit the API@@ -42,7 +61,7 @@ import { getIconForField, getUniqueFieldId } from "./utils/fields";// eslint-disable-next-line @typescript-eslint/no-empty-object-typeinterface Field extends Omit<ApiField,- "table" | "target" | "name_field" | "fingerprint"+ "table" | "target" | "name_field" | "fingerprint" | "dimensions"> {}/**@@ -58,6 +77,7 @@ class Field {table?: Table;target?: Field;name_field?: Field;+ dimensions?: HydratedFieldDimension[];fingerprint?: FieldFingerprint;_plainObject: NormalizedField;metadata?: Metadata;@@ -235,43 +255,15 @@ class Field {// REMAPPINGSstatic remappedField(fields: Field[]): Field | null {- const remappedFields = fields.map((field) => field.remappedField());- const remappedFieldIds = new Set(remappedFields.map((field) => field?.id));- if (remappedFields[0] != null && remappedFieldIds.size === 1) {- return remappedFields[0];- }- return null;+ return getSharedRemappedField<Field>(fields);}remappedField() {- return this.remappedInternalField() ?? this.remappedExternalField();- }-- remappedInternalField() {- const dimensions = this.dimensions ?? [];- if (dimensions.length > 0 && dimensions[0].type === "internal") {- return this;- }-- return null;+ return getRemappedField<Field>(this);}remappedExternalField() {- const displayFieldId = this.dimensions?.[0]?.human_readable_field_id;-- if (displayFieldId != null) {- return this.metadata?.field(displayFieldId) ?? null;- }-- // enables "implicit" remapping from type/PK to type/Name on the same table,- // or type/FK to type/Name on the type/FK table;- // used in FieldValuesWidget, but not table/object detail listings- const maybePkField = this.target ?? this;- if (maybePkField.name_field) {- return maybePkField.name_field;- }-- return null;+ return getExternalRemappedField<Field>(this);}remappedValue(value: unknown) {@@ -296,21 +288,11 @@ class Field {// Returns true if this field can be searched, e.g. in filter or parameter widgetsisSearchable() {- // TODO: ...?- return this.isString();+ return isSearchableField(this);}searchField(disablePKRemapping = false): Field | null {- if (disablePKRemapping && this.isPK()) {- return this.isSearchable() ? this : null;- }-- const remappedField = this.remappedExternalField();- if (remappedField && remappedField.isSearchable()) {- return remappedField;- }-- return this.isSearchable() ? this : null;+ return getSearchField<Field>(this, disablePKRemapping);}clone(fieldMetadata?: Partial<NormalizedField>) {diff --git a/frontend/src/metabase-lib/v1/metadata/utils/remapping.ts b/frontend/src/metabase-lib/v1/metadata/utils/remapping.tsnew file mode 100644index 00000000000..e6751d836cd--- /dev/null+++ b/frontend/src/metabase-lib/v1/metadata/utils/remapping.ts@@ -0,0 +1,121 @@+import {+ type FieldTypeInfo,+ isPK,+ isString,+} from "metabase-lib/v1/types/utils/isa";+import type {+ FieldDimensionType,+ FieldId,+ FieldReference,+} from "metabase-types/api";++/**+ * The parts of a field that decide how its values are labelled and searched.+ *+ * The API field and the v1 `Field` wrapper both match it, and the type+ * parameter keeps a caller in its own world: give it API fields and it returns+ * an API field.+ *+ * A field answers this on its own, so it has to carry its remap target rather+ * than an id to look up. The metadata store hydrates all three, so a store+ * field always does. An API field does only where its endpoint nests them:+ * `param_fields` nests all three, while `GET /api/field/:id` and a table's+ * `query_metadata` send `human_readable_field_id` without the field. Give those+ * to `getExternalRemappedField` and an externally remapped field reports no+ * remapping, so pass a store field until those endpoints nest it too.+ */+export interface RemappableField<T> extends FieldTypeInfo {+ id: FieldId | FieldReference;+ dimensions?: {+ type: FieldDimensionType;+ human_readable_field_id?: FieldId;+ human_readable_field?: T;+ }[];+ target?: T;+ name_field?: T;+}++/**+ * Whether a field's values can be searched, such as in a filter or a parameter+ * widget.+ */+export function isSearchableField(field: FieldTypeInfo): boolean {+ return isString(field);+}++/**+ * The field that gives human-readable labels to this field's values.+ *+ * An internal remapping keeps the labels on the field itself, so the field is+ * its own remap target. An external remapping points at another field.+ */+export function getRemappedField<T extends RemappableField<T>>(+ field: T,+): T | null {+ return getInternalRemappedField(field) ?? getExternalRemappedField(field);+}++/**+ * The one field that every field in `fields` remaps to, or null when they+ * disagree.+ */+export function getSharedRemappedField<T extends RemappableField<T>>(+ fields: T[],+): T | null {+ const remappedFields = fields.map(getRemappedField);+ const remappedFieldIds = new Set(remappedFields.map((field) => field?.id));++ if (remappedFields[0] != null && remappedFieldIds.size === 1) {+ return remappedFields[0];+ }++ return null;+}++/**+ * Reads the remap target off the field itself. Both the API and the metadata+ * store nest it, either on a dimension or as a `name_field`, so this needs no+ * lookup by id.+ */+export function getExternalRemappedField<T extends RemappableField<T>>(+ field: T,+): T | null {+ const dimension = field.dimensions?.[0];++ if (dimension?.human_readable_field_id != null) {+ return dimension.human_readable_field ?? null;+ }++ // enables "implicit" remapping from type/PK to type/Name on the same table,+ // or type/FK to type/Name on the type/FK table;+ // used in FieldValuesWidget, but not table/object detail listings+ const maybePkField = field.target ?? field;+ return maybePkField.name_field ?? null;+}++/**+ * The field to search when a user types into a value picker. A field that+ * remaps to a searchable field is searched through that field, so the user+ * matches the label they see rather than the stored value.+ */+export function getSearchField<T extends RemappableField<T>>(+ field: T,+ disablePKRemapping = false,+): T | null {+ if (disablePKRemapping && isPK(field)) {+ return isSearchableField(field) ? field : null;+ }++ const remappedField = getExternalRemappedField(field);+ if (remappedField && isSearchableField(remappedField)) {+ return remappedField;+ }++ return isSearchableField(field) ? field : null;+}++function getInternalRemappedField<T extends RemappableField<T>>(+ field: T,+): T | null {+ return field.dimensions?.[0]?.type === "internal" ? field : null;+}diff --git a/frontend/src/metabase-lib/v1/metadata/utils/remapping.unit.spec.ts b/frontend/src/metabase-lib/v1/metadata/utils/remapping.unit.spec.tsnew file mode 100644index 00000000000..8d4ed9831d2--- /dev/null+++ b/frontend/src/metabase-lib/v1/metadata/utils/remapping.unit.spec.ts@@ -0,0 +1,225 @@+import type { Field, FieldId } from "metabase-types/api";+import {+ createMockField,+ createMockFieldDimension,+} from "metabase-types/api/mocks";++import {+ getExternalRemappedField,+ getRemappedField,+ getSearchField,+ getSharedRemappedField,+ isSearchableField,+} from "./remapping";++const TEXT_FIELD_ID = 2;+const OTHER_TEXT_FIELD_ID = 3;+const NUMBER_FIELD_ID = 4;++const createTextField = (id: FieldId, opts?: Partial<Field>) =>+ createMockField({ id, base_type: "type/Text", ...opts });++const createNumberField = (id: FieldId, opts?: Partial<Field>) =>+ createMockField({ id, base_type: "type/Integer", ...opts });++/**+ * A field whose dimension carries `displayField` as its remap target, the way+ * the API nests it.+ */+const createFieldRemappedTo = (+ displayFieldId: FieldId,+ displayField: Field,+ opts?: Partial<Field>,+) =>+ createMockField({+ ...opts,+ dimensions: [+ createMockFieldDimension({+ type: "external",+ human_readable_field_id: displayFieldId,+ human_readable_field: displayField,+ }),+ ],+ });++describe("isSearchableField", () => {+ it("accepts a string field", () => {+ expect(isSearchableField(createTextField(1))).toBe(true);+ });++ it("rejects a number field", () => {+ expect(isSearchableField(createNumberField(1))).toBe(false);+ });+});++describe("getExternalRemappedField", () => {+ it("returns the display field the dimension carries", () => {+ const displayField = createTextField(TEXT_FIELD_ID);++ expect(+ getExternalRemappedField(+ createFieldRemappedTo(TEXT_FIELD_ID, displayField),+ ),+ ).toBe(displayField);+ });++ it("returns null when the dimension names a display field it does not carry", () => {+ // the id is what decides, so a field whose display field never arrived+ // remaps to nothing rather than falling back to its name field+ const field = createMockField({+ name_field: createTextField(OTHER_TEXT_FIELD_ID),+ dimensions: [+ createMockFieldDimension({+ type: "external",+ human_readable_field_id: TEXT_FIELD_ID,+ }),+ ],+ });++ expect(getExternalRemappedField(field)).toBeNull();+ });++ it("falls back to the field's own name field", () => {+ const nameField = createTextField(OTHER_TEXT_FIELD_ID);+ const field = createNumberField(1, {+ semantic_type: "type/PK",+ name_field: nameField,+ });++ expect(getExternalRemappedField(field)).toBe(nameField);+ });++ it("prefers the name field of an FK target over its own", () => {+ const targetNameField = createTextField(NUMBER_FIELD_ID);+ const field = createNumberField(1, {+ name_field: createTextField(OTHER_TEXT_FIELD_ID),+ target: createNumberField(5, { name_field: targetNameField }),+ });++ expect(getExternalRemappedField(field)).toBe(targetNameField);+ });++ it("returns null when nothing remaps the field", () => {+ expect(getExternalRemappedField(createTextField(1))).toBeNull();+ });+});++describe("getRemappedField", () => {+ it("returns the field itself when the remapping is internal", () => {+ const field = createMockField({+ dimensions: [createMockFieldDimension({ type: "internal" })],+ });++ expect(getRemappedField(field)).toBe(field);+ });++ it("returns the external remap target otherwise", () => {+ const displayField = createTextField(TEXT_FIELD_ID);++ expect(+ getRemappedField(createFieldRemappedTo(TEXT_FIELD_ID, displayField)),+ ).toBe(displayField);+ });+});++describe("getSharedRemappedField", () => {+ it("returns the target when every field remaps to it", () => {+ const displayField = createTextField(TEXT_FIELD_ID);++ expect(+ getSharedRemappedField([+ createFieldRemappedTo(TEXT_FIELD_ID, displayField, { id: 10 }),+ createFieldRemappedTo(TEXT_FIELD_ID, displayField, { id: 11 }),+ ]),+ ).toBe(displayField);+ });++ it("returns null when the fields remap to different targets", () => {+ expect(+ getSharedRemappedField([+ createFieldRemappedTo(TEXT_FIELD_ID, createTextField(TEXT_FIELD_ID), {+ id: 10,+ }),+ createFieldRemappedTo(+ OTHER_TEXT_FIELD_ID,+ createTextField(OTHER_TEXT_FIELD_ID),+ { id: 11 },+ ),+ ]),+ ).toBeNull();+ });++ it("returns null for an empty list", () => {+ expect(getSharedRemappedField([])).toBeNull();+ });+});++describe("getSearchField", () => {+ it("returns a searchable field itself", () => {+ const field = createTextField(1);++ expect(getSearchField(field)).toBe(field);+ });++ it("returns null for a field that cannot be searched", () => {+ expect(getSearchField(createNumberField(1))).toBeNull();+ });++ it("returns the remap target when it is searchable", () => {+ const displayField = createTextField(TEXT_FIELD_ID);+ const field = createFieldRemappedTo(TEXT_FIELD_ID, displayField, {+ base_type: "type/Integer",+ });++ expect(getSearchField(field)).toBe(displayField);+ });++ it("ignores a remap target that cannot be searched", () => {+ const field = createFieldRemappedTo(+ NUMBER_FIELD_ID,+ createNumberField(NUMBER_FIELD_ID),+ {+ base_type: "type/Text",+ },+ );++ expect(getSearchField(field)).toBe(field);+ });++ describe("when PK remapping is disabled", () => {+ it("searches a string PK through itself, not its remap target", () => {+ const field = createFieldRemappedTo(+ TEXT_FIELD_ID,+ createTextField(TEXT_FIELD_ID),+ {+ base_type: "type/Text",+ semantic_type: "type/PK",+ },+ );++ expect(getSearchField(field, true)).toBe(field);+ });++ it("returns null for a number PK", () => {+ const field = createFieldRemappedTo(+ TEXT_FIELD_ID,+ createTextField(TEXT_FIELD_ID),+ {+ base_type: "type/Integer",+ semantic_type: "type/PK",+ },+ );++ expect(getSearchField(field, true)).toBeNull();+ });++ it("still remaps a field that is not a PK", () => {+ const displayField = createTextField(TEXT_FIELD_ID);+ const field = createFieldRemappedTo(TEXT_FIELD_ID, displayField, {+ base_type: "type/Integer",+ });++ expect(getSearchField(field, true)).toBe(displayField);+ });+ });+});diff --git a/frontend/src/metabase-types/api/schema.ts b/frontend/src/metabase-types/api/schema.tsindex 1e0e9c26d5a..8d257ab95ca 100644--- a/frontend/src/metabase-types/api/schema.ts+++ b/frontend/src/metabase-types/api/schema.ts@@ -76,7 +76,7 @@ export interface NormalizedField extends Omit<target?: FieldId;table?: TableId;name_field?: FieldId;- dimensions?: NormalizedFieldDimension;+ dimensions?: NormalizedFieldDimension[];}export interface NormalizedSegment extends Omit<Segment, "table"> {diff --git a/frontend/src/metabase/metadata-store/selectors.ts b/frontend/src/metabase/metadata-store/selectors.tsindex 57750e94b9a..e5a71f75ea9 100644--- a/frontend/src/metabase/metadata-store/selectors.ts+++ b/frontend/src/metabase/metadata-store/selectors.ts@@ -5,7 +5,9 @@ import type { EntitiesState, State } from "metabase/redux/store";import { getSettings } from "metabase/settings";import Question from "metabase-lib/v1/Question";import Database from "metabase-lib/v1/metadata/Database";-import Field from "metabase-lib/v1/metadata/Field";+import Field, {+ type HydratedFieldDimension,+} from "metabase-lib/v1/metadata/Field";import ForeignKey from "metabase-lib/v1/metadata/ForeignKey";import Metadata from "metabase-lib/v1/metadata/Metadata";import type Schema from "metabase-lib/v1/metadata/Schema";@@ -385,6 +387,7 @@ function hydrateField(field: Field, metadata: Metadata) {field.table = hydrateFieldTable(field, metadata);field.target = hydrateFieldTarget(field, metadata);field.name_field = hydrateNameField(field, metadata);+ field.dimensions = hydrateFieldDimensions(field, metadata);field.values = getFieldValues(field);field.remapping = new Map(getRemappings(field));}@@ -432,6 +435,26 @@ function hydrateFieldTarget(return metadata.field(field.fk_target_field_id) ?? undefined;}+/**+ * Normalizing a field flattens each dimension's `human_readable_field` to an+ * id. The API nests the field itself, so it is put back here and a store field+ * answers a remapping question the same way an API field does.+ */+function hydrateFieldDimensions(+ field: Field,+ metadata: Metadata,+): HydratedFieldDimension[] {+ const dimensions = field.getPlainObject().dimensions ?? [];++ return dimensions.map((dimension) => ({+ ...dimension,+ human_readable_field:+ dimension.human_readable_field_id != null+ ? (metadata.field(dimension.human_readable_field_id) ?? undefined)+ : undefined,+ }));+}+function hydrateNameField(field: Field, metadata: Metadata): Field | undefined {const nameFieldId = field.getPlainObject().name_field;if (nameFieldId != null) {diff --git a/frontend/src/metabase/parameters/components/widgets/ParameterFieldWidget/FieldValuesWidget/testMocks.spec.ts b/frontend/src/metabase/parameters/components/widgets/ParameterFieldWidget/FieldValuesWidget/testMocks.spec.tsindex e8c25ec79b7..33baed9f573 100644--- a/frontend/src/metabase/parameters/components/widgets/ParameterFieldWidget/FieldValuesWidget/testMocks.spec.ts+++ b/frontend/src/metabase/parameters/components/widgets/ParameterFieldWidget/FieldValuesWidget/testMocks.spec.ts@@ -1,8 +1,13 @@import { createMockEntitiesState } from "__support__/store";import { getMetadata } from "metabase/metadata-store";import { createMockState } from "metabase/redux/store/mocks";-import { createMockField } from "metabase-types/api/mocks";import {+ createMockField,+ createMockFieldDimension,+} from "metabase-types/api/mocks";+import {+ ORDERS,+ PRODUCTS,REVIEWS_ID,createOrdersTable,createPeoplePasswordField,@@ -17,6 +22,9 @@ export const LISTABLE_PK_FIELD_VALUE = "1234";export const STRING_PK_FIELD_ID = 101;export const SEARCHABLE_FK_FIELD_ID = 102;export const LISTABLE_FIELD_WITH_MANY_VALUES_ID = 103;+export const REMAPPED_TO_STRING_FIELD_ID = 104;+export const REMAPPED_TO_NUMBER_FIELD_ID = 105;+export const PK_REMAPPED_TO_NUMBER_FIELD_ID = 106;export const EXPRESSION_FIELD_ID = ["field","CC",@@ -66,6 +74,46 @@ const database = createSampleDatabase({has_field_values: "list",has_more_values: true,}),+ createMockField({+ id: REMAPPED_TO_STRING_FIELD_ID,+ table_id: REVIEWS_ID,+ display_name: "Remapped to a string",+ base_type: "type/Text",+ effective_type: "type/Text",+ dimensions: [+ createMockFieldDimension({+ type: "external",+ human_readable_field_id: PRODUCTS.TITLE,+ }),+ ],+ }),+ createMockField({+ id: REMAPPED_TO_NUMBER_FIELD_ID,+ table_id: REVIEWS_ID,+ display_name: "Remapped to a number",+ base_type: "type/Text",+ effective_type: "type/Text",+ dimensions: [+ createMockFieldDimension({+ type: "external",+ human_readable_field_id: ORDERS.TOTAL,+ }),+ ],+ }),+ createMockField({+ id: PK_REMAPPED_TO_NUMBER_FIELD_ID,+ table_id: REVIEWS_ID,+ display_name: "Number ID remapped to a number",+ base_type: "type/BigInteger",+ effective_type: "type/BigInteger",+ semantic_type: "type/PK",+ dimensions: [+ createMockFieldDimension({+ type: "external",+ human_readable_field_id: ORDERS.TOTAL,+ }),+ ],+ }),createMockField({// Unjustified type cast. FIXMEid: EXPRESSION_FIELD_ID as any,diff --git a/frontend/src/metabase/parameters/components/widgets/ParameterFieldWidget/FieldValuesWidget/utils.unit.spec.tsx b/frontend/src/metabase/parameters/components/widgets/ParameterFieldWidget/FieldValuesWidget/utils.unit.spec.tsxindex 512e72dcb74..c2cbe5837a0 100644--- a/frontend/src/metabase/parameters/components/widgets/ParameterFieldWidget/FieldValuesWidget/utils.unit.spec.tsx+++ b/frontend/src/metabase/parameters/components/widgets/ParameterFieldWidget/FieldValuesWidget/utils.unit.spec.tsx@@ -4,6 +4,9 @@ import { ORDERS, PEOPLE, PRODUCTS } from "metabase-types/api/mocks/presets";import {LISTABLE_FIELD_WITH_MANY_VALUES_ID,+ PK_REMAPPED_TO_NUMBER_FIELD_ID,+ REMAPPED_TO_NUMBER_FIELD_ID,+ REMAPPED_TO_STRING_FIELD_ID,STRING_PK_FIELD_ID,metadata,} from "./testMocks.spec";@@ -122,27 +125,24 @@ describe("Components > FieldValuesWidget > utils", () => {});describe("when the field is remapped to a searchable field", () => {- const stringField = getField(PRODUCTS.TITLE);- const remappedField = getField(PRODUCTS.CATEGORY).clone();- remappedField.remappedExternalField = () => stringField;-it("should return the remapped field", () => {- expect(searchField(remappedField)).toBe(stringField);+ const remappedField = getField(REMAPPED_TO_STRING_FIELD_ID);++ expect(searchField(remappedField)).toBe(getField(PRODUCTS.TITLE));});});describe("when the field is remapped to a non-searchable field", () => {it("should ignore it and return the original field, assuming it is searchable", () => {- const numberField = getField(ORDERS.TOTAL);+ const remappedField = getField(REMAPPED_TO_NUMBER_FIELD_ID);- const remappedField = getField(PRODUCTS.CATEGORY).clone();- remappedField.remappedExternalField = () => numberField;+ expect(searchField(remappedField)).toBe(remappedField);+ });- const nonSearchableRemappedField = getField(PRODUCTS.ID);- nonSearchableRemappedField.remappedExternalField = () => numberField;+ it("should return null when the original field is not searchable either", () => {+ const remappedField = getField(PK_REMAPPED_TO_NUMBER_FIELD_ID);- expect(searchField(remappedField)).toBe(remappedField);- expect(searchField(nonSearchableRemappedField)).toBeNull();+ expect(searchField(remappedField)).toBeNull();});});diff --git a/frontend/src/metabase/utils/formatting/field.ts b/frontend/src/metabase/utils/formatting/field.tsindex 8592a46e7e7..9167aac5370 100644--- a/frontend/src/metabase/utils/formatting/field.ts+++ b/frontend/src/metabase/utils/formatting/field.ts@@ -1,6 +1,12 @@-import type { Field } from "metabase-types/api/field";--type FormattableField = Pick<Field, "name" | "display_name" | "dimensions">;+/**+ * The three names `formatField` chooses between, in order of preference. Both+ * the API field and the v1 `Field` wrapper match it.+ */+type FormattableField = {+ name: string;+ display_name: string;+ dimensions?: { name: string }[];+};export function formatField(field: FormattableField) {if (!field) {