The open alternative to Salesforce, designed for AI.
TypeScript crmcrm-systemcustomergood-first-issuegraphqlhacktoberfestjavascriptmarketingmonoreponestjsopen-sourcepostgresqlreactreactjssalestypescriptweb
Repair stale timeline activity target metadata (#24726)
Félix Malfaitd4ba07fec165
diff --git a/packages/twenty-server/src/database/commands/upgrade-version-command/2-35/2-35-upgrade-version-command.module.ts b/packages/twenty-server/src/database/commands/upgrade-version-command/2-35/2-35-upgrade-version-command.module.tsindex 10da9c5d0d7..a33a9568d29 100644--- a/packages/twenty-server/src/database/commands/upgrade-version-command/2-35/2-35-upgrade-version-command.module.ts+++ b/packages/twenty-server/src/database/commands/upgrade-version-command/2-35/2-35-upgrade-version-command.module.ts@@ -4,6 +4,7 @@ import { WorkspaceIteratorModule } from 'src/database/commands/command-runners/wimport { RepairAttachmentTimelineActivityTypesCommand } from 'src/database/commands/upgrade-version-command/2-35/2-35-workspace-command-1787561579075-repair-attachment-timeline-activity-types.command';import { BackfillCommandMenuItemTargetObjectMetadataCommand } from 'src/database/commands/upgrade-version-command/2-35/2-35-workspace-command-1787572700000-backfill-command-menu-item-target-object-metadata.command';import { RestoreStandardDefaultRelationFieldsCommand } from 'src/database/commands/upgrade-version-command/2-35/2-35-workspace-command-1787582101000-restore-standard-default-relation-fields.command';+import { RepairTimelineActivityTargetFieldNamesCommand } from 'src/database/commands/upgrade-version-command/2-35/2-35-workspace-command-1787641226000-repair-timeline-activity-target-field-names.command';import { ApplicationModule } from 'src/engine/core-modules/application/application.module';import { WorkspaceCacheModule } from 'src/engine/workspace-cache/workspace-cache.module';import { WorkspaceMigrationRunnerModule } from 'src/engine/workspace-manager/workspace-migration/workspace-migration-runner/workspace-migration-runner.module';@@ -21,6 +22,7 @@ import { WorkspaceMigrationModule } from 'src/engine/workspace-manager/workspaceRepairAttachmentTimelineActivityTypesCommand,BackfillCommandMenuItemTargetObjectMetadataCommand,RestoreStandardDefaultRelationFieldsCommand,+ RepairTimelineActivityTargetFieldNamesCommand,],})export class V2_35_UpgradeVersionCommandModule {}diff --git a/packages/twenty-server/src/database/commands/upgrade-version-command/2-35/2-35-workspace-command-1787641226000-repair-timeline-activity-target-field-names.command.ts b/packages/twenty-server/src/database/commands/upgrade-version-command/2-35/2-35-workspace-command-1787641226000-repair-timeline-activity-target-field-names.command.tsnew file mode 100644index 00000000000..1e7757b853b--- /dev/null+++ b/packages/twenty-server/src/database/commands/upgrade-version-command/2-35/2-35-workspace-command-1787641226000-repair-timeline-activity-target-field-names.command.ts@@ -0,0 +1,158 @@+import { Command } from 'nest-commander';+import { STANDARD_OBJECTS } from 'twenty-shared/metadata';+import { isDefined } from 'twenty-shared/utils';+import { type DataSource } from 'typeorm';++import { ProvisionedWorkspaceCommandRunner } from 'src/database/commands/command-runners/provisioned-workspace.command-runner';+import { WorkspaceIteratorService } from 'src/database/commands/command-runners/workspace-iterator.service';+import { type RunOnWorkspaceArgs } from 'src/database/commands/command-runners/workspace.command-runner';+import { buildTimelineActivityTargetFieldRepairs } from 'src/database/commands/upgrade-version-command/2-35/utils/build-timeline-activity-target-field-repairs.util';+import { RegisteredWorkspaceCommand } from 'src/engine/core-modules/upgrade/decorators/registered-workspace-command.decorator';+import { findFlatEntityByUniversalIdentifier } from 'src/engine/metadata-modules/flat-entity/utils/find-flat-entity-by-universal-identifier.util';+import { type FlatObjectMetadata } from 'src/engine/metadata-modules/flat-object-metadata/types/flat-object-metadata.type';+import { WorkspaceCacheService } from 'src/engine/workspace-cache/services/workspace-cache.service';+import { getWorkspaceSchemaContextForMigration } from 'src/engine/workspace-manager/workspace-migration/workspace-migration-runner/utils/get-workspace-schema-context-for-migration.util';+import { WorkspaceMigrationValidateBuildAndRunService } from 'src/engine/workspace-manager/workspace-migration/services/workspace-migration-validate-build-and-run-service';++@RegisteredWorkspaceCommand('2.35.0', 1787641226000)+@Command({+ name: 'upgrade:2-35:repair-timeline-activity-target-field-names',+ description:+ 'Repair timeline activity target morph field names left stale by object renames',+})+export class RepairTimelineActivityTargetFieldNamesCommand extends ProvisionedWorkspaceCommandRunner {+ constructor(+ protected readonly workspaceIteratorService: WorkspaceIteratorService,+ private readonly workspaceCacheService: WorkspaceCacheService,+ private readonly workspaceMigrationValidateBuildAndRunService: WorkspaceMigrationValidateBuildAndRunService,+ ) {+ super(workspaceIteratorService);+ }++ override async runOnWorkspace({+ workspaceId,+ dataSource,+ options,+ }: RunOnWorkspaceArgs): Promise<void> {+ const { flatObjectMetadataMaps, flatFieldMetadataMaps, flatIndexMaps } =+ await this.workspaceCacheService.getOrRecompute(workspaceId, [+ 'flatObjectMetadataMaps',+ 'flatFieldMetadataMaps',+ 'flatIndexMaps',+ ]);++ const timelineActivityFlatObjectMetadata =+ findFlatEntityByUniversalIdentifier<FlatObjectMetadata>({+ flatEntityMaps: flatObjectMetadataMaps,+ universalIdentifier:+ STANDARD_OBJECTS.timelineActivity.universalIdentifier,+ });++ if (!isDefined(timelineActivityFlatObjectMetadata)) {+ return;+ }++ if (!isDefined(dataSource)) {+ this.logger.error(+ `Cannot verify timeline activity target columns for workspace ${workspaceId}: no data source. Skipping, rerun once the workspace is reachable.`,+ );++ return;+ }++ const existingColumnNames = await this.readExistingColumnNames({+ dataSource,+ workspaceId,+ timelineActivityFlatObjectMetadata,+ });++ const {+ flatFieldMetadatasToUpdate,+ flatIndexMetadatasToUpdate,+ unrepairableTargetFields,+ } = buildTimelineActivityTargetFieldRepairs({+ flatObjectMetadataMaps,+ flatFieldMetadataMaps,+ flatIndexMaps,+ existingColumnNames,+ });++ if (unrepairableTargetFields.length > 0) {+ // Left as an error rather than a throw: a thrown workspace step aborts the+ // whole instance upgrade sequence, and this drift predates the command.+ this.logger.error(+ [+ `MANUAL REPAIR REQUIRED: ${unrepairableTargetFields.length} timeline activity target field(s) in workspace ${workspaceId} cannot be repaired automatically.`,+ ...unrepairableTargetFields.map(+ ({ fieldName, expectedName, reason }) =>+ ` - ${fieldName} -> ${expectedName}: ${reason}`,+ ),+ ].join('\n'),+ );+ }++ if (flatFieldMetadatasToUpdate.length === 0) {+ return;+ }++ if (options.dryRun ?? false) {+ this.logger.log(+ `[DRY RUN] Would repair ${flatFieldMetadatasToUpdate.length} timeline activity target field(s) and ${flatIndexMetadatasToUpdate.length} index(es) for workspace ${workspaceId}`,+ );++ return;+ }++ const result =+ await this.workspaceMigrationValidateBuildAndRunService.validateBuildAndRunLegacyWorkspaceMigration(+ {+ isSystemBuild: true,+ workspaceId,+ applicationUniversalIdentifier:+ timelineActivityFlatObjectMetadata.applicationUniversalIdentifier,+ allFlatEntityOperationByMetadataName: {+ fieldMetadata: {+ flatEntityToCreate: [],+ flatEntityToDelete: [],+ flatEntityToUpdate: flatFieldMetadatasToUpdate,+ },+ index: {+ flatEntityToCreate: [],+ flatEntityToDelete: [],+ flatEntityToUpdate: flatIndexMetadatasToUpdate,+ },+ },+ },+ );++ if (result.status === 'fail') {+ throw new Error(+ `Failed to repair timeline activity target fields for workspace ${workspaceId}:\n${JSON.stringify(result, null, 2)}`,+ );+ }+ }++ private async readExistingColumnNames({+ dataSource,+ workspaceId,+ timelineActivityFlatObjectMetadata,+ }: {+ dataSource: DataSource;+ workspaceId: string;+ timelineActivityFlatObjectMetadata: Parameters<+ typeof getWorkspaceSchemaContextForMigration+ >[0]['objectMetadata'];+ }): Promise<Set<string>> {+ const { schemaName, tableName } = getWorkspaceSchemaContextForMigration({+ workspaceId,+ objectMetadata: timelineActivityFlatObjectMetadata,+ });++ const rows = await dataSource.query<{ column_name: string }[]>(+ `SELECT column_name FROM information_schema.columns WHERE table_schema = $1 AND table_name = $2`,+ [schemaName, tableName],+ );++ return new Set(rows.map(({ column_name }) => column_name));+ }+}diff --git a/packages/twenty-server/src/database/commands/upgrade-version-command/2-35/__tests__/2-35-workspace-command-1787641226000-repair-timeline-activity-target-field-names.command.spec.ts b/packages/twenty-server/src/database/commands/upgrade-version-command/2-35/__tests__/2-35-workspace-command-1787641226000-repair-timeline-activity-target-field-names.command.spec.tsnew file mode 100644index 00000000000..3b9714bc5ff--- /dev/null+++ b/packages/twenty-server/src/database/commands/upgrade-version-command/2-35/__tests__/2-35-workspace-command-1787641226000-repair-timeline-activity-target-field-names.command.spec.ts@@ -0,0 +1,255 @@+import { STANDARD_OBJECTS } from 'twenty-shared/metadata';+import { FieldMetadataType, RelationType } from 'twenty-shared/types';+import { type DataSource } from 'typeorm';++import { type WorkspaceIteratorService } from 'src/database/commands/command-runners/workspace-iterator.service';+import { RepairTimelineActivityTargetFieldNamesCommand } from 'src/database/commands/upgrade-version-command/2-35/2-35-workspace-command-1787641226000-repair-timeline-activity-target-field-names.command';+import { type WorkspaceCacheService } from 'src/engine/workspace-cache/services/workspace-cache.service';+import { type WorkspaceMigrationValidateBuildAndRunService } from 'src/engine/workspace-manager/workspace-migration/services/workspace-migration-validate-build-and-run-service';++const WORKSPACE_ID = '00000000-0000-4000-8000-000000000001';+const TIMELINE_ACTIVITY_OBJECT_ID = '00000000-0000-4000-8000-000000000002';+const TARGET_OBJECT_ID = '00000000-0000-4000-8000-000000000003';+const TARGET_FIELD_ID = '00000000-0000-4000-8000-000000000005';+const TARGET_FIELD_UNIVERSAL_IDENTIFIER =+ '00000000-0000-4000-8000-000000000006';+const APPLICATION_UNIVERSAL_IDENTIFIER = '00000000-0000-4000-8000-000000000007';+const TARGET_INDEX_ID = '00000000-0000-4000-8000-000000000008';+const TARGET_INDEX_UNIVERSAL_IDENTIFIER =+ '00000000-0000-4000-8000-000000000009';+const TARGET_OBJECT_UNIVERSAL_IDENTIFIER =+ '00000000-0000-4000-8000-000000000004';++const buildCommand = ({+ targetFieldName = 'targetPhoneNumber',+ columnNames = ['targetPhoneNumberId'],+ migrationResult = { status: 'success' },+}: {+ targetFieldName?: string;+ columnNames?: string[];+ migrationResult?: { status: 'success' | 'fail' };+} = {}) => {+ const validateBuildAndRunLegacyWorkspaceMigration = jest+ .fn()+ .mockResolvedValue(migrationResult);+ const command = new RepairTimelineActivityTargetFieldNamesCommand(+ {} as WorkspaceIteratorService,+ {+ getOrRecompute: jest.fn().mockResolvedValue({+ flatObjectMetadataMaps: {+ byUniversalIdentifier: {+ [STANDARD_OBJECTS.timelineActivity.universalIdentifier]: {+ id: TIMELINE_ACTIVITY_OBJECT_ID,+ universalIdentifier:+ STANDARD_OBJECTS.timelineActivity.universalIdentifier,+ applicationUniversalIdentifier: APPLICATION_UNIVERSAL_IDENTIFIER,+ nameSingular: 'timelineActivity',+ namePlural: 'timelineActivities',+ isCustom: false,+ fieldIds: [TARGET_FIELD_ID],+ indexMetadataIds: [TARGET_INDEX_ID],+ },+ [TARGET_OBJECT_UNIVERSAL_IDENTIFIER]: {+ id: TARGET_OBJECT_ID,+ universalIdentifier: TARGET_OBJECT_UNIVERSAL_IDENTIFIER,+ nameSingular: 'phoneNumber2',+ },+ },+ universalIdentifierById: {+ [TIMELINE_ACTIVITY_OBJECT_ID]:+ STANDARD_OBJECTS.timelineActivity.universalIdentifier,+ [TARGET_OBJECT_ID]: TARGET_OBJECT_UNIVERSAL_IDENTIFIER,+ },+ universalIdentifiersByApplicationId: {},+ },+ flatFieldMetadataMaps: {+ byUniversalIdentifier: {+ [TARGET_FIELD_UNIVERSAL_IDENTIFIER]: {+ id: TARGET_FIELD_ID,+ universalIdentifier: TARGET_FIELD_UNIVERSAL_IDENTIFIER,+ applicationUniversalIdentifier: APPLICATION_UNIVERSAL_IDENTIFIER,+ objectMetadataId: TIMELINE_ACTIVITY_OBJECT_ID,+ relationTargetObjectMetadataId: TARGET_OBJECT_ID,+ type: FieldMetadataType.MORPH_RELATION,+ morphId:+ STANDARD_OBJECTS.timelineActivity.morphIds.targetMorphId+ .morphId,+ name: targetFieldName,+ label: 'PhoneNumber',+ isUnique: false,+ isSystemSideEffect: true,+ universalSettings: {+ relationType: RelationType.MANY_TO_ONE,+ joinColumnName: `${targetFieldName}Id`,+ },+ },+ },+ universalIdentifierById: {+ [TARGET_FIELD_ID]: TARGET_FIELD_UNIVERSAL_IDENTIFIER,+ },+ universalIdentifiersByApplicationId: {},+ },+ flatIndexMaps: {+ byUniversalIdentifier: {+ [TARGET_INDEX_UNIVERSAL_IDENTIFIER]: {+ id: TARGET_INDEX_ID,+ universalIdentifier: TARGET_INDEX_UNIVERSAL_IDENTIFIER,+ applicationUniversalIdentifier: APPLICATION_UNIVERSAL_IDENTIFIER,+ objectMetadataId: TIMELINE_ACTIVITY_OBJECT_ID,+ name: 'IDX_STALE_TARGET_PHONE_NUMBER_ID',+ isUnique: false,+ indexWhereClause: null,+ flatIndexFieldMetadatas: [+ {+ fieldMetadataId: TARGET_FIELD_ID,+ order: 0,+ subFieldName: null,+ },+ ],+ universalFlatIndexFieldMetadatas: [+ {+ fieldMetadataUniversalIdentifier:+ TARGET_FIELD_UNIVERSAL_IDENTIFIER,+ order: 0,+ subFieldName: null,+ },+ ],+ },+ },+ universalIdentifierById: {+ [TARGET_INDEX_ID]: TARGET_INDEX_UNIVERSAL_IDENTIFIER,+ },+ universalIdentifiersByApplicationId: {},+ },+ }),+ } as unknown as WorkspaceCacheService,+ {+ validateBuildAndRunLegacyWorkspaceMigration,+ } as unknown as WorkspaceMigrationValidateBuildAndRunService,+ );++ const dataSource = {+ query: jest+ .fn()+ .mockResolvedValue(columnNames.map((name) => ({ column_name: name }))),+ } as unknown as DataSource;++ return { command, dataSource, validateBuildAndRunLegacyWorkspaceMigration };+};++const runCommand = (+ {+ command,+ dataSource,+ }: Pick<ReturnType<typeof buildCommand>, 'command' | 'dataSource'>,+ { dryRun = false, withDataSource = true } = {},+) =>+ command.runOnWorkspace({+ workspaceId: WORKSPACE_ID,+ dataSource: withDataSource ? dataSource : undefined,+ options: { dryRun },+ index: 0,+ total: 1,+ });++describe('RepairTimelineActivityTargetFieldNamesCommand', () => {+ it('submits the renamed field and its recomputed index in one migration', async () => {+ const context = buildCommand();++ await runCommand(context);++ expect(+ context.validateBuildAndRunLegacyWorkspaceMigration,+ ).toHaveBeenCalledWith(+ expect.objectContaining({+ isSystemBuild: true,+ workspaceId: WORKSPACE_ID,+ applicationUniversalIdentifier: APPLICATION_UNIVERSAL_IDENTIFIER,+ allFlatEntityOperationByMetadataName: {+ fieldMetadata: {+ flatEntityToCreate: [],+ flatEntityToDelete: [],+ flatEntityToUpdate: [+ expect.objectContaining({+ universalIdentifier: TARGET_FIELD_UNIVERSAL_IDENTIFIER,+ name: 'targetPhoneNumber2',+ label: 'PhoneNumber2',+ universalSettings: expect.objectContaining({+ joinColumnName: 'targetPhoneNumber2Id',+ }),+ }),+ ],+ },+ index: {+ flatEntityToCreate: [],+ flatEntityToDelete: [],+ flatEntityToUpdate: [+ expect.objectContaining({+ universalIdentifier: TARGET_INDEX_UNIVERSAL_IDENTIFIER,+ }),+ ],+ },+ },+ }),+ );+ });++ it('does nothing when the target field already matches the object name', async () => {+ const context = buildCommand({+ targetFieldName: 'targetPhoneNumber2',+ columnNames: ['targetPhoneNumber2Id'],+ });++ await runCommand(context);++ expect(+ context.validateBuildAndRunLegacyWorkspaceMigration,+ ).not.toHaveBeenCalled();+ });++ it('reports manual repair and runs no migration when the column was already renamed', async () => {+ const context = buildCommand({ columnNames: ['targetPhoneNumber2Id'] });+ const errorSpy = jest.spyOn(context.command['logger'], 'error');++ await runCommand(context);++ expect(errorSpy).toHaveBeenCalledWith(+ expect.stringContaining('MANUAL REPAIR REQUIRED'),+ );+ expect(+ context.validateBuildAndRunLegacyWorkspaceMigration,+ ).not.toHaveBeenCalled();+ });++ it('skips the workspace when no data source is available to verify columns', async () => {+ const context = buildCommand();+ const errorSpy = jest.spyOn(context.command['logger'], 'error');++ await runCommand(context, { withDataSource: false });++ expect(errorSpy).toHaveBeenCalledWith(+ expect.stringContaining('no data source'),+ );+ expect(+ context.validateBuildAndRunLegacyWorkspaceMigration,+ ).not.toHaveBeenCalled();+ });++ it('does not mutate metadata during a dry run', async () => {+ const context = buildCommand();++ await runCommand(context, { dryRun: true });++ expect(+ context.validateBuildAndRunLegacyWorkspaceMigration,+ ).not.toHaveBeenCalled();+ });++ it('fails when the workspace migration is rejected', async () => {+ const context = buildCommand({ migrationResult: { status: 'fail' } });++ await expect(runCommand(context)).rejects.toThrow(+ 'Failed to repair timeline activity target fields',+ );+ });+});diff --git a/packages/twenty-server/src/database/commands/upgrade-version-command/2-35/utils/__tests__/build-timeline-activity-target-field-repairs.util.spec.ts b/packages/twenty-server/src/database/commands/upgrade-version-command/2-35/utils/__tests__/build-timeline-activity-target-field-repairs.util.spec.tsnew file mode 100644index 00000000000..0f708266ff4--- /dev/null+++ b/packages/twenty-server/src/database/commands/upgrade-version-command/2-35/utils/__tests__/build-timeline-activity-target-field-repairs.util.spec.ts@@ -0,0 +1,366 @@+import { STANDARD_OBJECTS } from 'twenty-shared/metadata';+import { FieldMetadataType, RelationType } from 'twenty-shared/types';++import { buildTimelineActivityTargetFieldRepairs } from 'src/database/commands/upgrade-version-command/2-35/utils/build-timeline-activity-target-field-repairs.util';+import { type AllFlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/types/all-flat-entity-maps.type';++const TIMELINE_ACTIVITY_OBJECT_ID = 'timeline-activity-object-id';+const TARGET_MORPH_ID =+ STANDARD_OBJECTS.timelineActivity.morphIds.targetMorphId.morphId;++type FieldSpecification = {+ name: string;+ targetObjectKey: string;+ label?: string;+ isSystemSideEffect?: boolean;+ morphId?: string;+ relationType?: RelationType;+};++type BuildArgs = {+ targetObjectNameSingularByKey: Record<string, string>;+ fields: FieldSpecification[];+ indexedFieldNamesByIndexKey?: Record<string, string[]>;+ orphanedIndexIds?: string[];+ columnNames?: string[];+};++const buildArgs = ({+ targetObjectNameSingularByKey,+ fields,+ indexedFieldNamesByIndexKey = {},+ orphanedIndexIds = [],+ columnNames,+}: BuildArgs) => {+ const indexKeys = Object.keys(indexedFieldNamesByIndexKey);+ const entries = <TValue>(record: Record<string, TValue>) =>+ Object.entries(record);++ return {+ existingColumnNames: new Set(+ columnNames ?? fields.map(({ name }) => `${name}Id`),+ ),+ flatObjectMetadataMaps: {+ byUniversalIdentifier: {+ [STANDARD_OBJECTS.timelineActivity.universalIdentifier]: {+ id: TIMELINE_ACTIVITY_OBJECT_ID,+ universalIdentifier:+ STANDARD_OBJECTS.timelineActivity.universalIdentifier,+ applicationUniversalIdentifier: 'app-uid',+ nameSingular: 'timelineActivity',+ namePlural: 'timelineActivities',+ isCustom: false,+ fieldIds: fields.map(({ name }) => `field-${name}`),+ indexMetadataIds: [+ ...indexKeys.map((key) => `index-${key}`),+ ...orphanedIndexIds,+ ],+ },+ ...Object.fromEntries(+ entries(targetObjectNameSingularByKey).map(([key, nameSingular]) => [+ `object-uid-${key}`,+ {+ id: `object-${key}`,+ universalIdentifier: `object-uid-${key}`,+ nameSingular,+ },+ ]),+ ),+ },+ universalIdentifierById: {+ [TIMELINE_ACTIVITY_OBJECT_ID]:+ STANDARD_OBJECTS.timelineActivity.universalIdentifier,+ ...Object.fromEntries(+ Object.keys(targetObjectNameSingularByKey).map((key) => [+ `object-${key}`,+ `object-uid-${key}`,+ ]),+ ),+ },+ universalIdentifiersByApplicationId: {},+ },+ flatFieldMetadataMaps: {+ byUniversalIdentifier: Object.fromEntries(+ fields.map((field) => [+ `field-uid-${field.name}`,+ {+ id: `field-${field.name}`,+ universalIdentifier: `field-uid-${field.name}`,+ applicationUniversalIdentifier: 'app-uid',+ objectMetadataId: TIMELINE_ACTIVITY_OBJECT_ID,+ relationTargetObjectMetadataId: `object-${field.targetObjectKey}`,+ type: FieldMetadataType.MORPH_RELATION,+ morphId: field.morphId ?? TARGET_MORPH_ID,+ name: field.name,+ label: field.label ?? 'Stale label',+ isUnique: false,+ isSystemSideEffect: field.isSystemSideEffect ?? true,+ universalSettings: {+ relationType: field.relationType ?? RelationType.MANY_TO_ONE,+ joinColumnName: `${field.name}Id`,+ },+ },+ ]),+ ),+ universalIdentifierById: Object.fromEntries(+ fields.map(({ name }) => [`field-${name}`, `field-uid-${name}`]),+ ),+ universalIdentifiersByApplicationId: {},+ },+ flatIndexMaps: {+ byUniversalIdentifier: Object.fromEntries(+ entries(indexedFieldNamesByIndexKey).map(([key, fieldNames]) => [+ `index-uid-${key}`,+ {+ id: `index-${key}`,+ universalIdentifier: `index-uid-${key}`,+ applicationUniversalIdentifier: 'app-uid',+ objectMetadataId: TIMELINE_ACTIVITY_OBJECT_ID,+ name: `IDX_STALE_${key}`,+ isUnique: false,+ indexWhereClause: null,+ flatIndexFieldMetadatas: fieldNames.map((name, order) => ({+ fieldMetadataId: `field-${name}`,+ order,+ subFieldName: null,+ })),+ universalFlatIndexFieldMetadatas: fieldNames.map((name, order) => ({+ fieldMetadataUniversalIdentifier: `field-uid-${name}`,+ order,+ subFieldName: null,+ })),+ },+ ]),+ ),+ universalIdentifierById: Object.fromEntries(+ indexKeys.map((key) => [`index-${key}`, `index-uid-${key}`]),+ ),+ universalIdentifiersByApplicationId: {},+ },+ } as unknown as Parameters<+ typeof buildTimelineActivityTargetFieldRepairs+ >[0] &+ Pick<AllFlatEntityMaps, 'flatObjectMetadataMaps'>;+};++const staleField = {+ targetObjectNameSingularByKey: { phoneNumber: 'phoneNumber2' },+ fields: [{ name: 'targetPhoneNumber', targetObjectKey: 'phoneNumber' }],+};++// A chain: targetContact wants the name targetPhoneNumber is about to vacate.+const renameChain: BuildArgs = {+ targetObjectNameSingularByKey: {+ phoneNumber: 'phoneNumber2',+ contact: 'phoneNumber',+ },+ fields: [+ { name: 'targetPhoneNumber', targetObjectKey: 'phoneNumber' },+ { name: 'targetContact', targetObjectKey: 'contact' },+ ],+};++describe('buildTimelineActivityTargetFieldRepairs', () => {+ it('renames a stale field, its join column and its system label', () => {+ const { flatFieldMetadatasToUpdate, unrepairableTargetFields } =+ buildTimelineActivityTargetFieldRepairs(+ buildArgs({+ ...staleField,+ fields: [{ ...staleField.fields[0], label: 'PhoneNumber' }],+ }),+ );++ expect(unrepairableTargetFields).toEqual([]);+ expect(flatFieldMetadatasToUpdate).toHaveLength(1);+ expect(flatFieldMetadatasToUpdate[0]).toEqual(+ expect.objectContaining({+ name: 'targetPhoneNumber2',+ label: 'PhoneNumber2',+ universalSettings: expect.objectContaining({+ joinColumnName: 'targetPhoneNumber2Id',+ }),+ }),+ );+ });++ it('leaves a curated label untouched when the field is not a system side effect', () => {+ const { flatFieldMetadatasToUpdate } =+ buildTimelineActivityTargetFieldRepairs(+ buildArgs({+ ...staleField,+ fields: [+ {+ ...staleField.fields[0],+ label: 'Curated',+ isSystemSideEffect: false,+ },+ ],+ }),+ );++ expect(flatFieldMetadatasToUpdate[0].label).toBe('Curated');+ });++ it('does nothing when every target field already matches its object name', () => {+ const result = buildTimelineActivityTargetFieldRepairs(+ buildArgs({+ targetObjectNameSingularByKey: { phoneNumber: 'phoneNumber2' },+ fields: [+ { name: 'targetPhoneNumber2', targetObjectKey: 'phoneNumber' },+ ],+ }),+ );++ expect(result.flatFieldMetadatasToUpdate).toEqual([]);+ expect(result.unrepairableTargetFields).toEqual([]);+ });++ it('treats a rename chain identically whatever order the fields arrive in', () => {+ const summarise = (args: BuildArgs) => {+ const { flatFieldMetadatasToUpdate, unrepairableTargetFields } =+ buildTimelineActivityTargetFieldRepairs(buildArgs(args));++ return {+ renamed: flatFieldMetadatasToUpdate.map(({ name }) => name).sort(),+ blocked: unrepairableTargetFields.map(({ fieldName }) => fieldName),+ };+ };++ const forwardOrder = summarise(renameChain);+ const reversedOrder = summarise({+ ...renameChain,+ fields: [...renameChain.fields].reverse(),+ });++ expect(forwardOrder).toEqual(reversedOrder);+ // The chain cannot be applied at all: targetContact wants a name whose+ // column targetPhoneNumber is still occupying when the batch is planned.+ expect(forwardOrder.renamed).toEqual(['targetPhoneNumber2']);+ expect(forwardOrder.blocked).toEqual(['targetContact']);+ });++ it('reports a rename blocked by a field it will never rename', () => {+ const { flatFieldMetadatasToUpdate, unrepairableTargetFields } =+ buildTimelineActivityTargetFieldRepairs(+ buildArgs({+ targetObjectNameSingularByKey: {+ renamed: 'person',+ person: 'person',+ },+ fields: [+ { name: 'targetContact', targetObjectKey: 'renamed' },+ { name: 'targetPerson', targetObjectKey: 'person' },+ ],+ columnNames: ['targetContactId'],+ }),+ );++ expect(flatFieldMetadatasToUpdate).toEqual([]);+ expect(unrepairableTargetFields).toEqual([+ expect.objectContaining({+ fieldName: 'targetContact',+ expectedName: 'targetPerson',+ reason: expect.stringContaining('held by another field'),+ }),+ ]);+ });++ it('recomputes an index covering two repaired fields once, from the final names', () => {+ const { flatIndexMetadatasToUpdate } =+ buildTimelineActivityTargetFieldRepairs(+ buildArgs({+ targetObjectNameSingularByKey: { a: 'alpha2', b: 'beta2' },+ fields: [+ { name: 'targetAlpha', targetObjectKey: 'a' },+ { name: 'targetBeta', targetObjectKey: 'b' },+ ],+ indexedFieldNamesByIndexKey: {+ shared: ['targetAlpha', 'targetBeta'],+ },+ }),+ );++ expect(flatIndexMetadatasToUpdate).toHaveLength(1);+ expect(flatIndexMetadatasToUpdate[0].universalIdentifier).toBe(+ 'index-uid-shared',+ );+ expect(flatIndexMetadatasToUpdate[0].name).not.toBe('IDX_STALE_shared');+ });++ it('reports orphaned index metadata instead of attempting a partial repair', () => {+ const result = buildTimelineActivityTargetFieldRepairs(+ buildArgs({+ ...staleField,+ orphanedIndexIds: ['missing-index-id'],+ }),+ );++ expect(result.flatFieldMetadatasToUpdate).toEqual([]);+ expect(result.flatIndexMetadatasToUpdate).toEqual([]);+ expect(result.unrepairableTargetFields).toEqual([+ expect.objectContaining({+ fieldName: 'targetPhoneNumber',+ expectedName: 'targetPhoneNumber2',+ reason: expect.stringContaining('missing-index-id'),+ }),+ ]);+ });++ it('refuses to repair when the expected column already exists', () => {+ const { flatFieldMetadatasToUpdate, unrepairableTargetFields } =+ buildTimelineActivityTargetFieldRepairs(+ buildArgs({ ...staleField, columnNames: ['targetPhoneNumber2Id'] }),+ );++ expect(flatFieldMetadatasToUpdate).toEqual([]);+ expect(unrepairableTargetFields[0].reason).toContain(+ 'already exists while metadata still names it',+ );+ });++ it('refuses to repair when both columns exist', () => {+ const { unrepairableTargetFields } =+ buildTimelineActivityTargetFieldRepairs(+ buildArgs({+ ...staleField,+ columnNames: ['targetPhoneNumberId', 'targetPhoneNumber2Id'],+ }),+ );++ expect(unrepairableTargetFields[0].reason).toContain('both exist');+ });++ it('refuses to repair when neither column exists', () => {+ const { unrepairableTargetFields } =+ buildTimelineActivityTargetFieldRepairs(+ buildArgs({ ...staleField, columnNames: [] }),+ );++ expect(unrepairableTargetFields[0].reason).toContain('neither column');+ });++ it('ignores morph fields outside the timeline target morph', () => {+ const result = buildTimelineActivityTargetFieldRepairs(+ buildArgs({+ ...staleField,+ fields: [{ ...staleField.fields[0], morphId: 'another-morph-id' }],+ }),+ );++ expect(result.flatFieldMetadatasToUpdate).toEqual([]);+ expect(result.unrepairableTargetFields).toEqual([]);+ });++ it('ignores the one to many leg of the morph relation', () => {+ const result = buildTimelineActivityTargetFieldRepairs(+ buildArgs({+ ...staleField,+ fields: [+ { ...staleField.fields[0], relationType: RelationType.ONE_TO_MANY },+ ],+ }),+ );++ expect(result.flatFieldMetadatasToUpdate).toEqual([]);+ });+});diff --git a/packages/twenty-server/src/database/commands/upgrade-version-command/2-35/utils/build-timeline-activity-target-field-repairs.util.ts b/packages/twenty-server/src/database/commands/upgrade-version-command/2-35/utils/build-timeline-activity-target-field-repairs.util.tsnew file mode 100644index 00000000000..cd9b4e69828--- /dev/null+++ b/packages/twenty-server/src/database/commands/upgrade-version-command/2-35/utils/build-timeline-activity-target-field-repairs.util.ts@@ -0,0 +1,306 @@+import { STANDARD_OBJECTS } from 'twenty-shared/metadata';+import { FieldMetadataType, RelationType } from 'twenty-shared/types';+import { capitalize, isDefined } from 'twenty-shared/utils';++import { getFlatFieldsFromFlatObjectMetadata } from 'src/engine/api/graphql/workspace-schema-builder/utils/get-flat-fields-for-flat-object-metadata.util';+import { computeMorphOrRelationFieldJoinColumnName } from 'src/engine/metadata-modules/field-metadata/utils/compute-morph-or-relation-field-join-column-name.util';+import { type AllFlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/types/all-flat-entity-maps.type';+import { findFlatEntityByIdInFlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/utils/find-flat-entity-by-id-in-flat-entity-maps.util';+import { findFlatEntityByUniversalIdentifier } from 'src/engine/metadata-modules/flat-entity/utils/find-flat-entity-by-universal-identifier.util';+import { findFieldRelatedIndexes } from 'src/engine/metadata-modules/flat-field-metadata/utils/find-field-related-index.util';+import { isFlatFieldMetadataOfType } from 'src/engine/metadata-modules/flat-field-metadata/utils/is-flat-field-metadata-of-type.util';+import { type FlatFieldMetadata } from 'src/engine/metadata-modules/flat-field-metadata/types/flat-field-metadata.type';+import { type FlatIndexMetadata } from 'src/engine/metadata-modules/flat-index-metadata/types/flat-index-metadata.type';+import { type FlatObjectMetadata } from 'src/engine/metadata-modules/flat-object-metadata/types/flat-object-metadata.type';+import { generateFlatIndexMetadataWithNameOrThrow } from 'src/engine/metadata-modules/index-metadata/utils/generate-flat-index.util';+import { type UniversalFlatFieldMetadata } from 'src/engine/workspace-manager/workspace-migration/universal-flat-entity/types/universal-flat-field-metadata.type';+import { type UniversalFlatIndexMetadata } from 'src/engine/workspace-manager/workspace-migration/universal-flat-entity/types/universal-flat-index-metadata.type';++export type UnrepairableTargetField = {+ fieldName: string;+ expectedName: string;+ reason: string;+};++export type TimelineActivityTargetFieldRepairs = {+ flatFieldMetadatasToUpdate: UniversalFlatFieldMetadata<FieldMetadataType.MORPH_RELATION>[];+ flatIndexMetadatasToUpdate: UniversalFlatIndexMetadata[];+ unrepairableTargetFields: UnrepairableTargetField[];+};++type BuildTimelineActivityTargetFieldRepairsArgs = Pick<+ AllFlatEntityMaps,+ 'flatObjectMetadataMaps' | 'flatFieldMetadataMaps' | 'flatIndexMaps'+> & {+ existingColumnNames: Set<string>;+};++type RepairCandidate = {+ flatFieldMetadata: FlatFieldMetadata<FieldMetadataType.MORPH_RELATION>;+ targetObjectNameSingular: string;+ expectedName: string;+ expectedJoinColumnName: string;+};++const EMPTY_REPAIRS: TimelineActivityTargetFieldRepairs = {+ flatFieldMetadatasToUpdate: [],+ flatIndexMetadatasToUpdate: [],+ unrepairableTargetFields: [],+};++const collectRepairCandidates = ({+ timelineActivityFlatFieldMetadatas,+ flatObjectMetadataMaps,+}: {+ timelineActivityFlatFieldMetadatas: FlatFieldMetadata[];+} & Pick<AllFlatEntityMaps, 'flatObjectMetadataMaps'>): RepairCandidate[] =>+ timelineActivityFlatFieldMetadatas.flatMap((flatFieldMetadata) => {+ if (+ !isFlatFieldMetadataOfType(+ flatFieldMetadata,+ FieldMetadataType.MORPH_RELATION,+ ) ||+ flatFieldMetadata.morphId !==+ STANDARD_OBJECTS.timelineActivity.morphIds.targetMorphId.morphId ||+ flatFieldMetadata.universalSettings.relationType !==+ RelationType.MANY_TO_ONE ||+ !isDefined(flatFieldMetadata.relationTargetObjectMetadataId)+ ) {+ return [];+ }++ const targetFlatObjectMetadata = findFlatEntityByIdInFlatEntityMaps({+ flatEntityMaps: flatObjectMetadataMaps,+ flatEntityId: flatFieldMetadata.relationTargetObjectMetadataId,+ });++ if (!isDefined(targetFlatObjectMetadata)) {+ return [];+ }++ const expectedName = `target${capitalize(+ targetFlatObjectMetadata.nameSingular,+ )}`;++ if (flatFieldMetadata.name === expectedName) {+ return [];+ }++ return [+ {+ flatFieldMetadata,+ targetObjectNameSingular: targetFlatObjectMetadata.nameSingular,+ expectedName,+ expectedJoinColumnName: computeMorphOrRelationFieldJoinColumnName({+ name: expectedName,+ }),+ },+ ];+ });++const classifyPhysicalColumn = ({+ repairCandidate,+ existingColumnNames,+}: {+ repairCandidate: RepairCandidate;+ existingColumnNames: Set<string>;+}): string | undefined => {+ const currentColumnName = computeMorphOrRelationFieldJoinColumnName({+ name: repairCandidate.flatFieldMetadata.name,+ });+ const hasCurrentColumn = existingColumnNames.has(currentColumnName);+ const hasExpectedColumn = existingColumnNames.has(+ repairCandidate.expectedJoinColumnName,+ );++ if (hasCurrentColumn && !hasExpectedColumn) {+ return undefined;+ }++ if (!hasCurrentColumn && hasExpectedColumn) {+ return `column ${repairCandidate.expectedJoinColumnName} already exists while metadata still names it ${currentColumnName}; the rename path cannot apply a metadata-only fix`;+ }++ if (hasCurrentColumn && hasExpectedColumn) {+ return `columns ${currentColumnName} and ${repairCandidate.expectedJoinColumnName} both exist; renaming would collide`;+ }++ return `neither column ${currentColumnName} nor ${repairCandidate.expectedJoinColumnName} exists on the table`;+};++// One index can cover several repaired fields, so it is recomputed once against+// every accepted rename rather than once per field, which would emit the same+// index twice under two partially-renamed names.+const recomputeAffectedIndexes = ({+ acceptedRepairCandidates,+ timelineActivityFlatObjectMetadata,+ timelineActivityFlatFieldMetadatas,+ flatIndexMaps,+}: {+ acceptedRepairCandidates: RepairCandidate[];+ timelineActivityFlatObjectMetadata: FlatObjectMetadata;+ timelineActivityFlatFieldMetadatas: FlatFieldMetadata[];+} & Pick<AllFlatEntityMaps, 'flatIndexMaps'>): UniversalFlatIndexMetadata[] => {+ const expectedNameByFieldId = new Map(+ acceptedRepairCandidates.map((repairCandidate) => [+ repairCandidate.flatFieldMetadata.id,+ repairCandidate.expectedName,+ ]),+ );++ const optimisticFlatFieldMetadatas = timelineActivityFlatFieldMetadatas.map(+ (flatFieldMetadata) => {+ const expectedName = expectedNameByFieldId.get(flatFieldMetadata.id);++ return isDefined(expectedName)+ ? { ...flatFieldMetadata, name: expectedName }+ : flatFieldMetadata;+ },+ );++ const affectedFlatIndexById = new Map<string, FlatIndexMetadata>();++ for (const repairCandidate of acceptedRepairCandidates) {+ for (const flatIndexMetadata of findFieldRelatedIndexes({+ flatFieldMetadata: repairCandidate.flatFieldMetadata,+ flatObjectMetadata: timelineActivityFlatObjectMetadata,+ flatIndexMaps,+ })) {+ affectedFlatIndexById.set(flatIndexMetadata.id, flatIndexMetadata);+ }+ }++ return [...affectedFlatIndexById.values()].map((flatIndex) =>+ generateFlatIndexMetadataWithNameOrThrow({+ flatIndex,+ flatObjectMetadata: timelineActivityFlatObjectMetadata,+ objectFlatFieldMetadatas: optimisticFlatFieldMetadatas,+ }),+ );+};++const findMissingIndexMetadataIds = ({+ timelineActivityFlatObjectMetadata,+ flatIndexMaps,+}: {+ timelineActivityFlatObjectMetadata: FlatObjectMetadata;+} & Pick<AllFlatEntityMaps, 'flatIndexMaps'>): string[] =>+ timelineActivityFlatObjectMetadata.indexMetadataIds.filter(+ (indexMetadataId) =>+ !isDefined(+ findFlatEntityByIdInFlatEntityMaps({+ flatEntityMaps: flatIndexMaps,+ flatEntityId: indexMetadataId,+ }),+ ),+ );++export const buildTimelineActivityTargetFieldRepairs = ({+ flatObjectMetadataMaps,+ flatFieldMetadataMaps,+ flatIndexMaps,+ existingColumnNames,+}: BuildTimelineActivityTargetFieldRepairsArgs): TimelineActivityTargetFieldRepairs => {+ const timelineActivityFlatObjectMetadata =+ findFlatEntityByUniversalIdentifier<FlatObjectMetadata>({+ flatEntityMaps: flatObjectMetadataMaps,+ universalIdentifier:+ STANDARD_OBJECTS.timelineActivity.universalIdentifier,+ });++ if (!isDefined(timelineActivityFlatObjectMetadata)) {+ return EMPTY_REPAIRS;+ }++ const timelineActivityFlatFieldMetadatas =+ getFlatFieldsFromFlatObjectMetadata(+ timelineActivityFlatObjectMetadata,+ flatFieldMetadataMaps,+ );++ // A rename is judged only against the workspace as it stands, never against+ // the outcome of another rename in the same batch. Chains therefore stay+ // blocked rather than resolving differently depending on field order, which+ // is what the physical columns force anyway: the name a chain wants to move+ // into is still occupied by a column at the moment the batch is planned.+ const heldFieldNames = new Set(+ timelineActivityFlatFieldMetadatas.map(({ name }) => name),+ );++ const { accepted, unrepairableTargetFields } = collectRepairCandidates({+ timelineActivityFlatFieldMetadatas,+ flatObjectMetadataMaps,+ }).reduce<{+ accepted: RepairCandidate[];+ unrepairableTargetFields: UnrepairableTargetField[];+ }>(+ (accumulator, repairCandidate) => {+ const reason = heldFieldNames.has(repairCandidate.expectedName)+ ? `${repairCandidate.expectedName} is held by another field on timelineActivity that this command does not rename`+ : classifyPhysicalColumn({ repairCandidate, existingColumnNames });++ if (isDefined(reason)) {+ accumulator.unrepairableTargetFields.push({+ fieldName: repairCandidate.flatFieldMetadata.name,+ expectedName: repairCandidate.expectedName,+ reason,+ });++ return accumulator;+ }++ accumulator.accepted.push(repairCandidate);++ return accumulator;+ },+ { accepted: [], unrepairableTargetFields: [] },+ );++ const missingIndexMetadataIds = findMissingIndexMetadataIds({+ timelineActivityFlatObjectMetadata,+ flatIndexMaps,+ });++ if (accepted.length > 0 && missingIndexMetadataIds.length > 0) {+ return {+ flatFieldMetadatasToUpdate: [],+ flatIndexMetadatasToUpdate: [],+ unrepairableTargetFields: [+ ...unrepairableTargetFields,+ ...accepted.map(({ flatFieldMetadata, expectedName }) => ({+ fieldName: flatFieldMetadata.name,+ expectedName,+ reason: `timelineActivity references missing index metadata ${missingIndexMetadataIds.join(', ')}; index dependencies cannot be recomputed safely`,+ })),+ ],+ };+ }++ return {+ flatFieldMetadatasToUpdate: accepted.map(+ ({+ flatFieldMetadata,+ expectedName,+ expectedJoinColumnName,+ targetObjectNameSingular,+ }) => ({+ ...flatFieldMetadata,+ name: expectedName,+ label: flatFieldMetadata.isSystemSideEffect+ ? capitalize(targetObjectNameSingular)+ : flatFieldMetadata.label,+ universalSettings: {+ ...flatFieldMetadata.universalSettings,+ joinColumnName: expectedJoinColumnName,+ },+ }),+ ),+ flatIndexMetadatasToUpdate: recomputeAffectedIndexes({+ acceptedRepairCandidates: accepted,+ timelineActivityFlatObjectMetadata,+ timelineActivityFlatFieldMetadatas,+ flatIndexMaps,+ }),+ unrepairableTargetFields,+ };+};