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>

packages/twenty-server/src/engine/metadata-modules/command-menu-item/utils/__tests__/interpolate-navigation-command-menu-item-field.util.spec.ts

@@ -20,7 +20,7 @@ const mockObjectMetadata = {
   labelSingular: 'Person',
   description: 'A person',
   icon: 'IconUser',
-  standardOverrides: undefined,
+  overrides: undefined,
 } as unknown as ObjectMetadataDTO;
 
 const baseCommandMenuItem = {

packages/twenty-server/src/engine/metadata-modules/command-menu-item/utils/build-navigation-interpolation-context.util.ts

@@ -1,15 +1,15 @@
 import { type I18n } from '@lingui/core';
 import { type APP_LOCALES } from 'twenty-shared/translations';
 
-import { type ObjectStandardOverridesDTO } from 'src/engine/metadata-modules/object-metadata/dtos/object-standard-overrides.dto';
-import { resolveObjectMetadataStandardOverride } from 'src/engine/metadata-modules/object-metadata/utils/resolve-object-metadata-standard-override.util';
+import { type ObjectMetadataOverrides } from 'src/engine/metadata-modules/object-metadata/types/object-metadata-overrides.type';
+import { resolveEffectiveEntityProperty } from 'src/engine/metadata-modules/utils/resolve-effective-entity-property.util';
 
 export type NavigationInterpolationObjectMetadata = {
   labelPlural: string;
   labelSingular: string;
   description?: string | null;
   icon?: string | null;
-  standardOverrides?: ObjectStandardOverridesDTO | null;
+  overrides?: ObjectMetadataOverrides | null;
 };
 
 export const buildNavigationInterpolationContext = ({
@@ -25,31 +25,29 @@ export const buildNavigationInterpolationContext = ({
   i18nInstance: I18n;
   applicationCatalog?: Record<string, string>;
 }): Record<string, unknown> => {
-  const overrideInput = {
-    labelPlural: objectMetadata.labelPlural,
-    labelSingular: objectMetadata.labelSingular,
-    description: objectMetadata.description ?? undefined,
-    icon: objectMetadata.icon ?? undefined,
-    standardOverrides: objectMetadata.standardOverrides ?? undefined,
+  const overrides = objectMetadata.overrides ?? undefined;
+  const i18nContext = {
+    locale,
+    i18nInstance,
+    isStandardApp,
+    applicationCatalog,
   };
 
-  const resolvedLabelPlural = resolveObjectMetadataStandardOverride(
-    overrideInput,
-    'labelPlural',
-    locale,
-    i18nInstance,
-    isStandardApp,
-    applicationCatalog,
-  );
+  const resolvedLabelPlural = resolveEffectiveEntityProperty({
+    metadataName: 'objectMetadata',
+    baseValue: objectMetadata.labelPlural,
+    overrides,
+    property: 'labelPlural',
+    i18nContext,
+  });
 
-  const resolvedIcon = resolveObjectMetadataStandardOverride(
-    overrideInput,
-    'icon',
-    locale,
-    i18nInstance,
-    isStandardApp,
-    applicationCatalog,
-  );
+  const resolvedIcon = resolveEffectiveEntityProperty({
+    metadataName: 'objectMetadata',
+    baseValue: objectMetadata.icon,
+    overrides,
+    property: 'icon',
+    i18nContext,
+  });
 
   return {
     navigateToObjectMetadataItem: {