The open alternative to Salesforce, designed for AI.
TypeScript crmcrm-systemcustomergood-first-issuegraphqlhacktoberfestjavascriptmarketingmonoreponestjsopen-sourcepostgresqlreactreactjssalestypescriptweb
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.tsindex 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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,+ }),+ }));+ },+ );