Skip to content

The open alternative to Salesforce, designed for AI.

Provision missing object system relations (#25169)

Thomas Trompette59646f421c70
diff --git a/packages/twenty-server/src/database/commands/upgrade-version-command/2-38/2-38-upgrade-version-command.module.ts b/packages/twenty-server/src/database/commands/upgrade-version-command/2-38/2-38-upgrade-version-command.module.ts
index 919ddaf02d8..81e27295c11 100644
--- a/packages/twenty-server/src/database/commands/upgrade-version-command/2-38/2-38-upgrade-version-command.module.ts
+++ b/packages/twenty-server/src/database/commands/upgrade-version-command/2-38/2-38-upgrade-version-command.module.ts
@@ -13,6 +13,7 @@ import { SyncMessageCampaignSchemaCommand } from 'src/database/commands/upgrade-
import { ReownObjectNavigationCommandMenuItemsCommand } from 'src/database/commands/upgrade-version-command/2-38/2-38-workspace-command-1788166853000-reown-object-navigation-command-menu-items.command';
import { ProvisionMissingObjectNavigationCommandMenuItemsCommand } from 'src/database/commands/upgrade-version-command/2-38/2-38-workspace-command-1788181550000-provision-missing-object-navigation-command-menu-items.command';
import { EnableStandardActivityTargetFieldsCommand } from 'src/database/commands/upgrade-version-command/2-38/2-38-workspace-command-1788197000000-enable-standard-activity-target-fields.command';
+import { ProvisionMissingObjectSystemRelationsCommand } from 'src/database/commands/upgrade-version-command/2-38/2-38-workspace-command-1788266912940-provision-missing-object-system-relations.command';
import { HideAskAiInSidePanelCommand } from 'src/database/commands/upgrade-version-command/2-38/2-38-workspace-command-1788266562942-hide-ask-ai-in-side-panel.command';
import { ApplicationModule } from 'src/engine/core-modules/application/application.module';
import { CommandMenuItemEntity } from 'src/engine/metadata-modules/command-menu-item/entities/command-menu-item.entity';
@@ -43,6 +44,7 @@ import { WorkspaceMigrationModule } from 'src/engine/workspace-manager/workspace
ReownObjectNavigationCommandMenuItemsCommand,
ProvisionMissingObjectNavigationCommandMenuItemsCommand,
EnableStandardActivityTargetFieldsCommand,
+ ProvisionMissingObjectSystemRelationsCommand,
HideAskAiInSidePanelCommand,
],
})
diff --git a/packages/twenty-server/src/database/commands/upgrade-version-command/2-38/2-38-workspace-command-1788266912940-provision-missing-object-system-relations.command.ts b/packages/twenty-server/src/database/commands/upgrade-version-command/2-38/2-38-workspace-command-1788266912940-provision-missing-object-system-relations.command.ts
new file mode 100644
index 00000000000..3b1102eecd2
--- /dev/null
+++ b/packages/twenty-server/src/database/commands/upgrade-version-command/2-38/2-38-workspace-command-1788266912940-provision-missing-object-system-relations.command.ts
@@ -0,0 +1,303 @@
+import { Command } from 'nest-commander';
+import {
+ DEFAULT_RELATIONS_OBJECTS_STANDARD_IDS,
+ 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 {
+ buildMissingObjectSystemRelationCandidates,
+ type DefaultRelationHolderNameSingular,
+ type MissingObjectSystemRelationCandidate,
+} from 'src/database/commands/upgrade-version-command/2-38/utils/build-missing-object-system-relation-candidates.util';
+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 FlatObjectMetadata } from 'src/engine/metadata-modules/flat-object-metadata/types/flat-object-metadata.type';
+import {
+ buildSystemRelationFlatFieldMetadatasForObject,
+ type SystemRelationFlatFieldMetadataBundle,
+} from 'src/engine/metadata-modules/object-metadata/utils/build-system-relation-flat-field-metadatas-for-object.util';
+import { WorkspaceCacheService } from 'src/engine/workspace-cache/services/workspace-cache.service';
+import { WorkspaceMigrationValidateBuildAndRunService } from 'src/engine/workspace-manager/workspace-migration/services/workspace-migration-validate-build-and-run-service';
+import { getWorkspaceSchemaContextForMigration } from 'src/engine/workspace-manager/workspace-migration/workspace-migration-runner/utils/get-workspace-schema-context-for-migration.util';
+
+@RegisteredWorkspaceCommand('2.38.0', 1788266912940)
+@Command({
+ name: 'upgrade:2-38:provision-missing-object-system-relations',
+ description:
+ 'Provision the default system-relation pairs (forward relation field on the object, target* morph leg on timelineActivity/attachment/noteTarget/taskTarget, join-column index) for non-standard objects that lost them, typically to pre-2.20 application syncs. The 2-35 restore command only recreated the pairs twenty-standard authors for its own objects; pairs of custom or app-installed objects were never restored, so runtime writes deriving the join column from the object name throw UNKNOWN_COLUMN on every event (Sentry TWENTY-SERVER-JRV). Mints exactly what the objectSystemRelationsOnCreate handler mints at object creation, only for pairs where both legs are absent, and reports pairs it cannot complete safely (partial pair, taken field name, surviving physical column) instead of guessing.',
+})
+export class ProvisionMissingObjectSystemRelationsCommand 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,
+ dataSource,
+ options,
+ }: RunOnWorkspaceArgs): Promise<void> {
+ const isDryRun = options.dryRun ?? false;
+
+ const { flatObjectMetadataMaps, flatFieldMetadataMaps, flatIndexMaps } =
+ await this.workspaceCacheService.getOrRecompute(workspaceId, [
+ 'flatObjectMetadataMaps',
+ 'flatFieldMetadataMaps',
+ 'flatIndexMaps',
+ ]);
+
+ const holderFlatObjectMetadataByNameSingular = {} as Record<
+ DefaultRelationHolderNameSingular,
+ FlatObjectMetadata
+ >;
+
+ for (const holderNameSingular of DEFAULT_RELATIONS_OBJECTS_STANDARD_IDS) {
+ const holderFlatObjectMetadata =
+ findFlatEntityByUniversalIdentifier<FlatObjectMetadata>({
+ flatEntityMaps: flatObjectMetadataMaps,
+ universalIdentifier:
+ STANDARD_OBJECTS[holderNameSingular].universalIdentifier,
+ });
+
+ if (!isDefined(holderFlatObjectMetadata)) {
+ this.logger.log(
+ `Standard object ${holderNameSingular} does not exist for workspace ${workspaceId}, skipping`,
+ );
+
+ return;
+ }
+
+ holderFlatObjectMetadataByNameSingular[holderNameSingular] =
+ holderFlatObjectMetadata;
+ }
+
+ if (!isDefined(dataSource)) {
+ this.logger.error(
+ `Cannot verify system relation columns for workspace ${workspaceId}: no data source. Skipping, rerun once the workspace is reachable.`,
+ );
+
+ return;
+ }
+
+ const existingColumnNamesByHolderNameSingular =
+ await this.readExistingColumnNamesByHolder({
+ dataSource,
+ workspaceId,
+ holderFlatObjectMetadataByNameSingular,
+ });
+
+ const { twentyStandardFlatApplication } =
+ await this.applicationService.findWorkspaceTwentyStandardAndCustomApplicationOrThrow(
+ { workspaceId },
+ );
+
+ const { candidates, unprovisionableSystemRelations } =
+ buildMissingObjectSystemRelationCandidates({
+ flatObjectMetadataMaps,
+ flatFieldMetadataMaps,
+ holderFlatObjectMetadataByNameSingular,
+ existingColumnNamesByHolderNameSingular,
+ twentyStandardApplicationUniversalIdentifier:
+ twentyStandardFlatApplication.universalIdentifier,
+ });
+
+ if (unprovisionableSystemRelations.length > 0) {
+ this.logger.error(
+ [
+ `MANUAL REPAIR REQUIRED: ${unprovisionableSystemRelations.length} system relation(s) in workspace ${workspaceId} cannot be provisioned automatically:`,
+ ...unprovisionableSystemRelations.map(
+ ({ sourceObjectNameSingular, holderNameSingular, reason }) =>
+ ` - ${sourceObjectNameSingular} <-> ${holderNameSingular}: ${reason}`,
+ ),
+ ].join('\n'),
+ );
+ }
+
+ if (candidates.length === 0) {
+ if (unprovisionableSystemRelations.length === 0) {
+ this.logger.log(
+ `Object system relations are complete for workspace ${workspaceId}, skipping`,
+ );
+ }
+
+ return;
+ }
+
+ const totalPairCount = candidates.reduce(
+ (count, candidate) => count + candidate.missingHolderNameSingulars.length,
+ 0,
+ );
+
+ this.logger.log(
+ `${isDryRun ? '[DRY RUN] ' : ''}Provisioning ${totalPairCount} missing system relation pair(s) across ${candidates.length} object(s) for workspace ${workspaceId}: ${candidates
+ .map(
+ ({ sourceFlatObjectMetadata, missingHolderNameSingulars }) =>
+ `${sourceFlatObjectMetadata.nameSingular} (${missingHolderNameSingulars.join(', ')})`,
+ )
+ .join('; ')}`,
+ );
+
+ if (isDryRun) {
+ return;
+ }
+
+ const candidatesByApplicationUniversalIdentifier = new Map<
+ string,
+ MissingObjectSystemRelationCandidate[]
+ >();
+
+ for (const candidate of candidates) {
+ const { applicationUniversalIdentifier } =
+ candidate.sourceFlatObjectMetadata;
+ const existing =
+ candidatesByApplicationUniversalIdentifier.get(
+ applicationUniversalIdentifier,
+ ) ?? [];
+
+ existing.push(candidate);
+ candidatesByApplicationUniversalIdentifier.set(
+ applicationUniversalIdentifier,
+ existing,
+ );
+ }
+
+ for (const [
+ applicationUniversalIdentifier,
+ applicationCandidates,
+ ] of candidatesByApplicationUniversalIdentifier) {
+ const bundlesToCreate = applicationCandidates.flatMap((candidate) =>
+ this.buildBundlesForCandidate({
+ candidate,
+ holderFlatObjectMetadataByNameSingular,
+ }),
+ );
+
+ const indexesToCreate = bundlesToCreate
+ .map(({ flatIndexMetadata }) => flatIndexMetadata)
+ .filter(
+ (flatIndexMetadata) =>
+ !isDefined(
+ flatIndexMaps.byUniversalIdentifier[
+ flatIndexMetadata.universalIdentifier
+ ],
+ ),
+ );
+
+ const result =
+ await this.workspaceMigrationValidateBuildAndRunService.validateBuildAndRunLegacyWorkspaceMigration(
+ {
+ isSystemBuild: true,
+ workspaceId,
+ applicationUniversalIdentifier,
+ allFlatEntityOperationByMetadataName: {
+ fieldMetadata: {
+ flatEntityToCreate: bundlesToCreate.flatMap(
+ ({ forwardFlatFieldMetadata, reverseFlatFieldMetadata }) => [
+ forwardFlatFieldMetadata,
+ reverseFlatFieldMetadata,
+ ],
+ ),
+ flatEntityToDelete: [],
+ flatEntityToUpdate: [],
+ },
+ index: {
+ flatEntityToCreate: indexesToCreate,
+ flatEntityToDelete: [],
+ flatEntityToUpdate: [],
+ },
+ },
+ },
+ );
+
+ if (result.status === 'fail') {
+ throw new Error(
+ `Failed to provision system relations for application ${applicationUniversalIdentifier} in workspace ${workspaceId}:\n${JSON.stringify(result, null, 2)}`,
+ );
+ }
+ }
+
+ this.logger.log(
+ `Provisioned ${totalPairCount} system relation pair(s) for workspace ${workspaceId}`,
+ );
+ }
+
+ private buildBundlesForCandidate({
+ candidate,
+ holderFlatObjectMetadataByNameSingular,
+ }: {
+ candidate: MissingObjectSystemRelationCandidate;
+ holderFlatObjectMetadataByNameSingular: Record<
+ DefaultRelationHolderNameSingular,
+ FlatObjectMetadata
+ >;
+ }): SystemRelationFlatFieldMetadataBundle[] {
+ const allBundles = buildSystemRelationFlatFieldMetadatasForObject({
+ sourceFlatObjectMetadata: candidate.sourceFlatObjectMetadata,
+ standardTargetFlatObjectMetadataByNameSingular:
+ holderFlatObjectMetadataByNameSingular,
+ applicationUniversalIdentifier:
+ candidate.sourceFlatObjectMetadata.applicationUniversalIdentifier,
+ });
+
+ const missingHolderUniversalIdentifiers = new Set(
+ candidate.missingHolderNameSingulars.map(
+ (holderNameSingular) =>
+ holderFlatObjectMetadataByNameSingular[holderNameSingular]
+ .universalIdentifier,
+ ),
+ );
+
+ return allBundles.filter(({ reverseFlatFieldMetadata }) =>
+ missingHolderUniversalIdentifiers.has(
+ reverseFlatFieldMetadata.objectMetadataUniversalIdentifier,
+ ),
+ );
+ }
+
+ private async readExistingColumnNamesByHolder({
+ dataSource,
+ workspaceId,
+ holderFlatObjectMetadataByNameSingular,
+ }: {
+ dataSource: DataSource;
+ workspaceId: string;
+ holderFlatObjectMetadataByNameSingular: Record<
+ DefaultRelationHolderNameSingular,
+ FlatObjectMetadata
+ >;
+ }): Promise<Record<DefaultRelationHolderNameSingular, Set<string>>> {
+ const existingColumnNamesByHolderNameSingular = {} as Record<
+ DefaultRelationHolderNameSingular,
+ Set<string>
+ >;
+
+ for (const holderNameSingular of DEFAULT_RELATIONS_OBJECTS_STANDARD_IDS) {
+ const { schemaName, tableName } = getWorkspaceSchemaContextForMigration({
+ workspaceId,
+ objectMetadata:
+ holderFlatObjectMetadataByNameSingular[holderNameSingular],
+ });
+
+ 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],
+ );
+
+ existingColumnNamesByHolderNameSingular[holderNameSingular] = new Set(
+ rows.map(({ column_name }) => column_name),
+ );
+ }
+
+ return existingColumnNamesByHolderNameSingular;
+ }
+}
diff --git a/packages/twenty-server/src/database/commands/upgrade-version-command/2-38/utils/__tests__/build-missing-object-system-relation-candidates.util.spec.ts b/packages/twenty-server/src/database/commands/upgrade-version-command/2-38/utils/__tests__/build-missing-object-system-relation-candidates.util.spec.ts
new file mode 100644
index 00000000000..98371a77832
--- /dev/null
+++ b/packages/twenty-server/src/database/commands/upgrade-version-command/2-38/utils/__tests__/build-missing-object-system-relation-candidates.util.spec.ts
@@ -0,0 +1,482 @@
+import { getSystemRelationFieldUniversalIdentifier } from 'twenty-shared/application';
+import {
+ DEFAULT_RELATIONS_OBJECTS_STANDARD_IDS,
+ STANDARD_OBJECTS,
+} from 'twenty-shared/metadata';
+import { FieldMetadataType } from 'twenty-shared/types';
+
+import {
+ buildMissingObjectSystemRelationCandidates,
+ type DefaultRelationHolderNameSingular,
+} from 'src/database/commands/upgrade-version-command/2-38/utils/build-missing-object-system-relation-candidates.util';
+import { createEmptyFlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/constant/create-empty-flat-entity-maps.constant';
+import { type FlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/types/flat-entity-maps.type';
+import { addFlatEntityToFlatEntityMapsOrThrow } from 'src/engine/metadata-modules/flat-entity/utils/add-flat-entity-to-flat-entity-maps-or-throw.util';
+import { getFlatFieldMetadataMock } from 'src/engine/metadata-modules/flat-field-metadata/__mocks__/get-flat-field-metadata.mock';
+import { type FlatFieldMetadata } from 'src/engine/metadata-modules/flat-field-metadata/types/flat-field-metadata.type';
+import { getFlatObjectMetadataMock } from 'src/engine/metadata-modules/flat-object-metadata/__mocks__/get-flat-object-metadata.mock';
+import { type FlatObjectMetadata } from 'src/engine/metadata-modules/flat-object-metadata/types/flat-object-metadata.type';
+
+const STANDARD_APP_UID = '20202020-0000-4000-8000-000000000001';
+const CUSTOM_APP_UID = '20202020-0000-4000-8000-000000000002';
+
+const HOLDER_NAME_PLURALS: Record<DefaultRelationHolderNameSingular, string> = {
+ timelineActivity: 'timelineActivities',
+ attachment: 'attachments',
+ noteTarget: 'noteTargets',
+ taskTarget: 'taskTargets',
+};
+
+type FieldSpecification = {
+ fieldId: string;
+ objectMetadataId: string;
+ name: string;
+ type?: FieldMetadataType;
+ morphId?: string;
+ relationTargetObjectMetadataId?: string;
+ universalIdentifier?: string;
+};
+
+type SourceSpecification = {
+ key: string;
+ nameSingular: string;
+ isActive?: boolean;
+ applicationUniversalIdentifier?: string;
+ pairedHolders?: DefaultRelationHolderNameSingular[];
+ reverseOnlyHolders?: DefaultRelationHolderNameSingular[];
+ forwardOnlyHolders?: DefaultRelationHolderNameSingular[];
+ extraFieldNames?: string[];
+ extraRelationFields?: {
+ name: string;
+ holderNameSingular: DefaultRelationHolderNameSingular;
+ }[];
+};
+
+type BuildArgs = {
+ sources: SourceSpecification[];
+ holderExtraFieldNames?: Partial<
+ Record<DefaultRelationHolderNameSingular, string[]>
+ >;
+ columnNamesByHolder?: Partial<
+ Record<DefaultRelationHolderNameSingular, string[]>
+ >;
+ detachedFields?: FieldSpecification[];
+};
+
+const buildArgs = ({
+ sources,
+ holderExtraFieldNames = {},
+ columnNamesByHolder = {},
+ detachedFields = [],
+}: BuildArgs) => {
+ const flatObjectMetadatas: FlatObjectMetadata[] = [];
+ const flatFieldMetadatas: FlatFieldMetadata[] = [];
+ const holderFieldIds: Record<DefaultRelationHolderNameSingular, string[]> = {
+ timelineActivity: [],
+ attachment: [],
+ noteTarget: [],
+ taskTarget: [],
+ };
+
+ const registerField = ({
+ fieldId,
+ objectMetadataId,
+ name,
+ type = FieldMetadataType.TEXT,
+ morphId,
+ relationTargetObjectMetadataId,
+ universalIdentifier,
+ }: FieldSpecification) => {
+ flatFieldMetadatas.push(
+ getFlatFieldMetadataMock({
+ id: fieldId,
+ universalIdentifier: universalIdentifier ?? `uid-${fieldId}`,
+ objectMetadataId,
+ name,
+ type,
+ morphId: morphId ?? null,
+ relationTargetObjectMetadataId,
+ }),
+ );
+ };
+
+ for (const holderNameSingular of DEFAULT_RELATIONS_OBJECTS_STANDARD_IDS) {
+ for (const name of holderExtraFieldNames[holderNameSingular] ?? []) {
+ const fieldId = `field-${holderNameSingular}-${name}`;
+
+ holderFieldIds[holderNameSingular].push(fieldId);
+ registerField({
+ fieldId,
+ objectMetadataId: `object-${holderNameSingular}`,
+ name,
+ });
+ }
+ }
+
+ for (const source of sources) {
+ const sourceFieldIds: string[] = [];
+
+ for (const holderNameSingular of [
+ ...(source.pairedHolders ?? []),
+ ...(source.reverseOnlyHolders ?? []),
+ ]) {
+ const fieldId = `field-${holderNameSingular}-target-${source.key}`;
+
+ holderFieldIds[holderNameSingular].push(fieldId);
+ registerField({
+ fieldId,
+ objectMetadataId: `object-${holderNameSingular}`,
+ name: `target${source.nameSingular[0].toUpperCase()}${source.nameSingular.slice(1)}`,
+ type: FieldMetadataType.MORPH_RELATION,
+ morphId:
+ STANDARD_OBJECTS[holderNameSingular].morphIds.targetMorphId.morphId,
+ relationTargetObjectMetadataId: `object-${source.key}`,
+ });
+ }
+
+ for (const holderNameSingular of [
+ ...(source.pairedHolders ?? []),
+ ...(source.forwardOnlyHolders ?? []),
+ ]) {
+ const fieldId = `field-${source.key}-${holderNameSingular}`;
+
+ sourceFieldIds.push(fieldId);
+ registerField({
+ fieldId,
+ objectMetadataId: `object-${source.key}`,
+ name: HOLDER_NAME_PLURALS[holderNameSingular],
+ type: FieldMetadataType.RELATION,
+ relationTargetObjectMetadataId: `object-${holderNameSingular}`,
+ });
+ }
+
+ for (const name of source.extraFieldNames ?? []) {
+ const fieldId = `field-${source.key}-${name}`;
+
+ sourceFieldIds.push(fieldId);
+ registerField({
+ fieldId,
+ objectMetadataId: `object-${source.key}`,
+ name,
+ });
+ }
+
+ for (const { name, holderNameSingular } of source.extraRelationFields ??
+ []) {
+ const fieldId = `field-${source.key}-${name}`;
+
+ sourceFieldIds.push(fieldId);
+ registerField({
+ fieldId,
+ objectMetadataId: `object-${source.key}`,
+ name,
+ type: FieldMetadataType.RELATION,
+ relationTargetObjectMetadataId: `object-${holderNameSingular}`,
+ });
+ }
+
+ flatObjectMetadatas.push(
+ getFlatObjectMetadataMock({
+ id: `object-${source.key}`,
+ universalIdentifier: `object-uid-${source.key}`,
+ applicationUniversalIdentifier:
+ source.applicationUniversalIdentifier ?? CUSTOM_APP_UID,
+ nameSingular: source.nameSingular,
+ namePlural: `${source.nameSingular}s`,
+ isActive: source.isActive ?? true,
+ fieldIds: sourceFieldIds,
+ }),
+ );
+ }
+
+ detachedFields.forEach(registerField);
+
+ const holderFlatObjectMetadataByNameSingular = {} as Record<
+ DefaultRelationHolderNameSingular,
+ FlatObjectMetadata
+ >;
+
+ for (const holderNameSingular of DEFAULT_RELATIONS_OBJECTS_STANDARD_IDS) {
+ const holderFlatObjectMetadata = getFlatObjectMetadataMock({
+ id: `object-${holderNameSingular}`,
+ universalIdentifier:
+ STANDARD_OBJECTS[holderNameSingular].universalIdentifier,
+ applicationUniversalIdentifier: STANDARD_APP_UID,
+ nameSingular: holderNameSingular,
+ namePlural: HOLDER_NAME_PLURALS[holderNameSingular],
+ fieldIds: holderFieldIds[holderNameSingular],
+ });
+
+ flatObjectMetadatas.push(holderFlatObjectMetadata);
+ holderFlatObjectMetadataByNameSingular[holderNameSingular] =
+ holderFlatObjectMetadata;
+ }
+
+ return {
+ flatObjectMetadataMaps: flatObjectMetadatas.reduce<
+ FlatEntityMaps<FlatObjectMetadata>
+ >(
+ (flatEntityMaps, flatEntity) =>
+ addFlatEntityToFlatEntityMapsOrThrow({ flatEntity, flatEntityMaps }),
+ createEmptyFlatEntityMaps(),
+ ),
+ flatFieldMetadataMaps: flatFieldMetadatas.reduce<
+ FlatEntityMaps<FlatFieldMetadata>
+ >(
+ (flatEntityMaps, flatEntity) =>
+ addFlatEntityToFlatEntityMapsOrThrow({ flatEntity, flatEntityMaps }),
+ createEmptyFlatEntityMaps(),
+ ),
+ holderFlatObjectMetadataByNameSingular,
+ existingColumnNamesByHolderNameSingular: {
+ timelineActivity: new Set(columnNamesByHolder.timelineActivity ?? []),
+ attachment: new Set(columnNamesByHolder.attachment ?? []),
+ noteTarget: new Set(columnNamesByHolder.noteTarget ?? []),
+ taskTarget: new Set(columnNamesByHolder.taskTarget ?? []),
+ },
+ twentyStandardApplicationUniversalIdentifier: STANDARD_APP_UID,
+ };
+};
+
+describe('buildMissingObjectSystemRelationCandidates', () => {
+ it('provisions all four pairs for an object that has none', () => {
+ const result = buildMissingObjectSystemRelationCandidates(
+ buildArgs({
+ sources: [{ key: 'phone', nameSingular: 'phoneNumber2' }],
+ }),
+ );
+
+ expect(result.unprovisionableSystemRelations).toEqual([]);
+ expect(result.candidates).toHaveLength(1);
+ expect(result.candidates[0].sourceFlatObjectMetadata.nameSingular).toBe(
+ 'phoneNumber2',
+ );
+ expect(result.candidates[0].missingHolderNameSingulars).toEqual([
+ 'timelineActivity',
+ 'attachment',
+ 'noteTarget',
+ 'taskTarget',
+ ]);
+ });
+
+ it('skips objects owned by twenty-standard', () => {
+ const result = buildMissingObjectSystemRelationCandidates(
+ buildArgs({
+ sources: [
+ {
+ key: 'company',
+ nameSingular: 'company',
+ applicationUniversalIdentifier: STANDARD_APP_UID,
+ },
+ ],
+ }),
+ );
+
+ expect(result.candidates).toEqual([]);
+ expect(result.unprovisionableSystemRelations).toEqual([]);
+ });
+
+ it('skips pairs where both legs already exist', () => {
+ const result = buildMissingObjectSystemRelationCandidates(
+ buildArgs({
+ sources: [
+ {
+ key: 'deal',
+ nameSingular: 'deal',
+ pairedHolders: [...DEFAULT_RELATIONS_OBJECTS_STANDARD_IDS],
+ },
+ ],
+ }),
+ );
+
+ expect(result.candidates).toEqual([]);
+ expect(result.unprovisionableSystemRelations).toEqual([]);
+ });
+
+ it('reports a partial pair instead of completing it', () => {
+ const result = buildMissingObjectSystemRelationCandidates(
+ buildArgs({
+ sources: [
+ {
+ key: 'deal',
+ nameSingular: 'deal',
+ reverseOnlyHolders: ['timelineActivity'],
+ forwardOnlyHolders: ['attachment'],
+ },
+ ],
+ }),
+ );
+
+ expect(result.unprovisionableSystemRelations).toEqual([
+ {
+ sourceObjectNameSingular: 'deal',
+ holderNameSingular: 'timelineActivity',
+ reason: expect.stringContaining('reverse morph'),
+ },
+ {
+ sourceObjectNameSingular: 'deal',
+ holderNameSingular: 'attachment',
+ reason: expect.stringContaining('forward relation'),
+ },
+ ]);
+ expect(result.candidates[0].missingHolderNameSingulars).toEqual([
+ 'noteTarget',
+ 'taskTarget',
+ ]);
+ });
+
+ it('provisions pairs for an inactive object like creation would have', () => {
+ const result = buildMissingObjectSystemRelationCandidates(
+ buildArgs({
+ sources: [
+ {
+ key: 'archived',
+ nameSingular: 'estateLeadArchived',
+ isActive: false,
+ },
+ ],
+ }),
+ );
+
+ expect(result.unprovisionableSystemRelations).toEqual([]);
+ expect(result.candidates[0].missingHolderNameSingulars).toEqual([
+ 'timelineActivity',
+ 'attachment',
+ 'noteTarget',
+ 'taskTarget',
+ ]);
+ });
+
+ it('does not let an unrelated relation to a holder mask a missing pair', () => {
+ const result = buildMissingObjectSystemRelationCandidates(
+ buildArgs({
+ sources: [
+ {
+ key: 'phone',
+ nameSingular: 'phoneNumber2',
+ extraRelationFields: [
+ { name: 'myAttachmentLink', holderNameSingular: 'attachment' },
+ ],
+ },
+ ],
+ }),
+ );
+
+ expect(result.unprovisionableSystemRelations).toEqual([]);
+ expect(result.candidates[0].missingHolderNameSingulars).toEqual([
+ 'timelineActivity',
+ 'attachment',
+ 'noteTarget',
+ 'taskTarget',
+ ]);
+ });
+
+ it('reports a reverse field name already taken on the holder', () => {
+ const result = buildMissingObjectSystemRelationCandidates(
+ buildArgs({
+ sources: [{ key: 'phone', nameSingular: 'phoneNumber2' }],
+ holderExtraFieldNames: { timelineActivity: ['targetPhoneNumber2'] },
+ }),
+ );
+
+ expect(result.unprovisionableSystemRelations).toEqual([
+ {
+ sourceObjectNameSingular: 'phoneNumber2',
+ holderNameSingular: 'timelineActivity',
+ reason: expect.stringContaining('already exists on timelineActivity'),
+ },
+ ]);
+ expect(result.candidates[0].missingHolderNameSingulars).toEqual([
+ 'attachment',
+ 'noteTarget',
+ 'taskTarget',
+ ]);
+ });
+
+ it('reports a forward field name already taken on the source', () => {
+ const result = buildMissingObjectSystemRelationCandidates(
+ buildArgs({
+ sources: [
+ {
+ key: 'phone',
+ nameSingular: 'phoneNumber2',
+ extraFieldNames: ['attachments'],
+ },
+ ],
+ }),
+ );
+
+ expect(result.unprovisionableSystemRelations).toEqual([
+ {
+ sourceObjectNameSingular: 'phoneNumber2',
+ holderNameSingular: 'attachment',
+ reason: expect.stringContaining('already exists on phoneNumber2'),
+ },
+ ]);
+ expect(result.candidates[0].missingHolderNameSingulars).toEqual([
+ 'timelineActivity',
+ 'noteTarget',
+ 'taskTarget',
+ ]);
+ });
+
+ it('reports a surviving physical join column', () => {
+ const result = buildMissingObjectSystemRelationCandidates(
+ buildArgs({
+ sources: [{ key: 'phone', nameSingular: 'phoneNumber2' }],
+ columnNamesByHolder: {
+ timelineActivity: ['targetPhoneNumber2Id'],
+ },
+ }),
+ );
+
+ expect(result.unprovisionableSystemRelations).toEqual([
+ {
+ sourceObjectNameSingular: 'phoneNumber2',
+ holderNameSingular: 'timelineActivity',
+ reason: expect.stringContaining(
+ 'column "targetPhoneNumber2Id" already exists',
+ ),
+ },
+ ]);
+ expect(result.candidates[0].missingHolderNameSingulars).toEqual([
+ 'attachment',
+ 'noteTarget',
+ 'taskTarget',
+ ]);
+ });
+
+ it('counts a leg held by its deterministic identifier even without matching relation semantics', () => {
+ const result = buildMissingObjectSystemRelationCandidates(
+ buildArgs({
+ sources: [{ key: 'phone', nameSingular: 'phoneNumber2' }],
+ detachedFields: [
+ {
+ fieldId: 'field-detached',
+ objectMetadataId: 'object-detached',
+ name: 'unrelated',
+ universalIdentifier: getSystemRelationFieldUniversalIdentifier({
+ applicationUniversalIdentifier: CUSTOM_APP_UID,
+ objectUniversalIdentifier:
+ STANDARD_OBJECTS.timelineActivity.universalIdentifier,
+ relationTargetObjectUniversalIdentifier: 'object-uid-phone',
+ }),
+ },
+ ],
+ }),
+ );
+
+ expect(result.unprovisionableSystemRelations).toEqual([
+ {
+ sourceObjectNameSingular: 'phoneNumber2',
+ holderNameSingular: 'timelineActivity',
+ reason: expect.stringContaining('partial pair'),
+ },
+ ]);
+ expect(result.candidates[0].missingHolderNameSingulars).toEqual([
+ 'attachment',
+ 'noteTarget',
+ 'taskTarget',
+ ]);
+ });
+});
diff --git a/packages/twenty-server/src/database/commands/upgrade-version-command/2-38/utils/build-missing-object-system-relation-candidates.util.ts b/packages/twenty-server/src/database/commands/upgrade-version-command/2-38/utils/build-missing-object-system-relation-candidates.util.ts
new file mode 100644
index 00000000000..85a4d358980
--- /dev/null
+++ b/packages/twenty-server/src/database/commands/upgrade-version-command/2-38/utils/build-missing-object-system-relation-candidates.util.ts
@@ -0,0 +1,221 @@
+import { getSystemRelationFieldUniversalIdentifier } from 'twenty-shared/application';
+import {
+ DEFAULT_RELATIONS_OBJECTS_STANDARD_IDS,
+ STANDARD_OBJECTS,
+} from 'twenty-shared/metadata';
+import { FieldMetadataType } 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 { type FlatObjectMetadata } from 'src/engine/metadata-modules/flat-object-metadata/types/flat-object-metadata.type';
+
+export type DefaultRelationHolderNameSingular =
+ (typeof DEFAULT_RELATIONS_OBJECTS_STANDARD_IDS)[number];
+
+export type UnprovisionableSystemRelation = {
+ sourceObjectNameSingular: string;
+ holderNameSingular: DefaultRelationHolderNameSingular;
+ reason: string;
+};
+
+export type MissingObjectSystemRelationCandidate = {
+ sourceFlatObjectMetadata: FlatObjectMetadata;
+ missingHolderNameSingulars: DefaultRelationHolderNameSingular[];
+};
+
+export type MissingObjectSystemRelationCandidates = {
+ candidates: MissingObjectSystemRelationCandidate[];
+ unprovisionableSystemRelations: UnprovisionableSystemRelation[];
+};
+
+type BuildMissingObjectSystemRelationCandidatesArgs = Pick<
+ AllFlatEntityMaps,
+ 'flatObjectMetadataMaps' | 'flatFieldMetadataMaps'
+> & {
+ holderFlatObjectMetadataByNameSingular: Record<
+ DefaultRelationHolderNameSingular,
+ FlatObjectMetadata
+ >;
+ existingColumnNamesByHolderNameSingular: Record<
+ DefaultRelationHolderNameSingular,
+ Set<string>
+ >;
+ twentyStandardApplicationUniversalIdentifier: string;
+};
+
+export const buildMissingObjectSystemRelationCandidates = ({
+ flatObjectMetadataMaps,
+ flatFieldMetadataMaps,
+ holderFlatObjectMetadataByNameSingular,
+ existingColumnNamesByHolderNameSingular,
+ twentyStandardApplicationUniversalIdentifier,
+}: BuildMissingObjectSystemRelationCandidatesArgs): MissingObjectSystemRelationCandidates => {
+ const holderContexts = DEFAULT_RELATIONS_OBJECTS_STANDARD_IDS.map(
+ (holderNameSingular) => {
+ const holderFlatObjectMetadata =
+ holderFlatObjectMetadataByNameSingular[holderNameSingular];
+ const holderFlatFieldMetadatas = getFlatFieldsFromFlatObjectMetadata(
+ holderFlatObjectMetadata,
+ flatFieldMetadataMaps,
+ );
+
+ return {
+ holderNameSingular,
+ holderFlatObjectMetadata,
+ holderFieldNames: new Set(
+ holderFlatFieldMetadatas.map(({ name }) => name),
+ ),
+ morphTargetObjectMetadataIds: new Set(
+ holderFlatFieldMetadatas
+ .filter(
+ (flatFieldMetadata) =>
+ flatFieldMetadata.type === FieldMetadataType.MORPH_RELATION &&
+ flatFieldMetadata.morphId ===
+ STANDARD_OBJECTS[holderNameSingular].morphIds.targetMorphId
+ .morphId,
+ )
+ .map(
+ (flatFieldMetadata) =>
+ flatFieldMetadata.relationTargetObjectMetadataId,
+ )
+ .filter(isDefined),
+ ),
+ existingColumnNames:
+ existingColumnNamesByHolderNameSingular[holderNameSingular],
+ };
+ },
+ );
+
+ const candidates: MissingObjectSystemRelationCandidate[] = [];
+ const unprovisionableSystemRelations: UnprovisionableSystemRelation[] = [];
+
+ for (const sourceFlatObjectMetadata of Object.values(
+ flatObjectMetadataMaps.byUniversalIdentifier,
+ ).filter(isDefined)) {
+ if (
+ sourceFlatObjectMetadata.applicationUniversalIdentifier ===
+ twentyStandardApplicationUniversalIdentifier
+ ) {
+ continue;
+ }
+
+ const sourceFlatFieldMetadatas = getFlatFieldsFromFlatObjectMetadata(
+ sourceFlatObjectMetadata,
+ flatFieldMetadataMaps,
+ );
+ const sourceFieldNames = new Set(
+ sourceFlatFieldMetadatas.map(({ name }) => name),
+ );
+ const missingHolderNameSingulars: DefaultRelationHolderNameSingular[] = [];
+
+ for (const holderContext of holderContexts) {
+ const { holderNameSingular, holderFlatObjectMetadata } = holderContext;
+
+ const pushUnprovisionable = (reason: string) =>
+ unprovisionableSystemRelations.push({
+ sourceObjectNameSingular: sourceFlatObjectMetadata.nameSingular,
+ holderNameSingular,
+ reason,
+ });
+
+ const reverseFieldUniversalIdentifier =
+ getSystemRelationFieldUniversalIdentifier({
+ applicationUniversalIdentifier:
+ sourceFlatObjectMetadata.applicationUniversalIdentifier,
+ objectUniversalIdentifier:
+ holderFlatObjectMetadata.universalIdentifier,
+ relationTargetObjectUniversalIdentifier:
+ sourceFlatObjectMetadata.universalIdentifier,
+ });
+ const forwardFieldUniversalIdentifier =
+ getSystemRelationFieldUniversalIdentifier({
+ applicationUniversalIdentifier:
+ sourceFlatObjectMetadata.applicationUniversalIdentifier,
+ objectUniversalIdentifier:
+ sourceFlatObjectMetadata.universalIdentifier,
+ relationTargetObjectUniversalIdentifier:
+ holderFlatObjectMetadata.universalIdentifier,
+ });
+
+ const reverseFieldExists =
+ isDefined(
+ flatFieldMetadataMaps.byUniversalIdentifier[
+ reverseFieldUniversalIdentifier
+ ],
+ ) ||
+ holderContext.morphTargetObjectMetadataIds.has(
+ sourceFlatObjectMetadata.id,
+ );
+ const forwardFieldExists =
+ isDefined(
+ flatFieldMetadataMaps.byUniversalIdentifier[
+ forwardFieldUniversalIdentifier
+ ],
+ ) ||
+ sourceFlatFieldMetadatas.some(
+ (flatFieldMetadata) =>
+ flatFieldMetadata.type === FieldMetadataType.RELATION &&
+ flatFieldMetadata.name === holderFlatObjectMetadata.namePlural &&
+ flatFieldMetadata.relationTargetObjectMetadataId ===
+ holderFlatObjectMetadata.id,
+ );
+
+ if (reverseFieldExists && forwardFieldExists) {
+ continue;
+ }
+
+ if (reverseFieldExists || forwardFieldExists) {
+ pushUnprovisionable(
+ `only the ${
+ reverseFieldExists ? 'reverse morph' : 'forward relation'
+ } leg of the pair exists; a partial pair cannot be completed automatically`,
+ );
+ continue;
+ }
+
+ const reverseFieldName = `target${capitalize(
+ sourceFlatObjectMetadata.nameSingular,
+ )}`;
+
+ if (holderContext.holderFieldNames.has(reverseFieldName)) {
+ pushUnprovisionable(
+ `field "${reverseFieldName}" already exists on ${holderNameSingular}`,
+ );
+ continue;
+ }
+
+ const forwardFieldName = holderFlatObjectMetadata.namePlural;
+
+ if (sourceFieldNames.has(forwardFieldName)) {
+ pushUnprovisionable(
+ `field "${forwardFieldName}" already exists on ${sourceFlatObjectMetadata.nameSingular}`,
+ );
+ continue;
+ }
+
+ const joinColumnName = computeMorphOrRelationFieldJoinColumnName({
+ name: reverseFieldName,
+ });
+
+ if (holderContext.existingColumnNames.has(joinColumnName)) {
+ pushUnprovisionable(
+ `column "${joinColumnName}" already exists on the ${holderNameSingular} table`,
+ );
+ continue;
+ }
+
+ missingHolderNameSingulars.push(holderNameSingular);
+ }
+
+ if (missingHolderNameSingulars.length > 0) {
+ candidates.push({
+ sourceFlatObjectMetadata,
+ missingHolderNameSingulars,
+ });
+ }
+ }
+
+ return { candidates, unprovisionableSystemRelations };
+};