Skip to content

The open alternative to Salesforce, designed for AI.

Backfill the missing index of app-owned system relation legs (#26175)

Charles Bochet4a86f692fe69
diff --git a/packages/twenty-server/src/database/commands/upgrade-version-command/2-42/2-42-upgrade-version-command.module.ts b/packages/twenty-server/src/database/commands/upgrade-version-command/2-42/2-42-upgrade-version-command.module.ts
index 01581abde25..6847bf7f5fd 100644
--- a/packages/twenty-server/src/database/commands/upgrade-version-command/2-42/2-42-upgrade-version-command.module.ts
+++ b/packages/twenty-server/src/database/commands/upgrade-version-command/2-42/2-42-upgrade-version-command.module.ts
@@ -3,7 +3,10 @@ import { Module } from '@nestjs/common';
import { WorkspaceIteratorModule } from 'src/database/commands/command-runners/workspace-iterator.module';
import { UnpinCreationCommandsOnRecordSelectionCommand } from 'src/database/commands/upgrade-version-command/2-42/2-42-workspace-command-1789634112046-unpin-creation-commands-on-record-selection.command';
+import { BackfillMissingSystemRelationIndexesCommand } from 'src/database/commands/upgrade-version-command/2-42/2-42-workspace-command-1789663454000-backfill-missing-system-relation-indexes.command';
import { RelinkWorkflowVersionsToCoreWorkflowsCommand } from 'src/database/commands/upgrade-version-command/2-42/2-42-workspace-command-1789645879295-relink-workflow-versions-to-core-workflows.command';
+import { ApplicationModule } from 'src/engine/core-modules/application/application.module';
+import { WorkspaceSchemaManagerModule } from 'src/engine/twenty-orm/workspace-schema-manager/workspace-schema-manager.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';
import { WorkspaceMigrationModule } from 'src/engine/workspace-manager/workspace-migration/workspace-migration.module';
@@ -11,16 +14,19 @@ import { WorkspaceSchemaMigrationRunnerActionHandlersModule } from 'src/engine/w
@Module({
imports: [
+ ApplicationModule,
WorkspaceCacheModule,
WorkspaceIteratorModule,
WorkspaceMigrationModule,
WorkspaceMigrationRunnerModule,
+ WorkspaceSchemaManagerModule,
WorkspaceSchemaMigrationRunnerActionHandlersModule,
],
providers: [
UnpinCreationCommandsOnRecordSelectionCommand,
RelinkWorkflowVersionsToCoreWorkflowsCommand,
BackfillWorkspaceWorkflowVersionIdCommand,
+ BackfillMissingSystemRelationIndexesCommand,
],
exports: [RelinkWorkflowVersionsToCoreWorkflowsCommand],
})
diff --git a/packages/twenty-server/src/database/commands/upgrade-version-command/2-42/2-42-workspace-command-1789663454000-backfill-missing-system-relation-indexes.command.ts b/packages/twenty-server/src/database/commands/upgrade-version-command/2-42/2-42-workspace-command-1789663454000-backfill-missing-system-relation-indexes.command.ts
new file mode 100644
index 00000000000..ff227e85991
--- /dev/null
+++ b/packages/twenty-server/src/database/commands/upgrade-version-command/2-42/2-42-workspace-command-1789663454000-backfill-missing-system-relation-indexes.command.ts
@@ -0,0 +1,263 @@
+import { Command } from 'nest-commander';
+import { type DataSource, type QueryRunner } from 'typeorm';
+import {
+ DEFAULT_RELATIONS_OBJECTS_STANDARD_IDS,
+ STANDARD_OBJECTS,
+} from 'twenty-shared/metadata';
+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 {
+ buildMissingSystemRelationIndexes,
+ type MissingSystemRelationIndex,
+ type SystemRelationHolderNameSingular,
+} from 'src/database/commands/upgrade-version-command/2-42/utils/build-missing-system-relation-indexes.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 { WorkspaceSchemaManagerService } from 'src/engine/twenty-orm/workspace-schema-manager/workspace-schema-manager.service';
+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.42.0', 1789663454000)
+@Command({
+ name: 'upgrade:2-42:backfill-missing-system-relation-indexes',
+ description:
+ 'Create the missing join column index of app-owned target* system relation legs on timelineActivity, attachment, noteTarget and taskTarget. Indexes are created with CONCURRENTLY so writes are not blocked.',
+})
+export class BackfillMissingSystemRelationIndexesCommand extends ProvisionedWorkspaceCommandRunner {
+ constructor(
+ protected readonly workspaceIteratorService: WorkspaceIteratorService,
+ private readonly applicationService: ApplicationService,
+ private readonly workspaceCacheService: WorkspaceCacheService,
+ private readonly workspaceMigrationValidateBuildAndRunService: WorkspaceMigrationValidateBuildAndRunService,
+ private readonly workspaceSchemaManagerService: WorkspaceSchemaManagerService,
+ ) {
+ super(workspaceIteratorService);
+ }
+
+ override async runOnWorkspace({
+ workspaceId,
+ dataSource,
+ options,
+ }: RunOnWorkspaceArgs): Promise<void> {
+ const isDryRun = options.dryRun ?? false;
+
+ if (!isDefined(dataSource)) {
+ this.logger.log(`No data source for workspace ${workspaceId}, skipping`);
+
+ return;
+ }
+
+ const { flatObjectMetadataMaps, flatFieldMetadataMaps, flatIndexMaps } =
+ await this.workspaceCacheService.getOrRecompute(workspaceId, [
+ 'flatObjectMetadataMaps',
+ 'flatFieldMetadataMaps',
+ 'flatIndexMaps',
+ ]);
+
+ const holderFlatObjectMetadataByNameSingular = {} as Record<
+ SystemRelationHolderNameSingular,
+ 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;
+ }
+
+ const { twentyStandardFlatApplication } =
+ await this.applicationService.findWorkspaceTwentyStandardAndCustomApplicationOrThrow(
+ { workspaceId },
+ );
+
+ const missingIndexes = buildMissingSystemRelationIndexes({
+ flatFieldMetadataMaps,
+ flatIndexMaps,
+ holderFlatObjectMetadataByNameSingular,
+ twentyStandardApplicationUniversalIdentifier:
+ twentyStandardFlatApplication.universalIdentifier,
+ });
+
+ if (missingIndexes.length === 0) {
+ this.logger.log(
+ `System relation indexes already present for workspace ${workspaceId}, skipping`,
+ );
+
+ return;
+ }
+
+ const indexesToCreate = missingIndexes.map((missingIndex) => ({
+ missingIndex,
+ ...getWorkspaceSchemaContextForMigration({
+ workspaceId,
+ objectMetadata: missingIndex.holderFlatObjectMetadata,
+ }),
+ }));
+
+ if (isDryRun) {
+ for (const { missingIndex, tableName } of indexesToCreate) {
+ this.logger.log(
+ `[DRY RUN] Would create index ${missingIndex.universalFlatIndexMetadata.name} on ${tableName}(${missingIndex.joinColumnName}) for workspace ${workspaceId}`,
+ );
+ }
+
+ return;
+ }
+
+ const queryRunner = dataSource.createQueryRunner();
+ let isQueryRunnerConnected = false;
+
+ try {
+ await queryRunner.connect();
+ isQueryRunnerConnected = true;
+
+ await this.dropInvalidIndexes({
+ dataSource,
+ queryRunner,
+ workspaceId,
+ indexesToCreate,
+ });
+
+ for (const { missingIndex, schemaName, tableName } of indexesToCreate) {
+ await this.workspaceSchemaManagerService.indexManager.createIndex({
+ queryRunner,
+ schemaName,
+ tableName,
+ index: {
+ name: missingIndex.universalFlatIndexMetadata.name,
+ columns: [missingIndex.joinColumnName],
+ isUnique: missingIndex.universalFlatIndexMetadata.isUnique,
+ type: missingIndex.universalFlatIndexMetadata.indexType,
+ },
+ concurrently: true,
+ });
+
+ this.logger.log(
+ `Created index ${missingIndex.universalFlatIndexMetadata.name} on ${tableName}(${missingIndex.joinColumnName}) for workspace ${workspaceId}`,
+ );
+ }
+ } finally {
+ if (isQueryRunnerConnected) {
+ await queryRunner.release();
+ }
+ }
+
+ const missingIndexesByApplicationUniversalIdentifier = new Map<
+ string,
+ MissingSystemRelationIndex[]
+ >();
+
+ for (const missingIndex of missingIndexes) {
+ const { applicationUniversalIdentifier } =
+ missingIndex.universalFlatIndexMetadata;
+
+ missingIndexesByApplicationUniversalIdentifier.set(applicationUniversalIdentifier, [
+ ...(missingIndexesByApplicationUniversalIdentifier.get(
+ applicationUniversalIdentifier,
+ ) ?? []),
+ missingIndex,
+ ]);
+ }
+
+ for (const [
+ applicationUniversalIdentifier,
+ applicationMissingIndexes,
+ ] of missingIndexesByApplicationUniversalIdentifier) {
+ const result =
+ await this.workspaceMigrationValidateBuildAndRunService.validateBuildAndRunLegacyWorkspaceMigration(
+ {
+ isSystemBuild: true,
+ workspaceId,
+ applicationUniversalIdentifier,
+ allFlatEntityOperationByMetadataName: {
+ index: {
+ flatEntityToCreate: applicationMissingIndexes.map(
+ ({ universalFlatIndexMetadata }) =>
+ universalFlatIndexMetadata,
+ ),
+ flatEntityToDelete: [],
+ flatEntityToUpdate: [],
+ },
+ },
+ },
+ );
+
+ if (result.status === 'fail') {
+ throw new Error(
+ `Failed to persist system relation index metadata for application ${applicationUniversalIdentifier} in workspace ${workspaceId}:\n${JSON.stringify(result, null, 2)}`,
+ );
+ }
+ }
+
+ this.logger.log(
+ `Backfilled ${missingIndexes.length} system relation index(es) for workspace ${workspaceId}`,
+ );
+ }
+
+ private async dropInvalidIndexes({
+ dataSource,
+ queryRunner,
+ workspaceId,
+ indexesToCreate,
+ }: {
+ dataSource: DataSource;
+ queryRunner: QueryRunner;
+ workspaceId: string;
+ indexesToCreate: {
+ missingIndex: MissingSystemRelationIndex;
+ schemaName: string;
+ }[];
+ }): Promise<void> {
+ const indexNamesBySchemaName = new Map<string, string[]>();
+
+ for (const { missingIndex, schemaName } of indexesToCreate) {
+ indexNamesBySchemaName.set(schemaName, [
+ ...(indexNamesBySchemaName.get(schemaName) ?? []),
+ missingIndex.universalFlatIndexMetadata.name,
+ ]);
+ }
+
+ for (const [schemaName, indexNames] of indexNamesBySchemaName) {
+ const invalidIndexes = await dataSource.query<{ name: string }[]>(
+ `SELECT c.relname AS name
+ FROM pg_index i
+ JOIN pg_class c ON c.oid = i.indexrelid
+ JOIN pg_namespace n ON n.oid = c.relnamespace
+ WHERE n.nspname = $1 AND c.relname = ANY($2) AND NOT i.indisvalid`,
+ [schemaName, indexNames],
+ );
+
+ for (const { name } of invalidIndexes) {
+ await this.workspaceSchemaManagerService.indexManager.dropIndex({
+ queryRunner,
+ schemaName,
+ indexName: name,
+ });
+
+ this.logger.warn(
+ `Dropped invalid index ${name} left by an interrupted build in workspace ${workspaceId}, recreating it`,
+ );
+ }
+ }
+ }
+}
diff --git a/packages/twenty-server/src/database/commands/upgrade-version-command/2-42/utils/__tests__/build-missing-system-relation-indexes.util.spec.ts b/packages/twenty-server/src/database/commands/upgrade-version-command/2-42/utils/__tests__/build-missing-system-relation-indexes.util.spec.ts
new file mode 100644
index 00000000000..cd5f974f34b
--- /dev/null
+++ b/packages/twenty-server/src/database/commands/upgrade-version-command/2-42/utils/__tests__/build-missing-system-relation-indexes.util.spec.ts
@@ -0,0 +1,252 @@
+import {
+ DEFAULT_RELATIONS_OBJECTS_STANDARD_IDS,
+ STANDARD_OBJECTS,
+} from 'twenty-shared/metadata';
+import {
+ FieldMetadataType,
+ IndexType,
+ RelationType,
+} from 'twenty-shared/types';
+
+import {
+ buildMissingSystemRelationIndexes,
+ type SystemRelationHolderNameSingular,
+} from 'src/database/commands/upgrade-version-command/2-42/utils/build-missing-system-relation-indexes.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 { getFlatIndexMetadataMock } from 'src/engine/metadata-modules/flat-index-metadata/__mocks__/get-flat-index-metadata.mock';
+import {
+ type FlatIndexFieldMetadata,
+ type FlatIndexMetadata,
+} from 'src/engine/metadata-modules/flat-index-metadata/types/flat-index-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';
+
+type TargetLegSpecification = {
+ holderNameSingular: SystemRelationHolderNameSingular;
+ name: string;
+ applicationUniversalIdentifier?: string;
+ morphId?: string;
+ relationType?: RelationType;
+ indexedAtPosition?: 0 | 1;
+};
+
+const addAll = <TFlatEntity extends FlatObjectMetadata | FlatFieldMetadata | FlatIndexMetadata>(
+ flatEntities: TFlatEntity[],
+): FlatEntityMaps<TFlatEntity> =>
+ flatEntities.reduce<FlatEntityMaps<TFlatEntity>>(
+ (flatEntityMaps, flatEntity) =>
+ addFlatEntityToFlatEntityMapsOrThrow({ flatEntity, flatEntityMaps }),
+ createEmptyFlatEntityMaps(),
+ );
+
+const buildArgs = (targetLegs: TargetLegSpecification[]) => {
+ const flatFieldMetadatas: FlatFieldMetadata[] = [];
+ const flatIndexMetadatas: FlatIndexMetadata[] = [];
+ const fieldIdsByHolder: Record<SystemRelationHolderNameSingular, string[]> = {
+ timelineActivity: [],
+ attachment: [],
+ noteTarget: [],
+ taskTarget: [],
+ };
+
+ for (const holderNameSingular of DEFAULT_RELATIONS_OBJECTS_STANDARD_IDS) {
+ const deletedAtFieldId = `field-${holderNameSingular}-deletedAt`;
+
+ fieldIdsByHolder[holderNameSingular].push(deletedAtFieldId);
+ flatFieldMetadatas.push(
+ getFlatFieldMetadataMock({
+ id: deletedAtFieldId,
+ universalIdentifier: `uid-${deletedAtFieldId}`,
+ objectMetadataId: `object-${holderNameSingular}`,
+ name: 'deletedAt',
+ type: FieldMetadataType.DATE_TIME,
+ applicationUniversalIdentifier: STANDARD_APP_UID,
+ }),
+ );
+ }
+
+ for (const leg of targetLegs) {
+ const fieldId = `field-${leg.holderNameSingular}-${leg.name}`;
+
+ fieldIdsByHolder[leg.holderNameSingular].push(fieldId);
+ flatFieldMetadatas.push(
+ getFlatFieldMetadataMock<FieldMetadataType.MORPH_RELATION>({
+ id: fieldId,
+ universalIdentifier: `uid-${fieldId}`,
+ objectMetadataId: `object-${leg.holderNameSingular}`,
+ name: leg.name,
+ type: FieldMetadataType.MORPH_RELATION,
+ morphId:
+ leg.morphId ??
+ STANDARD_OBJECTS[leg.holderNameSingular].morphIds.targetMorphId
+ .morphId,
+ settings: {
+ relationType: leg.relationType ?? RelationType.MANY_TO_ONE,
+ joinColumnName: `${leg.name}Id`,
+ },
+ applicationUniversalIdentifier:
+ leg.applicationUniversalIdentifier ?? CUSTOM_APP_UID,
+ }),
+ );
+
+ if (leg.indexedAtPosition === undefined) {
+ continue;
+ }
+
+ const indexFieldIds =
+ leg.indexedAtPosition === 0
+ ? [fieldId, `field-${leg.holderNameSingular}-deletedAt`]
+ : [`field-${leg.holderNameSingular}-deletedAt`, fieldId];
+
+ flatIndexMetadatas.push(
+ getFlatIndexMetadataMock({
+ universalIdentifier: `index-uid-${fieldId}`,
+ objectMetadataId: `object-${leg.holderNameSingular}`,
+ objectMetadataUniversalIdentifier:
+ STANDARD_OBJECTS[leg.holderNameSingular].universalIdentifier,
+ applicationUniversalIdentifier: CUSTOM_APP_UID,
+ flatIndexFieldMetadatas: indexFieldIds.map(
+ (indexFieldId, order): FlatIndexFieldMetadata => ({
+ id: `index-field-${fieldId}-${order}`,
+ indexMetadataId: `index-${fieldId}`,
+ fieldMetadataId: indexFieldId,
+ order,
+ subFieldName: null,
+ createdAt: '2024-01-01T00:00:00.000Z',
+ updatedAt: '2024-01-01T00:00:00.000Z',
+ workspaceId: 'workspace-id',
+ }),
+ ),
+ }),
+ );
+ }
+
+ const holderFlatObjectMetadataByNameSingular = {} as Record<
+ SystemRelationHolderNameSingular,
+ FlatObjectMetadata
+ >;
+
+ for (const holderNameSingular of DEFAULT_RELATIONS_OBJECTS_STANDARD_IDS) {
+ holderFlatObjectMetadataByNameSingular[holderNameSingular] =
+ getFlatObjectMetadataMock({
+ id: `object-${holderNameSingular}`,
+ universalIdentifier:
+ STANDARD_OBJECTS[holderNameSingular].universalIdentifier,
+ applicationUniversalIdentifier: STANDARD_APP_UID,
+ nameSingular: holderNameSingular,
+ namePlural: `${holderNameSingular}s`,
+ fieldIds: fieldIdsByHolder[holderNameSingular],
+ });
+ }
+
+ return {
+ flatFieldMetadataMaps: addAll(flatFieldMetadatas),
+ flatIndexMaps: addAll(flatIndexMetadatas),
+ holderFlatObjectMetadataByNameSingular,
+ twentyStandardApplicationUniversalIdentifier: STANDARD_APP_UID,
+ };
+};
+
+describe('buildMissingSystemRelationIndexes', () => {
+ it('returns an index for an app-owned target leg that has none, on every holder', () => {
+ const missingIndexes = buildMissingSystemRelationIndexes(
+ buildArgs(
+ DEFAULT_RELATIONS_OBJECTS_STANDARD_IDS.map((holderNameSingular) => ({
+ holderNameSingular,
+ name: 'targetSalesActionItem',
+ })),
+ ),
+ );
+
+ expect(
+ missingIndexes.map(({ holderFlatObjectMetadata, joinColumnName }) => [
+ holderFlatObjectMetadata.nameSingular,
+ joinColumnName,
+ ]),
+ ).toEqual([
+ ['timelineActivity', 'targetSalesActionItemId'],
+ ['attachment', 'targetSalesActionItemId'],
+ ['noteTarget', 'targetSalesActionItemId'],
+ ['taskTarget', 'targetSalesActionItemId'],
+ ]);
+
+ const [{ universalFlatIndexMetadata }] = missingIndexes;
+
+ expect(universalFlatIndexMetadata.applicationUniversalIdentifier).toBe(
+ CUSTOM_APP_UID,
+ );
+ expect(universalFlatIndexMetadata.name).toMatch(/^IDX_/);
+ expect(universalFlatIndexMetadata).toMatchObject({
+ indexType: IndexType.BTREE,
+ indexWhereClause: null,
+ isCustom: true,
+ isUnique: false,
+ isSystemSideEffect: true,
+ objectMetadataUniversalIdentifier:
+ STANDARD_OBJECTS.timelineActivity.universalIdentifier,
+ });
+ expect(universalFlatIndexMetadata.universalFlatIndexFieldMetadatas).toEqual(
+ [
+ expect.objectContaining({
+ fieldMetadataUniversalIdentifier:
+ 'uid-field-timelineActivity-targetSalesActionItem',
+ indexMetadataUniversalIdentifier:
+ universalFlatIndexMetadata.universalIdentifier,
+ order: 0,
+ }),
+ ],
+ );
+ });
+
+ it('skips legs already leading an index but not legs only in second position', () => {
+ const missingIndexes = buildMissingSystemRelationIndexes(
+ buildArgs([
+ {
+ holderNameSingular: 'timelineActivity',
+ name: 'targetCalBooking',
+ indexedAtPosition: 0,
+ },
+ {
+ holderNameSingular: 'timelineActivity',
+ name: 'targetStripeCustomer',
+ indexedAtPosition: 1,
+ },
+ ]),
+ );
+
+ expect(missingIndexes.map(({ joinColumnName }) => joinColumnName)).toEqual([
+ 'targetStripeCustomerId',
+ ]);
+ });
+
+ it('leaves standard-owned legs, foreign morph ids and one-to-many sides alone', () => {
+ const missingIndexes = buildMissingSystemRelationIndexes(
+ buildArgs([
+ {
+ holderNameSingular: 'timelineActivity',
+ name: 'targetMessageList',
+ applicationUniversalIdentifier: STANDARD_APP_UID,
+ },
+ {
+ holderNameSingular: 'timelineActivity',
+ name: 'targetOther',
+ morphId: '20202020-0000-4000-8000-00000000ffff',
+ },
+ {
+ holderNameSingular: 'attachment',
+ name: 'targetInverse',
+ relationType: RelationType.ONE_TO_MANY,
+ },
+ ]),
+ );
+
+ expect(missingIndexes).toEqual([]);
+ });
+});
diff --git a/packages/twenty-server/src/database/commands/upgrade-version-command/2-42/utils/build-missing-system-relation-indexes.util.ts b/packages/twenty-server/src/database/commands/upgrade-version-command/2-42/utils/build-missing-system-relation-indexes.util.ts
new file mode 100644
index 00000000000..c4849be50f9
--- /dev/null
+++ b/packages/twenty-server/src/database/commands/upgrade-version-command/2-42/utils/build-missing-system-relation-indexes.util.ts
@@ -0,0 +1,100 @@
+import {
+ type DEFAULT_RELATIONS_OBJECTS_STANDARD_IDS,
+ STANDARD_OBJECTS,
+} from 'twenty-shared/metadata';
+import { FieldMetadataType } from 'twenty-shared/types';
+import { 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 FlatFieldMetadata } from 'src/engine/metadata-modules/flat-field-metadata/types/flat-field-metadata.type';
+import { generateIndexForFlatFieldMetadata } from 'src/engine/metadata-modules/flat-field-metadata/utils/generate-index-for-flat-field-metadata.util';
+import { isMorphOrRelationFlatFieldMetadata } from 'src/engine/metadata-modules/flat-field-metadata/utils/is-morph-or-relation-flat-field-metadata.util';
+import { type FlatObjectMetadata } from 'src/engine/metadata-modules/flat-object-metadata/types/flat-object-metadata.type';
+import { isManyToOneFlatFieldMetadata } from 'src/engine/twenty-orm/utils/is-many-to-one-flat-field-metadata.util';
+import { type UniversalFlatIndexMetadata } from 'src/engine/workspace-manager/workspace-migration/universal-flat-entity/types/universal-flat-index-metadata.type';
+
+export type SystemRelationHolderNameSingular =
+ (typeof DEFAULT_RELATIONS_OBJECTS_STANDARD_IDS)[number];
+
+export type MissingSystemRelationIndex = {
+ holderFlatObjectMetadata: FlatObjectMetadata;
+ joinColumnName: string;
+ universalFlatIndexMetadata: UniversalFlatIndexMetadata;
+};
+
+type BuildMissingSystemRelationIndexesArgs = Pick<
+ AllFlatEntityMaps,
+ 'flatFieldMetadataMaps' | 'flatIndexMaps'
+> & {
+ holderFlatObjectMetadataByNameSingular: Record<
+ SystemRelationHolderNameSingular,
+ FlatObjectMetadata
+ >;
+ twentyStandardApplicationUniversalIdentifier: string;
+};
+
+const collectLeadingIndexedFieldMetadataIds = ({
+ flatIndexMaps,
+ objectMetadataId,
+}: Pick<BuildMissingSystemRelationIndexesArgs, 'flatIndexMaps'> & {
+ objectMetadataId: string;
+}): Set<string> =>
+ new Set(
+ Object.values(flatIndexMaps.byUniversalIdentifier)
+ .filter(isDefined)
+ .filter((flatIndex) => flatIndex.objectMetadataId === objectMetadataId)
+ .map(
+ (flatIndex) =>
+ [...flatIndex.flatIndexFieldMetadatas].sort(
+ (first, second) => first.order - second.order,
+ )[0]?.fieldMetadataId,
+ )
+ .filter(isDefined),
+ );
+
+export const buildMissingSystemRelationIndexes = ({
+ flatFieldMetadataMaps,
+ flatIndexMaps,
+ holderFlatObjectMetadataByNameSingular,
+ twentyStandardApplicationUniversalIdentifier,
+}: BuildMissingSystemRelationIndexesArgs): MissingSystemRelationIndex[] =>
+ Object.entries(holderFlatObjectMetadataByNameSingular).flatMap(
+ ([holderNameSingular, holderFlatObjectMetadata]) => {
+ const targetMorphId =
+ STANDARD_OBJECTS[holderNameSingular as SystemRelationHolderNameSingular]
+ .morphIds.targetMorphId.morphId;
+
+ const leadingIndexedFieldMetadataIds =
+ collectLeadingIndexedFieldMetadataIds({
+ flatIndexMaps,
+ objectMetadataId: holderFlatObjectMetadata.id,
+ });
+
+ return getFlatFieldsFromFlatObjectMetadata(
+ holderFlatObjectMetadata,
+ flatFieldMetadataMaps,
+ )
+ .filter(
+ (flatFieldMetadata): flatFieldMetadata is FlatFieldMetadata =>
+ flatFieldMetadata.type === FieldMetadataType.MORPH_RELATION &&
+ flatFieldMetadata.morphId === targetMorphId &&
+ isMorphOrRelationFlatFieldMetadata(flatFieldMetadata) &&
+ isManyToOneFlatFieldMetadata(flatFieldMetadata) &&
+ flatFieldMetadata.applicationUniversalIdentifier !==
+ twentyStandardApplicationUniversalIdentifier &&
+ !leadingIndexedFieldMetadataIds.has(flatFieldMetadata.id),
+ )
+ .map((flatFieldMetadata) => ({
+ holderFlatObjectMetadata,
+ joinColumnName: computeMorphOrRelationFieldJoinColumnName({
+ name: flatFieldMetadata.name,
+ }),
+ universalFlatIndexMetadata: generateIndexForFlatFieldMetadata({
+ flatFieldMetadata,
+ flatObjectMetadata: holderFlatObjectMetadata,
+ }),
+ }));
+ },
+ );