refactor(server): unify the two metadata override mechanisms into one (#22417)

## Unify the two metadata override mechanisms into one

Twenty had **two** override mechanisms:

- **`standardOverrides`** — a bespoke JSONB column on
`objectMetadata`/`fieldMetadata` with typed DTOs and a per-locale
`translations` map, resolved by two i18n-aware resolvers.
- **`OverridableEntity.overrides`** — a flat, registry-driven JSONB blob
on view / view-field / view-field-group / command-menu-item /
page-layout-tab / page-layout-widget, resolved by a plain spread.

This PR collapses them into **one** concept: a single `overrides` blob,
one registry-driven overridable set, one i18n-aware read path, and one
write path (`computeMetadataOverridesBlob`, extracted in #22404).

Object/field **stay on `SyncableEntity`** (not reparented to
`OverridableEntity`) so their `isActive` default stays **FALSE** — this
sidesteps the `isActive` default conflict entirely.

### GraphQL breaking change (accepted)

The `standardOverrides` field is **removed** with no deprecation alias —
`overrides` (a `JSON` scalar) is exposed instead on `Object` and
`Field`. Product confirmed negligible external usage; the front-end has
no hand-written consumer (only generated types), which are regenerated
here.

### Commit structure (reviewable commit-by-commit)

1. **Unified resolver + parity harness** —
`resolveEffectiveEntityProperty` is a strict superset of the three
legacy resolvers; a corpus parity spec compares it against a *frozen
reference* of the old logic across every locale, `isStandardApp` branch
and override shape.
2. **Registry-driven** — object/field presentation props tagged
`isOverridable` + `translatable`; the overridable/translatable sets are
derived from the registry (a test asserts they equal the legacy
hardcoded lists).
3. **Rename + swap + delete** — `standardOverrides` → `overrides` across
entities, DTOs, flat/universal types, producers, the ~12
resolve/write/create/sync call sites, mocks and specs; the reconciler's
two compare entries collapse to one; the three legacy resolvers, both
DTOs and the hardcoded constants/types are deleted.
4. **Migration (zero-downtime, two-phase)** — split across two releases
so a rolling deploy never drops a column a previous-release pod still
`SELECT`s:
   - **2.19 fast** — add the `overrides` column (schema only).
- **2.19 slow** — backfill `overrides` from `standardOverrides` in
`runDataMigration` (kept out of the schema transaction so the bulk write
doesn't hold the ACCESS EXCLUSIVE lock; skipped on fresh installs, which
have no data to copy).
- **2.20 fast** — drop the legacy `standardOverrides` column (gated by
`TWENTY_NEXT_VERSIONS`, so it stays dormant until the instance reaches
2.20).
5. **Front/client-SDK regen** — regenerated metadata GraphQL types.
6. **Integration specs + i18n** — updated the standard object/field
update integration specs + snapshots, and the reworded validator message
catalog entry.

### Rolling-deploy safety

`standardOverrides` is retained through 2.19 and only dropped in 2.20,
mirroring the codebase's deferred-drop convention
(`isUIReadOnly`/`isCustom`). During the 2.19 rollout both columns exist,
so old and new pods coexist without "column does not exist" errors. The
backfill lives in a slow `runDataMigration` (per the
`no-data-mutation-in-fast-instance-command` rule) so it doesn't stall
reads.

### `isActive` guard

The migration never reads or writes `isActive`; the backfill asserts the
active-row count is unchanged and aborts otherwise. Verified on a real
DB: apply + revert preserves the blob **and** the nested `translations`
map, with `isActive` counts identical before/after.

### Verification (local)

- `nx typecheck twenty-server` + `nx typecheck twenty-front` — green
- `nx lint:diff-with-main twenty-server` (oxlint `--type-aware` + oxfmt)
— green
- `nx test twenty-server` — green (unit + parity + registry + migration
tests)
- `nx run twenty-server:test:integration:with-db-reset` — green
- `database:reset` applies the 2.19 phases and leaves **both** columns
present (2.20 drop stays dormant); backfill + revert round-trip verified
on a real DB
- Metadata integration suites (standard object/field update, application
sync) pass end-to-end against the two-column schema
- Metadata GraphQL types regenerated against a booted server; zero
`standardOverrides` references remain in application code (only the
migration commands + the legacy schema baseline)

---------

Co-authored-by: prastoin <paul@twenty.com>
This commit is contained in:
Félix Malfait
2026-07-02 12:01:15 +02:00
committed by GitHub
parent 63d092a31b
commit 5a4ebca226
121 changed files with 2394 additions and 3109 deletions
@@ -1,7 +0,0 @@
import { type MetadataUniversalFlatEntityPropertiesToCompare } from 'src/engine/workspace-manager/workspace-migration/universal-flat-entity/types/metadata-universal-flat-entity-properties-to-compare.type';
export const FIELD_METADATA_STANDARD_OVERRIDES_PROPERTIES = [
'label',
'description',
'icon',
] as const satisfies MetadataUniversalFlatEntityPropertiesToCompare<'fieldMetadata'>[];
@@ -15,7 +15,7 @@ export class CreateFieldInput extends OmitType(
'id',
'createdAt',
'updatedAt',
'standardOverrides',
'overrides',
'applicationId',
'morphId',
'universalIdentifier',
@@ -32,7 +32,7 @@ import {
import { UUIDScalarType } from 'src/engine/api/graphql/workspace-schema-builder/graphql-types/scalars';
import { IsValidMetadataName } from 'src/engine/decorators/metadata/is-valid-metadata-name.decorator';
import { FieldStandardOverridesDTO } from 'src/engine/metadata-modules/field-metadata/dtos/field-standard-overrides.dto';
import { type FieldMetadataOverrides } from 'src/engine/metadata-modules/field-metadata/types/field-metadata-overrides.type';
import { type FieldMetadataDefaultOption } from 'src/engine/metadata-modules/field-metadata/dtos/options.input';
import { ObjectMetadataDTO } from 'src/engine/metadata-modules/object-metadata/dtos/object-metadata.dto';
import { transformEnumValue } from 'src/engine/utils/transform-enum-value';
@@ -94,9 +94,8 @@ export class FieldMetadataDTO<T extends FieldMetadataType = FieldMetadataType> {
@Field({ nullable: true })
icon?: string;
@IsOptional()
@Field(() => FieldStandardOverridesDTO, { nullable: true })
standardOverrides?: FieldStandardOverridesDTO;
@HideField()
overrides?: FieldMetadataOverrides | null;
@IsBoolean()
@IsOptional()
@@ -1,42 +0,0 @@
import { Field, ObjectType } from '@nestjs/graphql';
import { IsJSON, IsOptional, IsString } from 'class-validator';
import { GraphQLJSON } from 'graphql-type-json';
import { type APP_LOCALES } from 'twenty-shared/translations';
import { FieldMetadataStandardOverridesProperties } from 'src/engine/metadata-modules/field-metadata/types/field-metadata-standard-overrides-properties.type';
@ObjectType('StandardOverrides')
export class FieldStandardOverridesDTO implements Partial<
Record<FieldMetadataStandardOverridesProperties, unknown>
> {
@IsString()
@IsOptional()
@Field(() => String, { nullable: true })
label?: string | null;
@IsString()
@IsOptional()
@Field(() => String, { nullable: true })
description?: string | null;
@IsString()
@IsOptional()
@Field(() => String, { nullable: true })
icon?: string | null;
@IsJSON()
@IsOptional()
@Field(() => GraphQLJSON, {
nullable: true,
})
translations?: Partial<
Record<
keyof typeof APP_LOCALES,
{
label?: string | null;
description?: string | null;
}
>
> | null;
}
@@ -27,7 +27,7 @@ export class UpdateFieldInput extends OmitType(
'type',
'createdAt',
'updatedAt',
'standardOverrides',
'overrides',
'applicationId',
'morphId',
] as const,
@@ -23,8 +23,9 @@ import {
import { WasIntroducedInUpgrade } from 'src/engine/core-modules/upgrade/decorators/was-introduced-in-upgrade.decorator';
import { WasRemovedInUpgrade } from 'src/engine/core-modules/upgrade/decorators/was-removed-in-upgrade.decorator';
import { ADD_IS_SYSTEM_SIDE_EFFECT_UPGRADE_COMMAND_NAME } from 'src/database/commands/upgrade-version-command/2-15/is-system-side-effect-upgrade-command-name.constant';
import { ADD_METADATA_OVERRIDES_COLUMN_UPGRADE_COMMAND_NAME } from 'src/database/commands/upgrade-version-command/2-19/add-metadata-overrides-column-upgrade-command-name.constant';
import { RENAME_IS_UI_READ_ONLY_TO_IS_UI_EDITABLE_UPGRADE_COMMAND_NAME } from 'src/engine/metadata-modules/object-metadata/constants/rename-is-ui-read-only-to-is-ui-editable-upgrade-command-name.constant';
import { type FieldStandardOverridesDTO } from 'src/engine/metadata-modules/field-metadata/dtos/field-standard-overrides.dto';
import { type FieldMetadataOverrides } from 'src/engine/metadata-modules/field-metadata/types/field-metadata-overrides.type';
import { AssignIfIsGivenFieldMetadataType } from 'src/engine/metadata-modules/field-metadata/types/assign-if-is-given-field-metadata-type.type';
import { AssignTypeIfIsMorphOrRelationFieldMetadataType } from 'src/engine/metadata-modules/field-metadata/types/assign-type-if-is-morph-or-relation-field-metadata-type.type';
import { IndexFieldMetadataEntity } from 'src/engine/metadata-modules/index-metadata/index-field-metadata.entity';
@@ -102,8 +103,18 @@ export class FieldMetadataEntity<
@Column({ nullable: true, type: 'varchar' })
icon: string | null;
@WasIntroducedInUpgrade({
upgradeCommandName: ADD_METADATA_OVERRIDES_COLUMN_UPGRADE_COMMAND_NAME,
})
@Column({ type: 'jsonb', nullable: true })
standardOverrides: JsonbProperty<FieldStandardOverridesDTO> | null;
overrides: JsonbProperty<FieldMetadataOverrides> | null;
/**
* @deprecated Superseded by `overrides`; kept readable for pods on the
* previous release during a rolling deploy. Drop deferred to 2-20/README.md.
*/
@Column({ type: 'jsonb', nullable: true })
standardOverrides: WasRemovedInUpgrade<JsonbProperty<FieldMetadataOverrides> | null>;
@Column('jsonb', { nullable: true })
options: JsonbProperty<FieldMetadataOptions<TFieldMetadataType>>;
@@ -22,16 +22,16 @@ import { RelationDTO } from 'src/engine/metadata-modules/field-metadata/dtos/rel
import { UpdateOneFieldMetadataInput } from 'src/engine/metadata-modules/field-metadata/dtos/update-field.input';
import { FieldMetadataService } from 'src/engine/metadata-modules/field-metadata/services/field-metadata.service';
import { fieldMetadataGraphqlApiExceptionHandler } from 'src/engine/metadata-modules/field-metadata/utils/field-metadata-graphql-api-exception-handler.util';
import { resolveFieldMetadataStandardOverride } from 'src/engine/metadata-modules/field-metadata/utils/resolve-field-metadata-standard-override.util';
import { fromFlatFieldMetadataToFieldMetadataDto } from 'src/engine/metadata-modules/flat-field-metadata/utils/from-flat-field-metadata-to-field-metadata-dto.util';
import { resolveEffectiveEntityProperty } from 'src/engine/metadata-modules/utils/resolve-effective-entity-property.util';
import { PermissionsGraphqlApiExceptionFilter } from 'src/engine/metadata-modules/permissions/utils/permissions-graphql-api-exception.filter';
// Keep @Parent() structurally typed so ResolverValidationPipe does not validate
// FieldMetadataDTO date decorators on already-loaded parent records.
type FieldMetadataStandardOverrideParent = Parameters<
typeof resolveFieldMetadataStandardOverride
>[0] &
Pick<FieldMetadataDTO, 'applicationId'>;
type FieldMetadataStandardOverrideParent = Pick<
FieldMetadataDTO,
'label' | 'description' | 'icon' | 'overrides' | 'applicationId'
>;
@UseGuards(WorkspaceAuthGuard)
@UsePipes(ResolverValidationPipe)
@@ -76,14 +76,18 @@ export class FieldMetadataResolver {
locale: context.req.locale,
});
return resolveFieldMetadataStandardOverride(
fieldMetadata,
labelKey,
context.req.locale,
i18n,
isStandardApp,
applicationCatalog,
);
return resolveEffectiveEntityProperty({
metadataName: 'fieldMetadata',
baseValue: fieldMetadata[labelKey],
overrides: fieldMetadata.overrides,
property: labelKey,
i18nContext: {
locale: context.req.locale,
i18nInstance: i18n,
isStandardApp,
applicationCatalog,
},
});
}
@ResolveField(() => String, { nullable: true })
@@ -0,0 +1,16 @@
import { type APP_LOCALES } from 'twenty-shared/translations';
export type FieldMetadataOverrides = {
label?: string | null;
description?: string | null;
icon?: string | null;
translations?: Partial<
Record<
keyof typeof APP_LOCALES,
{
label?: string | null;
description?: string | null;
}
>
> | null;
};
@@ -1,4 +0,0 @@
import { type FIELD_METADATA_STANDARD_OVERRIDES_PROPERTIES } from 'src/engine/metadata-modules/field-metadata/constants/field-metadata-standard-overrides-properties.constant';
export type FieldMetadataStandardOverridesProperties =
(typeof FIELD_METADATA_STANDARD_OVERRIDES_PROPERTIES)[number];
@@ -1,511 +0,0 @@
import { type I18n } from '@lingui/core';
import { SOURCE_LOCALE } from 'twenty-shared/translations';
import { generateMessageId } from 'src/engine/core-modules/i18n/utils/generateMessageId';
import { resolveFieldMetadataStandardOverride } from 'src/engine/metadata-modules/field-metadata/utils/resolve-field-metadata-standard-override.util';
jest.mock('src/engine/core-modules/i18n/utils/generateMessageId');
const mockGenerateMessageId = generateMessageId as jest.MockedFunction<
typeof generateMessageId
>;
describe('resolveFieldMetadataStandardOverride', () => {
let mockI18n: jest.Mocked<I18n>;
beforeEach(() => {
jest.clearAllMocks();
mockI18n = {
_: jest.fn(),
} as unknown as jest.Mocked<I18n>;
});
describe('Custom fields', () => {
it('should return the field value for custom label field', () => {
const fieldMetadata = {
label: 'Custom Label',
description: 'Custom Description',
icon: 'custom-icon',
isCustom: true,
standardOverrides: undefined,
};
const result = resolveFieldMetadataStandardOverride(
fieldMetadata,
'label',
'fr-FR',
mockI18n,
!fieldMetadata.isCustom,
);
expect(result).toBe('Custom Label');
});
it('should never translate a custom label even when it matches a standard catalog entry', () => {
const fieldMetadata = {
label: 'Status',
description: 'Custom Description',
icon: 'custom-icon',
isCustom: true,
standardOverrides: undefined,
};
mockGenerateMessageId.mockReturnValue('status.message.id');
mockI18n._.mockReturnValue('Statut');
const result = resolveFieldMetadataStandardOverride(
fieldMetadata,
'label',
'fr-FR',
mockI18n,
!fieldMetadata.isCustom,
);
expect(result).toBe('Status');
expect(mockGenerateMessageId).not.toHaveBeenCalled();
expect(mockI18n._).not.toHaveBeenCalled();
});
it('should return the field value for custom description field', () => {
const fieldMetadata = {
label: 'Custom Label',
description: 'Custom Description',
icon: 'custom-icon',
isCustom: true,
standardOverrides: undefined,
};
const result = resolveFieldMetadataStandardOverride(
fieldMetadata,
'description',
undefined,
mockI18n,
!fieldMetadata.isCustom,
);
expect(result).toBe('Custom Description');
});
it('should return the field value for custom icon field', () => {
const fieldMetadata = {
label: 'Custom Label',
description: 'Custom Description',
icon: 'custom-icon',
isCustom: true,
standardOverrides: undefined,
};
const result = resolveFieldMetadataStandardOverride(
fieldMetadata,
'icon',
SOURCE_LOCALE,
mockI18n,
!fieldMetadata.isCustom,
);
expect(result).toBe('custom-icon');
});
});
describe('Standard fields - Icon overrides', () => {
it('should return override icon when available for standard field', () => {
const fieldMetadata = {
label: 'Standard Label',
description: 'Standard Description',
icon: 'default-icon',
isCustom: false,
standardOverrides: {
icon: 'override-icon',
},
};
const result = resolveFieldMetadataStandardOverride(
fieldMetadata,
'icon',
'fr-FR',
mockI18n,
!fieldMetadata.isCustom,
);
expect(result).toBe('override-icon');
});
});
describe('Standard fields - Translation overrides', () => {
it('should return translation override when available for non-icon fields', () => {
const fieldMetadata = {
label: 'Standard Label',
description: 'Standard Description',
icon: 'default-icon',
isCustom: false,
standardOverrides: {
translations: {
'fr-FR': {
label: 'Libellé traduit',
description: 'Description traduite',
},
},
},
};
expect(
resolveFieldMetadataStandardOverride(
fieldMetadata,
'label',
'fr-FR',
mockI18n,
!fieldMetadata.isCustom,
),
).toBe('Libellé traduit');
expect(
resolveFieldMetadataStandardOverride(
fieldMetadata,
'description',
'fr-FR',
mockI18n,
!fieldMetadata.isCustom,
),
).toBe('Description traduite');
});
it('should fallback when translation override is not available for the locale', () => {
const fieldMetadata = {
label: 'Standard Label',
description: 'Standard Description',
icon: 'default-icon',
isCustom: false,
standardOverrides: {
translations: {
'es-ES': {
label: 'Etiqueta en español',
},
},
},
};
mockGenerateMessageId.mockReturnValue('generated-message-id');
mockI18n._.mockReturnValue('generated-message-id');
const result = resolveFieldMetadataStandardOverride(
fieldMetadata,
'label',
'fr-FR',
mockI18n,
!fieldMetadata.isCustom,
);
expect(result).toBe('Standard Label');
});
it('should fallback when translation override is not available for the labelKey', () => {
const fieldMetadata = {
label: 'Standard Label',
description: 'Standard Description',
icon: 'default-icon',
isCustom: false,
standardOverrides: {
translations: {
'fr-FR': {
label: 'Libellé traduit',
},
},
},
};
mockGenerateMessageId.mockReturnValue('generated-message-id');
mockI18n._.mockReturnValue('generated-message-id');
const result = resolveFieldMetadataStandardOverride(
fieldMetadata,
'description',
'fr-FR',
mockI18n,
!fieldMetadata.isCustom,
);
expect(result).toBe('Standard Description');
});
it('should not use translation overrides when locale is undefined', () => {
const fieldMetadata = {
label: 'Standard Label',
description: 'Standard Description',
icon: 'default-icon',
isCustom: false,
standardOverrides: {
translations: {
'fr-FR': {
label: 'Libellé traduit',
},
},
},
};
mockGenerateMessageId.mockReturnValue('generated-message-id');
mockI18n._.mockReturnValue('generated-message-id');
const result = resolveFieldMetadataStandardOverride(
fieldMetadata,
'label',
undefined,
mockI18n,
!fieldMetadata.isCustom,
);
expect(result).toBe('Standard Label');
});
});
describe('Standard fields - SOURCE_LOCALE overrides', () => {
it('should return direct override for SOURCE_LOCALE when available', () => {
const fieldMetadata = {
label: 'Standard Label',
description: 'Standard Description',
icon: 'default-icon',
isCustom: false,
standardOverrides: {
label: 'Overridden Label',
description: 'Overridden Description',
icon: 'overridden-icon',
},
};
expect(
resolveFieldMetadataStandardOverride(
fieldMetadata,
'label',
SOURCE_LOCALE,
mockI18n,
!fieldMetadata.isCustom,
),
).toBe('Overridden Label');
expect(
resolveFieldMetadataStandardOverride(
fieldMetadata,
'description',
SOURCE_LOCALE,
mockI18n,
!fieldMetadata.isCustom,
),
).toBe('Overridden Description');
expect(
resolveFieldMetadataStandardOverride(
fieldMetadata,
'icon',
SOURCE_LOCALE,
mockI18n,
!fieldMetadata.isCustom,
),
).toBe('overridden-icon');
});
it('should use direct override for non-SOURCE_LOCALE when translation override is missing', () => {
const fieldMetadata = {
label: 'Standard Label',
description: 'Standard Description',
icon: 'default-icon',
isCustom: false,
standardOverrides: {
label: 'Overridden Label',
},
};
mockGenerateMessageId.mockReturnValue('generated-message-id');
mockI18n._.mockReturnValue('generated-message-id');
const result = resolveFieldMetadataStandardOverride(
fieldMetadata,
'label',
'fr-FR',
mockI18n,
!fieldMetadata.isCustom,
);
expect(result).toBe('Overridden Label');
expect(mockGenerateMessageId).not.toHaveBeenCalled();
expect(mockI18n._).not.toHaveBeenCalled();
});
it('should not use empty string override for SOURCE_LOCALE', () => {
const fieldMetadata = {
label: 'Standard Label',
description: 'Standard Description',
icon: 'default-icon',
isCustom: false,
standardOverrides: {
label: '',
},
};
mockGenerateMessageId.mockReturnValue('generated-message-id');
mockI18n._.mockReturnValue('generated-message-id');
const result = resolveFieldMetadataStandardOverride(
fieldMetadata,
'label',
SOURCE_LOCALE,
mockI18n,
!fieldMetadata.isCustom,
);
expect(result).toBe('Standard Label');
});
it('should not use undefined override for SOURCE_LOCALE', () => {
const fieldMetadata = {
label: 'Standard Label',
description: 'Standard Description',
icon: 'default-icon',
isCustom: false,
standardOverrides: {
label: undefined,
},
};
mockGenerateMessageId.mockReturnValue('generated-message-id');
mockI18n._.mockReturnValue('generated-message-id');
const result = resolveFieldMetadataStandardOverride(
fieldMetadata,
'label',
SOURCE_LOCALE,
mockI18n,
!fieldMetadata.isCustom,
);
expect(result).toBe('Standard Label');
});
});
describe('Standard fields - Auto translation fallback', () => {
it('should return translated message when translation is available', () => {
const fieldMetadata = {
label: 'Standard Label',
description: 'Standard Description',
icon: 'default-icon',
isCustom: false,
standardOverrides: undefined,
};
mockGenerateMessageId.mockReturnValue('standard.label.message.id');
mockI18n._.mockReturnValue('Libellé traduit automatiquement');
const result = resolveFieldMetadataStandardOverride(
fieldMetadata,
'label',
'fr-FR',
mockI18n,
!fieldMetadata.isCustom,
);
expect(mockGenerateMessageId).toHaveBeenCalledWith('Standard Label');
expect(mockI18n._).toHaveBeenCalledWith('standard.label.message.id');
expect(result).toBe('Libellé traduit automatiquement');
});
it('should return original field value when no translation is found', () => {
const fieldMetadata = {
label: 'Standard Label',
description: 'Standard Description',
icon: 'default-icon',
isCustom: false,
standardOverrides: undefined,
};
const messageId = 'standard.label.message.id';
mockGenerateMessageId.mockReturnValue(messageId);
mockI18n._.mockReturnValue(messageId);
const result = resolveFieldMetadataStandardOverride(
fieldMetadata,
'label',
'fr-FR',
mockI18n,
!fieldMetadata.isCustom,
);
expect(result).toBe('Standard Label');
});
});
describe('Priority order - Standard fields', () => {
it('should prioritize translation override over SOURCE_LOCALE override for non-SOURCE_LOCALE', () => {
const fieldMetadata = {
label: 'Standard Label',
description: 'Standard Description',
icon: 'default-icon',
isCustom: false,
standardOverrides: {
label: 'Source Override',
translations: {
'fr-FR': {
label: 'Translation Override',
},
},
},
};
const result = resolveFieldMetadataStandardOverride(
fieldMetadata,
'label',
'fr-FR',
mockI18n,
!fieldMetadata.isCustom,
);
expect(result).toBe('Translation Override');
expect(mockGenerateMessageId).not.toHaveBeenCalled();
expect(mockI18n._).not.toHaveBeenCalled();
});
it('should prioritize SOURCE_LOCALE override over auto translation for SOURCE_LOCALE', () => {
const fieldMetadata = {
label: 'Standard Label',
description: 'Standard Description',
icon: 'default-icon',
isCustom: false,
standardOverrides: {
label: 'Source Override',
},
};
const result = resolveFieldMetadataStandardOverride(
fieldMetadata,
'label',
SOURCE_LOCALE,
mockI18n,
!fieldMetadata.isCustom,
);
expect(result).toBe('Source Override');
expect(mockGenerateMessageId).not.toHaveBeenCalled();
expect(mockI18n._).not.toHaveBeenCalled();
});
it('should use auto translation when no overrides are available', () => {
const fieldMetadata = {
label: 'Standard Label',
description: 'Standard Description',
icon: 'default-icon',
isCustom: false,
standardOverrides: {},
};
mockGenerateMessageId.mockReturnValue('auto.translation.id');
mockI18n._.mockReturnValue('Auto Translated Label');
const result = resolveFieldMetadataStandardOverride(
fieldMetadata,
'label',
'de-DE',
mockI18n,
!fieldMetadata.isCustom,
);
expect(result).toBe('Auto Translated Label');
expect(mockGenerateMessageId).toHaveBeenCalledWith('Standard Label');
expect(mockI18n._).toHaveBeenCalledWith('auto.translation.id');
});
});
});
@@ -17,7 +17,7 @@ export const fromFieldMetadataEntityToFieldMetadataDto = (
label: entity.label,
description: entity.description ?? undefined,
icon: entity.icon ?? undefined,
standardOverrides: entity.standardOverrides ?? undefined,
overrides: entity.overrides ?? undefined,
isActive: entity.isActive,
isSystem: entity.isSystem,
isUIEditable: entity.isUIEditable,
@@ -1,52 +0,0 @@
import { type I18n } from '@lingui/core';
import { isNonEmptyString } from '@sniptt/guards';
import { type APP_LOCALES, SOURCE_LOCALE } from 'twenty-shared/translations';
import { isDefined } from 'twenty-shared/utils';
import { translateStandardLabel } from 'src/engine/core-modules/i18n/utils/translate-standard-label.util';
import { type FieldMetadataDTO } from 'src/engine/metadata-modules/field-metadata/dtos/field-metadata.dto';
export const resolveFieldMetadataStandardOverride = (
fieldMetadata: Pick<
FieldMetadataDTO,
'label' | 'description' | 'icon' | 'standardOverrides'
>,
labelKey: 'label' | 'description' | 'icon',
locale: keyof typeof APP_LOCALES | undefined,
i18nInstance: I18n,
isStandardApp: boolean,
applicationCatalog?: Record<string, string>,
): string => {
const safeLocale = locale ?? SOURCE_LOCALE;
if (!isStandardApp && !isDefined(applicationCatalog)) {
return fieldMetadata[labelKey] ?? '';
}
if (labelKey === 'icon' && isDefined(fieldMetadata.standardOverrides?.icon)) {
return fieldMetadata.standardOverrides.icon;
}
if (
isDefined(fieldMetadata.standardOverrides?.translations) &&
labelKey !== 'icon'
) {
const translationValue =
fieldMetadata.standardOverrides.translations[safeLocale]?.[labelKey];
if (isDefined(translationValue)) {
return translationValue;
}
}
if (isNonEmptyString(fieldMetadata.standardOverrides?.[labelKey])) {
return fieldMetadata.standardOverrides[labelKey] ?? '';
}
return translateStandardLabel({
sourceValue: fieldMetadata[labelKey] ?? '',
isStandardApp,
applicationCatalog,
i18nInstance,
});
};