The open alternative to Salesforce, designed for AI.
TypeScript crmcrm-systemcustomergood-first-issuegraphqlhacktoberfestjavascriptmarketingmonoreponestjsopen-sourcepostgresqlreactreactjssalestypescriptweb
fix(server): restore standard default-relation fields wiped by pre-2.20 application syncs (#24001)
Thomas Trompetted7170793b1c9
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 2907ad8ee50..10da9c5d0d7 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@@ -3,6 +3,7 @@ import { Module } from '@nestjs/common';import { WorkspaceIteratorModule } from 'src/database/commands/command-runners/workspace-iterator.module';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 { 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';@@ -19,6 +20,7 @@ import { WorkspaceMigrationModule } from 'src/engine/workspace-manager/workspaceproviders: [RepairAttachmentTimelineActivityTypesCommand,BackfillCommandMenuItemTargetObjectMetadataCommand,+ RestoreStandardDefaultRelationFieldsCommand,],})export class V2_35_UpgradeVersionCommandModule {}diff --git a/packages/twenty-server/src/database/commands/upgrade-version-command/2-35/2-35-workspace-command-1787582101000-restore-standard-default-relation-fields.command.ts b/packages/twenty-server/src/database/commands/upgrade-version-command/2-35/2-35-workspace-command-1787582101000-restore-standard-default-relation-fields.command.tsnew file mode 100644index 00000000000..363e6e5fd4d--- /dev/null+++ b/packages/twenty-server/src/database/commands/upgrade-version-command/2-35/2-35-workspace-command-1787582101000-restore-standard-default-relation-fields.command.ts@@ -0,0 +1,298 @@+import { Command } from 'nest-commander';++import {+ DEFAULT_RELATIONS_OBJECTS_STANDARD_IDS,+ STANDARD_OBJECTS,+} from 'twenty-shared/metadata';+import { FieldMetadataType } from 'twenty-shared/types';+import { isDefined } from 'twenty-shared/utils';++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 { ApplicationService } from 'src/engine/core-modules/application/application.service';+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 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 { WorkspaceCacheService } from 'src/engine/workspace-cache/services/workspace-cache.service';+import { type TwentyStandardAllFlatEntityMaps } from 'src/engine/workspace-manager/twenty-standard-application/types/twenty-standard-all-flat-entity-maps.type';+import { computeTwentyStandardApplicationAllFlatEntityMaps } from 'src/engine/workspace-manager/twenty-standard-application/utils/twenty-standard-application-all-flat-entity-maps.constant';+import { WorkspaceMigrationValidateBuildAndRunService } from 'src/engine/workspace-manager/workspace-migration/services/workspace-migration-validate-build-and-run-service';++const DEFAULT_RELATION_TARGET_MORPH_IDS = new Set<string>(+ DEFAULT_RELATIONS_OBJECTS_STANDARD_IDS.map(+ (standardObjectNameSingular) =>+ STANDARD_OBJECTS[standardObjectNameSingular].morphIds.targetMorphId+ .morphId,+ ),+);++const computeQualifiedFieldName = ({+ flatFieldMetadata,+ standardFlatObjectMetadataMaps,+}: {+ flatFieldMetadata: FlatFieldMetadata;+ standardFlatObjectMetadataMaps: TwentyStandardAllFlatEntityMaps['flatObjectMetadataMaps'];+}) => {+ const hostObjectNameSingular =+ standardFlatObjectMetadataMaps.byUniversalIdentifier[+ flatFieldMetadata.objectMetadataUniversalIdentifier+ ]?.nameSingular ?? flatFieldMetadata.objectMetadataUniversalIdentifier;++ return `${hostObjectNameSingular}.${flatFieldMetadata.name}`;+};++@RegisteredWorkspaceCommand('2.35.0', 1787582101000)+@Command({+ name: 'upgrade:2-35:restore-standard-default-relation-fields',+ description:+ 'Recreate the standard default-relation pairs (target* morph legs on attachment/noteTarget/taskTarget/timelineActivity and their forward relation fields) that were deleted from some workspaces by pre-2.20 application syncs, along with their join-column indexes. No-op on healthy workspaces.',+})+export class RestoreStandardDefaultRelationFieldsCommand extends ProvisionedWorkspaceCommandRunner {+ constructor(+ protected readonly workspaceIteratorService: WorkspaceIteratorService,+ private readonly applicationService: ApplicationService,+ private readonly workspaceCacheService: WorkspaceCacheService,+ private readonly workspaceMigrationValidateBuildAndRunService: WorkspaceMigrationValidateBuildAndRunService,+ ) {+ super(workspaceIteratorService);+ }++ override async runOnWorkspace({+ workspaceId,+ options,+ }: RunOnWorkspaceArgs): Promise<void> {+ const isDryRun = options.dryRun ?? false;++ const { twentyStandardFlatApplication } =+ await this.applicationService.findWorkspaceTwentyStandardAndCustomApplicationOrThrow(+ { workspaceId },+ );++ const {+ flatFieldMetadataMaps: existingFlatFieldMetadataMaps,+ flatIndexMaps: existingFlatIndexMaps,+ flatObjectMetadataMaps: existingFlatObjectMetadataMaps,+ } = await this.workspaceCacheService.getOrRecompute(workspaceId, [+ 'flatFieldMetadataMaps',+ 'flatIndexMaps',+ 'flatObjectMetadataMaps',+ ]);++ const { allFlatEntityMaps: standardAllFlatEntityMaps } =+ computeTwentyStandardApplicationAllFlatEntityMaps({+ now: new Date().toISOString(),+ workspaceId,+ twentyStandardApplicationId: twentyStandardFlatApplication.id,+ });++ const takenFieldNamesByObject = new Map<string, Set<string>>();++ for (const existingFlatFieldMetadata of Object.values(+ existingFlatFieldMetadataMaps.byUniversalIdentifier,+ ).filter(isDefined)) {+ const takenFieldNames =+ takenFieldNamesByObject.get(+ existingFlatFieldMetadata.objectMetadataUniversalIdentifier,+ ) ?? new Set<string>();++ takenFieldNames.add(existingFlatFieldMetadata.name);+ takenFieldNamesByObject.set(+ existingFlatFieldMetadata.objectMetadataUniversalIdentifier,+ takenFieldNames,+ );+ }++ const standardDefaultRelationLegs = Object.values(+ standardAllFlatEntityMaps.flatFieldMetadataMaps.byUniversalIdentifier,+ )+ .filter(isDefined)+ .filter(+ (standardFlatFieldMetadata) =>+ standardFlatFieldMetadata.type === FieldMetadataType.MORPH_RELATION &&+ isDefined(standardFlatFieldMetadata.morphId) &&+ DEFAULT_RELATION_TARGET_MORPH_IDS.has(+ standardFlatFieldMetadata.morphId,+ ),+ );++ const fieldsToCreate: FlatFieldMetadata[] = [];+ const skippedPairLabels: string[] = [];++ for (const standardDefaultRelationLeg of standardDefaultRelationLegs) {+ const standardForwardFlatFieldMetadata = isDefined(+ standardDefaultRelationLeg.relationTargetFieldMetadataUniversalIdentifier,+ )+ ? standardAllFlatEntityMaps.flatFieldMetadataMaps.byUniversalIdentifier[+ standardDefaultRelationLeg+ .relationTargetFieldMetadataUniversalIdentifier+ ]+ : undefined;++ if (!isDefined(standardForwardFlatFieldMetadata)) {+ continue;+ }++ const standardPairMembers = [+ standardDefaultRelationLeg,+ standardForwardFlatFieldMetadata,+ ];++ const missingPairMembers = standardPairMembers.filter(+ (standardFlatFieldMetadata) =>+ !isDefined(+ existingFlatFieldMetadataMaps.byUniversalIdentifier[+ standardFlatFieldMetadata.universalIdentifier+ ],+ ),+ );++ if (missingPairMembers.length === 0) {+ continue;+ }++ const pairHasSurvivingMember =+ missingPairMembers.length < standardPairMembers.length;++ const pairIsBlocked = missingPairMembers.some(+ (standardFlatFieldMetadata) => {+ const hostObjectExists = isDefined(+ findFlatEntityByUniversalIdentifier<FlatObjectMetadata>({+ flatEntityMaps: existingFlatObjectMetadataMaps,+ universalIdentifier:+ standardFlatFieldMetadata.objectMetadataUniversalIdentifier,+ }),+ );++ const fieldNameIsTaken =+ takenFieldNamesByObject+ .get(standardFlatFieldMetadata.objectMetadataUniversalIdentifier)+ ?.has(standardFlatFieldMetadata.name) === true;++ return !hostObjectExists || fieldNameIsTaken;+ },+ );++ if (pairHasSurvivingMember || pairIsBlocked) {+ skippedPairLabels.push(+ standardPairMembers+ .map((standardFlatFieldMetadata) =>+ computeQualifiedFieldName({+ flatFieldMetadata: standardFlatFieldMetadata,+ standardFlatObjectMetadataMaps:+ standardAllFlatEntityMaps.flatObjectMetadataMaps,+ }),+ )+ .join(' / '),+ );+ continue;+ }++ fieldsToCreate.push(...missingPairMembers);+ }++ const availableFieldUniversalIdentifiers = new Set<string>([+ ...Object.keys(existingFlatFieldMetadataMaps.byUniversalIdentifier),+ ...fieldsToCreate.map(({ universalIdentifier }) => universalIdentifier),+ ]);+ const createdFieldUniversalIdentifiers = new Set<string>(+ fieldsToCreate.map(({ universalIdentifier }) => universalIdentifier),+ );++ const indexesToCreate: FlatIndexMetadata[] = Object.values(+ standardAllFlatEntityMaps.flatIndexMaps.byUniversalIdentifier,+ )+ .filter(isDefined)+ .filter((standardFlatIndexMetadata) => {+ const indexIsMissing = !isDefined(+ existingFlatIndexMaps.byUniversalIdentifier[+ standardFlatIndexMetadata.universalIdentifier+ ],+ );++ const indexReferencesARestoredField =+ standardFlatIndexMetadata.universalFlatIndexFieldMetadatas.some(+ (universalFlatIndexFieldMetadata) =>+ createdFieldUniversalIdentifiers.has(+ universalFlatIndexFieldMetadata.fieldMetadataUniversalIdentifier,+ ),+ );++ const allIndexFieldsExistOrAreRestored =+ standardFlatIndexMetadata.universalFlatIndexFieldMetadatas.every(+ (universalFlatIndexFieldMetadata) =>+ availableFieldUniversalIdentifiers.has(+ universalFlatIndexFieldMetadata.fieldMetadataUniversalIdentifier,+ ),+ );++ return (+ indexIsMissing &&+ indexReferencesARestoredField &&+ allIndexFieldsExistOrAreRestored+ );+ });++ if (skippedPairLabels.length > 0) {+ this.logger.warn(+ `Skipped ${skippedPairLabels.length} unrestorable standard default-relation pair(s) for workspace ${workspaceId}: ${skippedPairLabels.join(', ')}`,+ );+ }++ if (fieldsToCreate.length === 0) {+ if (skippedPairLabels.length === 0) {+ this.logger.log(+ `Standard default-relation fields are complete for workspace ${workspaceId}, skipping`,+ );+ }++ return;+ }++ this.logger.log(+ `${isDryRun ? '[DRY RUN] ' : ''}Restoring ${fieldsToCreate.length} standard default-relation field(s) and ${indexesToCreate.length} index(es) for workspace ${workspaceId}`,+ );++ if (isDryRun) {+ return;+ }++ const validateAndBuildResult =+ await this.workspaceMigrationValidateBuildAndRunService.validateBuildAndRunLegacyWorkspaceMigration(+ {+ isSystemBuild: true,+ applicationUniversalIdentifier:+ twentyStandardFlatApplication.universalIdentifier,+ workspaceId,+ allFlatEntityOperationByMetadataName: {+ fieldMetadata: {+ flatEntityToCreate: fieldsToCreate,+ flatEntityToDelete: [],+ flatEntityToUpdate: [],+ },+ index: {+ flatEntityToCreate: indexesToCreate,+ flatEntityToDelete: [],+ flatEntityToUpdate: [],+ },+ },+ },+ );++ if (validateAndBuildResult.status === 'fail') {+ throw new Error(+ `Failed to restore standard default-relation fields for workspace ${workspaceId}: ${JSON.stringify(+ validateAndBuildResult,+ null,+ 2,+ )}`,+ );+ }++ this.logger.log(+ `Restored ${fieldsToCreate.length} standard default-relation field(s) for workspace ${workspaceId}`,+ );+ }+}diff --git a/packages/twenty-server/src/database/commands/upgrade-version-command/2-35/__tests__/2-35-workspace-command-1787582101000-restore-standard-default-relation-fields.command.spec.ts b/packages/twenty-server/src/database/commands/upgrade-version-command/2-35/__tests__/2-35-workspace-command-1787582101000-restore-standard-default-relation-fields.command.spec.tsnew file mode 100644index 00000000000..949aab9df22--- /dev/null+++ b/packages/twenty-server/src/database/commands/upgrade-version-command/2-35/__tests__/2-35-workspace-command-1787582101000-restore-standard-default-relation-fields.command.spec.ts@@ -0,0 +1,335 @@+import { STANDARD_OBJECTS } from 'twenty-shared/metadata';+import { FieldMetadataType } from 'twenty-shared/types';++import { type WorkspaceIteratorService } from 'src/database/commands/command-runners/workspace-iterator.service';+import { RestoreStandardDefaultRelationFieldsCommand } from 'src/database/commands/upgrade-version-command/2-35/2-35-workspace-command-1787582101000-restore-standard-default-relation-fields.command';+import { type ApplicationService } from 'src/engine/core-modules/application/application.service';+import { type WorkspaceCacheService } from 'src/engine/workspace-cache/services/workspace-cache.service';+import { computeTwentyStandardApplicationAllFlatEntityMaps } from 'src/engine/workspace-manager/twenty-standard-application/utils/twenty-standard-application-all-flat-entity-maps.constant';+import { type WorkspaceMigrationValidateBuildAndRunService } from 'src/engine/workspace-manager/workspace-migration/services/workspace-migration-validate-build-and-run-service';++jest.mock(+ 'src/engine/workspace-manager/twenty-standard-application/utils/twenty-standard-application-all-flat-entity-maps.constant',+);++const computeTwentyStandardApplicationAllFlatEntityMapsMock =+ computeTwentyStandardApplicationAllFlatEntityMaps as jest.Mock;++const WORKSPACE_ID = '20202020-0000-0000-0000-000000000001';+const STANDARD_APPLICATION = {+ id: '20202020-0000-0000-0000-0000000000aa',+ universalIdentifier: '20202020-0000-0000-0000-0000000000bb',+};++const TIMELINE_ACTIVITY_TARGET_MORPH_ID =+ STANDARD_OBJECTS.timelineActivity.morphIds.targetMorphId.morphId;++const TIMELINE_ACTIVITY_OBJECT_UID = 'timeline-activity-object-uid';+const PERSON_OBJECT_UID = 'person-object-uid';+const COMPANY_OBJECT_UID = 'company-object-uid';+const TARGET_PERSON_LEG_UID = 'target-person-leg-uid';+const PERSON_FORWARD_FIELD_UID = 'person-forward-field-uid';+const TARGET_COMPANY_LEG_UID = 'target-company-leg-uid';+const COMPANY_FORWARD_FIELD_UID = 'company-forward-field-uid';+const PERSON_ID_INDEX_UID = 'person-id-index-uid';++const buildByUniversalIdentifierMap = <+ T extends { universalIdentifier: string },+>(+ flatEntities: T[],+) => ({+ byUniversalIdentifier: Object.fromEntries(+ flatEntities.map((flatEntity) => [+ flatEntity.universalIdentifier,+ flatEntity,+ ]),+ ),+});++const timelineActivityObject = {+ universalIdentifier: TIMELINE_ACTIVITY_OBJECT_UID,+ nameSingular: 'timelineActivity',+};++const personObject = {+ universalIdentifier: PERSON_OBJECT_UID,+ nameSingular: 'person',+};++const companyObject = {+ universalIdentifier: COMPANY_OBJECT_UID,+ nameSingular: 'company',+};++const standardTargetPersonLeg = {+ universalIdentifier: TARGET_PERSON_LEG_UID,+ name: 'targetPerson',+ type: FieldMetadataType.MORPH_RELATION,+ morphId: TIMELINE_ACTIVITY_TARGET_MORPH_ID,+ objectMetadataUniversalIdentifier: TIMELINE_ACTIVITY_OBJECT_UID,+ relationTargetFieldMetadataUniversalIdentifier: PERSON_FORWARD_FIELD_UID,+};++const standardPersonForwardField = {+ universalIdentifier: PERSON_FORWARD_FIELD_UID,+ name: 'timelineActivities',+ type: FieldMetadataType.RELATION,+ objectMetadataUniversalIdentifier: PERSON_OBJECT_UID,+ relationTargetFieldMetadataUniversalIdentifier: TARGET_PERSON_LEG_UID,+};++const standardTargetCompanyLeg = {+ universalIdentifier: TARGET_COMPANY_LEG_UID,+ name: 'targetCompany',+ type: FieldMetadataType.MORPH_RELATION,+ morphId: TIMELINE_ACTIVITY_TARGET_MORPH_ID,+ objectMetadataUniversalIdentifier: TIMELINE_ACTIVITY_OBJECT_UID,+ relationTargetFieldMetadataUniversalIdentifier: COMPANY_FORWARD_FIELD_UID,+};++const standardCompanyForwardField = {+ universalIdentifier: COMPANY_FORWARD_FIELD_UID,+ name: 'timelineActivities',+ type: FieldMetadataType.RELATION,+ objectMetadataUniversalIdentifier: COMPANY_OBJECT_UID,+ relationTargetFieldMetadataUniversalIdentifier: TARGET_COMPANY_LEG_UID,+};++const standardPersonIdIndex = {+ universalIdentifier: PERSON_ID_INDEX_UID,+ universalFlatIndexFieldMetadatas: [+ { fieldMetadataUniversalIdentifier: TARGET_PERSON_LEG_UID },+ ],+};++const mockStandardMaps = ({+ fields = [standardTargetPersonLeg, standardPersonForwardField],+ indexes = [standardPersonIdIndex],+ objects = [timelineActivityObject, personObject],+}: {+ fields?: { universalIdentifier: string }[];+ indexes?: { universalIdentifier: string }[];+ objects?: { universalIdentifier: string }[];+} = {}) => {+ computeTwentyStandardApplicationAllFlatEntityMapsMock.mockReturnValue({+ allFlatEntityMaps: {+ flatFieldMetadataMaps: buildByUniversalIdentifierMap(fields),+ flatIndexMaps: buildByUniversalIdentifierMap(indexes),+ flatObjectMetadataMaps: buildByUniversalIdentifierMap(objects),+ },+ });+};++describe('RestoreStandardDefaultRelationFieldsCommand', () => {+ let command: RestoreStandardDefaultRelationFieldsCommand;+ let getOrRecomputeMock: jest.Mock;+ let validateBuildAndRunLegacyWorkspaceMigrationMock: jest.Mock;++ beforeEach(() => {+ jest.clearAllMocks();++ getOrRecomputeMock = jest.fn();+ validateBuildAndRunLegacyWorkspaceMigrationMock = jest+ .fn()+ .mockResolvedValue({ status: 'success' });++ mockStandardMaps();++ command = new RestoreStandardDefaultRelationFieldsCommand(+ {} as WorkspaceIteratorService,+ {+ findWorkspaceTwentyStandardAndCustomApplicationOrThrow: jest+ .fn()+ .mockResolvedValue({+ twentyStandardFlatApplication: STANDARD_APPLICATION,+ }),+ } as unknown as ApplicationService,+ {+ getOrRecompute: getOrRecomputeMock,+ } as unknown as WorkspaceCacheService,+ {+ validateBuildAndRunLegacyWorkspaceMigration:+ validateBuildAndRunLegacyWorkspaceMigrationMock,+ } as unknown as WorkspaceMigrationValidateBuildAndRunService,+ );+ });++ const runOnWorkspace = (dryRun = false) =>+ command.runOnWorkspace({+ workspaceId: WORKSPACE_ID,+ options: { dryRun },+ index: 0,+ total: 1,+ });++ const mockWorkspaceCache = ({+ fields = [],+ indexes = [],+ objects = [timelineActivityObject, personObject],+ }: {+ fields?: {+ universalIdentifier: string;+ name: string;+ objectMetadataUniversalIdentifier: string;+ }[];+ indexes?: { universalIdentifier: string }[];+ objects?: { universalIdentifier: string }[];+ }) => {+ getOrRecomputeMock.mockResolvedValue({+ flatFieldMetadataMaps: buildByUniversalIdentifierMap(fields),+ flatIndexMaps: buildByUniversalIdentifierMap(indexes),+ flatObjectMetadataMaps: buildByUniversalIdentifierMap(objects),+ });+ };++ const getCreatedUniversalIdentifiers = () => {+ const [payload] =+ validateBuildAndRunLegacyWorkspaceMigrationMock.mock.calls[0];++ return {+ fields:+ payload.allFlatEntityOperationByMetadataName.fieldMetadata.flatEntityToCreate.map(+ ({ universalIdentifier }: { universalIdentifier: string }) =>+ universalIdentifier,+ ),+ indexes:+ payload.allFlatEntityOperationByMetadataName.index.flatEntityToCreate.map(+ ({ universalIdentifier }: { universalIdentifier: string }) =>+ universalIdentifier,+ ),+ };+ };++ it('recreates a missing default-relation pair with its index', async () => {+ mockWorkspaceCache({});++ await runOnWorkspace();++ expect(getCreatedUniversalIdentifiers()).toEqual({+ fields: [TARGET_PERSON_LEG_UID, PERSON_FORWARD_FIELD_UID],+ indexes: [PERSON_ID_INDEX_UID],+ });+ });++ it('does nothing when the pair already exists', async () => {+ const warnSpy = jest.spyOn(command['logger'], 'warn');++ mockWorkspaceCache({+ fields: [+ {+ universalIdentifier: TARGET_PERSON_LEG_UID,+ name: 'targetPerson',+ objectMetadataUniversalIdentifier: TIMELINE_ACTIVITY_OBJECT_UID,+ },+ {+ universalIdentifier: PERSON_FORWARD_FIELD_UID,+ name: 'timelineActivities',+ objectMetadataUniversalIdentifier: PERSON_OBJECT_UID,+ },+ ],+ indexes: [{ universalIdentifier: PERSON_ID_INDEX_UID }],+ });++ await runOnWorkspace();++ expect(+ validateBuildAndRunLegacyWorkspaceMigrationMock,+ ).not.toHaveBeenCalled();+ expect(warnSpy).not.toHaveBeenCalled();+ });++ it('skips and warns instead of recreating half of a pair when one member survives', async () => {+ const warnSpy = jest.spyOn(command['logger'], 'warn');++ mockWorkspaceCache({+ fields: [+ {+ universalIdentifier: TARGET_PERSON_LEG_UID,+ name: 'targetPerson',+ objectMetadataUniversalIdentifier: TIMELINE_ACTIVITY_OBJECT_UID,+ },+ ],+ indexes: [{ universalIdentifier: PERSON_ID_INDEX_UID }],+ });++ await runOnWorkspace();++ expect(+ validateBuildAndRunLegacyWorkspaceMigrationMock,+ ).not.toHaveBeenCalled();+ expect(warnSpy).toHaveBeenCalledWith(+ expect.stringContaining(+ 'timelineActivity.targetPerson / person.timelineActivities',+ ),+ );+ });++ it('skips the whole pair when a member name is taken by a drifted duplicate', async () => {+ mockWorkspaceCache({+ fields: [+ {+ universalIdentifier: 'drifted-duplicate-uid',+ name: 'targetPerson',+ objectMetadataUniversalIdentifier: TIMELINE_ACTIVITY_OBJECT_UID,+ },+ ],+ });++ await runOnWorkspace();++ expect(+ validateBuildAndRunLegacyWorkspaceMigrationMock,+ ).not.toHaveBeenCalled();+ });++ it('skips the whole pair when a member host object is missing', async () => {+ mockWorkspaceCache({+ objects: [timelineActivityObject],+ });++ await runOnWorkspace();++ expect(+ validateBuildAndRunLegacyWorkspaceMigrationMock,+ ).not.toHaveBeenCalled();+ });++ it('restores an intact pair when another pair is blocked', async () => {+ mockStandardMaps({+ fields: [+ standardTargetPersonLeg,+ standardPersonForwardField,+ standardTargetCompanyLeg,+ standardCompanyForwardField,+ ],+ objects: [timelineActivityObject, personObject, companyObject],+ });+ mockWorkspaceCache({+ fields: [+ {+ universalIdentifier: 'drifted-duplicate-uid',+ name: 'targetPerson',+ objectMetadataUniversalIdentifier: TIMELINE_ACTIVITY_OBJECT_UID,+ },+ ],+ objects: [timelineActivityObject, personObject, companyObject],+ });++ await runOnWorkspace();++ expect(getCreatedUniversalIdentifiers()).toEqual({+ fields: [TARGET_COMPANY_LEG_UID, COMPANY_FORWARD_FIELD_UID],+ indexes: [],+ });+ });++ it('does not run the migration on dry run', async () => {+ mockWorkspaceCache({});++ await runOnWorkspace(true);++ expect(+ validateBuildAndRunLegacyWorkspaceMigrationMock,+ ).not.toHaveBeenCalled();+ });+});