The open alternative to Salesforce, designed for AI.
TypeScript crmcrm-systemcustomergood-first-issuegraphqlhacktoberfestjavascriptmarketingmonoreponestjsopen-sourcepostgresqlreactreactjssalestypescriptweb
fix(server): normalize legacy index names (command) (#22053)
Marie4eb28b73c776
diff --git a/packages/twenty-server/src/database/commands/upgrade-version-command/2-18/2-18-upgrade-version-command.module.ts b/packages/twenty-server/src/database/commands/upgrade-version-command/2-18/2-18-upgrade-version-command.module.tsnew file mode 100644index 00000000000..e5631e6bebd--- /dev/null+++ b/packages/twenty-server/src/database/commands/upgrade-version-command/2-18/2-18-upgrade-version-command.module.ts@@ -0,0 +1,16 @@+import { Module } from '@nestjs/common';++import { WorkspaceIteratorModule } from 'src/database/commands/command-runners/workspace-iterator.module';+import { NormalizeLegacyIndexNamesCommand } from 'src/database/commands/upgrade-version-command/2-18/2-18-workspace-command-1799200000000-normalize-legacy-index-names.command';+import { WorkspaceSchemaManagerModule } from 'src/engine/twenty-orm/workspace-schema-manager/workspace-schema-manager.module';+import { WorkspaceCacheModule } from 'src/engine/workspace-cache/workspace-cache.module';++@Module({+ imports: [+ WorkspaceCacheModule,+ WorkspaceIteratorModule,+ WorkspaceSchemaManagerModule,+ ],+ providers: [NormalizeLegacyIndexNamesCommand],+})+export class V2_18_UpgradeVersionCommandModule {}diff --git a/packages/twenty-server/src/database/commands/upgrade-version-command/2-18/2-18-workspace-command-1799200000000-normalize-legacy-index-names.command.ts b/packages/twenty-server/src/database/commands/upgrade-version-command/2-18/2-18-workspace-command-1799200000000-normalize-legacy-index-names.command.tsnew file mode 100644index 00000000000..010c626f3e7--- /dev/null+++ b/packages/twenty-server/src/database/commands/upgrade-version-command/2-18/2-18-workspace-command-1799200000000-normalize-legacy-index-names.command.ts@@ -0,0 +1,206 @@+import { Command } from 'nest-commander';+import { isDefined } from 'twenty-shared/utils';++import { ActiveOrSuspendedWorkspaceCommandRunner } from 'src/database/commands/command-runners/active-or-suspended-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 {+ type FlatIndexNameStatus,+ planIndexNameNormalization,+} from 'src/database/commands/upgrade-version-command/2-18/utils/plan-index-name-normalization.util';+import { RegisteredWorkspaceCommand } from 'src/engine/core-modules/upgrade/decorators/registered-workspace-command.decorator';+import { findManyFlatEntityByUniversalIdentifierInUniversalFlatEntityMapsOrThrow } from 'src/engine/metadata-modules/flat-entity/utils/find-many-flat-entity-by-universal-identifier-in-universal-flat-entity-maps-or-throw.util';+import { generateFlatIndexMetadataWithNameOrThrow } from 'src/engine/metadata-modules/index-metadata/utils/generate-flat-index.util';+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 { getWorkspaceSchemaName } from 'src/engine/workspace-datasource/utils/get-workspace-schema-name.util';+import {+ deleteIndexMetadata,+ dropIndexFromWorkspaceSchema,+} from 'src/engine/workspace-manager/workspace-migration/workspace-migration-runner/action-handlers/index/utils/index-action-handler.utils';++@RegisteredWorkspaceCommand('2.18.0', 1799200000000)+@Command({+ name: 'upgrade:2-18:normalize-legacy-index-names',+ description:+ 'Rename indexes whose stored name predates the v2 deterministic naming convention to their recomputed name, and drop redundant duplicates.',+})+export class NormalizeLegacyIndexNamesCommand extends ActiveOrSuspendedWorkspaceCommandRunner {+ constructor(+ protected readonly workspaceIteratorService: WorkspaceIteratorService,+ private readonly workspaceCacheService: WorkspaceCacheService,+ private readonly workspaceSchemaManagerService: WorkspaceSchemaManagerService,+ ) {+ super(workspaceIteratorService);+ }++ override async runOnWorkspace({+ workspaceId,+ dataSource,+ options,+ }: RunOnWorkspaceArgs): Promise<void> {+ if (!isDefined(dataSource)) {+ this.logger.log(`No data source for workspace ${workspaceId}, skipping`);++ return;+ }++ const { flatIndexMaps, flatObjectMetadataMaps, flatFieldMetadataMaps } =+ await this.workspaceCacheService.getOrRecompute(workspaceId, [+ 'flatIndexMaps',+ 'flatObjectMetadataMaps',+ 'flatFieldMetadataMaps',+ ]);++ const indexStatuses: FlatIndexNameStatus[] = [];++ for (const flatObjectMetadata of Object.values(+ flatObjectMetadataMaps.byUniversalIdentifier,+ )) {+ if (!isDefined(flatObjectMetadata)) {+ continue;+ }++ const objectIndexes =+ findManyFlatEntityByUniversalIdentifierInUniversalFlatEntityMapsOrThrow(+ {+ flatEntityMaps: flatIndexMaps,+ universalIdentifiers:+ flatObjectMetadata.indexMetadataUniversalIdentifiers,+ },+ );++ if (objectIndexes.length === 0) {+ continue;+ }++ const objectFlatFieldMetadatas =+ findManyFlatEntityByUniversalIdentifierInUniversalFlatEntityMapsOrThrow(+ {+ flatEntityMaps: flatFieldMetadataMaps,+ universalIdentifiers: flatObjectMetadata.fieldUniversalIdentifiers,+ },+ );++ for (const flatIndex of objectIndexes) {+ try {+ const expectedName = generateFlatIndexMetadataWithNameOrThrow({+ flatObjectMetadata,+ objectFlatFieldMetadatas,+ flatIndex,+ }).name;++ indexStatuses.push({+ indexMetadataId: flatIndex.id,+ objectMetadataId: flatIndex.objectMetadataId,+ currentName: flatIndex.name,+ expectedName,+ });+ } catch (error) {+ this.logger.warn(+ `Could not recompute expected name for index ${flatIndex.name} (${flatIndex.id}) in workspace ${workspaceId}, skipping: ${error instanceof Error ? error.message : String(error)}`,+ );+ }+ }+ }++ const operations = planIndexNameNormalization(indexStatuses);++ if (operations.length === 0) {+ this.logger.log(+ `No legacy index names to normalize for workspace ${workspaceId}, skipping`,+ );++ return;+ }++ if (options.dryRun) {+ for (const operation of operations) {+ if (operation.type === 'rename') {+ this.logger.log(+ `[DRY RUN] Would rename index ${operation.fromName} -> ${operation.toName} (workspace ${workspaceId})`,+ );+ } else {+ this.logger.log(+ `[DRY RUN] Would drop redundant duplicate index ${operation.redundantName} (kept ${operation.keptName}) (workspace ${workspaceId})`,+ );+ }+ }++ return;+ }++ const schemaName = getWorkspaceSchemaName(workspaceId);+ const queryRunner = dataSource.createQueryRunner();+ let isQueryRunnerConnected = false;+ let isTransactionStarted = false;++ try {+ await queryRunner.connect();+ isQueryRunnerConnected = true;++ await queryRunner.startTransaction();+ isTransactionStarted = true;++ for (const operation of operations) {+ if (operation.type === 'rename') {+ await this.workspaceSchemaManagerService.indexManager.renameIndexWithoutRebuild(+ {+ queryRunner,+ schemaName,+ fromIndexName: operation.fromName,+ toIndexName: operation.toName,+ },+ );++ await queryRunner.query(+ `UPDATE "core"."indexMetadata"+ SET "name" = $1+ WHERE "id" = $2+ AND "workspaceId" = $3`,+ [operation.toName, operation.indexMetadataId, workspaceId],+ );++ this.logger.log(+ `Renamed index ${operation.fromName} -> ${operation.toName} (workspace ${workspaceId})`,+ );+ } else {+ await dropIndexFromWorkspaceSchema({+ indexName: operation.redundantName,+ workspaceSchemaManagerService: this.workspaceSchemaManagerService,+ queryRunner,+ schemaName,+ });++ await deleteIndexMetadata({+ entityId: operation.indexMetadataId,+ queryRunner,+ workspaceId,+ });++ this.logger.log(+ `Dropped redundant duplicate index ${operation.redundantName} (kept ${operation.keptName}) (workspace ${workspaceId})`,+ );+ }+ }++ await queryRunner.commitTransaction();+ } catch (error) {+ if (isTransactionStarted) {+ await queryRunner.rollbackTransaction();+ }++ throw error;+ } finally {+ if (isQueryRunnerConnected) {+ await queryRunner.release();+ }+ }++ await this.workspaceCacheService.invalidateAndRecompute(workspaceId, [+ 'flatIndexMaps',+ 'flatObjectMetadataMaps',+ 'flatFieldMetadataMaps',+ ]);+ }+}diff --git a/packages/twenty-server/src/database/commands/upgrade-version-command/2-18/__tests__/2-18-workspace-command-1799200000000-normalize-legacy-index-names.command.spec.ts b/packages/twenty-server/src/database/commands/upgrade-version-command/2-18/__tests__/2-18-workspace-command-1799200000000-normalize-legacy-index-names.command.spec.tsnew file mode 100644index 00000000000..cbbc207a0e6--- /dev/null+++ b/packages/twenty-server/src/database/commands/upgrade-version-command/2-18/__tests__/2-18-workspace-command-1799200000000-normalize-legacy-index-names.command.spec.ts@@ -0,0 +1,292 @@+import { type DataSource, type QueryRunner } from 'typeorm';++import { NormalizeLegacyIndexNamesCommand } from 'src/database/commands/upgrade-version-command/2-18/2-18-workspace-command-1799200000000-normalize-legacy-index-names.command';+import { type WorkspaceCacheService } from 'src/engine/workspace-cache/services/workspace-cache.service';+import { type WorkspaceIteratorService } from 'src/database/commands/command-runners/workspace-iterator.service';+import { type WorkspaceSchemaManagerService } from 'src/engine/twenty-orm/workspace-schema-manager/workspace-schema-manager.service';+import { generateFlatIndexMetadataWithNameOrThrow } from 'src/engine/metadata-modules/index-metadata/utils/generate-flat-index.util';+import {+ deleteIndexMetadata,+ dropIndexFromWorkspaceSchema,+} from 'src/engine/workspace-manager/workspace-migration/workspace-migration-runner/action-handlers/index/utils/index-action-handler.utils';++jest.mock(+ 'src/engine/metadata-modules/index-metadata/utils/generate-flat-index.util',+);+jest.mock(+ 'src/engine/workspace-manager/workspace-migration/workspace-migration-runner/action-handlers/index/utils/index-action-handler.utils',+);++const generateFlatIndexMetadataWithNameOrThrowMock =+ generateFlatIndexMetadataWithNameOrThrow as jest.Mock;+const deleteIndexMetadataMock = deleteIndexMetadata as jest.Mock;+const dropIndexFromWorkspaceSchemaMock = dropIndexFromWorkspaceSchema as jest.Mock;++const WORKSPACE_ID = '20202020-0000-0000-0000-000000000001';++type IndexFixture = {+ universalIdentifier: string;+ id: string;+ name: string;+ expectedName: string;+};++const buildFlatEntityMaps = (indexes: IndexFixture[]) => {+ const flatIndexMaps = {+ byUniversalIdentifier: Object.fromEntries(+ indexes.map((index) => [+ index.universalIdentifier,+ {+ universalIdentifier: index.universalIdentifier,+ id: index.id,+ name: index.name,+ objectMetadataId: 'object-1',+ },+ ]),+ ),+ };++ const flatObjectMetadataMaps = {+ byUniversalIdentifier: {+ 'object-uid': {+ universalIdentifier: 'object-uid',+ nameSingular: 'myObject',+ indexMetadataUniversalIdentifiers: indexes.map(+ (index) => index.universalIdentifier,+ ),+ fieldUniversalIdentifiers: [],+ },+ },+ };++ const flatFieldMetadataMaps = { byUniversalIdentifier: {} };++ // Drive expected names per index via the mocked generator.+ generateFlatIndexMetadataWithNameOrThrowMock.mockImplementation(+ ({ flatIndex }: { flatIndex: { id: string } }) => {+ const match = indexes.find((index) => index.id === flatIndex.id);++ return { name: match?.expectedName ?? flatIndex.id };+ },+ );++ // eslint-disable-next-line @typescript-eslint/no-explicit-any+ return { flatIndexMaps, flatObjectMetadataMaps, flatFieldMetadataMaps } as any;+};++const buildQueryRunner = (): {+ queryRunner: QueryRunner;+ query: jest.Mock;+ commit: jest.Mock;+ rollback: jest.Mock;+} => {+ const query = jest.fn();+ const commit = jest.fn();+ const rollback = jest.fn();++ const queryRunner = {+ connect: jest.fn(),+ startTransaction: jest.fn(),+ commitTransaction: commit,+ rollbackTransaction: rollback,+ release: jest.fn(),+ query,+ } as unknown as QueryRunner;++ return { queryRunner, query, commit, rollback };+};++describe('NormalizeLegacyIndexNamesCommand', () => {+ let command: NormalizeLegacyIndexNamesCommand;+ let renameIndexMock: jest.Mock;+ let dropIndexMock: jest.Mock;+ let getOrRecomputeMock: jest.Mock;+ let invalidateAndRecomputeMock: jest.Mock;++ beforeEach(() => {+ jest.clearAllMocks();++ renameIndexMock = jest.fn();+ dropIndexMock = jest.fn();+ getOrRecomputeMock = jest.fn();+ invalidateAndRecomputeMock = jest.fn();++ const workspaceIteratorService = {} as WorkspaceIteratorService;+ const workspaceCacheService = {+ getOrRecompute: getOrRecomputeMock,+ invalidateAndRecompute: invalidateAndRecomputeMock,+ } as unknown as WorkspaceCacheService;+ const workspaceSchemaManagerService = {+ indexManager: {+ renameIndexWithoutRebuild: renameIndexMock,+ dropIndex: dropIndexMock,+ },+ } as unknown as WorkspaceSchemaManagerService;++ command = new NormalizeLegacyIndexNamesCommand(+ workspaceIteratorService,+ workspaceCacheService,+ workspaceSchemaManagerService,+ );+ });++ const runOnWorkspace = (dataSource: DataSource, dryRun = false) =>+ command.runOnWorkspace({+ workspaceId: WORKSPACE_ID,+ dataSource: dataSource as never,+ options: { dryRun },+ index: 0,+ total: 1,+ });++ it('renames a legacy-named index and updates its metadata row, then invalidates the cache', async () => {+ getOrRecomputeMock.mockResolvedValue(+ buildFlatEntityMaps([+ {+ universalIdentifier: 'idx-uid',+ id: 'index-1',+ name: 'legacyhash',+ expectedName: 'IDX_UNIQUE_new',+ },+ ]),+ );++ const { queryRunner, query, commit } = buildQueryRunner();+ const dataSource = {+ createQueryRunner: () => queryRunner,+ } as unknown as DataSource;++ await runOnWorkspace(dataSource);++ expect(renameIndexMock).toHaveBeenCalledWith(+ expect.objectContaining({+ fromIndexName: 'legacyhash',+ toIndexName: 'IDX_UNIQUE_new',+ }),+ );+ expect(query).toHaveBeenCalledWith(expect.stringContaining('UPDATE'), [+ 'IDX_UNIQUE_new',+ 'index-1',+ WORKSPACE_ID,+ ]);+ expect(dropIndexFromWorkspaceSchemaMock).not.toHaveBeenCalled();+ expect(commit).toHaveBeenCalled();+ expect(invalidateAndRecomputeMock).toHaveBeenCalledWith(WORKSPACE_ID, [+ 'flatIndexMaps',+ 'flatObjectMetadataMaps',+ 'flatFieldMetadataMaps',+ ]);+ });++ it('drops the redundant duplicate and renames the survivor when two indexes collide', async () => {+ getOrRecomputeMock.mockResolvedValue(+ buildFlatEntityMaps([+ {+ universalIdentifier: 'idx-a',+ id: 'index-a',+ name: 'legacyA',+ expectedName: 'IDX_UNIQUE_shared',+ },+ {+ universalIdentifier: 'idx-b',+ id: 'index-b',+ name: 'legacyB',+ expectedName: 'IDX_UNIQUE_shared',+ },+ ]),+ );++ const { queryRunner } = buildQueryRunner();+ const dataSource = {+ createQueryRunner: () => queryRunner,+ } as unknown as DataSource;++ await runOnWorkspace(dataSource);++ expect(renameIndexMock).toHaveBeenCalledTimes(1);+ expect(renameIndexMock).toHaveBeenCalledWith(+ expect.objectContaining({+ fromIndexName: 'legacyA',+ toIndexName: 'IDX_UNIQUE_shared',+ }),+ );+ expect(dropIndexFromWorkspaceSchemaMock).toHaveBeenCalledTimes(1);+ expect(dropIndexFromWorkspaceSchemaMock).toHaveBeenCalledWith(+ expect.objectContaining({ indexName: 'legacyB' }),+ );+ expect(deleteIndexMetadataMock).toHaveBeenCalledWith(+ expect.objectContaining({ entityId: 'index-b', workspaceId: WORKSPACE_ID }),+ );+ });++ it('does nothing when all index names already match', async () => {+ getOrRecomputeMock.mockResolvedValue(+ buildFlatEntityMaps([+ {+ universalIdentifier: 'idx-uid',+ id: 'index-1',+ name: 'IDX_ok',+ expectedName: 'IDX_ok',+ },+ ]),+ );++ const createQueryRunner = jest.fn();+ const dataSource = { createQueryRunner } as unknown as DataSource;++ await runOnWorkspace(dataSource);++ expect(createQueryRunner).not.toHaveBeenCalled();+ expect(renameIndexMock).not.toHaveBeenCalled();+ expect(invalidateAndRecomputeMock).not.toHaveBeenCalled();+ });++ it('does not write anything in dry-run mode', async () => {+ getOrRecomputeMock.mockResolvedValue(+ buildFlatEntityMaps([+ {+ universalIdentifier: 'idx-uid',+ id: 'index-1',+ name: 'legacyhash',+ expectedName: 'IDX_UNIQUE_new',+ },+ ]),+ );++ const createQueryRunner = jest.fn();+ const dataSource = { createQueryRunner } as unknown as DataSource;++ await runOnWorkspace(dataSource, true);++ expect(createQueryRunner).not.toHaveBeenCalled();+ expect(renameIndexMock).not.toHaveBeenCalled();+ expect(dropIndexFromWorkspaceSchemaMock).not.toHaveBeenCalled();+ expect(invalidateAndRecomputeMock).not.toHaveBeenCalled();+ });++ it('rolls back the transaction when an operation fails', async () => {+ getOrRecomputeMock.mockResolvedValue(+ buildFlatEntityMaps([+ {+ universalIdentifier: 'idx-uid',+ id: 'index-1',+ name: 'legacyhash',+ expectedName: 'IDX_UNIQUE_new',+ },+ ]),+ );++ renameIndexMock.mockRejectedValueOnce(new Error('boom'));++ const { queryRunner, commit, rollback } = buildQueryRunner();+ const dataSource = {+ createQueryRunner: () => queryRunner,+ } as unknown as DataSource;++ await expect(runOnWorkspace(dataSource)).rejects.toThrow('boom');++ expect(rollback).toHaveBeenCalled();+ expect(commit).not.toHaveBeenCalled();+ expect(invalidateAndRecomputeMock).not.toHaveBeenCalled();+ });+});diff --git a/packages/twenty-server/src/database/commands/upgrade-version-command/2-18/utils/__tests__/plan-index-name-normalization.util.spec.ts b/packages/twenty-server/src/database/commands/upgrade-version-command/2-18/utils/__tests__/plan-index-name-normalization.util.spec.tsnew file mode 100644index 00000000000..d37d5106e83--- /dev/null+++ b/packages/twenty-server/src/database/commands/upgrade-version-command/2-18/utils/__tests__/plan-index-name-normalization.util.spec.ts@@ -0,0 +1,169 @@+import {+ type FlatIndexNameStatus,+ planIndexNameNormalization,+} from 'src/database/commands/upgrade-version-command/2-18/utils/plan-index-name-normalization.util';++const buildStatus = (+ overrides: Partial<FlatIndexNameStatus> &+ Pick<FlatIndexNameStatus, 'indexMetadataId' | 'currentName' | 'expectedName'>,+): FlatIndexNameStatus => ({+ objectMetadataId: 'object-1',+ ...overrides,+});++describe('planIndexNameNormalization', () => {+ it('returns no operations for an empty input', () => {+ expect(planIndexNameNormalization([])).toEqual([]);+ });++ it('returns no operations when every index name already matches', () => {+ const statuses = [+ buildStatus({+ indexMetadataId: 'index-1',+ currentName: 'IDX_UNIQUE_aaa',+ expectedName: 'IDX_UNIQUE_aaa',+ }),+ buildStatus({+ indexMetadataId: 'index-2',+ currentName: 'IDX_bbb',+ expectedName: 'IDX_bbb',+ }),+ ];++ expect(planIndexNameNormalization(statuses)).toEqual([]);+ });++ it('renames a single legacy-named index to its expected name', () => {+ const statuses = [+ buildStatus({+ indexMetadataId: 'index-1',+ currentName: 'legacyhash000000000000000000',+ expectedName: 'IDX_UNIQUE_newhash',+ }),+ ];++ expect(planIndexNameNormalization(statuses)).toEqual([+ {+ type: 'rename',+ indexMetadataId: 'index-1',+ objectMetadataId: 'object-1',+ fromName: 'legacyhash000000000000000000',+ toName: 'IDX_UNIQUE_newhash',+ },+ ]);+ });++ it('renames the survivor and drops the duplicate when two legacy indexes resolve to the same name', () => {+ const statuses = [+ buildStatus({+ indexMetadataId: 'index-legacy-a',+ currentName: 'legacyhashA',+ expectedName: 'IDX_UNIQUE_shared',+ }),+ buildStatus({+ indexMetadataId: 'index-legacy-b',+ currentName: 'legacyhashB',+ expectedName: 'IDX_UNIQUE_shared',+ }),+ ];++ expect(planIndexNameNormalization(statuses)).toEqual([+ {+ type: 'rename',+ indexMetadataId: 'index-legacy-a',+ objectMetadataId: 'object-1',+ fromName: 'legacyhashA',+ toName: 'IDX_UNIQUE_shared',+ },+ {+ type: 'dropRedundant',+ indexMetadataId: 'index-legacy-b',+ objectMetadataId: 'object-1',+ redundantName: 'legacyhashB',+ keptName: 'IDX_UNIQUE_shared',+ },+ ]);+ });++ it('keeps the already-correct twin and only drops the legacy duplicate (no rename)', () => {+ const statuses = [+ buildStatus({+ indexMetadataId: 'index-legacy',+ currentName: 'legacyhash',+ expectedName: 'IDX_UNIQUE_shared',+ }),+ buildStatus({+ indexMetadataId: 'index-correct',+ currentName: 'IDX_UNIQUE_shared',+ expectedName: 'IDX_UNIQUE_shared',+ }),+ ];++ expect(planIndexNameNormalization(statuses)).toEqual([+ {+ type: 'dropRedundant',+ indexMetadataId: 'index-legacy',+ objectMetadataId: 'object-1',+ redundantName: 'legacyhash',+ keptName: 'IDX_UNIQUE_shared',+ },+ ]);+ });++ it('handles a mix of correct, legacy, and duplicate indexes across objects', () => {+ const statuses = [+ // already correct -> ignored+ buildStatus({+ indexMetadataId: 'ok',+ objectMetadataId: 'object-a',+ currentName: 'IDX_ok',+ expectedName: 'IDX_ok',+ }),+ // legacy single -> rename+ buildStatus({+ indexMetadataId: 'legacy-single',+ objectMetadataId: 'object-a',+ currentName: 'oldname',+ expectedName: 'IDX_renamed',+ }),+ // duplicate pair on another object -> rename + drop+ buildStatus({+ indexMetadataId: 'dup-1',+ objectMetadataId: 'object-b',+ currentName: 'oldDup1',+ expectedName: 'IDX_UNIQUE_dup',+ }),+ buildStatus({+ indexMetadataId: 'dup-2',+ objectMetadataId: 'object-b',+ currentName: 'oldDup2',+ expectedName: 'IDX_UNIQUE_dup',+ }),+ ];++ const operations = planIndexNameNormalization(statuses);++ expect(operations).toHaveLength(3);+ expect(operations).toContainEqual({+ type: 'rename',+ indexMetadataId: 'legacy-single',+ objectMetadataId: 'object-a',+ fromName: 'oldname',+ toName: 'IDX_renamed',+ });+ expect(operations).toContainEqual({+ type: 'rename',+ indexMetadataId: 'dup-1',+ objectMetadataId: 'object-b',+ fromName: 'oldDup1',+ toName: 'IDX_UNIQUE_dup',+ });+ expect(operations).toContainEqual({+ type: 'dropRedundant',+ indexMetadataId: 'dup-2',+ objectMetadataId: 'object-b',+ redundantName: 'oldDup2',+ keptName: 'IDX_UNIQUE_dup',+ });+ });+});diff --git a/packages/twenty-server/src/database/commands/upgrade-version-command/2-18/utils/plan-index-name-normalization.util.ts b/packages/twenty-server/src/database/commands/upgrade-version-command/2-18/utils/plan-index-name-normalization.util.tsnew file mode 100644index 00000000000..ea321a99544--- /dev/null+++ b/packages/twenty-server/src/database/commands/upgrade-version-command/2-18/utils/plan-index-name-normalization.util.ts@@ -0,0 +1,72 @@+export type FlatIndexNameStatus = {+ indexMetadataId: string;+ objectMetadataId: string;+ currentName: string;+ expectedName: string;+};++export type RenameIndexNameOperation = {+ type: 'rename';+ indexMetadataId: string;+ objectMetadataId: string;+ fromName: string;+ toName: string;+};++export type DropRedundantIndexOperation = {+ type: 'dropRedundant';+ indexMetadataId: string;+ objectMetadataId: string;+ redundantName: string;+ keptName: string;+};++export type IndexNameNormalizationOperation =+ | RenameIndexNameOperation+ | DropRedundantIndexOperation;++export const planIndexNameNormalization = (+ indexStatuses: FlatIndexNameStatus[],+): IndexNameNormalizationOperation[] => {+ const operations: IndexNameNormalizationOperation[] = [];++ const statusesByExpectedName = new Map<string, FlatIndexNameStatus[]>();++ for (const status of indexStatuses) {+ const group = statusesByExpectedName.get(status.expectedName) ?? [];++ group.push(status);+ statusesByExpectedName.set(status.expectedName, group);+ }++ for (const [expectedName, group] of statusesByExpectedName) {+ const survivor =+ group.find((status) => status.currentName === expectedName) ?? group[0];++ if (survivor.currentName !== expectedName) {+ operations.push({+ type: 'rename',+ indexMetadataId: survivor.indexMetadataId,+ objectMetadataId: survivor.objectMetadataId,+ fromName: survivor.currentName,+ toName: expectedName,+ });+ }++ for (const status of group) {+ if (status.indexMetadataId === survivor.indexMetadataId) {+ continue;+ }++ operations.push({+ type: 'dropRedundant',+ indexMetadataId: status.indexMetadataId,+ objectMetadataId: status.objectMetadataId,+ redundantName: status.currentName,+ keptName: expectedName,+ });+ }+ }++ return operations;+};diff --git a/packages/twenty-server/src/database/commands/upgrade-version-command/workspace-command-provider.module.ts b/packages/twenty-server/src/database/commands/upgrade-version-command/workspace-command-provider.module.tsindex 33112e8e57c..852da026fe2 100644--- a/packages/twenty-server/src/database/commands/upgrade-version-command/workspace-command-provider.module.ts+++ b/packages/twenty-server/src/database/commands/upgrade-version-command/workspace-command-provider.module.ts@@ -18,6 +18,7 @@ import { V2_14_UpgradeVersionCommandModule } from 'src/database/commands/upgradeimport { V2_15_UpgradeVersionCommandModule } from 'src/database/commands/upgrade-version-command/2-15/2-15-upgrade-version-command.module';import { V2_16_UpgradeVersionCommandModule } from 'src/database/commands/upgrade-version-command/2-16/2-16-upgrade-version-command.module';import { V2_17_UpgradeVersionCommandModule } from 'src/database/commands/upgrade-version-command/2-17/2-17-upgrade-version-command.module';+import { V2_18_UpgradeVersionCommandModule } from 'src/database/commands/upgrade-version-command/2-18/2-18-upgrade-version-command.module';@Module({imports: [@@ -39,6 +40,7 @@ import { V2_17_UpgradeVersionCommandModule } from 'src/database/commands/upgradeV2_15_UpgradeVersionCommandModule,V2_16_UpgradeVersionCommandModule,V2_17_UpgradeVersionCommandModule,+ V2_18_UpgradeVersionCommandModule,],})export class WorkspaceCommandProviderModule {}diff --git a/packages/twenty-server/src/engine/twenty-orm/workspace-schema-manager/services/workspace-schema-index-manager.service.ts b/packages/twenty-server/src/engine/twenty-orm/workspace-schema-manager/services/workspace-schema-index-manager.service.tsindex 528018aec27..6392e6a3d1d 100644--- a/packages/twenty-server/src/engine/twenty-orm/workspace-schema-manager/services/workspace-schema-index-manager.service.ts+++ b/packages/twenty-server/src/engine/twenty-orm/workspace-schema-manager/services/workspace-schema-index-manager.service.ts@@ -90,4 +90,20 @@ export class WorkspaceSchemaIndexManagerService {await queryRunner.query(sql);}++ async renameIndexWithoutRebuild({+ queryRunner,+ schemaName,+ fromIndexName,+ toIndexName,+ }: {+ queryRunner: QueryRunner;+ schemaName: string;+ fromIndexName: string;+ toIndexName: string;+ }): Promise<void> {+ const sql = `ALTER INDEX ${escapeIdentifier(schemaName)}.${escapeIdentifier(fromIndexName)} RENAME TO ${escapeIdentifier(toIndexName)}`;++ await queryRunner.query(sql);+ }}