Skip to content

The open alternative to Salesforce, designed for AI.

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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
index 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/upgrade
import { 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.ts
new file mode 100644
index 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}`;