Skip to content

The open alternative to Salesforce, designed for AI.

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.ts
index 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/w
import { 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/workspace
RepairAttachmentTimelineActivityTypesCommand,
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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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,
+ };
+};