The open alternative to Salesforce, designed for AI.
TypeScript crmcrm-systemcustomergood-first-issuegraphqlhacktoberfestjavascriptmarketingmonoreponestjsopen-sourcepostgresqlreactreactjssalestypescriptweb
Provision and backfill message and calendar targets (#24780)
Félix Malfaitd91dc126e7ef
diff --git a/packages/twenty-server/src/database/commands/upgrade-version-command/2-37/2-37-upgrade-version-command.module.ts b/packages/twenty-server/src/database/commands/upgrade-version-command/2-37/2-37-upgrade-version-command.module.tsnew file mode 100644index 00000000000..0cc00a80325--- /dev/null+++ b/packages/twenty-server/src/database/commands/upgrade-version-command/2-37/2-37-upgrade-version-command.module.ts@@ -0,0 +1,22 @@+import { Module } from '@nestjs/common';++import { WorkspaceIteratorModule } from 'src/database/commands/command-runners/workspace-iterator.module';+import { BackfillMessageCalendarTargetsCommand } from 'src/database/commands/upgrade-version-command/2-37/2-37-workspace-command-1787832413051-backfill-message-calendar-targets.command';+import { SyncMessageCalendarTargetMetadataCommand } from 'src/database/commands/upgrade-version-command/2-37/2-37-workspace-command-1787832412051-sync-message-calendar-target-metadata.command';+import { ApplicationModule } from 'src/engine/core-modules/application/application.module';+import { WorkspaceCacheModule } from 'src/engine/workspace-cache/workspace-cache.module';+import { WorkspaceMigrationModule } from 'src/engine/workspace-manager/workspace-migration/workspace-migration.module';++@Module({+ imports: [+ ApplicationModule,+ WorkspaceCacheModule,+ WorkspaceIteratorModule,+ WorkspaceMigrationModule,+ ],+ providers: [+ SyncMessageCalendarTargetMetadataCommand,+ BackfillMessageCalendarTargetsCommand,+ ],+})+export class V2_37_UpgradeVersionCommandModule {}diff --git a/packages/twenty-server/src/database/commands/upgrade-version-command/2-37/2-37-workspace-command-1787832412051-sync-message-calendar-target-metadata.command.ts b/packages/twenty-server/src/database/commands/upgrade-version-command/2-37/2-37-workspace-command-1787832412051-sync-message-calendar-target-metadata.command.tsnew file mode 100644index 00000000000..7efdf7a900a--- /dev/null+++ b/packages/twenty-server/src/database/commands/upgrade-version-command/2-37/2-37-workspace-command-1787832412051-sync-message-calendar-target-metadata.command.ts@@ -0,0 +1,262 @@+import { Command } from 'nest-commander';+import { STANDARD_OBJECTS } from 'twenty-shared/metadata';++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 { getStandardFlatEntitiesToCreateOrThrow } from 'src/database/commands/upgrade-version-command/2-10/utils/get-standard-flat-entities-to-create-or-throw.util';+import {+ buildTargetFieldCollisionRenameUpdates,+ buildTargetObjectCollisionRenameUpdates,+} from 'src/database/commands/upgrade-version-command/2-37/utils/build-target-metadata-collision-renames.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 { type FlatFieldMetadata } from 'src/engine/metadata-modules/flat-field-metadata/types/flat-field-metadata.type';+import { type FlatIndexMetadata } from 'src/engine/metadata-modules/flat-index-metadata/types/flat-index-metadata.type';+import { type FlatObjectMetadata } from 'src/engine/metadata-modules/flat-object-metadata/types/flat-object-metadata.type';+import { WorkspaceCacheService } from 'src/engine/workspace-cache/services/workspace-cache.service';+import { computeTwentyStandardApplicationAllFlatEntityMaps } from 'src/engine/workspace-manager/twenty-standard-application/utils/twenty-standard-application-all-flat-entity-maps.constant';+import { WorkspaceMigrationValidateBuildAndRunService } from 'src/engine/workspace-manager/workspace-migration/services/workspace-migration-validate-build-and-run-service';++const getUniversalIdentifiers = (+ entitiesByName: Record<string, { universalIdentifier: string }>,+) =>+ Object.values(entitiesByName).map(+ ({ universalIdentifier }) => universalIdentifier,+ );++const TARGET_OBJECT_UNIVERSAL_IDENTIFIERS = [+ STANDARD_OBJECTS.calendarEventTarget.universalIdentifier,+ STANDARD_OBJECTS.messageThreadTarget.universalIdentifier,+];++const TARGET_FIELD_UNIVERSAL_IDENTIFIERS = [+ ...getUniversalIdentifiers(STANDARD_OBJECTS.calendarEventTarget.fields),+ ...getUniversalIdentifiers(STANDARD_OBJECTS.messageThreadTarget.fields),+ STANDARD_OBJECTS.calendarEvent.fields.calendarEventTargets+ .universalIdentifier,+ STANDARD_OBJECTS.messageThread.fields.messageThreadTargets+ .universalIdentifier,+ ...(['person', 'company', 'opportunity'] as const).flatMap((objectName) => [+ STANDARD_OBJECTS[objectName].fields.calendarEventTargets+ .universalIdentifier,+ STANDARD_OBJECTS[objectName].fields.messageThreadTargets+ .universalIdentifier,+ ]),+];++const TARGET_INDEX_UNIVERSAL_IDENTIFIERS = [+ ...getUniversalIdentifiers(STANDARD_OBJECTS.calendarEventTarget.indexes),+ ...getUniversalIdentifiers(STANDARD_OBJECTS.messageThreadTarget.indexes),+];++@RegisteredWorkspaceCommand('2.37.0', 1787832412051)+@Command({+ name: 'upgrade:2-37:sync-message-calendar-target-metadata',+ description:+ 'Create messageThreadTarget and calendarEventTarget standard metadata in existing workspaces',+})+export class SyncMessageCalendarTargetMetadataCommand extends ProvisionedWorkspaceCommandRunner {+ constructor(+ protected readonly workspaceIteratorService: WorkspaceIteratorService,+ private readonly applicationService: ApplicationService,+ private readonly workspaceCacheService: WorkspaceCacheService,+ private readonly workspaceMigrationValidateBuildAndRunService: WorkspaceMigrationValidateBuildAndRunService,+ ) {+ super(workspaceIteratorService);+ }++ override async runOnWorkspace({+ workspaceId,+ options,+ }: RunOnWorkspaceArgs): Promise<void> {+ const isDryRun = options.dryRun ?? false;+ const { flatObjectMetadataMaps, flatFieldMetadataMaps, flatIndexMaps } =+ await this.workspaceCacheService.getOrRecompute(workspaceId, [+ 'flatObjectMetadataMaps',+ 'flatFieldMetadataMaps',+ 'flatIndexMaps',+ ]);+ const requiredObjectNames = [+ 'calendarEvent',+ 'messageThread',+ 'person',+ 'company',+ 'opportunity',+ ] as const;+ const missingObjectNames = requiredObjectNames.filter(+ (objectName) =>+ !flatObjectMetadataMaps.byUniversalIdentifier[+ STANDARD_OBJECTS[objectName].universalIdentifier+ ],+ );++ if (missingObjectNames.length > 0) {+ this.logger.warn(+ `Skipping message and calendar target metadata for workspace ${workspaceId}: missing ${missingObjectNames.join(', ')} metadata`,+ );++ return;+ }+ const { twentyStandardFlatApplication } =+ await this.applicationService.findWorkspaceTwentyStandardAndCustomApplicationOrThrow(+ { workspaceId },+ );+ const now = new Date().toISOString();+ const { allFlatEntityMaps: standardAllFlatEntityMaps } =+ computeTwentyStandardApplicationAllFlatEntityMaps({+ now,+ workspaceId,+ twentyStandardApplicationId: twentyStandardFlatApplication.id,+ });+ const objectRenameUpdates = buildTargetObjectCollisionRenameUpdates({+ flatObjectMetadataMaps,+ now,+ });+ const fieldRenameUpdates = buildTargetFieldCollisionRenameUpdates({+ flatFieldMetadataMaps,+ now,+ });+ const allFlatEntityOperationByMetadataName = {+ objectMetadata: {+ flatEntityToCreate:+ getStandardFlatEntitiesToCreateOrThrow<FlatObjectMetadata>({+ standardFlatEntityMaps:+ standardAllFlatEntityMaps.flatObjectMetadataMaps,+ existingFlatEntityMaps: flatObjectMetadataMaps,+ universalIdentifiers: TARGET_OBJECT_UNIVERSAL_IDENTIFIERS,+ }),+ flatEntityToDelete: [],+ flatEntityToUpdate: [],+ },+ fieldMetadata: {+ flatEntityToCreate:+ getStandardFlatEntitiesToCreateOrThrow<FlatFieldMetadata>({+ standardFlatEntityMaps:+ standardAllFlatEntityMaps.flatFieldMetadataMaps,+ existingFlatEntityMaps: flatFieldMetadataMaps,+ universalIdentifiers: TARGET_FIELD_UNIVERSAL_IDENTIFIERS,+ }),+ flatEntityToDelete: [],+ flatEntityToUpdate: [],+ },+ index: {+ flatEntityToCreate:+ getStandardFlatEntitiesToCreateOrThrow<FlatIndexMetadata>({+ standardFlatEntityMaps: standardAllFlatEntityMaps.flatIndexMaps,+ existingFlatEntityMaps: flatIndexMaps,+ universalIdentifiers: TARGET_INDEX_UNIVERSAL_IDENTIFIERS,+ }),+ flatEntityToDelete: [],+ flatEntityToUpdate: [],+ },+ };+ const createOperationCount = Object.values(+ allFlatEntityOperationByMetadataName,+ ).reduce(+ (count, operations) => count + operations.flatEntityToCreate.length,+ 0,+ );+ const totalOperationCount =+ objectRenameUpdates.length ++ fieldRenameUpdates.length ++ createOperationCount;++ if (totalOperationCount === 0) {+ this.logger.log(+ `Message and calendar target metadata already exists for workspace ${workspaceId}, skipping`,+ );++ return;+ }++ if (isDryRun) {+ this.logger.log(+ `[DRY RUN] Would rename ${objectRenameUpdates.length} object and ${fieldRenameUpdates.length} field collision(s), then create ${createOperationCount} target metadata entities for workspace ${workspaceId}`,+ );++ return;+ }++ for (const flatObjectMetadata of objectRenameUpdates) {+ await this.runRenameMigration({+ workspaceId,+ applicationUniversalIdentifier:+ flatObjectMetadata.applicationUniversalIdentifier,+ allFlatEntityOperationByMetadataName: {+ objectMetadata: {+ flatEntityToCreate: [],+ flatEntityToDelete: [],+ flatEntityToUpdate: [flatObjectMetadata],+ },+ },+ });+ }++ for (const flatFieldMetadata of fieldRenameUpdates) {+ await this.runRenameMigration({+ workspaceId,+ applicationUniversalIdentifier:+ flatFieldMetadata.applicationUniversalIdentifier,+ allFlatEntityOperationByMetadataName: {+ fieldMetadata: {+ flatEntityToCreate: [],+ flatEntityToDelete: [],+ flatEntityToUpdate: [flatFieldMetadata],+ },+ },+ });+ }++ if (createOperationCount > 0) {+ const result =+ await this.workspaceMigrationValidateBuildAndRunService.validateBuildAndRunLegacyWorkspaceMigration(+ {+ allFlatEntityOperationByMetadataName,+ workspaceId,+ isSystemBuild: true,+ applicationUniversalIdentifier:+ twentyStandardFlatApplication.universalIdentifier,+ },+ );++ if (result.status === 'fail') {+ throw new Error(+ `Failed to create message and calendar target metadata for workspace ${workspaceId}: ${JSON.stringify(result, null, 2)}`,+ );+ }+ }++ this.logger.log(+ `Created message and calendar target metadata for workspace ${workspaceId}`,+ );+ }++ private async runRenameMigration({+ workspaceId,+ applicationUniversalIdentifier,+ allFlatEntityOperationByMetadataName,+ }: {+ workspaceId: string;+ applicationUniversalIdentifier: string;+ allFlatEntityOperationByMetadataName: Parameters<+ WorkspaceMigrationValidateBuildAndRunService['validateBuildAndRunLegacyWorkspaceMigration']+ >[0]['allFlatEntityOperationByMetadataName'];+ }): Promise<void> {+ const result =+ await this.workspaceMigrationValidateBuildAndRunService.validateBuildAndRunLegacyWorkspaceMigration(+ {+ allFlatEntityOperationByMetadataName,+ workspaceId,+ isSystemBuild: true,+ applicationUniversalIdentifier,+ },+ );++ if (result.status === 'fail') {+ throw new Error(+ `Failed to rename target metadata collision for workspace ${workspaceId}: ${JSON.stringify(result, null, 2)}`,+ );+ }+ }+}diff --git a/packages/twenty-server/src/database/commands/upgrade-version-command/2-37/2-37-workspace-command-1787832413051-backfill-message-calendar-targets.command.ts b/packages/twenty-server/src/database/commands/upgrade-version-command/2-37/2-37-workspace-command-1787832413051-backfill-message-calendar-targets.command.tsnew file mode 100644index 00000000000..20b7898e78e--- /dev/null+++ b/packages/twenty-server/src/database/commands/upgrade-version-command/2-37/2-37-workspace-command-1787832413051-backfill-message-calendar-targets.command.ts@@ -0,0 +1,110 @@+import { Command } from 'nest-commander';+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 { buildMessageCalendarTargetBackfillQueries } from 'src/database/commands/upgrade-version-command/2-37/utils/build-message-calendar-target-backfill-queries.util';+import { RegisteredWorkspaceCommand } from 'src/engine/core-modules/upgrade/decorators/registered-workspace-command.decorator';+import {+ MESSAGE_CALENDAR_TARGET_BACKFILL_TIMESTAMP,+ MESSAGE_CALENDAR_TARGET_MIGRATION_VERSION,+} from 'src/engine/core-modules/target/constants/message-calendar-target-migration.constants';+import { getWorkspaceSchemaName } from 'src/engine/workspace-datasource/utils/get-workspace-schema-name.util';++const BACKFILL_BATCH_SIZE = 5_000;++@RegisteredWorkspaceCommand(+ MESSAGE_CALENDAR_TARGET_MIGRATION_VERSION,+ MESSAGE_CALENDAR_TARGET_BACKFILL_TIMESTAMP,+)+@Command({+ name: 'upgrade:2-37:backfill-message-calendar-targets',+ description:+ 'Backfill message and calendar target junctions without emitting record events',+})+export class BackfillMessageCalendarTargetsCommand extends ProvisionedWorkspaceCommandRunner {+ constructor(+ protected readonly workspaceIteratorService: WorkspaceIteratorService,+ ) {+ super(workspaceIteratorService);+ }++ override async runOnWorkspace({+ workspaceId,+ options,+ dataSource,+ }: RunOnWorkspaceArgs): Promise<void> {+ if (!isDefined(dataSource)) {+ this.logger.warn(+ `Skipping message and calendar target backfill for workspace ${workspaceId}: no workspace data source`,+ );++ return;+ }++ const schemaName = getWorkspaceSchemaName(workspaceId);+ const [targetTables] = await dataSource.query<+ Array<{+ calendarEventTarget: string | null;+ messageThreadTarget: string | null;+ }>+ >(+ `SELECT+ to_regclass($1) AS "calendarEventTarget",+ to_regclass($2) AS "messageThreadTarget"`,+ [+ `"${schemaName}"."calendarEventTarget"`,+ `"${schemaName}"."messageThreadTarget"`,+ ],+ );++ if (+ !isDefined(targetTables?.calendarEventTarget) ||+ !isDefined(targetTables.messageThreadTarget)+ ) {+ this.logger.warn(+ `Skipping message and calendar target backfill for workspace ${workspaceId}: target tables are not provisioned`,+ );++ return;+ }++ const queries = buildMessageCalendarTargetBackfillQueries({+ batchSize: BACKFILL_BATCH_SIZE,+ schemaName,+ });++ if (options.dryRun) {+ for (const query of queries) {+ const [result] = await dataSource.query<Array<{ count: number }>>(+ query.countSql,+ );++ this.logger.log(+ `[DRY RUN] Would create ${result?.count ?? 0} ${query.label} for workspace ${workspaceId}`,+ );+ }++ return;+ }++ for (const query of queries) {+ let candidateCount = 0;+ let totalInsertedCount = 0;++ do {+ const [result] = await dataSource.query<+ Array<{ candidateCount: number; insertedCount: number }>+ >(query.insertSql);++ candidateCount = result?.candidateCount ?? 0;+ totalInsertedCount += result?.insertedCount ?? 0;+ } while (candidateCount === BACKFILL_BATCH_SIZE);++ this.logger.log(+ `Created ${totalInsertedCount} ${query.label} for workspace ${workspaceId}`,+ );+ }+ }+}diff --git a/packages/twenty-server/src/database/commands/upgrade-version-command/2-37/__tests__/2-37-workspace-command-1787832413051-backfill-message-calendar-targets.command.spec.ts b/packages/twenty-server/src/database/commands/upgrade-version-command/2-37/__tests__/2-37-workspace-command-1787832413051-backfill-message-calendar-targets.command.spec.tsnew file mode 100644index 00000000000..083a460e5d8--- /dev/null+++ b/packages/twenty-server/src/database/commands/upgrade-version-command/2-37/__tests__/2-37-workspace-command-1787832413051-backfill-message-calendar-targets.command.spec.ts@@ -0,0 +1,86 @@+import { type WorkspaceIteratorService } from 'src/database/commands/command-runners/workspace-iterator.service';+import { BackfillMessageCalendarTargetsCommand } from 'src/database/commands/upgrade-version-command/2-37/2-37-workspace-command-1787832413051-backfill-message-calendar-targets.command';++const WORKSPACE_ID = '20202020-0000-0000-0000-000000000001';++describe('BackfillMessageCalendarTargetsCommand', () => {+ it('skips workspaces without a data source', async () => {+ const command = new BackfillMessageCalendarTargetsCommand(+ {} as WorkspaceIteratorService,+ );++ jest.spyOn(command['logger'], 'warn').mockImplementation();++ await expect(+ command.runOnWorkspace({+ workspaceId: WORKSPACE_ID,+ options: {},+ dataSource: undefined,+ index: 0,+ total: 1,+ }),+ ).resolves.toBeUndefined();+ expect(command['logger'].warn).toHaveBeenCalledWith(+ `Skipping message and calendar target backfill for workspace ${WORKSPACE_ID}: no workspace data source`,+ );+ });++ it('continues a full candidate batch when conflicts reduce inserted rows', async () => {+ const query = jest+ .fn()+ .mockResolvedValueOnce([+ {+ calendarEventTarget: 'workspace.calendarEventTarget',+ messageThreadTarget: 'workspace.messageThreadTarget',+ },+ ])+ .mockResolvedValueOnce([{ candidateCount: 5_000, insertedCount: 4_999 }])+ .mockResolvedValueOnce([{ candidateCount: 1, insertedCount: 1 }])+ .mockResolvedValue([{ candidateCount: 0, insertedCount: 0 }]);+ const command = new BackfillMessageCalendarTargetsCommand(+ {} as WorkspaceIteratorService,+ );++ jest.spyOn(command['logger'], 'log').mockImplementation();++ await command.runOnWorkspace({+ workspaceId: WORKSPACE_ID,+ options: {},+ dataSource: { query } as never,+ index: 0,+ total: 1,+ });++ expect(query).toHaveBeenCalledTimes(8);+ expect(command['logger'].log).toHaveBeenCalledWith(+ `Created 5000 calendar event person targets for workspace ${WORKSPACE_ID}`,+ );+ });++ it('skips workspaces whose target tables were not provisioned', async () => {+ const query = jest.fn().mockResolvedValue([+ {+ calendarEventTarget: null,+ messageThreadTarget: null,+ },+ ]);+ const command = new BackfillMessageCalendarTargetsCommand(+ {} as WorkspaceIteratorService,+ );++ jest.spyOn(command['logger'], 'warn').mockImplementation();++ await command.runOnWorkspace({+ workspaceId: WORKSPACE_ID,+ options: {},+ dataSource: { query } as never,+ index: 0,+ total: 1,+ });++ expect(query).toHaveBeenCalledTimes(1);+ expect(command['logger'].warn).toHaveBeenCalledWith(+ `Skipping message and calendar target backfill for workspace ${WORKSPACE_ID}: target tables are not provisioned`,+ );+ });+});diff --git a/packages/twenty-server/src/database/commands/upgrade-version-command/2-37/utils/__tests__/build-message-calendar-target-backfill-queries.util.spec.ts b/packages/twenty-server/src/database/commands/upgrade-version-command/2-37/utils/__tests__/build-message-calendar-target-backfill-queries.util.spec.tsnew file mode 100644index 00000000000..7954d4a3463--- /dev/null+++ b/packages/twenty-server/src/database/commands/upgrade-version-command/2-37/utils/__tests__/build-message-calendar-target-backfill-queries.util.spec.ts@@ -0,0 +1,60 @@+import { buildMessageCalendarTargetBackfillQueries } from 'src/database/commands/upgrade-version-command/2-37/utils/build-message-calendar-target-backfill-queries.util';++describe('buildMessageCalendarTargetBackfillQueries', () => {+ const queries = buildMessageCalendarTargetBackfillQueries({+ batchSize: 5_000,+ schemaName: 'workspace_test',+ });++ it('builds one event-free raw insert for every parent and target type', () => {+ expect(queries).toHaveLength(6);+ expect(queries.map(({ label }) => label)).toEqual([+ 'calendar event person targets',+ 'calendar event company targets',+ 'calendar event opportunity targets',+ 'message thread person targets',+ 'message thread company targets',+ 'message thread opportunity targets',+ ]);+ });++ it.each(queries)('makes $label restartable and bounded', ({ insertSql }) => {+ expect(insertSql).toContain('NOT EXISTS');+ expect(insertSql).toContain('LIMIT 5000');+ expect(insertSql).toContain('ON CONFLICT DO NOTHING');+ expect(insertSql).toContain('AS "candidateCount"');+ expect(insertSql).toContain('AS "insertedCount"');+ expect(insertSql).toContain('TRUE, FALSE');+ expect(insertSql).not.toContain('messageParticipantTarget');+ });++ it('quotes the workspace schema in every query', () => {+ for (const { countSql, insertSql } of queries) {+ expect(countSql).toContain('"workspace_test"');+ expect(insertSql).toContain('"workspace_test"');+ }+ });++ it.each(queries)(+ 'excludes soft-deleted source records from $label',+ ({ label, insertSql }) => {+ expect(insertSql).toContain('participant."deletedAt" IS NULL');+ expect(insertSql).toContain('person."deletedAt" IS NULL');++ if (label.startsWith('calendar event')) {+ expect(insertSql).toContain('calendar_event."deletedAt" IS NULL');+ } else {+ expect(insertSql).toContain('message."deletedAt" IS NULL');+ expect(insertSql).toContain('message_thread."deletedAt" IS NULL');+ }++ if (label.includes('company')) {+ expect(insertSql).toContain('company."deletedAt" IS NULL');+ }++ if (label.includes('opportunity')) {+ expect(insertSql).toContain('opportunity."deletedAt" IS NULL');+ }+ },+ );+});diff --git a/packages/twenty-server/src/database/commands/upgrade-version-command/2-37/utils/__tests__/build-target-metadata-collision-renames.util.spec.ts b/packages/twenty-server/src/database/commands/upgrade-version-command/2-37/utils/__tests__/build-target-metadata-collision-renames.util.spec.tsnew file mode 100644index 00000000000..e1778bb16f1--- /dev/null+++ b/packages/twenty-server/src/database/commands/upgrade-version-command/2-37/utils/__tests__/build-target-metadata-collision-renames.util.spec.ts@@ -0,0 +1,121 @@+import { STANDARD_OBJECTS } from 'twenty-shared/metadata';++import { type FlatFieldMetadata } from 'src/engine/metadata-modules/flat-field-metadata/types/flat-field-metadata.type';+import { type FlatObjectMetadata } from 'src/engine/metadata-modules/flat-object-metadata/types/flat-object-metadata.type';+import {+ buildTargetFieldCollisionRenameUpdates,+ buildTargetObjectCollisionRenameUpdates,+} from 'src/database/commands/upgrade-version-command/2-37/utils/build-target-metadata-collision-renames.util';++const NOW = '2026-08-25T00:00:00.000Z';++describe('target metadata collision renames', () => {+ it('renames a custom object occupying a target object name', () => {+ const collidingObject = {+ universalIdentifier: 'custom-object',+ nameSingular: 'calendarEventTarget',+ namePlural: 'calendarEventTargets',+ labelSingular: 'Calendar Event Target',+ labelPlural: 'Calendar Event Targets',+ } as FlatObjectMetadata;+ const flatObjectMetadataMaps = {+ byUniversalIdentifier: { 'custom-object': collidingObject },+ };++ expect(+ buildTargetObjectCollisionRenameUpdates({+ flatObjectMetadataMaps,+ now: NOW,+ }),+ ).toEqual([+ expect.objectContaining({+ nameSingular: 'calendarEventTargetOld',+ namePlural: 'calendarEventTargetsOld',+ labelSingular: 'Calendar Event Target (Old)',+ updatedAt: NOW,+ }),+ ]);+ });++ it('bases both renamed names on the custom object during a partial collision', () => {+ const collidingObject = {+ universalIdentifier: 'custom-object',+ nameSingular: 'calendarEventTarget',+ namePlural: 'customerInteractions',+ labelSingular: 'Customer interaction',+ labelPlural: 'Customer interactions',+ } as FlatObjectMetadata;++ expect(+ buildTargetObjectCollisionRenameUpdates({+ flatObjectMetadataMaps: {+ byUniversalIdentifier: { 'custom-object': collidingObject },+ },+ now: NOW,+ }),+ ).toEqual([+ expect.objectContaining({+ nameSingular: 'calendarEventTargetOld',+ namePlural: 'customerInteractionsOld',+ }),+ ]);+ });++ it('renames only a conflicting field on the same parent object', () => {+ const collidingField = {+ universalIdentifier: 'custom-field',+ objectMetadataUniversalIdentifier:+ STANDARD_OBJECTS.company.universalIdentifier,+ name: 'messageThreadTargets',+ label: 'Email history',+ } as FlatFieldMetadata;+ const unrelatedField = {+ universalIdentifier: 'unrelated-field',+ objectMetadataUniversalIdentifier:+ STANDARD_OBJECTS.person.universalIdentifier,+ name: 'messageThreadTargetsOld',+ label: 'Unrelated',+ } as FlatFieldMetadata;+ const flatFieldMetadataMaps = {+ byUniversalIdentifier: {+ 'custom-field': collidingField,+ 'unrelated-field': unrelatedField,+ },+ };++ expect(+ buildTargetFieldCollisionRenameUpdates({+ flatFieldMetadataMaps,+ now: NOW,+ }),+ ).toEqual([+ expect.objectContaining({+ universalIdentifier: 'custom-field',+ name: 'messageThreadTargetsOld',+ label: 'Email history (Old)',+ updatedAt: NOW,+ }),+ ]);+ });++ it('does not rename the standard target fields themselves', () => {+ const standardField = {+ universalIdentifier:+ STANDARD_OBJECTS.calendarEvent.fields.calendarEventTargets+ .universalIdentifier,+ objectMetadataUniversalIdentifier:+ STANDARD_OBJECTS.calendarEvent.universalIdentifier,+ name: 'calendarEventTargets',+ } as FlatFieldMetadata;+ const flatFieldMetadataMaps = {+ byUniversalIdentifier: { standard: standardField },+ };++ expect(+ buildTargetFieldCollisionRenameUpdates({+ flatFieldMetadataMaps,+ now: NOW,+ }),+ ).toEqual([]);+ });+});diff --git a/packages/twenty-server/src/database/commands/upgrade-version-command/2-37/utils/build-message-calendar-target-backfill-queries.util.ts b/packages/twenty-server/src/database/commands/upgrade-version-command/2-37/utils/build-message-calendar-target-backfill-queries.util.tsnew file mode 100644index 00000000000..a26bfa8688f--- /dev/null+++ b/packages/twenty-server/src/database/commands/upgrade-version-command/2-37/utils/build-message-calendar-target-backfill-queries.util.ts@@ -0,0 +1,186 @@+type TargetBackfillQuery = {+ label: string;+ countSql: string;+ insertSql: string;+};++const buildTargetBackfillQuery = ({+ batchSize,+ candidateFromSql,+ label,+ parentColumnName,+ schemaName,+ targetColumnName,+ targetTableName,+}: {+ batchSize: number;+ candidateFromSql: string;+ label: string;+ parentColumnName: 'calendarEventId' | 'messageThreadId';+ schemaName: string;+ targetColumnName:+ | 'targetPersonId'+ | 'targetCompanyId'+ | 'targetOpportunityId';+ targetTableName: 'calendarEventTarget' | 'messageThreadTarget';+}): TargetBackfillQuery => {+ const candidateSql = `SELECT DISTINCT source."parentId", source."targetId"+${candidateFromSql}+WHERE source."parentId" IS NOT NULL+ AND source."targetId" IS NOT NULL+ AND NOT EXISTS (+ SELECT 1+ FROM "${schemaName}"."${targetTableName}" existing_target+ WHERE existing_target."${parentColumnName}" = source."parentId"+ AND existing_target."${targetColumnName}" = source."targetId"+ )`;++ return {+ label,+ countSql: `SELECT COUNT(*)::int AS "count" FROM (${candidateSql}) candidates`,+ insertSql: `WITH candidates AS (+ ${candidateSql}+ ORDER BY source."parentId", source."targetId"+ LIMIT ${batchSize}+), inserted AS (+ INSERT INTO "${schemaName}"."${targetTableName}" (+ "${parentColumnName}",+ "${targetColumnName}",+ "isAutomaticallyAssigned",+ "isManuallyAssigned"+ )+ SELECT "parentId", "targetId", TRUE, FALSE+ FROM candidates+ ON CONFLICT DO NOTHING+ RETURNING "id"+)+SELECT+ (SELECT COUNT(*)::int FROM candidates) AS "candidateCount",+ (SELECT COUNT(*)::int FROM inserted) AS "insertedCount"`,+ };+};++export const buildMessageCalendarTargetBackfillQueries = ({+ batchSize,+ schemaName,+}: {+ batchSize: number;+ schemaName: string;+}): TargetBackfillQuery[] => [+ buildTargetBackfillQuery({+ batchSize,+ schemaName,+ label: 'calendar event person targets',+ targetTableName: 'calendarEventTarget',+ parentColumnName: 'calendarEventId',+ targetColumnName: 'targetPersonId',+ candidateFromSql: `FROM (+ SELECT participant."calendarEventId" AS "parentId", participant."personId" AS "targetId"+ FROM "${schemaName}"."calendarEventParticipant" participant+ INNER JOIN "${schemaName}"."calendarEvent" calendar_event ON calendar_event."id" = participant."calendarEventId"+ INNER JOIN "${schemaName}"."person" person ON person."id" = participant."personId"+ WHERE participant."deletedAt" IS NULL+ AND calendar_event."deletedAt" IS NULL+ AND person."deletedAt" IS NULL+) source`,+ }),+ buildTargetBackfillQuery({+ batchSize,+ schemaName,+ label: 'calendar event company targets',+ targetTableName: 'calendarEventTarget',+ parentColumnName: 'calendarEventId',+ targetColumnName: 'targetCompanyId',+ candidateFromSql: `FROM (+ SELECT participant."calendarEventId" AS "parentId", person."companyId" AS "targetId"+ FROM "${schemaName}"."calendarEventParticipant" participant+ INNER JOIN "${schemaName}"."calendarEvent" calendar_event ON calendar_event."id" = participant."calendarEventId"+ INNER JOIN "${schemaName}"."person" person ON person."id" = participant."personId"+ INNER JOIN "${schemaName}"."company" company ON company."id" = person."companyId"+ WHERE participant."deletedAt" IS NULL+ AND calendar_event."deletedAt" IS NULL+ AND person."deletedAt" IS NULL+ AND company."deletedAt" IS NULL+) source`,+ }),+ buildTargetBackfillQuery({+ batchSize,+ schemaName,+ label: 'calendar event opportunity targets',+ targetTableName: 'calendarEventTarget',+ parentColumnName: 'calendarEventId',+ targetColumnName: 'targetOpportunityId',+ candidateFromSql: `FROM (+ SELECT participant."calendarEventId" AS "parentId", opportunity."id" AS "targetId"+ FROM "${schemaName}"."calendarEventParticipant" participant+ INNER JOIN "${schemaName}"."calendarEvent" calendar_event ON calendar_event."id" = participant."calendarEventId"+ INNER JOIN "${schemaName}"."person" person ON person."id" = participant."personId"+ INNER JOIN "${schemaName}"."opportunity" opportunity ON opportunity."pointOfContactId" = participant."personId"+ WHERE participant."deletedAt" IS NULL+ AND calendar_event."deletedAt" IS NULL+ AND person."deletedAt" IS NULL+ AND opportunity."deletedAt" IS NULL+) source`,+ }),+ buildTargetBackfillQuery({+ batchSize,+ schemaName,+ label: 'message thread person targets',+ targetTableName: 'messageThreadTarget',+ parentColumnName: 'messageThreadId',+ targetColumnName: 'targetPersonId',+ candidateFromSql: `FROM (+ SELECT message."messageThreadId" AS "parentId", participant."personId" AS "targetId"+ FROM "${schemaName}"."messageParticipant" participant+ INNER JOIN "${schemaName}"."message" message ON message."id" = participant."messageId"+ INNER JOIN "${schemaName}"."messageThread" message_thread ON message_thread."id" = message."messageThreadId"+ INNER JOIN "${schemaName}"."person" person ON person."id" = participant."personId"+ WHERE participant."deletedAt" IS NULL+ AND message."deletedAt" IS NULL+ AND message_thread."deletedAt" IS NULL+ AND person."deletedAt" IS NULL+) source`,+ }),+ buildTargetBackfillQuery({+ batchSize,+ schemaName,+ label: 'message thread company targets',+ targetTableName: 'messageThreadTarget',+ parentColumnName: 'messageThreadId',+ targetColumnName: 'targetCompanyId',+ candidateFromSql: `FROM (+ SELECT message."messageThreadId" AS "parentId", person."companyId" AS "targetId"+ FROM "${schemaName}"."messageParticipant" participant+ INNER JOIN "${schemaName}"."message" message ON message."id" = participant."messageId"+ INNER JOIN "${schemaName}"."messageThread" message_thread ON message_thread."id" = message."messageThreadId"+ INNER JOIN "${schemaName}"."person" person ON person."id" = participant."personId"+ INNER JOIN "${schemaName}"."company" company ON company."id" = person."companyId"+ WHERE participant."deletedAt" IS NULL+ AND message."deletedAt" IS NULL+ AND message_thread."deletedAt" IS NULL+ AND person."deletedAt" IS NULL+ AND company."deletedAt" IS NULL+) source`,+ }),+ buildTargetBackfillQuery({+ batchSize,+ schemaName,+ label: 'message thread opportunity targets',+ targetTableName: 'messageThreadTarget',+ parentColumnName: 'messageThreadId',+ targetColumnName: 'targetOpportunityId',+ candidateFromSql: `FROM (+ SELECT message."messageThreadId" AS "parentId", opportunity."id" AS "targetId"+ FROM "${schemaName}"."messageParticipant" participant+ INNER JOIN "${schemaName}"."message" message ON message."id" = participant."messageId"+ INNER JOIN "${schemaName}"."messageThread" message_thread ON message_thread."id" = message."messageThreadId"+ INNER JOIN "${schemaName}"."person" person ON person."id" = participant."personId"+ INNER JOIN "${schemaName}"."opportunity" opportunity ON opportunity."pointOfContactId" = participant."personId"+ WHERE participant."deletedAt" IS NULL+ AND message."deletedAt" IS NULL+ AND message_thread."deletedAt" IS NULL+ AND person."deletedAt" IS NULL+ AND opportunity."deletedAt" IS NULL+) source`,+ }),+];diff --git a/packages/twenty-server/src/database/commands/upgrade-version-command/2-37/utils/build-target-metadata-collision-renames.util.ts b/packages/twenty-server/src/database/commands/upgrade-version-command/2-37/utils/build-target-metadata-collision-renames.util.tsnew file mode 100644index 00000000000..3b74e2f1008--- /dev/null+++ b/packages/twenty-server/src/database/commands/upgrade-version-command/2-37/utils/build-target-metadata-collision-renames.util.ts@@ -0,0 +1,196 @@+import { STANDARD_OBJECTS } from 'twenty-shared/metadata';+import { isDefined } from 'twenty-shared/utils';++import { type FlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/types/flat-entity-maps.type';+import { type FlatFieldMetadata } from 'src/engine/metadata-modules/flat-field-metadata/types/flat-field-metadata.type';+import { type FlatObjectMetadata } from 'src/engine/metadata-modules/flat-object-metadata/types/flat-object-metadata.type';++const MAX_RENAME_ATTEMPTS = 100;++const TARGET_OBJECT_DEFINITIONS = [+ {+ universalIdentifier:+ STANDARD_OBJECTS.calendarEventTarget.universalIdentifier,+ nameSingular: 'calendarEventTarget',+ namePlural: 'calendarEventTargets',+ },+ {+ universalIdentifier:+ STANDARD_OBJECTS.messageThreadTarget.universalIdentifier,+ nameSingular: 'messageThreadTarget',+ namePlural: 'messageThreadTargets',+ },+] as const;++const TARGET_OBJECT_UNIVERSAL_IDENTIFIERS = new Set<string>(+ TARGET_OBJECT_DEFINITIONS.map(+ ({ universalIdentifier }) => universalIdentifier,+ ),+);+const TARGET_OBJECT_NAMES = new Set<string>(+ TARGET_OBJECT_DEFINITIONS.flatMap(({ nameSingular, namePlural }) => [+ nameSingular,+ namePlural,+ ]),+);++const TARGET_RELATION_FIELD_DEFINITIONS = [+ {+ objectUniversalIdentifier:+ STANDARD_OBJECTS.calendarEvent.universalIdentifier,+ universalIdentifier:+ STANDARD_OBJECTS.calendarEvent.fields.calendarEventTargets+ .universalIdentifier,+ name: 'calendarEventTargets',+ },+ {+ objectUniversalIdentifier:+ STANDARD_OBJECTS.messageThread.universalIdentifier,+ universalIdentifier:+ STANDARD_OBJECTS.messageThread.fields.messageThreadTargets+ .universalIdentifier,+ name: 'messageThreadTargets',+ },+ ...(['person', 'company', 'opportunity'] as const).flatMap((objectName) => [+ {+ objectUniversalIdentifier:+ STANDARD_OBJECTS[objectName].universalIdentifier,+ universalIdentifier:+ STANDARD_OBJECTS[objectName].fields.calendarEventTargets+ .universalIdentifier,+ name: 'calendarEventTargets',+ },+ {+ objectUniversalIdentifier:+ STANDARD_OBJECTS[objectName].universalIdentifier,+ universalIdentifier:+ STANDARD_OBJECTS[objectName].fields.messageThreadTargets+ .universalIdentifier,+ name: 'messageThreadTargets',+ },+ ]),+] as const;++const findAvailableName = ({+ baseName,+ takenNames,+}: {+ baseName: string;+ takenNames: Set<string>;+}): string => {+ for (let attempt = 0; attempt < MAX_RENAME_ATTEMPTS; attempt++) {+ const suffix = attempt === 0 ? 'Old' : `Old${attempt + 1}`;+ const candidate = `${baseName}${suffix}`;++ if (!takenNames.has(candidate)) {+ takenNames.add(candidate);++ return candidate;+ }+ }++ throw new Error(+ `Could not find an available old name for ${baseName} after ${MAX_RENAME_ATTEMPTS} attempts`,+ );+};++export const buildTargetObjectCollisionRenameUpdates = ({+ flatObjectMetadataMaps,+ now,+}: {+ flatObjectMetadataMaps: Pick<+ FlatEntityMaps<FlatObjectMetadata>,+ 'byUniversalIdentifier'+ >;+ now: string;+}): FlatObjectMetadata[] => {+ const allObjects = Object.values(+ flatObjectMetadataMaps.byUniversalIdentifier,+ ).filter(isDefined);+ const takenNames = new Set(+ allObjects.flatMap(({ nameSingular, namePlural }) => [+ nameSingular,+ namePlural,+ ]),+ );++ return allObjects+ .filter(+ (objectMetadata) =>+ !TARGET_OBJECT_UNIVERSAL_IDENTIFIERS.has(+ objectMetadata.universalIdentifier,+ ) &&+ [objectMetadata.nameSingular, objectMetadata.namePlural].some((name) =>+ TARGET_OBJECT_NAMES.has(name),+ ),+ )+ .map((objectMetadata) => ({+ ...objectMetadata,+ nameSingular: findAvailableName({+ baseName: objectMetadata.nameSingular,+ takenNames,+ }),+ namePlural: findAvailableName({+ baseName: objectMetadata.namePlural,+ takenNames,+ }),+ labelSingular: `${objectMetadata.labelSingular} (Old)`,+ labelPlural: `${objectMetadata.labelPlural} (Old)`,+ isLabelSyncedWithName: false,+ updatedAt: now,+ }));+};++export const buildTargetFieldCollisionRenameUpdates = ({+ flatFieldMetadataMaps,+ now,+}: {+ flatFieldMetadataMaps: Pick<+ FlatEntityMaps<FlatFieldMetadata>,+ 'byUniversalIdentifier'+ >;+ now: string;+}): FlatFieldMetadata[] => {+ const allFields = Object.values(+ flatFieldMetadataMaps.byUniversalIdentifier,+ ).filter(isDefined);+ const takenNamesByObjectUniversalIdentifier = new Map<string, Set<string>>();++ for (const fieldMetadata of allFields) {+ const takenNames =+ takenNamesByObjectUniversalIdentifier.get(+ fieldMetadata.objectMetadataUniversalIdentifier,+ ) ?? new Set<string>();++ takenNames.add(fieldMetadata.name);+ takenNamesByObjectUniversalIdentifier.set(+ fieldMetadata.objectMetadataUniversalIdentifier,+ takenNames,+ );+ }++ return TARGET_RELATION_FIELD_DEFINITIONS.flatMap((definition) =>+ allFields+ .filter(+ (fieldMetadata) =>+ fieldMetadata.objectMetadataUniversalIdentifier ===+ definition.objectUniversalIdentifier &&+ fieldMetadata.universalIdentifier !==+ definition.universalIdentifier &&+ fieldMetadata.name === definition.name,+ )+ .map((fieldMetadata) => ({+ ...fieldMetadata,+ name: findAvailableName({+ baseName: definition.name,+ takenNames:+ takenNamesByObjectUniversalIdentifier.get(+ definition.objectUniversalIdentifier,+ ) ?? new Set<string>(),+ }),+ label: `${fieldMetadata.label} (Old)`,+ isLabelSyncedWithName: false,+ updatedAt: now,+ })),+ );+};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 30882a227f6..e0ea164b4d3 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@@ -29,6 +29,7 @@ import { V2_33_UpgradeVersionCommandModule } from 'src/database/commands/upgradeimport { V2_34_UpgradeVersionCommandModule } from 'src/database/commands/upgrade-version-command/2-34/2-34-upgrade-version-command.module';import { V2_35_UpgradeVersionCommandModule } from 'src/database/commands/upgrade-version-command/2-35/2-35-upgrade-version-command.module';import { V2_36_UpgradeVersionCommandModule } from 'src/database/commands/upgrade-version-command/2-36/2-36-upgrade-version-command.module';+import { V2_37_UpgradeVersionCommandModule } from 'src/database/commands/upgrade-version-command/2-37/2-37-upgrade-version-command.module';import { V2_4_UpgradeVersionCommandModule } from 'src/database/commands/upgrade-version-command/2-4/2-4-upgrade-version-command.module';import { V2_5_UpgradeVersionCommandModule } from 'src/database/commands/upgrade-version-command/2-5/2-5-upgrade-version-command.module';import { V2_7_UpgradeVersionCommandModule } from 'src/database/commands/upgrade-version-command/2-7/2-7-upgrade-version-command.module';@@ -71,6 +72,7 @@ import { V2_9_UpgradeVersionCommandModule } from 'src/database/commands/upgrade-V2_34_UpgradeVersionCommandModule,V2_35_UpgradeVersionCommandModule,V2_36_UpgradeVersionCommandModule,+ V2_37_UpgradeVersionCommandModule,],})export class WorkspaceCommandProviderModule {}diff --git a/packages/twenty-server/src/engine/core-modules/target/constants/message-calendar-target-migration.constants.ts b/packages/twenty-server/src/engine/core-modules/target/constants/message-calendar-target-migration.constants.tsnew file mode 100644index 00000000000..b1f5574b4da--- /dev/null+++ b/packages/twenty-server/src/engine/core-modules/target/constants/message-calendar-target-migration.constants.ts@@ -0,0 +1,3 @@+export const MESSAGE_CALENDAR_TARGET_MIGRATION_VERSION = '2.37.0';+export const MESSAGE_CALENDAR_TARGET_BACKFILL_TIMESTAMP = 1787832413051;+export const MESSAGE_CALENDAR_TARGET_BACKFILL_UPGRADE_COMMAND_NAME = `${MESSAGE_CALENDAR_TARGET_MIGRATION_VERSION}_BackfillMessageCalendarTargetsCommand_${MESSAGE_CALENDAR_TARGET_BACKFILL_TIMESTAMP}`;