The open alternative to Salesforce, designed for AI.
TypeScript crmcrm-systemcustomergood-first-issuegraphqlhacktoberfestjavascriptmarketingmonoreponestjsopen-sourcepostgresqlreactreactjssalestypescriptweb
feat(server): upgrade-aware entity decorators for cross-version upgrades (#20686)
Charles Bochet1d3d3999e23d
diff --git a/packages/twenty-server/src/database/typeorm/typeorm.module.ts b/packages/twenty-server/src/database/typeorm/typeorm.module.tsindex ee2691e6519..cd47754df24 100644--- a/packages/twenty-server/src/database/typeorm/typeorm.module.ts+++ b/packages/twenty-server/src/database/typeorm/typeorm.module.ts@@ -1,12 +1,28 @@import { Module } from '@nestjs/common';import { TypeOrmModule } from '@nestjs/typeorm';+import { DataSource, type DataSourceOptions } from 'typeorm';+import { typeORMCoreModuleOptions } from 'src/database/typeorm/core/core.datasource';import { DatabaseGaugeService } from 'src/database/typeorm/database-gauge.service';import { MetricsModule } from 'src/engine/core-modules/metrics/metrics.module';+import { installUpgradeAwareRepositoryProxy } from 'src/engine/twenty-orm/upgrade-aware/install-upgrade-aware-repository-proxy';@Module({- imports: [TypeOrmModule.forRoot(typeORMCoreModuleOptions), MetricsModule],+ imports: [+ TypeOrmModule.forRootAsync({+ useFactory: () => typeORMCoreModuleOptions,+ dataSourceFactory: async (options) => {+ const dataSource = new DataSource(options as DataSourceOptions);++ await dataSource.initialize();+ installUpgradeAwareRepositoryProxy(dataSource);++ return dataSource;+ },+ }),+ MetricsModule,+ ],providers: [DatabaseGaugeService],exports: [],})diff --git a/packages/twenty-server/src/engine/core-modules/upgrade/decorators/upgrade-decorator-metadata.util.ts b/packages/twenty-server/src/engine/core-modules/upgrade/decorators/upgrade-decorator-metadata.util.tsnew file mode 100644index 00000000000..95289766423--- /dev/null+++ b/packages/twenty-server/src/engine/core-modules/upgrade/decorators/upgrade-decorator-metadata.util.ts@@ -0,0 +1,33 @@+import 'reflect-metadata';++import { isDefined } from 'twenty-shared/utils';++export const defineUpgradeMetadataOnClassOrProperty = <T>({+ classMetadataKey,+ propertyMetadataKey,+ value,+ target,+ propertyKey,+}: {+ classMetadataKey: string;+ propertyMetadataKey: string;+ value: T;+ target: object;+ propertyKey: string | symbol | undefined;+}): void => {+ if (!isDefined(propertyKey)) {+ Reflect.defineMetadata(classMetadataKey, value, target);++ return;+ }++ const constructor = (target as { constructor: Function }).constructor;+ const existing: Record<string, T> =+ Reflect.getMetadata(propertyMetadataKey, constructor) ?? {};++ Reflect.defineMetadata(+ propertyMetadataKey,+ { ...existing, [String(propertyKey)]: value },+ constructor,+ );+};diff --git a/packages/twenty-server/src/engine/core-modules/upgrade/decorators/was-introduced-in-upgrade.decorator.ts b/packages/twenty-server/src/engine/core-modules/upgrade/decorators/was-introduced-in-upgrade.decorator.tsnew file mode 100644index 00000000000..1631391cb91--- /dev/null+++ b/packages/twenty-server/src/engine/core-modules/upgrade/decorators/was-introduced-in-upgrade.decorator.ts@@ -0,0 +1,43 @@+import 'reflect-metadata';++import { defineUpgradeMetadataOnClassOrProperty } from 'src/engine/core-modules/upgrade/decorators/upgrade-decorator-metadata.util';++export type WasIntroducedInUpgradeOptions = {+ upgradeCommandName: string;+};++export const WAS_INTRODUCED_IN_UPGRADE_CLASS_METADATA_KEY =+ 'WAS_INTRODUCED_IN_UPGRADE_CLASS';++export const WAS_INTRODUCED_IN_UPGRADE_PROPERTIES_METADATA_KEY =+ 'WAS_INTRODUCED_IN_UPGRADE_PROPERTIES';++export type WasIntroducedInUpgradePropertyMap = Record<+ string,+ WasIntroducedInUpgradeOptions+>;++export const WasIntroducedInUpgrade =+ (options: WasIntroducedInUpgradeOptions) =>+ (target: object, propertyKey?: string | symbol): void => {+ defineUpgradeMetadataOnClassOrProperty({+ classMetadataKey: WAS_INTRODUCED_IN_UPGRADE_CLASS_METADATA_KEY,+ propertyMetadataKey: WAS_INTRODUCED_IN_UPGRADE_PROPERTIES_METADATA_KEY,+ value: options,+ target,+ propertyKey,+ });+ };++export const getWasIntroducedInUpgradeClassMetadata = (+ target: Function,+): WasIntroducedInUpgradeOptions | undefined =>+ Reflect.getMetadata(WAS_INTRODUCED_IN_UPGRADE_CLASS_METADATA_KEY, target);++export const getWasIntroducedInUpgradePropertyMetadata = (+ target: Function,+): WasIntroducedInUpgradePropertyMap =>+ Reflect.getMetadata(+ WAS_INTRODUCED_IN_UPGRADE_PROPERTIES_METADATA_KEY,+ target,+ ) ?? {};diff --git a/packages/twenty-server/src/engine/core-modules/upgrade/decorators/was-renamed-in-upgrade.decorator.ts b/packages/twenty-server/src/engine/core-modules/upgrade/decorators/was-renamed-in-upgrade.decorator.tsnew file mode 100644index 00000000000..bd340c5330e--- /dev/null+++ b/packages/twenty-server/src/engine/core-modules/upgrade/decorators/was-renamed-in-upgrade.decorator.ts@@ -0,0 +1,42 @@+import 'reflect-metadata';++import { defineUpgradeMetadataOnClassOrProperty } from 'src/engine/core-modules/upgrade/decorators/upgrade-decorator-metadata.util';++export type WasRenamedInUpgradeHistoryEntry = {+ previousName: string;+ upgradeCommandName: string;+};++export const WAS_RENAMED_IN_UPGRADE_CLASS_METADATA_KEY =+ 'WAS_RENAMED_IN_UPGRADE_CLASS';++export const WAS_RENAMED_IN_UPGRADE_PROPERTIES_METADATA_KEY =+ 'WAS_RENAMED_IN_UPGRADE_PROPERTIES';++export type WasRenamedInUpgradePropertyMap = Record<+ string,+ WasRenamedInUpgradeHistoryEntry[]+>;++export const WasRenamedInUpgrade =+ (history: WasRenamedInUpgradeHistoryEntry[]) =>+ (target: object, propertyKey?: string | symbol): void => {+ defineUpgradeMetadataOnClassOrProperty({+ classMetadataKey: WAS_RENAMED_IN_UPGRADE_CLASS_METADATA_KEY,+ propertyMetadataKey: WAS_RENAMED_IN_UPGRADE_PROPERTIES_METADATA_KEY,+ value: history,+ target,+ propertyKey,+ });+ };++export const getWasRenamedInUpgradeClassMetadata = (+ target: Function,+): WasRenamedInUpgradeHistoryEntry[] | undefined =>+ Reflect.getMetadata(WAS_RENAMED_IN_UPGRADE_CLASS_METADATA_KEY, target);++export const getWasRenamedInUpgradePropertyMetadata = (+ target: Function,+): WasRenamedInUpgradePropertyMap =>+ Reflect.getMetadata(WAS_RENAMED_IN_UPGRADE_PROPERTIES_METADATA_KEY, target) ??+ {};diff --git a/packages/twenty-server/src/engine/core-modules/upgrade/services/upgrade-sequence-runner.service.ts b/packages/twenty-server/src/engine/core-modules/upgrade/services/upgrade-sequence-runner.service.tsindex 5e370e6e659..9f12b0fa23f 100644--- a/packages/twenty-server/src/engine/core-modules/upgrade/services/upgrade-sequence-runner.service.ts+++ b/packages/twenty-server/src/engine/core-modules/upgrade/services/upgrade-sequence-runner.service.ts@@ -18,6 +18,7 @@ import {} from 'src/engine/core-modules/upgrade/services/upgrade-sequence-reader.service';import { WorkspaceCommandRunnerService } from 'src/engine/core-modules/upgrade/services/workspace-command-runner.service';import { formatUpgradeLog } from 'src/engine/core-modules/upgrade/utils/format-upgrade-log.util';+import { UpgradeAwareEntityMetadataAdapter } from 'src/engine/twenty-orm/upgrade-aware/upgrade-aware-entity-metadata.adapter';import { WorkspaceVersionService } from 'src/engine/workspace-manager/workspace-version/services/workspace-version.service';import { assertUnreachable, isDefined } from 'twenty-shared/utils';@@ -35,6 +36,7 @@ export class UpgradeSequenceRunnerService {private readonly instanceCommandRunnerService: InstanceCommandRunnerService,private readonly workspaceCommandRunnerService: WorkspaceCommandRunnerService,private readonly upgradeSequenceReaderService: UpgradeSequenceReaderService,+ private readonly upgradeAwareEntityMetadataAdapter: UpgradeAwareEntityMetadataAdapter,private readonly workspaceIteratorService: WorkspaceIteratorService,private readonly workspaceVersionService: WorkspaceVersionService,) {}@@ -50,6 +52,31 @@ export class UpgradeSequenceRunnerService {return { totalSuccesses: 0, totalFailures: 0 };}+ await this.upgradeAwareEntityMetadataAdapter.refresh();++ try {+ return await this.runInner({ sequence, options });+ } finally {+ try {+ await this.upgradeAwareEntityMetadataAdapter.refresh();+ } catch (refreshError) {+ this.logger.error(+ `Failed to refresh upgrade-aware entity metadata after run`,+ refreshError instanceof Error+ ? refreshError.stack+ : String(refreshError),+ );+ }+ }+ }++ private async runInner({+ sequence,+ options,+ }: {+ sequence: UpgradeStep[];+ options: ParsedUpgradeCommandOptions;+ }): Promise<UpgradeSequenceRunnerReport> {const allActiveOrSuspendedWorkspaceIds =await this.workspaceVersionService.getActiveOrSuspendedWorkspaceIds();@@ -107,6 +134,8 @@ export class UpgradeSequenceRunnerService {skipDataMigration: allActiveOrSuspendedWorkspaceIds.length === 0,});+ await this.upgradeAwareEntityMetadataAdapter.refresh();+cursor++;continue;}diff --git a/packages/twenty-server/src/engine/core-modules/upgrade/upgrade.module.ts b/packages/twenty-server/src/engine/core-modules/upgrade/upgrade.module.tsindex a9bad4f5bcf..b57873efd50 100644--- a/packages/twenty-server/src/engine/core-modules/upgrade/upgrade.module.ts+++ b/packages/twenty-server/src/engine/core-modules/upgrade/upgrade.module.ts@@ -18,6 +18,7 @@ import { WorkspaceCommandRunnerService } from 'src/engine/core-modules/upgrade/simport { UpgradeGaugeService } from 'src/engine/core-modules/upgrade/upgrade-gauge.service';import { UpgradeMigrationEntity } from 'src/engine/core-modules/upgrade/upgrade-migration.entity';import { WorkspaceEntity } from 'src/engine/core-modules/workspace/workspace.entity';+import { UpgradeAwareEntityMetadataAdapter } from 'src/engine/twenty-orm/upgrade-aware/upgrade-aware-entity-metadata.adapter';import { WorkspaceVersionModule } from 'src/engine/workspace-manager/workspace-version/workspace-version.module';@Module({@@ -36,6 +37,7 @@ import { WorkspaceVersionModule } from 'src/engine/workspace-manager/workspace-vInstanceCommandRunnerService,WorkspaceCommandRunnerService,UpgradeCommandRegistryService,+ UpgradeAwareEntityMetadataAdapter,UpgradeSequenceReaderService,UpgradeSequenceRunnerService,UpgradeStatusService,@@ -47,6 +49,7 @@ import { WorkspaceVersionModule } from 'src/engine/workspace-manager/workspace-vInstanceCommandRunnerService,WorkspaceCommandRunnerService,UpgradeCommandRegistryService,+ UpgradeAwareEntityMetadataAdapter,UpgradeSequenceReaderService,UpgradeSequenceRunnerService,UpgradeStatusService,diff --git a/packages/twenty-server/src/engine/core-modules/upgrade/utils/__tests__/resolve-entity-shape-at-upgrade-cursor.util.spec.ts b/packages/twenty-server/src/engine/core-modules/upgrade/utils/__tests__/resolve-entity-shape-at-upgrade-cursor.util.spec.tsnew file mode 100644index 00000000000..6e969b11b57--- /dev/null+++ b/packages/twenty-server/src/engine/core-modules/upgrade/utils/__tests__/resolve-entity-shape-at-upgrade-cursor.util.spec.ts@@ -0,0 +1,185 @@+import { WasIntroducedInUpgrade } from 'src/engine/core-modules/upgrade/decorators/was-introduced-in-upgrade.decorator';+import { WasRenamedInUpgrade } from 'src/engine/core-modules/upgrade/decorators/was-renamed-in-upgrade.decorator';+import { resolveEntityShapeAtUpgradeCursor } from 'src/engine/core-modules/upgrade/utils/resolve-entity-shape-at-upgrade-cursor.util';++const INTRODUCE_CMD = '2.7.0_IntroduceCommand_1800000000000';+const RENAME_CMD = '2.6.0_RenameCommand_1700000000000';+const PROP_INTRODUCE_CMD = '2.7.0_AddColumnCommand_1800000000001';+const PROP_RENAME_CMD = '2.6.0_RenameColumnCommand_1700000000001';++const buildPredicate = (applied: string[]) => {+ const set = new Set(applied);++ return (stepName: string) => set.has(stepName);+};++describe('resolveEntityShapeAtUpgradeCursor', () => {+ describe('class-level @WasIntroducedInUpgrade', () => {+ @WasIntroducedInUpgrade({ upgradeCommandName: INTRODUCE_CMD })+ class IntroducedEntity {}++ it('should mark entity unavailable before its introduction step applied', () => {+ const result = resolveEntityShapeAtUpgradeCursor({+ entityClass: IntroducedEntity,+ currentTableName: 'introducedEntity',+ currentColumns: [],+ isStepApplied: buildPredicate([]),+ });++ expect(result.isAvailable).toBe(false);+ });++ it('should mark entity available once introduction applied', () => {+ const result = resolveEntityShapeAtUpgradeCursor({+ entityClass: IntroducedEntity,+ currentTableName: 'introducedEntity',+ currentColumns: [],+ isStepApplied: buildPredicate([INTRODUCE_CMD]),+ });++ expect(result.isAvailable).toBe(true);+ });+ });++ describe('class-level @WasRenamedInUpgrade', () => {+ @WasRenamedInUpgrade([+ { previousName: 'oldEntity', upgradeCommandName: RENAME_CMD },+ ])+ class RenamedEntity {}++ it('should report historical table name when rename not yet applied', () => {+ const result = resolveEntityShapeAtUpgradeCursor({+ entityClass: RenamedEntity,+ currentTableName: 'newEntity',+ currentColumns: [],+ isStepApplied: buildPredicate([]),+ });++ expect(result.effectiveTableName).toBe('oldEntity');+ expect(result.isAvailable).toBe(true);+ });++ it('should report current table name once rename applied', () => {+ const result = resolveEntityShapeAtUpgradeCursor({+ entityClass: RenamedEntity,+ currentTableName: 'newEntity',+ currentColumns: [],+ isStepApplied: buildPredicate([RENAME_CMD]),+ });++ expect(result.effectiveTableName).toBe('newEntity');+ });++ it('should walk a multi-step rename history chronologically', () => {+ const FIRST_RENAME_CMD = '2.5.0_FirstRename_1600000000000';+ const SECOND_RENAME_CMD = '2.6.0_SecondRename_1700000000000';++ @WasRenamedInUpgrade([+ { previousName: 'firstName', upgradeCommandName: FIRST_RENAME_CMD },+ { previousName: 'secondName', upgradeCommandName: SECOND_RENAME_CMD },+ ])+ class TwiceRenamedEntity {}++ expect(+ resolveEntityShapeAtUpgradeCursor({+ entityClass: TwiceRenamedEntity,+ currentTableName: 'thirdName',+ currentColumns: [],+ isStepApplied: buildPredicate([]),+ }).effectiveTableName,+ ).toBe('firstName');++ expect(+ resolveEntityShapeAtUpgradeCursor({+ entityClass: TwiceRenamedEntity,+ currentTableName: 'thirdName',+ currentColumns: [],+ isStepApplied: buildPredicate([FIRST_RENAME_CMD]),+ }).effectiveTableName,+ ).toBe('secondName');++ expect(+ resolveEntityShapeAtUpgradeCursor({+ entityClass: TwiceRenamedEntity,+ currentTableName: 'thirdName',+ currentColumns: [],+ isStepApplied: buildPredicate([FIRST_RENAME_CMD, SECOND_RENAME_CMD]),+ }).effectiveTableName,+ ).toBe('thirdName');+ });+ });++ describe('property-level decorators', () => {+ class EntityWithProperties {+ @WasIntroducedInUpgrade({ upgradeCommandName: PROP_INTRODUCE_CMD })+ newColumn!: string;++ @WasRenamedInUpgrade([+ { previousName: 'oldColumn', upgradeCommandName: PROP_RENAME_CMD },+ ])+ renamedColumn!: string;++ untouchedColumn!: string;+ }++ const currentColumns = [+ { propertyName: 'newColumn', databaseName: 'newColumn' },+ { propertyName: 'renamedColumn', databaseName: 'renamedColumn' },+ { propertyName: 'untouchedColumn', databaseName: 'untouchedColumn' },+ ];++ it('should hide not-yet-introduced columns and remap not-yet-renamed columns', () => {+ const result = resolveEntityShapeAtUpgradeCursor({+ entityClass: EntityWithProperties,+ currentTableName: 'entityWithProperties',+ currentColumns,+ isStepApplied: buildPredicate([]),+ });++ expect(result.hiddenPropertyNames).toEqual(new Set(['newColumn']));+ expect(Object.fromEntries(result.columnDatabaseNameRemap)).toEqual({+ renamedColumn: 'oldColumn',+ });+ });++ it('should leave both alone once both steps applied', () => {+ const result = resolveEntityShapeAtUpgradeCursor({+ entityClass: EntityWithProperties,+ currentTableName: 'entityWithProperties',+ currentColumns,+ isStepApplied: buildPredicate([PROP_INTRODUCE_CMD, PROP_RENAME_CMD]),+ });++ expect(result.hiddenPropertyNames.size).toBe(0);+ expect(result.columnDatabaseNameRemap.size).toBe(0);+ });++ it('should leave undecorated columns untouched in all cases', () => {+ const result = resolveEntityShapeAtUpgradeCursor({+ entityClass: EntityWithProperties,+ currentTableName: 'entityWithProperties',+ currentColumns,+ isStepApplied: buildPredicate([]),+ });++ expect(result.hiddenPropertyNames.has('untouchedColumn')).toBe(false);+ expect(result.columnDatabaseNameRemap.has('untouchedColumn')).toBe(false);+ });+ });++ it('should treat an entity with no decorators as available and unchanged', () => {+ class Plain {}++ const result = resolveEntityShapeAtUpgradeCursor({+ entityClass: Plain,+ currentTableName: 'plain',+ currentColumns: [{ propertyName: 'id', databaseName: 'id' }],+ isStepApplied: buildPredicate([]),+ });++ expect(result.isAvailable).toBe(true);+ expect(result.effectiveTableName).toBe('plain');+ expect(result.hiddenPropertyNames.size).toBe(0);+ expect(result.columnDatabaseNameRemap.size).toBe(0);+ });+});diff --git a/packages/twenty-server/src/engine/core-modules/upgrade/utils/__tests__/validate-upgrade-aware-entity-decorators.util.spec.ts b/packages/twenty-server/src/engine/core-modules/upgrade/utils/__tests__/validate-upgrade-aware-entity-decorators.util.spec.tsnew file mode 100644index 00000000000..d1cd4a18897--- /dev/null+++ b/packages/twenty-server/src/engine/core-modules/upgrade/utils/__tests__/validate-upgrade-aware-entity-decorators.util.spec.ts@@ -0,0 +1,76 @@+import { WasIntroducedInUpgrade } from 'src/engine/core-modules/upgrade/decorators/was-introduced-in-upgrade.decorator';+import { WasRenamedInUpgrade } from 'src/engine/core-modules/upgrade/decorators/was-renamed-in-upgrade.decorator';+import { validateUpgradeAwareEntityDecorators } from 'src/engine/core-modules/upgrade/utils/validate-upgrade-aware-entity-decorators.util';++describe('validateUpgradeAwareEntityDecorators', () => {+ const KNOWN_CMD = '2.6.0_KnownCommand_1700000000000';+ const KNOWN_RENAME_CMD = '2.6.0_KnownRename_1700000000001';+ const KNOWN_LATER_RENAME_CMD = '2.7.0_LaterRename_1800000000000';+ const UNKNOWN_CMD = '2.6.0_UnknownCommand_9999999999999';++ const buildStepNameToIndex = (names: string[]): ReadonlyMap<string, number> =>+ new Map(names.map((name, index) => [name, index]));++ it('should report no problems when every decorator references a known command', () => {+ @WasIntroducedInUpgrade({ upgradeCommandName: KNOWN_CMD })+ class IntroducedEntity {}++ @WasRenamedInUpgrade([+ { previousName: 'oldName', upgradeCommandName: KNOWN_RENAME_CMD },+ ])+ class RenamedEntity {}++ expect(+ validateUpgradeAwareEntityDecorators({+ entityClasses: [IntroducedEntity, RenamedEntity],+ stepNameToIndex: buildStepNameToIndex([KNOWN_CMD, KNOWN_RENAME_CMD]),+ }),+ ).toEqual([]);+ });++ it('should report a class-level unknown upgradeCommandName', () => {+ @WasIntroducedInUpgrade({ upgradeCommandName: UNKNOWN_CMD })+ class BrokenIntroduced {}++ const problems = validateUpgradeAwareEntityDecorators({+ entityClasses: [BrokenIntroduced],+ stepNameToIndex: buildStepNameToIndex([KNOWN_CMD]),+ });++ expect(problems).toEqual([+ {+ kind: 'unknown-step-name',+ entityName: 'BrokenIntroduced',+ decorator: '@WasIntroducedInUpgrade',+ scope: 'class',+ upgradeCommandName: UNKNOWN_CMD,+ },+ ]);+ });++ it('should report a rename history that is out of order versus the sequence', () => {+ @WasRenamedInUpgrade([+ { previousName: 'first', upgradeCommandName: KNOWN_LATER_RENAME_CMD },+ { previousName: 'second', upgradeCommandName: KNOWN_RENAME_CMD },+ ])+ class ReverseOrdered {}++ const problems = validateUpgradeAwareEntityDecorators({+ entityClasses: [ReverseOrdered],+ stepNameToIndex: buildStepNameToIndex([+ KNOWN_RENAME_CMD,+ KNOWN_LATER_RENAME_CMD,+ ]),+ });++ expect(problems).toEqual([+ {+ kind: 'rename-history-out-of-order',+ entityName: 'ReverseOrdered',+ scope: 'class',+ offendingUpgradeCommandName: KNOWN_RENAME_CMD,+ precedingUpgradeCommandName: KNOWN_LATER_RENAME_CMD,+ },+ ]);+ });+});diff --git a/packages/twenty-server/src/engine/core-modules/upgrade/utils/resolve-effective-name-from-rename-history.util.ts b/packages/twenty-server/src/engine/core-modules/upgrade/utils/resolve-effective-name-from-rename-history.util.tsnew file mode 100644index 00000000000..7585e81673a--- /dev/null+++ b/packages/twenty-server/src/engine/core-modules/upgrade/utils/resolve-effective-name-from-rename-history.util.ts@@ -0,0 +1,19 @@+import { type WasRenamedInUpgradeHistoryEntry } from 'src/engine/core-modules/upgrade/decorators/was-renamed-in-upgrade.decorator';++export const resolveEffectiveNameFromRenameHistory = ({+ currentName,+ history,+ isStepApplied,+}: {+ currentName: string;+ history: WasRenamedInUpgradeHistoryEntry[];+ isStepApplied: (stepName: string) => boolean;+}): string => {+ for (const entry of history) {+ if (!isStepApplied(entry.upgradeCommandName)) {+ return entry.previousName;+ }+ }++ return currentName;+};diff --git a/packages/twenty-server/src/engine/core-modules/upgrade/utils/resolve-entity-shape-at-upgrade-cursor.util.ts b/packages/twenty-server/src/engine/core-modules/upgrade/utils/resolve-entity-shape-at-upgrade-cursor.util.tsnew file mode 100644index 00000000000..c991c47d0b0--- /dev/null+++ b/packages/twenty-server/src/engine/core-modules/upgrade/utils/resolve-entity-shape-at-upgrade-cursor.util.ts@@ -0,0 +1,85 @@+import { isDefined } from 'twenty-shared/utils';++import {+ getWasIntroducedInUpgradeClassMetadata,+ getWasIntroducedInUpgradePropertyMetadata,+} from 'src/engine/core-modules/upgrade/decorators/was-introduced-in-upgrade.decorator';+import {+ getWasRenamedInUpgradeClassMetadata,+ getWasRenamedInUpgradePropertyMetadata,+} from 'src/engine/core-modules/upgrade/decorators/was-renamed-in-upgrade.decorator';+import { resolveEffectiveNameFromRenameHistory } from 'src/engine/core-modules/upgrade/utils/resolve-effective-name-from-rename-history.util';++export type ResolvedEntityShapeAtUpgradeCursor = {+ isAvailable: boolean;+ effectiveTableName: string;+ hiddenPropertyNames: ReadonlySet<string>;+ columnDatabaseNameRemap: ReadonlyMap<string, string>;+};++export const resolveEntityShapeAtUpgradeCursor = ({+ entityClass,+ currentTableName,+ currentColumns,+ isStepApplied,+}: {+ entityClass: Function;+ currentTableName: string;+ currentColumns: { propertyName: string; databaseName: string }[];+ isStepApplied: (stepName: string) => boolean;+}): ResolvedEntityShapeAtUpgradeCursor => {+ const classIntroduced = getWasIntroducedInUpgradeClassMetadata(entityClass);+ const isAvailable =+ !isDefined(classIntroduced) ||+ isStepApplied(classIntroduced.upgradeCommandName);++ const classRenameHistory =+ getWasRenamedInUpgradeClassMetadata(entityClass) ?? [];+ const effectiveTableName = resolveEffectiveNameFromRenameHistory({+ currentName: currentTableName,+ history: classRenameHistory,+ isStepApplied,+ });++ const propertyIntroductionMap =+ getWasIntroducedInUpgradePropertyMetadata(entityClass);+ const propertyRenameMap = getWasRenamedInUpgradePropertyMetadata(entityClass);++ const hiddenPropertyNames = new Set<string>();+ const columnDatabaseNameRemap = new Map<string, string>();++ for (const column of currentColumns) {+ const introduced = propertyIntroductionMap[column.propertyName];++ if (+ isDefined(introduced) &&+ !isStepApplied(introduced.upgradeCommandName)+ ) {+ hiddenPropertyNames.add(column.propertyName);+ continue;+ }++ const renameHistory = propertyRenameMap[column.propertyName] ?? [];++ if (renameHistory.length === 0) {+ continue;+ }++ const effectiveColumnName = resolveEffectiveNameFromRenameHistory({+ currentName: column.databaseName,+ history: renameHistory,+ isStepApplied,+ });++ if (effectiveColumnName !== column.databaseName) {+ columnDatabaseNameRemap.set(column.propertyName, effectiveColumnName);+ }+ }++ return {+ isAvailable,+ effectiveTableName,+ hiddenPropertyNames,+ columnDatabaseNameRemap,+ };+};diff --git a/packages/twenty-server/src/engine/core-modules/upgrade/utils/validate-upgrade-aware-entity-decorators.util.ts b/packages/twenty-server/src/engine/core-modules/upgrade/utils/validate-upgrade-aware-entity-decorators.util.tsnew file mode 100644index 00000000000..25705602c7f--- /dev/null+++ b/packages/twenty-server/src/engine/core-modules/upgrade/utils/validate-upgrade-aware-entity-decorators.util.ts@@ -0,0 +1,154 @@+import { isDefined } from 'twenty-shared/utils';++import {+ getWasIntroducedInUpgradeClassMetadata,+ getWasIntroducedInUpgradePropertyMetadata,+} from 'src/engine/core-modules/upgrade/decorators/was-introduced-in-upgrade.decorator';+import {+ getWasRenamedInUpgradeClassMetadata,+ getWasRenamedInUpgradePropertyMetadata,+ type WasRenamedInUpgradeHistoryEntry,+} from 'src/engine/core-modules/upgrade/decorators/was-renamed-in-upgrade.decorator';++export type UpgradeAwareDecoratorReferenceProblem =+ | {+ kind: 'unknown-step-name';+ entityName: string;+ decorator: '@WasIntroducedInUpgrade' | '@WasRenamedInUpgrade';+ scope: 'class' | `property:${string}`;+ upgradeCommandName: string;+ }+ | {+ kind: 'rename-history-out-of-order';+ entityName: string;+ scope: 'class' | `property:${string}`;+ offendingUpgradeCommandName: string;+ precedingUpgradeCommandName: string;+ };++export const validateUpgradeAwareEntityDecorators = ({+ entityClasses,+ stepNameToIndex,+}: {+ entityClasses: Function[];+ stepNameToIndex: ReadonlyMap<string, number>;+}): UpgradeAwareDecoratorReferenceProblem[] => {+ const problems: UpgradeAwareDecoratorReferenceProblem[] = [];++ for (const entityClass of entityClasses) {+ const entityName = entityClass.name;++ const classIntroduced = getWasIntroducedInUpgradeClassMetadata(entityClass);++ if (+ isDefined(classIntroduced) &&+ !stepNameToIndex.has(classIntroduced.upgradeCommandName)+ ) {+ problems.push({+ kind: 'unknown-step-name',+ entityName,+ decorator: '@WasIntroducedInUpgrade',+ scope: 'class',+ upgradeCommandName: classIntroduced.upgradeCommandName,+ });+ }++ const classRenameHistory =+ getWasRenamedInUpgradeClassMetadata(entityClass) ?? [];++ checkHistoryForReferenceAndOrder({+ entityName,+ scope: 'class',+ history: classRenameHistory,+ stepNameToIndex,+ problems,+ });++ const propIntroducedMap =+ getWasIntroducedInUpgradePropertyMetadata(entityClass);++ for (const [propertyName, options] of Object.entries(propIntroducedMap)) {+ if (!stepNameToIndex.has(options.upgradeCommandName)) {+ problems.push({+ kind: 'unknown-step-name',+ entityName,+ decorator: '@WasIntroducedInUpgrade',+ scope: `property:${propertyName}`,+ upgradeCommandName: options.upgradeCommandName,+ });+ }+ }++ const propRenameMap = getWasRenamedInUpgradePropertyMetadata(entityClass);++ for (const [propertyName, history] of Object.entries(propRenameMap)) {+ checkHistoryForReferenceAndOrder({+ entityName,+ scope: `property:${propertyName}`,+ history,+ stepNameToIndex,+ problems,+ });+ }+ }++ return problems;+};++const checkHistoryForReferenceAndOrder = ({+ entityName,+ scope,+ history,+ stepNameToIndex,+ problems,+}: {+ entityName: string;+ scope: 'class' | `property:${string}`;+ history: WasRenamedInUpgradeHistoryEntry[];+ stepNameToIndex: ReadonlyMap<string, number>;+ problems: UpgradeAwareDecoratorReferenceProblem[];+}): void => {+ let previousIndex = -1;+ let previousName: string | undefined;++ for (const entry of history) {+ const index = stepNameToIndex.get(entry.upgradeCommandName);++ if (!isDefined(index)) {+ problems.push({+ kind: 'unknown-step-name',+ entityName,+ decorator: '@WasRenamedInUpgrade',+ scope,+ upgradeCommandName: entry.upgradeCommandName,+ });+ continue;+ }++ if (index <= previousIndex) {+ problems.push({+ kind: 'rename-history-out-of-order',+ entityName,+ scope,+ offendingUpgradeCommandName: entry.upgradeCommandName,+ precedingUpgradeCommandName: previousName ?? '',+ });+ }++ previousIndex = index;+ previousName = entry.upgradeCommandName;+ }+};++export const formatUpgradeAwareDecoratorReferenceProblems = (+ problems: UpgradeAwareDecoratorReferenceProblem[],+): string =>+ problems+ .map((problem) => {+ if (problem.kind === 'unknown-step-name') {+ return ` - ${problem.entityName} ${problem.decorator} (${problem.scope}): unknown upgradeCommandName "${problem.upgradeCommandName}"`;+ }++ return ` - ${problem.entityName} @WasRenamedInUpgrade (${problem.scope}): "${problem.offendingUpgradeCommandName}" must come after "${problem.precedingUpgradeCommandName}" in the upgrade sequence`;+ })+ .join('\n');diff --git a/packages/twenty-server/src/engine/metadata-modules/permission-flag/permission-flag.entity.ts b/packages/twenty-server/src/engine/metadata-modules/permission-flag/permission-flag.entity.tsindex 984b39bf3e7..c0c4809dbed 100644--- a/packages/twenty-server/src/engine/metadata-modules/permission-flag/permission-flag.entity.ts+++ b/packages/twenty-server/src/engine/metadata-modules/permission-flag/permission-flag.entity.ts@@ -10,11 +10,16 @@ import {UpdateDateColumn,} from 'typeorm';+import { WasIntroducedInUpgrade } from 'src/engine/core-modules/upgrade/decorators/was-introduced-in-upgrade.decorator';import { type PermissionFlagPermissionType } from 'src/engine/metadata-modules/permission-flag/constants/permission-flag-permission-type.constant';import { RolePermissionFlagEntity } from 'src/engine/metadata-modules/role-permission-flag/role-permission-flag.entity';import { SyncableEntity } from 'src/engine/workspace-manager/types/syncable-entity.interface';@Entity('permissionFlag')+@WasIntroducedInUpgrade({+ upgradeCommandName:+ '2.6.0_PermissionFlagSyncableEntityFastInstanceCommand_1778235340021',+})@Unique('IDX_PERMISSION_FLAG_KEY_WORKSPACE_ID_UNIQUE', ['key', 'workspaceId'])@Index('IDX_PERMISSION_FLAG_APPLICATION_ID', ['applicationId'])export class PermissionFlagEntity extends SyncableEntity {diff --git a/packages/twenty-server/src/engine/metadata-modules/role-permission-flag/role-permission-flag.entity.ts b/packages/twenty-server/src/engine/metadata-modules/role-permission-flag/role-permission-flag.entity.tsindex 5a30dd022ff..3a328c6f8ea 100644--- a/packages/twenty-server/src/engine/metadata-modules/role-permission-flag/role-permission-flag.entity.ts+++ b/packages/twenty-server/src/engine/metadata-modules/role-permission-flag/role-permission-flag.entity.ts@@ -12,11 +12,20 @@ import {UpdateDateColumn,} from 'typeorm';+import { WasIntroducedInUpgrade } from 'src/engine/core-modules/upgrade/decorators/was-introduced-in-upgrade.decorator';+import { WasRenamedInUpgrade } from 'src/engine/core-modules/upgrade/decorators/was-renamed-in-upgrade.decorator';import { PermissionFlagEntity } from 'src/engine/metadata-modules/permission-flag/permission-flag.entity';import { RoleEntity } from 'src/engine/metadata-modules/role/role.entity';import { SyncableEntity } from 'src/engine/workspace-manager/types/syncable-entity.interface';@Entity('rolePermissionFlag')+@WasRenamedInUpgrade([+ {+ previousName: 'permissionFlag',+ upgradeCommandName:+ '2.6.0_RenamePermissionFlagToRolePermissionFlagFastInstanceCommand_1778235340020',+ },+])@Unique('IDX_ROLE_PERMISSION_FLAG_FLAG_ROLE_ID_UNIQUE', ['flag', 'roleId'])@Unique('IDX_ROLE_PERMISSION_FLAG_PERMISSION_FLAG_ID_ROLE_ID_UNIQUE', ['permissionFlagId',@@ -40,6 +49,10 @@ export class RolePermissionFlagEntity extends SyncableEntity {@Column({ nullable: false, type: 'varchar' })flag: PermissionFlagType;+ @WasIntroducedInUpgrade({+ upgradeCommandName:+ '2.6.0_LinkRolePermissionFlagToPermissionFlagFastInstanceCommand_1778235340022',+ })@Column({ nullable: true, type: 'uuid' })permissionFlagId: string | null;diff --git a/packages/twenty-server/src/engine/twenty-orm/upgrade-aware/__tests__/upgrade-aware-entity-metadata.adapter.spec.ts b/packages/twenty-server/src/engine/twenty-orm/upgrade-aware/__tests__/upgrade-aware-entity-metadata.adapter.spec.tsnew file mode 100644index 00000000000..2200076f506--- /dev/null+++ b/packages/twenty-server/src/engine/twenty-orm/upgrade-aware/__tests__/upgrade-aware-entity-metadata.adapter.spec.ts@@ -0,0 +1,67 @@+import 'reflect-metadata';++import { Test } from '@nestjs/testing';+import { getDataSourceToken } from '@nestjs/typeorm';++import { type DataSource } from 'typeorm';+import { type EntityMetadata } from 'typeorm/metadata/EntityMetadata';++import { WasRenamedInUpgrade } from 'src/engine/core-modules/upgrade/decorators/was-renamed-in-upgrade.decorator';+import { UpgradeMigrationService } from 'src/engine/core-modules/upgrade/services/upgrade-migration.service';+import { UpgradeSequenceReaderService } from 'src/engine/core-modules/upgrade/services/upgrade-sequence-reader.service';+import { UpgradeAwareEntityMetadataAdapter } from 'src/engine/twenty-orm/upgrade-aware/upgrade-aware-entity-metadata.adapter';++const RENAME_STEP = '2.6.0_Rename_1700000000000';++@WasRenamedInUpgrade([+ { previousName: 'oldEntity', upgradeCommandName: RENAME_STEP },+])+class RenamedEntity {}++describe('UpgradeAwareEntityMetadataAdapter', () => {+ it('rewrites tableName / tablePath / givenTableName when the rename step is not yet applied', async () => {+ const metadata = {+ target: RenamedEntity,+ tableName: 'newEntity',+ tablePath: 'core.newEntity',+ givenTableName: 'newEntity',+ schema: 'core',+ columns: [],+ } as unknown as EntityMetadata;++ const dataSource = {+ entityMetadatas: [metadata],+ } as unknown as DataSource;++ const moduleRef = await Test.createTestingModule({+ providers: [+ UpgradeAwareEntityMetadataAdapter,+ {+ provide: UpgradeMigrationService,+ useValue: {+ getLastAttemptedInstanceCommand: jest.fn().mockResolvedValue(null),+ },+ },+ {+ provide: UpgradeSequenceReaderService,+ useValue: {+ getUpgradeSequence: jest+ .fn()+ .mockReturnValue([{ name: RENAME_STEP }]),+ },+ },+ { provide: getDataSourceToken(), useValue: dataSource },+ ],+ }).compile();++ const adapter = moduleRef.get(UpgradeAwareEntityMetadataAdapter);++ await adapter.onModuleInit();++ await adapter.refresh();++ expect(metadata.tableName).toBe('oldEntity');+ expect(metadata.tablePath).toBe('core.oldEntity');+ expect(metadata.givenTableName).toBe('oldEntity');+ });+});diff --git a/packages/twenty-server/src/engine/twenty-orm/upgrade-aware/__tests__/upgrade-aware-repository.proxy.spec.ts b/packages/twenty-server/src/engine/twenty-orm/upgrade-aware/__tests__/upgrade-aware-repository.proxy.spec.tsnew file mode 100644index 00000000000..9961f9a3f7a--- /dev/null+++ b/packages/twenty-server/src/engine/twenty-orm/upgrade-aware/__tests__/upgrade-aware-repository.proxy.spec.ts@@ -0,0 +1,74 @@+import 'reflect-metadata';++import { Test } from '@nestjs/testing';+import { getDataSourceToken } from '@nestjs/typeorm';++import { type DataSource, type Repository } from 'typeorm';+import { type EntityMetadata } from 'typeorm/metadata/EntityMetadata';++import { WasIntroducedInUpgrade } from 'src/engine/core-modules/upgrade/decorators/was-introduced-in-upgrade.decorator';+import { UpgradeMigrationService } from 'src/engine/core-modules/upgrade/services/upgrade-migration.service';+import { UpgradeSequenceReaderService } from 'src/engine/core-modules/upgrade/services/upgrade-sequence-reader.service';+import { UpgradeAwareEntityMetadataAdapter } from 'src/engine/twenty-orm/upgrade-aware/upgrade-aware-entity-metadata.adapter';+import { UpgradeAwareRepositoryState } from 'src/engine/twenty-orm/upgrade-aware/upgrade-aware-repository-state';+import { wrapRepositoryWithUpgradeAwareProxy } from 'src/engine/twenty-orm/upgrade-aware/upgrade-aware-repository.proxy';++const INTRODUCE_STEP = '2.7.0_Introduce_1800000000000';++@WasIntroducedInUpgrade({ upgradeCommandName: INTRODUCE_STEP })+class UnavailableEntity {}++describe('wrapRepositoryWithUpgradeAwareProxy', () => {+ it('short-circuits find() to an empty array when the entity is unavailable', async () => {+ const metadata = {+ target: UnavailableEntity,+ tableName: 'unavailableEntity',+ tablePath: 'core.unavailableEntity',+ givenTableName: 'unavailableEntity',+ schema: 'core',+ columns: [],+ } as unknown as EntityMetadata;++ const dataSource = {+ entityMetadatas: [metadata],+ } as unknown as DataSource;++ const moduleRef = await Test.createTestingModule({+ providers: [+ UpgradeAwareEntityMetadataAdapter,+ {+ provide: UpgradeMigrationService,+ useValue: {+ getLastAttemptedInstanceCommand: jest.fn().mockResolvedValue(null),+ },+ },+ {+ provide: UpgradeSequenceReaderService,+ useValue: {+ getUpgradeSequence: jest+ .fn()+ .mockReturnValue([{ name: INTRODUCE_STEP }]),+ },+ },+ { provide: getDataSourceToken(), useValue: dataSource },+ ],+ }).compile();++ const adapter = moduleRef.get(UpgradeAwareEntityMetadataAdapter);++ await adapter.onModuleInit();+ await adapter.refresh();++ const find = jest.fn().mockResolvedValue([{ id: 1 }]);+ const repository = { find } as unknown as Repository<UnavailableEntity>;++ const wrapped = wrapRepositoryWithUpgradeAwareProxy({+ repository,+ entityClass: UnavailableEntity,+ state: UpgradeAwareRepositoryState.getInstance(),+ });++ await expect(wrapped.find()).resolves.toEqual([]);+ expect(find).not.toHaveBeenCalled();+ });+});diff --git a/packages/twenty-server/src/engine/twenty-orm/upgrade-aware/exceptions/upgrade-unavailable-entity-write.exception.ts b/packages/twenty-server/src/engine/twenty-orm/upgrade-aware/exceptions/upgrade-unavailable-entity-write.exception.tsnew file mode 100644index 00000000000..a7d2eef9f75--- /dev/null+++ b/packages/twenty-server/src/engine/twenty-orm/upgrade-aware/exceptions/upgrade-unavailable-entity-write.exception.ts@@ -0,0 +1,12 @@+export class UpgradeUnavailableEntityWriteException extends Error {+ constructor(entityName: string, method: string) {+ super(+ `Cannot ${method} on ${entityName}: this entity is decorated with ` ++ `@WasIntroducedInUpgrade and the introducing command has not been ` ++ `applied at the current upgrade position. Run the upgrade further ` ++ `before writing to it, or move the write later in the sequence.`,+ );++ this.name = 'UpgradeUnavailableEntityWriteException';+ }+}diff --git a/packages/twenty-server/src/engine/twenty-orm/upgrade-aware/install-upgrade-aware-repository-proxy.ts b/packages/twenty-server/src/engine/twenty-orm/upgrade-aware/install-upgrade-aware-repository-proxy.tsnew file mode 100644index 00000000000..8f415118f94--- /dev/null+++ b/packages/twenty-server/src/engine/twenty-orm/upgrade-aware/install-upgrade-aware-repository-proxy.ts@@ -0,0 +1,92 @@+import { Logger } from '@nestjs/common';++import {+ type DataSource,+ type EntityManager,+ type EntityTarget,+ type Repository,+} from 'typeorm';+import { isDefined } from 'twenty-shared/utils';++import { UpgradeAwareRepositoryState } from 'src/engine/twenty-orm/upgrade-aware/upgrade-aware-repository-state';+import { wrapRepositoryWithUpgradeAwareProxy } from 'src/engine/twenty-orm/upgrade-aware/upgrade-aware-repository.proxy';++const logger = new Logger('InstallUpgradeAwareRepositoryProxy');++const wrappedRepositoryCache = new WeakMap<object, object>();++export const installUpgradeAwareRepositoryProxy = (+ dataSource: DataSource,+): void => {+ const state = UpgradeAwareRepositoryState.getInstance();++ const wrapIfNeeded = <Entity extends object>(+ target: EntityTarget<Entity>,+ repository: Repository<Entity>,+ ): Repository<Entity> => {+ const entityClass = resolveEntityClass(target);++ if (!isDefined(entityClass)) {+ return repository;+ }++ const cached = wrappedRepositoryCache.get(repository);++ if (isDefined(cached)) {+ return cached as typeof repository;+ }++ const wrapped = wrapRepositoryWithUpgradeAwareProxy({+ repository,+ entityClass,+ state,+ });++ wrappedRepositoryCache.set(repository, wrapped);++ return wrapped;+ };++ const originalDataSourceGetRepository =+ dataSource.getRepository.bind(dataSource);++ dataSource.getRepository = function getRepositoryWithUpgradeAwareProxy<+ Entity extends object,+ >(target: EntityTarget<Entity>) {+ return wrapIfNeeded(target, originalDataSourceGetRepository(target));+ } as DataSource['getRepository'];++ const entityManagerPrototype = Object.getPrototypeOf(dataSource.manager) as {+ getRepository: EntityManager['getRepository'];+ };+ const originalEntityManagerGetRepository =+ entityManagerPrototype.getRepository;++ entityManagerPrototype.getRepository =+ function getRepositoryWithUpgradeAwareProxy<Entity extends object>(+ this: EntityManager,+ target: EntityTarget<Entity>,+ ) {+ const repository = originalEntityManagerGetRepository.call(this, target);++ if (this.connection !== dataSource) {+ return repository;+ }++ return wrapIfNeeded(target, repository);+ } as EntityManager['getRepository'];++ logger.log(+ '[upgrade-proxy] installed getRepository proxy on core DataSource and EntityManager.prototype',+ );+};++const resolveEntityClass = <Entity extends object>(+ target: EntityTarget<Entity>,+): Function | undefined => {+ if (typeof target === 'function') {+ return target;+ }++ return undefined;+};diff --git a/packages/twenty-server/src/engine/twenty-orm/upgrade-aware/upgrade-aware-entity-metadata.adapter.ts b/packages/twenty-server/src/engine/twenty-orm/upgrade-aware/upgrade-aware-entity-metadata.adapter.tsnew file mode 100644index 00000000000..3ecd73baedb--- /dev/null+++ b/packages/twenty-server/src/engine/twenty-orm/upgrade-aware/upgrade-aware-entity-metadata.adapter.ts@@ -0,0 +1,347 @@+import { Injectable, Logger, type OnModuleInit } from '@nestjs/common';+import { InjectDataSource } from '@nestjs/typeorm';++import { type ColumnMetadata } from 'typeorm/metadata/ColumnMetadata';+import { type EntityMetadata } from 'typeorm/metadata/EntityMetadata';++import { DataSource } from 'typeorm';+import { isDefined } from 'twenty-shared/utils';++import { UpgradeMigrationService } from 'src/engine/core-modules/upgrade/services/upgrade-migration.service';+import { UpgradeSequenceReaderService } from 'src/engine/core-modules/upgrade/services/upgrade-sequence-reader.service';+import {+ resolveEntityShapeAtUpgradeCursor,+ type ResolvedEntityShapeAtUpgradeCursor,+} from 'src/engine/core-modules/upgrade/utils/resolve-entity-shape-at-upgrade-cursor.util';+import {+ formatUpgradeAwareDecoratorReferenceProblems,+ validateUpgradeAwareEntityDecorators,+} from 'src/engine/core-modules/upgrade/utils/validate-upgrade-aware-entity-decorators.util';+import { UpgradeAwareRepositoryState } from 'src/engine/twenty-orm/upgrade-aware/upgrade-aware-repository-state';++type EntityMetadataSnapshot = {+ tableName: string;+ tablePath: string;+ givenTableName: string | undefined;+ columnDatabaseNamesByPropertyName: ReadonlyMap<string, string>;+ columnSelectByPropertyName: ReadonlyMap<string, boolean>;+};++@Injectable()+export class UpgradeAwareEntityMetadataAdapter implements OnModuleInit {+ private readonly logger = new Logger(UpgradeAwareEntityMetadataAdapter.name);++ private readonly snapshotByMetadata = new WeakMap<+ EntityMetadata,+ EntityMetadataSnapshot+ >();++ private readonly availabilityByEntityClass = new WeakMap<Function, boolean>();+ private readonly hiddenColumnsByEntityClass = new WeakMap<+ Function,+ ReadonlySet<string>+ >();++ private stepNameToIndex: Map<string, number> = new Map();+ private currentCursor = Number.MAX_SAFE_INTEGER;++ constructor(+ @InjectDataSource()+ private readonly coreDataSource: DataSource,+ private readonly upgradeSequenceReaderService: UpgradeSequenceReaderService,+ private readonly upgradeMigrationService: UpgradeMigrationService,+ ) {}++ async onModuleInit(): Promise<void> {+ const sequence = this.upgradeSequenceReaderService.getUpgradeSequence();++ for (const [index, step] of sequence.entries()) {+ this.stepNameToIndex.set(step.name, index);+ }++ this.validateDecoratorsAgainstSequence();+ this.captureCanonicalSnapshots();++ this.currentCursor = sequence.length;+ this.applyCursorToMetadata();++ UpgradeAwareRepositoryState.getInstance().setMetadataService(this);++ try {+ await this.refresh();+ } catch (error) {+ this.logger.log(+ `[upgrade-metadata] initial refresh skipped (core.upgradeMigration not readable yet): ${+ error instanceof Error ? error.message : String(error)+ }`,+ );+ }+ }++ async refresh(): Promise<void> {+ const lastAttempted =+ await this.upgradeMigrationService.getLastAttemptedInstanceCommand();++ let nextCursor: number;++ if (!isDefined(lastAttempted)) {+ nextCursor = 0;+ } else {+ const index = this.stepNameToIndex.get(lastAttempted.name);++ if (!isDefined(index)) {+ nextCursor = 0;+ } else {+ nextCursor = lastAttempted.status === 'completed' ? index + 1 : index;+ }+ }++ if (nextCursor === this.currentCursor) {+ return;+ }++ this.currentCursor = nextCursor;+ this.applyCursorToMetadata();+ }++ isEntityAvailable(entityClass: Function): boolean {+ return this.availabilityByEntityClass.get(entityClass) ?? true;+ }++ getHiddenColumnPropertyNames(entityClass: Function): ReadonlySet<string> {+ return this.hiddenColumnsByEntityClass.get(entityClass) ?? new Set();+ }++ private captureCanonicalSnapshots(): void {+ for (const metadata of this.coreDataSource.entityMetadatas) {+ const columnDatabaseNamesByPropertyName = new Map<string, string>();+ const columnSelectByPropertyName = new Map<string, boolean>();++ for (const column of metadata.columns) {+ columnDatabaseNamesByPropertyName.set(+ column.propertyName,+ column.databaseName,+ );+ columnSelectByPropertyName.set(column.propertyName, column.isSelect);+ }++ this.snapshotByMetadata.set(metadata, {+ tableName: metadata.tableName,+ tablePath: metadata.tablePath,+ givenTableName: metadata.givenTableName,+ columnDatabaseNamesByPropertyName,+ columnSelectByPropertyName,+ });+ }+ }++ private applyCursorToMetadata(): void {+ const isStepApplied = this.buildIsStepAppliedPredicate();++ let renamedCount = 0;+ let unavailableCount = 0;+ let hiddenColumnCount = 0;++ for (const metadata of this.coreDataSource.entityMetadatas) {+ const applied = this.applyCursorToEntity({ metadata, isStepApplied });++ if (!isDefined(applied)) {+ continue;+ }++ if (applied.resolved.effectiveTableName !== applied.snapshot.tableName) {+ renamedCount++;+ }++ if (!applied.resolved.isAvailable) {+ unavailableCount++;+ }++ hiddenColumnCount += applied.resolved.hiddenPropertyNames.size;+ }++ this.logger.log(+ `[upgrade-metadata] applied cursor=${this.currentCursor} renamed=${renamedCount} unavailable=${unavailableCount} hiddenColumns=${hiddenColumnCount}`,+ );+ }++ private buildIsStepAppliedPredicate(): (stepName: string) => boolean {+ return (stepName: string) => {+ const index = this.stepNameToIndex.get(stepName);++ if (!isDefined(index)) {+ return false;+ }++ return index < this.currentCursor;+ };+ }++ private applyCursorToEntity({+ metadata,+ isStepApplied,+ }: {+ metadata: EntityMetadata;+ isStepApplied: (stepName: string) => boolean;+ }):+ | {+ snapshot: EntityMetadataSnapshot;+ resolved: ResolvedEntityShapeAtUpgradeCursor;+ }+ | undefined {+ const snapshot = this.snapshotByMetadata.get(metadata);++ if (!isDefined(snapshot) || typeof metadata.target !== 'function') {+ return undefined;+ }++ const entityClass = metadata.target;++ const currentColumns = [...snapshot.columnDatabaseNamesByPropertyName].map(+ ([propertyName, databaseName]) => ({ propertyName, databaseName }),+ );++ const resolved = resolveEntityShapeAtUpgradeCursor({+ entityClass,+ currentTableName: snapshot.tableName,+ currentColumns,+ isStepApplied,+ });++ this.applyResolvedShapeToMetadata({ metadata, snapshot, resolved });++ this.availabilityByEntityClass.set(entityClass, resolved.isAvailable);+ this.hiddenColumnsByEntityClass.set(+ entityClass,+ resolved.hiddenPropertyNames,+ );++ this.logResolvedShape({ entityClass, snapshot, resolved });++ return { snapshot, resolved };+ }++ private logResolvedShape({+ entityClass,+ snapshot,+ resolved,+ }: {+ entityClass: Function;+ snapshot: EntityMetadataSnapshot;+ resolved: ResolvedEntityShapeAtUpgradeCursor;+ }): void {+ if (resolved.effectiveTableName !== snapshot.tableName) {+ this.logger.log(+ `[upgrade-metadata] rename ${entityClass.name} ${snapshot.tableName} -> ${resolved.effectiveTableName}`,+ );+ }++ if (!resolved.isAvailable) {+ this.logger.log(`[upgrade-metadata] unavailable ${entityClass.name}`);+ }++ if (resolved.hiddenPropertyNames.size > 0) {+ this.logger.log(+ `[upgrade-metadata] hidden columns on ${entityClass.name}: ${[...resolved.hiddenPropertyNames].join(',')}`,+ );+ }+ }++ private applyResolvedShapeToMetadata({+ metadata,+ snapshot,+ resolved,+ }: {+ metadata: EntityMetadata;+ snapshot: EntityMetadataSnapshot;+ resolved: ResolvedEntityShapeAtUpgradeCursor;+ }): void {+ if (resolved.effectiveTableName === snapshot.tableName) {+ metadata.tableName = snapshot.tableName;+ metadata.tablePath = snapshot.tablePath;+ metadata.givenTableName = snapshot.givenTableName;+ } else {+ metadata.tableName = resolved.effectiveTableName;+ metadata.tablePath = this.computeTablePath({+ metadata,+ effectiveTableName: resolved.effectiveTableName,+ });+ metadata.givenTableName = resolved.effectiveTableName;+ }++ for (const column of metadata.columns) {+ this.applyColumnShape({ column, snapshot, resolved });+ }+ }++ private applyColumnShape({+ column,+ snapshot,+ resolved,+ }: {+ column: ColumnMetadata;+ snapshot: EntityMetadataSnapshot;+ resolved: ResolvedEntityShapeAtUpgradeCursor;+ }): void {+ const canonicalName = snapshot.columnDatabaseNamesByPropertyName.get(+ column.propertyName,+ );++ if (!isDefined(canonicalName)) {+ return;+ }++ const remappedName = resolved.columnDatabaseNameRemap.get(+ column.propertyName,+ );++ column.databaseName = remappedName ?? canonicalName;++ const canonicalIsSelect =+ snapshot.columnSelectByPropertyName.get(column.propertyName) ?? true;++ column.isSelect = resolved.hiddenPropertyNames.has(column.propertyName)+ ? false+ : canonicalIsSelect;+ }++ private computeTablePath({+ metadata,+ effectiveTableName,+ }: {+ metadata: EntityMetadata;+ effectiveTableName: string;+ }): string {+ if (metadata.schema) {+ return `${metadata.schema}.${effectiveTableName}`;+ }++ if (metadata.database) {+ return `${metadata.database}.${effectiveTableName}`;+ }++ return effectiveTableName;+ }++ private validateDecoratorsAgainstSequence(): void {+ const entityClasses = this.coreDataSource.entityMetadatas+ .map((metadata) => metadata.target)+ .filter((target): target is Function => typeof target === 'function');++ const problems = validateUpgradeAwareEntityDecorators({+ entityClasses,+ stepNameToIndex: this.stepNameToIndex,+ });++ if (problems.length === 0) {+ return;+ }++ const formatted = formatUpgradeAwareDecoratorReferenceProblems(problems);++ throw new Error(+ `Upgrade-aware entity decorators have problems. ` ++ `Either fix the upgradeCommandName strings, register the missing steps, or reorder the rename history.\n${formatted}`,+ );+ }+}diff --git a/packages/twenty-server/src/engine/twenty-orm/upgrade-aware/upgrade-aware-repository-state.ts b/packages/twenty-server/src/engine/twenty-orm/upgrade-aware/upgrade-aware-repository-state.tsnew file mode 100644index 00000000000..4157f310094--- /dev/null+++ b/packages/twenty-server/src/engine/twenty-orm/upgrade-aware/upgrade-aware-repository-state.ts@@ -0,0 +1,37 @@+import { isDefined } from 'twenty-shared/utils';++import { type UpgradeAwareEntityMetadataAdapter } from 'src/engine/twenty-orm/upgrade-aware/upgrade-aware-entity-metadata.adapter';++export class UpgradeAwareRepositoryState {+ private static singleton: UpgradeAwareRepositoryState | undefined;++ private metadataService: UpgradeAwareEntityMetadataAdapter | undefined;++ static getInstance(): UpgradeAwareRepositoryState {+ if (!isDefined(this.singleton)) {+ this.singleton = new UpgradeAwareRepositoryState();+ }++ return this.singleton;+ }++ setMetadataService(service: UpgradeAwareEntityMetadataAdapter): void {+ this.metadataService = service;+ }++ isEntityAvailable(entityClass: Function): boolean {+ if (!isDefined(this.metadataService)) {+ return true;+ }++ return this.metadataService.isEntityAvailable(entityClass);+ }++ getHiddenColumnPropertyNames(entityClass: Function): ReadonlySet<string> {+ if (!isDefined(this.metadataService)) {+ return new Set();+ }++ return this.metadataService.getHiddenColumnPropertyNames(entityClass);+ }+}diff --git a/packages/twenty-server/src/engine/twenty-orm/upgrade-aware/upgrade-aware-repository.proxy.ts b/packages/twenty-server/src/engine/twenty-orm/upgrade-aware/upgrade-aware-repository.proxy.tsnew file mode 100644index 00000000000..8f0de48bd4f--- /dev/null+++ b/packages/twenty-server/src/engine/twenty-orm/upgrade-aware/upgrade-aware-repository.proxy.ts@@ -0,0 +1,275 @@+import { Logger } from '@nestjs/common';++import { type Repository } from 'typeorm';+import { EntityNotFoundError } from 'typeorm/error/EntityNotFoundError';+import { type EntityMetadata } from 'typeorm/metadata/EntityMetadata';+import { isDefined } from 'twenty-shared/utils';++import { type UpgradeAwareRepositoryState } from 'src/engine/twenty-orm/upgrade-aware/upgrade-aware-repository-state';+import { UpgradeUnavailableEntityWriteException } from 'src/engine/twenty-orm/upgrade-aware/exceptions/upgrade-unavailable-entity-write.exception';++const logger = new Logger('UpgradeAwareRepositoryProxy');++type RepositoryMethodBehavior =+ | {+ kind: 'short-circuit-read';+ produceEmpty: (entityClass: Function) => Promise<unknown>;+ }+ | { kind: 'throw-on-unavailable-write' };++const REPOSITORY_METHOD_BEHAVIORS = new Map<string, RepositoryMethodBehavior>([+ [+ 'find',+ { kind: 'short-circuit-read', produceEmpty: () => Promise.resolve([]) },+ ],+ [+ 'findBy',+ { kind: 'short-circuit-read', produceEmpty: () => Promise.resolve([]) },+ ],+ [+ 'findAndCount',+ {+ kind: 'short-circuit-read',+ produceEmpty: () => Promise.resolve([[], 0]),+ },+ ],+ [+ 'findAndCountBy',+ {+ kind: 'short-circuit-read',+ produceEmpty: () => Promise.resolve([[], 0]),+ },+ ],+ [+ 'findOne',+ { kind: 'short-circuit-read', produceEmpty: () => Promise.resolve(null) },+ ],+ [+ 'findOneBy',+ { kind: 'short-circuit-read', produceEmpty: () => Promise.resolve(null) },+ ],+ [+ 'findOneOrFail',+ {+ kind: 'short-circuit-read',+ produceEmpty: (entityClass) =>+ Promise.reject(new EntityNotFoundError(entityClass, undefined)),+ },+ ],+ [+ 'findOneByOrFail',+ {+ kind: 'short-circuit-read',+ produceEmpty: (entityClass) =>+ Promise.reject(new EntityNotFoundError(entityClass, undefined)),+ },+ ],+ [+ 'count',+ { kind: 'short-circuit-read', produceEmpty: () => Promise.resolve(0) },+ ],+ [+ 'countBy',+ { kind: 'short-circuit-read', produceEmpty: () => Promise.resolve(0) },+ ],+ [+ 'exists',+ { kind: 'short-circuit-read', produceEmpty: () => Promise.resolve(false) },+ ],+ [+ 'existsBy',+ { kind: 'short-circuit-read', produceEmpty: () => Promise.resolve(false) },+ ],+ ['save', { kind: 'throw-on-unavailable-write' }],+ ['insert', { kind: 'throw-on-unavailable-write' }],+ ['update', { kind: 'throw-on-unavailable-write' }],+ ['delete', { kind: 'throw-on-unavailable-write' }],+ ['remove', { kind: 'throw-on-unavailable-write' }],+ ['softRemove', { kind: 'throw-on-unavailable-write' }],+ ['recover', { kind: 'throw-on-unavailable-write' }],+ ['upsert', { kind: 'throw-on-unavailable-write' }],+ ['increment', { kind: 'throw-on-unavailable-write' }],+ ['decrement', { kind: 'throw-on-unavailable-write' }],+ ['restore', { kind: 'throw-on-unavailable-write' }],+ ['softDelete', { kind: 'throw-on-unavailable-write' }],+]);++const METHODS_THAT_ACCEPT_FIND_OPTIONS = new Set<string>([+ 'find',+ 'findBy',+ 'findAndCount',+ 'findAndCountBy',+ 'findOne',+ 'findOneBy',+ 'findOneOrFail',+ 'findOneByOrFail',+ 'count',+ 'countBy',+ 'exists',+ 'existsBy',+]);++const stripUnavailableRelations = (+ metadata: EntityMetadata,+ state: UpgradeAwareRepositoryState,+ options: unknown,+): unknown => {+ if (!isDefined(options) || typeof options !== 'object') {+ return options;+ }++ const withRelations = options as { relations?: unknown };++ if (!isDefined(withRelations.relations)) {+ return options;+ }++ if (Array.isArray(withRelations.relations)) {+ const filtered = (withRelations.relations as string[]).filter((name) =>+ isRelationAvailable(metadata, state, name),+ );++ if (filtered.length === withRelations.relations.length) {+ return options;+ }++ return { ...withRelations, relations: filtered };+ }++ if (typeof withRelations.relations === 'object') {+ const filtered: Record<string, unknown> = {};++ for (const [name, value] of Object.entries(+ withRelations.relations as Record<string, unknown>,+ )) {+ if (isRelationAvailable(metadata, state, name)) {+ filtered[name] = value;+ }+ }++ return { ...withRelations, relations: filtered };+ }++ return options;+};++const isRelationAvailable = (+ metadata: EntityMetadata,+ state: UpgradeAwareRepositoryState,+ relationPropertyName: string,+): boolean => {+ const relation = metadata.relations.find(+ (candidate) => candidate.propertyName === relationPropertyName,+ );++ if (!isDefined(relation)) {+ return true;+ }++ const relatedTarget = relation.inverseEntityMetadata?.target;++ if (typeof relatedTarget !== 'function') {+ return true;+ }++ const available = state.isEntityAvailable(relatedTarget);++ if (!available) {+ logger.log(+ `[upgrade-proxy] strip relation ${metadata.targetName}.${relationPropertyName} -> ${relatedTarget.name}`,+ );+ }++ return available;+};++const isClassConstructor = (fn: Function): boolean =>+ typeof fn.prototype === 'object' &&+ fn.prototype !== null &&+ fn.prototype.constructor === fn &&+ fn.toString().startsWith('class ');++export const wrapRepositoryWithUpgradeAwareProxy = <Entity extends object>({+ repository,+ entityClass,+ state,+}: {+ repository: Repository<Entity>;+ entityClass: Function;+ state: UpgradeAwareRepositoryState;+}): Repository<Entity> =>+ new Proxy(repository, {+ get(target, prop, receiver) {+ const methodName = typeof prop === 'string' ? prop : undefined;+ const behavior = isDefined(methodName)+ ? REPOSITORY_METHOD_BEHAVIORS.get(methodName)+ : undefined;++ if (isDefined(methodName) && isDefined(behavior)) {+ return (...args: unknown[]) =>+ handleRepositoryMethodCall({+ target,+ methodName,+ entityClass,+ state,+ behavior,+ args,+ });+ }++ const value = Reflect.get(target, prop, receiver);++ if (typeof value === 'function' && !isClassConstructor(value)) {+ return value.bind(target);+ }++ return value;+ },+ });++const handleRepositoryMethodCall = <Entity extends object>({+ target,+ methodName,+ entityClass,+ state,+ behavior,+ args,+}: {+ target: Repository<Entity>;+ methodName: string;+ entityClass: Function;+ state: UpgradeAwareRepositoryState;+ behavior: RepositoryMethodBehavior;+ args: unknown[];+}): unknown => {+ if (!state.isEntityAvailable(entityClass)) {+ if (behavior.kind === 'throw-on-unavailable-write') {+ return Promise.reject(+ new UpgradeUnavailableEntityWriteException(+ entityClass.name,+ methodName,+ ),+ );+ }++ logger.log(+ `[upgrade-proxy] short-circuit ${entityClass.name}.${methodName}`,+ );++ return behavior.produceEmpty(entityClass);+ }++ const rewrittenArgs =+ METHODS_THAT_ACCEPT_FIND_OPTIONS.has(methodName) && args.length > 0+ ? [+ stripUnavailableRelations(target.metadata, state, args[0]),+ ...args.slice(1),+ ]+ : args;++ return (+ target[methodName as keyof Repository<Entity>] as unknown as (+ ...callArgs: unknown[]+ ) => unknown+ ).apply(target, rewrittenArgs);+};diff --git a/packages/twenty-server/test/integration/upgrade/utils/upgrade-sequence-runner-integration-test.util.ts b/packages/twenty-server/test/integration/upgrade/utils/upgrade-sequence-runner-integration-test.util.tsindex 947ce71895b..1da628878e7 100644--- a/packages/twenty-server/test/integration/upgrade/utils/upgrade-sequence-runner-integration-test.util.ts+++ b/packages/twenty-server/test/integration/upgrade/utils/upgrade-sequence-runner-integration-test.util.ts@@ -14,6 +14,7 @@ import {type WorkspaceUpgradeStep,} from 'src/engine/core-modules/upgrade/services/upgrade-sequence-reader.service';import { UpgradeSequenceRunnerService } from 'src/engine/core-modules/upgrade/services/upgrade-sequence-runner.service';+import { UpgradeAwareEntityMetadataAdapter } from 'src/engine/twenty-orm/upgrade-aware/upgrade-aware-entity-metadata.adapter';import { UpgradeStatusService } from 'src/engine/core-modules/upgrade/services/upgrade-status.service';import { WorkspaceCommandRunnerService } from 'src/engine/core-modules/upgrade/services/workspace-command-runner.service';import { UpgradeMigrationEntity } from 'src/engine/core-modules/upgrade/upgrade-migration.entity';@@ -178,6 +179,14 @@ export const createUpgradeSequenceRunnerIntegrationTestModule = async () => {}),},},+ {+ provide: UpgradeAwareEntityMetadataAdapter,+ useValue: {+ refresh: jest.fn().mockResolvedValue(undefined),+ isEntityAvailable: jest.fn().mockReturnValue(true),+ getHiddenColumnPropertyNames: jest.fn().mockReturnValue(new Set()),+ },+ },UpgradeSequenceRunnerService,],}).compile();