Skip to content

The open alternative to Salesforce, designed for AI.

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.ts
index 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/workspace
providers: [
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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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();
+ });
+});