Skip to content

The open alternative to Salesforce, designed for AI.

Allow merging records on objects without duplicate criteria (#29042)

Félix Malfait64be0d7ae779
diff --git a/packages/twenty-server/src/database/commands/upgrade-version-command/2-53/2-53-upgrade-version-command.module.ts b/packages/twenty-server/src/database/commands/upgrade-version-command/2-53/2-53-upgrade-version-command.module.ts
index 391141898c2..59445d67639 100644
--- a/packages/twenty-server/src/database/commands/upgrade-version-command/2-53/2-53-upgrade-version-command.module.ts
+++ b/packages/twenty-server/src/database/commands/upgrade-version-command/2-53/2-53-upgrade-version-command.module.ts
@@ -3,6 +3,7 @@ import { Module } from '@nestjs/common';
import { WorkspaceIteratorModule } from 'src/database/commands/command-runners/workspace-iterator.module';
import { AddChatAssistantParticipationCommand } from 'src/database/commands/upgrade-version-command/2-53/2-53-workspace-command-1793111719062-add-chat-assistant-participation.command';
import { MoveApplicationAndSystemAccessToDisabledActionsCommand } from 'src/database/commands/upgrade-version-command/2-53/2-53-workspace-command-1793176233512-move-application-and-system-access-to-disabled-actions.command';
+import { UngateMergeFromDuplicateCriteriaCommand } from 'src/database/commands/upgrade-version-command/2-53/2-53-workspace-command-1793180997766-ungate-merge-from-duplicate-criteria.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';
@@ -17,6 +18,7 @@ import { WorkspaceMigrationModule } from 'src/engine/workspace-manager/workspace
providers: [
AddChatAssistantParticipationCommand,
MoveApplicationAndSystemAccessToDisabledActionsCommand,
+ UngateMergeFromDuplicateCriteriaCommand,
],
})
export class V2_53_UpgradeVersionCommandModule {}
diff --git a/packages/twenty-server/src/database/commands/upgrade-version-command/2-53/2-53-workspace-command-1793180997766-ungate-merge-from-duplicate-criteria.command.ts b/packages/twenty-server/src/database/commands/upgrade-version-command/2-53/2-53-workspace-command-1793180997766-ungate-merge-from-duplicate-criteria.command.ts
new file mode 100644
index 00000000000..1780fbd5508
--- /dev/null
+++ b/packages/twenty-server/src/database/commands/upgrade-version-command/2-53/2-53-workspace-command-1793180997766-ungate-merge-from-duplicate-criteria.command.ts
@@ -0,0 +1,97 @@
+import { Inject } from '@nestjs/common';
+import { Command } from 'nest-commander';
+import { TWENTY_STANDARD_APPLICATION_UNIVERSAL_IDENTIFIER } from 'twenty-shared/application';
+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 { buildUngateMergeCommandMenuItemUpdate } from 'src/database/commands/upgrade-version-command/2-53/utils/build-ungate-merge-command-menu-item-update.util';
+import { RegisteredWorkspaceCommand } from 'src/engine/core-modules/upgrade/decorators/registered-workspace-command.decorator';
+import { WorkspaceCacheService } from 'src/engine/workspace-cache/services/workspace-cache.service';
+import { WorkspaceMigrationBuilderException } from 'src/engine/workspace-manager/workspace-migration/exceptions/workspace-migration-builder-exception';
+import { WorkspaceMigrationValidateBuildAndRunService } from 'src/engine/workspace-manager/workspace-migration/services/workspace-migration-validate-build-and-run-service';
+
+@RegisteredWorkspaceCommand('2.53.0', 1793180997766)
+@Command({
+ name: 'upgrade:2-53:ungate-merge-from-duplicate-criteria',
+ description:
+ 'Offer the merge command on every object, not only those with duplicate criteria',
+})
+export class UngateMergeFromDuplicateCriteriaCommand extends ProvisionedWorkspaceCommandRunner {
+ @Inject(WorkspaceCacheService)
+ private readonly workspaceCacheService: WorkspaceCacheService;
+
+ @Inject(WorkspaceMigrationValidateBuildAndRunService)
+ private readonly workspaceMigrationValidateBuildAndRunService: WorkspaceMigrationValidateBuildAndRunService;
+
+ constructor(
+ protected readonly workspaceIteratorService: WorkspaceIteratorService,
+ ) {
+ super(workspaceIteratorService);
+ }
+
+ override async runOnWorkspace(args: RunOnWorkspaceArgs): Promise<void> {
+ await this.up(args);
+ }
+
+ async up(args: RunOnWorkspaceArgs): Promise<void> {
+ await this.apply({ ...args, direction: 'up' });
+ }
+
+ async down(args: RunOnWorkspaceArgs): Promise<void> {
+ await this.apply({ ...args, direction: 'down' });
+ }
+
+ private async apply({
+ workspaceId,
+ options,
+ direction,
+ }: Pick<RunOnWorkspaceArgs, 'workspaceId' | 'options'> & {
+ direction: 'up' | 'down';
+ }): Promise<void> {
+ const { flatCommandMenuItemMaps } =
+ await this.workspaceCacheService.getOrRecompute(workspaceId, [
+ 'flatCommandMenuItemMaps',
+ ]);
+
+ const mergeCommandMenuItemToUpdate = buildUngateMergeCommandMenuItemUpdate({
+ flatCommandMenuItemMaps,
+ direction,
+ now: new Date().toISOString(),
+ });
+
+ if (!isDefined(mergeCommandMenuItemToUpdate)) {
+ return;
+ }
+
+ this.logger.log(
+ `${options.dryRun ? '[DRY RUN] ' : ''}Workspace ${workspaceId}: updating merge command availability (${direction})`,
+ );
+
+ if (options.dryRun) {
+ return;
+ }
+
+ const result =
+ await this.workspaceMigrationValidateBuildAndRunService.validateBuildAndRunLegacyWorkspaceMigration(
+ {
+ workspaceId,
+ isSystemBuild: true,
+ applicationUniversalIdentifier:
+ TWENTY_STANDARD_APPLICATION_UNIVERSAL_IDENTIFIER,
+ allFlatEntityOperationByMetadataName: {
+ commandMenuItem: {
+ flatEntityToCreate: [],
+ flatEntityToDelete: [],
+ flatEntityToUpdate: [mergeCommandMenuItemToUpdate],
+ },
+ },
+ },
+ );
+
+ if (result.status === 'fail') {
+ throw new WorkspaceMigrationBuilderException(result);
+ }
+ }
+}
diff --git a/packages/twenty-server/src/database/commands/upgrade-version-command/2-53/utils/__tests__/build-ungate-merge-command-menu-item-update.util.spec.ts b/packages/twenty-server/src/database/commands/upgrade-version-command/2-53/utils/__tests__/build-ungate-merge-command-menu-item-update.util.spec.ts
new file mode 100644
index 00000000000..20d289ac848
--- /dev/null
+++ b/packages/twenty-server/src/database/commands/upgrade-version-command/2-53/utils/__tests__/build-ungate-merge-command-menu-item-update.util.spec.ts
@@ -0,0 +1,140 @@
+import { TWENTY_STANDARD_APPLICATION_UNIVERSAL_IDENTIFIER } from 'twenty-shared/application';
+import { CommandMenuItemAvailabilityType } from 'twenty-shared/types';
+
+import {
+ buildUngateMergeCommandMenuItemUpdate,
+ GATED_MERGE_AVAILABILITY_EXPRESSION,
+ MERGE_MULTIPLE_RECORDS_UNIVERSAL_IDENTIFIER,
+ UNGATED_MERGE_AVAILABILITY_EXPRESSION,
+} from 'src/database/commands/upgrade-version-command/2-53/utils/build-ungate-merge-command-menu-item-update.util';
+import { EngineComponentKey } from 'src/engine/metadata-modules/command-menu-item/enums/engine-component-key.enum';
+import { type FlatCommandMenuItem } from 'src/engine/metadata-modules/flat-command-menu-item/types/flat-command-menu-item.type';
+import { createEmptyFlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/constant/create-empty-flat-entity-maps.constant';
+import { type FlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/types/flat-entity-maps.type';
+import { STANDARD_COMMAND_MENU_ITEMS } from 'src/engine/workspace-manager/twenty-standard-application/constants/standard-command-menu-item.constant';
+
+const NOW = '2026-10-27T12:00:00.000Z';
+const CREATED_AT = '2026-01-01T00:00:00.000Z';
+
+const MERGE_COMMAND_MENU_ITEM: FlatCommandMenuItem = {
+ workspaceId: '20202020-1111-4111-8111-111111111111',
+ applicationId: '20202020-2222-4222-8222-222222222222',
+ applicationUniversalIdentifier:
+ TWENTY_STANDARD_APPLICATION_UNIVERSAL_IDENTIFIER,
+ createdAt: CREATED_AT,
+ updatedAt: CREATED_AT,
+ id: 'merge-command-id',
+ universalIdentifier: MERGE_MULTIPLE_RECORDS_UNIVERSAL_IDENTIFIER,
+ label: 'Merge {objectLabelPlural}',
+ shortLabel: 'Merge',
+ icon: 'IconArrowMerge',
+ position: 12,
+ isPinned: false,
+ isActive: true,
+ isSystemSideEffect: false,
+ engineComponentKey: EngineComponentKey.MERGE_MULTIPLE_RECORDS,
+ availabilityType: CommandMenuItemAvailabilityType.RECORD_SELECTION,
+ conditionalAvailabilityExpression: GATED_MERGE_AVAILABILITY_EXPRESSION,
+ conditionalPinnedExpression: null,
+ availabilityObjectMetadataId: null,
+ availabilityObjectMetadataUniversalIdentifier: null,
+ navigationTargetObjectMetadataId: null,
+ navigationTargetObjectMetadataUniversalIdentifier: null,
+ frontComponentId: null,
+ frontComponentUniversalIdentifier: null,
+ pageLayoutId: null,
+ pageLayoutUniversalIdentifier: null,
+ workflowVersionId: null,
+ coreWorkflowVersionId: null,
+ hotKeys: null,
+ payload: null,
+ overrides: null,
+ universalOverrides: null,
+};
+
+const buildMaps = (
+ commandMenuItem: FlatCommandMenuItem,
+): FlatEntityMaps<FlatCommandMenuItem> => ({
+ ...createEmptyFlatEntityMaps(),
+ byUniversalIdentifier: {
+ [commandMenuItem.universalIdentifier]: commandMenuItem,
+ },
+});
+
+describe('buildUngateMergeCommandMenuItemUpdate', () => {
+ it('should target the standard merge command and its current expression', () => {
+ expect(STANDARD_COMMAND_MENU_ITEMS.mergeMultipleRecords).toMatchObject({
+ universalIdentifier: MERGE_MULTIPLE_RECORDS_UNIVERSAL_IDENTIFIER,
+ conditionalAvailabilityExpression: UNGATED_MERGE_AVAILABILITY_EXPRESSION,
+ });
+ });
+
+ it('should drop the duplicate criteria condition on up', () => {
+ expect(
+ buildUngateMergeCommandMenuItemUpdate({
+ flatCommandMenuItemMaps: buildMaps(MERGE_COMMAND_MENU_ITEM),
+ direction: 'up',
+ now: NOW,
+ }),
+ ).toEqual({
+ ...MERGE_COMMAND_MENU_ITEM,
+ conditionalAvailabilityExpression: UNGATED_MERGE_AVAILABILITY_EXPRESSION,
+ updatedAt: NOW,
+ });
+ });
+
+ it('should restore the duplicate criteria condition on down', () => {
+ expect(
+ buildUngateMergeCommandMenuItemUpdate({
+ flatCommandMenuItemMaps: buildMaps({
+ ...MERGE_COMMAND_MENU_ITEM,
+ conditionalAvailabilityExpression:
+ UNGATED_MERGE_AVAILABILITY_EXPRESSION,
+ }),
+ direction: 'down',
+ now: NOW,
+ })?.conditionalAvailabilityExpression,
+ ).toBe(GATED_MERGE_AVAILABILITY_EXPRESSION);
+ });
+
+ it('should skip an item already updated', () => {
+ expect(
+ buildUngateMergeCommandMenuItemUpdate({
+ flatCommandMenuItemMaps: buildMaps({
+ ...MERGE_COMMAND_MENU_ITEM,
+ conditionalAvailabilityExpression:
+ UNGATED_MERGE_AVAILABILITY_EXPRESSION,
+ }),
+ direction: 'up',
+ now: NOW,
+ }),
+ ).toBeUndefined();
+ });
+
+ it('should skip an item with an unexpected expression', () => {
+ expect(
+ buildUngateMergeCommandMenuItemUpdate({
+ flatCommandMenuItemMaps: buildMaps({
+ ...MERGE_COMMAND_MENU_ITEM,
+ conditionalAvailabilityExpression: 'numberOfSelectedRecords >= 2',
+ }),
+ direction: 'up',
+ now: NOW,
+ }),
+ ).toBeUndefined();
+ });
+
+ it('should skip an item not owned by the standard application', () => {
+ expect(
+ buildUngateMergeCommandMenuItemUpdate({
+ flatCommandMenuItemMaps: buildMaps({
+ ...MERGE_COMMAND_MENU_ITEM,
+ applicationUniversalIdentifier:
+ '20202020-3333-4333-8333-333333333333',
+ }),
+ direction: 'up',
+ now: NOW,
+ }),
+ ).toBeUndefined();
+ });
+});
diff --git a/packages/twenty-server/src/database/commands/upgrade-version-command/2-53/utils/build-ungate-merge-command-menu-item-update.util.ts b/packages/twenty-server/src/database/commands/upgrade-version-command/2-53/utils/build-ungate-merge-command-menu-item-update.util.ts
new file mode 100644
index 00000000000..d9f8ba576f4
--- /dev/null
+++ b/packages/twenty-server/src/database/commands/upgrade-version-command/2-53/utils/build-ungate-merge-command-menu-item-update.util.ts
@@ -0,0 +1,58 @@
+import { TWENTY_STANDARD_APPLICATION_UNIVERSAL_IDENTIFIER } from 'twenty-shared/application';
+import { isDefined } from 'twenty-shared/utils';
+
+import { type FlatCommandMenuItem } from 'src/engine/metadata-modules/flat-command-menu-item/types/flat-command-menu-item.type';
+import { type FlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/types/flat-entity-maps.type';
+
+export const MERGE_MULTIPLE_RECORDS_UNIVERSAL_IDENTIFIER =
+ '6c14eb04-8e7e-4d47-93c0-8ec4834e2e60';
+
+export const GATED_MERGE_AVAILABILITY_EXPRESSION =
+ 'not isSelectAll and numberOfSelectedRecords >= 2 and isDefined(objectMetadataItem.duplicateCriteria) and objectPermissions.canUpdateObjectRecords and objectPermissions.canDestroyObjectRecords and numberOfSelectedRecords <= 9';
+
+export const UNGATED_MERGE_AVAILABILITY_EXPRESSION =
+ 'not isSelectAll and numberOfSelectedRecords >= 2 and not objectMetadataItem.isSystem and objectMetadataItem.nameSingular != "workflow" and objectMetadataItem.nameSingular != "dashboard" and objectPermissions.canUpdateObjectRecords and objectPermissions.canDestroyObjectRecords and numberOfSelectedRecords <= 9';
+
+export const buildUngateMergeCommandMenuItemUpdate = ({
+ flatCommandMenuItemMaps,
+ direction,
+ now,
+}: {
+ flatCommandMenuItemMaps: Pick<
+ FlatEntityMaps<FlatCommandMenuItem>,
+ 'byUniversalIdentifier'
+ >;
+ direction: 'up' | 'down';
+ now: string;
+}): FlatCommandMenuItem | undefined => {
+ const mergeCommandMenuItem =
+ flatCommandMenuItemMaps.byUniversalIdentifier[
+ MERGE_MULTIPLE_RECORDS_UNIVERSAL_IDENTIFIER
+ ];
+
+ const [fromExpression, toExpression] =
+ direction === 'up'
+ ? [
+ GATED_MERGE_AVAILABILITY_EXPRESSION,
+ UNGATED_MERGE_AVAILABILITY_EXPRESSION,
+ ]
+ : [
+ UNGATED_MERGE_AVAILABILITY_EXPRESSION,
+ GATED_MERGE_AVAILABILITY_EXPRESSION,
+ ];
+
+ if (
+ !isDefined(mergeCommandMenuItem) ||
+ mergeCommandMenuItem.applicationUniversalIdentifier !==
+ TWENTY_STANDARD_APPLICATION_UNIVERSAL_IDENTIFIER ||
+ mergeCommandMenuItem.conditionalAvailabilityExpression !== fromExpression
+ ) {
+ return undefined;
+ }
+
+ return {
+ ...mergeCommandMenuItem,
+ conditionalAvailabilityExpression: toExpression,
+ updatedAt: now,
+ };
+};
diff --git a/packages/twenty-server/src/engine/api/common/common-query-runners/common-merge-many-query-runner.service.ts b/packages/twenty-server/src/engine/api/common/common-query-runners/common-merge-many-query-runner.service.ts
index 5fa9cd35fe9..415d1b8d281 100644
--- a/packages/twenty-server/src/engine/api/common/common-query-runners/common-merge-many-query-runner.service.ts
+++ b/packages/twenty-server/src/engine/api/common/common-query-runners/common-merge-many-query-runner.service.ts
@@ -602,9 +602,10 @@ export class CommonMergeManyQueryRunnerService extends CommonBaseQueryRunnerServ
assertMutationNotOnRemoteObject(flatObjectMetadata);
- if (!isDefined(flatObjectMetadata.duplicateCriteria)) {
+ // Merge deletes through the repository, so it would bypass the delete and update hooks guarding system objects.
+ if (flatObjectMetadata.isSystem) {
throw new CommonQueryRunnerException(
- `Merge is only available for objects with duplicate criteria. Object '${flatObjectMetadata.nameSingular}' does not have duplicate criteria defined.`,
+ `Merge is not available on system object '${flatObjectMetadata.nameSingular}'.`,
CommonQueryRunnerExceptionCode.INVALID_QUERY_INPUT,
{ userFriendlyMessage: msg`This type of record cannot be merged.` },
);
diff --git a/packages/twenty-server/src/engine/api/graphql/workspace-resolver-builder/workspace-resolver-builder.service.ts b/packages/twenty-server/src/engine/api/graphql/workspace-resolver-builder/workspace-resolver-builder.service.ts
index e77c47030c2..59b9419e32d 100644
--- a/packages/twenty-server/src/engine/api/graphql/workspace-resolver-builder/workspace-resolver-builder.service.ts
+++ b/packages/twenty-server/src/engine/api/graphql/workspace-resolver-builder/workspace-resolver-builder.service.ts
@@ -5,7 +5,6 @@ import { isDefined } from 'twenty-shared/utils';
import { type WorkspaceResolverBuilderMethodNames } from 'src/engine/api/graphql/workspace-resolver-builder/interfaces/workspace-resolvers-builder.interface';
import { FindDuplicatesResolverFactory } from 'src/engine/api/graphql/workspace-resolver-builder/factories/find-duplicates-resolver.factory';
-import { MergeManyResolverFactory } from 'src/engine/api/graphql/workspace-resolver-builder/factories/merge-many-resolver.factory';
import { type ObjectMetadataEntity } from 'src/engine/metadata-modules/object-metadata/object-metadata.entity';
@Injectable()
@@ -19,8 +18,6 @@ export class WorkspaceResolverBuilderService {
switch (methodName) {
case FindDuplicatesResolverFactory.methodName:
return isDefined(objectMetadata.duplicateCriteria);
- case MergeManyResolverFactory.methodName:
- return isDefined(objectMetadata.duplicateCriteria);
default:
return true;
}
diff --git a/packages/twenty-server/src/engine/workspace-manager/twenty-standard-application/constants/standard-command-menu-item.constant.ts b/packages/twenty-server/src/engine/workspace-manager/twenty-standard-application/constants/standard-command-menu-item.constant.ts
index 37ea2724850..36ed637cce2 100644
--- a/packages/twenty-server/src/engine/workspace-manager/twenty-standard-application/constants/standard-command-menu-item.constant.ts
+++ b/packages/twenty-server/src/engine/workspace-manager/twenty-standard-application/constants/standard-command-menu-item.constant.ts
@@ -235,7 +235,7 @@ export const STANDARD_COMMAND_MENU_ITEMS = {
),
availabilityType: CommandMenuItemAvailabilityType.RECORD_SELECTION,
conditionalAvailabilityExpression:
- 'not isSelectAll and numberOfSelectedRecords >= 2 and isDefined(objectMetadataItem.duplicateCriteria) and objectPermissions.canUpdateObjectRecords and objectPermissions.canDestroyObjectRecords and numberOfSelectedRecords <= 9',
+ 'not isSelectAll and numberOfSelectedRecords >= 2 and not objectMetadataItem.isSystem and objectMetadataItem.nameSingular != "workflow" and objectMetadataItem.nameSingular != "dashboard" and objectPermissions.canUpdateObjectRecords and objectPermissions.canDestroyObjectRecords and numberOfSelectedRecords <= 9',
availabilityObjectMetadataUniversalIdentifier: null,
frontComponentUniversalIdentifier: null,
engineComponentKey: EngineComponentKey.MERGE_MULTIPLE_RECORDS,
diff --git a/packages/twenty-server/src/modules/dashboard/query-hooks/dashboard-merge-many.pre-query.hook.ts b/packages/twenty-server/src/modules/dashboard/query-hooks/dashboard-merge-many.pre-query.hook.ts
new file mode 100644
index 00000000000..45d026b72f1
--- /dev/null
+++ b/packages/twenty-server/src/modules/dashboard/query-hooks/dashboard-merge-many.pre-query.hook.ts
@@ -0,0 +1,24 @@
+import { msg } from '@lingui/core/macro';
+
+import { type WorkspacePreQueryHookInstance } from 'src/engine/api/graphql/workspace-query-runner/workspace-query-hook/interfaces/workspace-query-hook.interface';
+import { type MergeManyResolverArgs } from 'src/engine/api/graphql/workspace-resolver-builder/interfaces/workspace-resolvers-builder.interface';
+
+import {
+ CommonQueryRunnerException,
+ CommonQueryRunnerExceptionCode,
+} from 'src/engine/api/common/common-query-runners/errors/common-query-runner.exception';
+import { WorkspaceQueryHook } from 'src/engine/api/graphql/workspace-query-runner/workspace-query-hook/decorators/workspace-query-hook.decorator';
+
+// Merge hard-deletes the losing records, which would skip the destroy hooks that remove their page layouts.
+@WorkspaceQueryHook(`dashboard.mergeMany`)
+export class DashboardMergeManyPreQueryHook implements WorkspacePreQueryHookInstance {
+ async execute(): Promise<MergeManyResolverArgs> {
+ throw new CommonQueryRunnerException(
+ 'Method not allowed.',
+ CommonQueryRunnerExceptionCode.BAD_REQUEST,
+ {
+ userFriendlyMessage: msg`Merging dashboards is not allowed.`,
+ },
+ );
+ }
+}
diff --git a/packages/twenty-server/src/modules/dashboard/query-hooks/dashboard-query-hook.module.ts b/packages/twenty-server/src/modules/dashboard/query-hooks/dashboard-query-hook.module.ts
index 5557d827716..e2d581db211 100644
--- a/packages/twenty-server/src/modules/dashboard/query-hooks/dashboard-query-hook.module.ts
+++ b/packages/twenty-server/src/modules/dashboard/query-hooks/dashboard-query-hook.module.ts
@@ -6,6 +6,7 @@ import { DashboardCreateManyPreQueryHook } from 'src/modules/dashboard/query-hoo
import { DashboardCreateOnePreQueryHook } from 'src/modules/dashboard/query-hooks/dashboard-create-one.pre-query.hook';
import { DashboardDestroyManyPreQueryHook } from 'src/modules/dashboard/query-hooks/dashboard-destroy-many.pre-query.hook';
import { DashboardDestroyOnePreQueryHook } from 'src/modules/dashboard/query-hooks/dashboard-destroy-one.pre-query.hook';
+import { DashboardMergeManyPreQueryHook } from 'src/modules/dashboard/query-hooks/dashboard-merge-many.pre-query.hook';
import { DashboardToPageLayoutSyncService } from 'src/modules/dashboard/services/dashboard-to-page-layout-sync.service';
@Module({
@@ -16,6 +17,7 @@ import { DashboardToPageLayoutSyncService } from 'src/modules/dashboard/services
DashboardCreateManyPreQueryHook,
DashboardDestroyOnePreQueryHook,
DashboardDestroyManyPreQueryHook,
+ DashboardMergeManyPreQueryHook,
],
})
export class DashboardQueryHookModule {}
diff --git a/packages/twenty-server/test/integration/graphql/suites/hooks/__snapshots__/blocklist-scope-hooks.integration-spec.ts.snap b/packages/twenty-server/test/integration/graphql/suites/hooks/__snapshots__/blocklist-scope-hooks.integration-spec.ts.snap
index 5bc6def1d22..fea391de806 100644
--- a/packages/twenty-server/test/integration/graphql/suites/hooks/__snapshots__/blocklist-scope-hooks.integration-spec.ts.snap
+++ b/packages/twenty-server/test/integration/graphql/suites/hooks/__snapshots__/blocklist-scope-hooks.integration-spec.ts.snap
@@ -139,7 +139,7 @@ exports[`blocklist scope hooks refuses every bulk mutation of blocklist entries
"subCode": "INVALID_QUERY_INPUT",
"userFriendlyMessage": "This type of record cannot be merged.",
},
- "message": "Merge is only available for objects with duplicate criteria. Object 'blocklist' does not have duplicate criteria defined.",
+ "message": "Merge is not available on system object 'blocklist'.",
}
`;
diff --git a/packages/twenty-server/test/integration/graphql/suites/object-generated/merge-many-restricted-objects.integration-spec.ts b/packages/twenty-server/test/integration/graphql/suites/object-generated/merge-many-restricted-objects.integration-spec.ts
new file mode 100644
index 00000000000..895f1700f2a
--- /dev/null
+++ b/packages/twenty-server/test/integration/graphql/suites/object-generated/merge-many-restricted-objects.integration-spec.ts
@@ -0,0 +1,35 @@
+import { makeGraphqlApiRequest } from 'test/integration/graphql/utils/make-graphql-api-request.util';
+import { mergeManyOperationFactory } from 'test/integration/graphql/utils/merge-many-operation-factory.util';
+import { v4 } from 'uuid';
+
+describe('merge on restricted objects (integration)', () => {
+ it('should refuse merging records of a system object', async () => {
+ const response = await makeGraphqlApiRequest(
+ mergeManyOperationFactory({
+ objectMetadataPluralName: 'workspaceMembers',
+ gqlFields: 'id',
+ ids: [v4(), v4()],
+ conflictPriorityIndex: 0,
+ }),
+ );
+
+ expect(response.body.errors[0].message).toBe(
+ "Merge is not available on system object 'workspaceMember'.",
+ );
+ });
+
+ it('should refuse merging dashboards', async () => {
+ const response = await makeGraphqlApiRequest(
+ mergeManyOperationFactory({
+ objectMetadataPluralName: 'dashboards',
+ gqlFields: 'id',
+ ids: [v4(), v4()],
+ conflictPriorityIndex: 0,
+ }),
+ );
+
+ expect(response.body.errors[0].extensions.userFriendlyMessage).toBe(
+ 'Merging dashboards is not allowed.',
+ );
+ });
+});
diff --git a/packages/twenty-server/test/integration/graphql/suites/object-generated/opportunities-merge-many.integration-spec.ts b/packages/twenty-server/test/integration/graphql/suites/object-generated/opportunities-merge-many.integration-spec.ts
new file mode 100644
index 00000000000..285db8a9c24
--- /dev/null
+++ b/packages/twenty-server/test/integration/graphql/suites/object-generated/opportunities-merge-many.integration-spec.ts
@@ -0,0 +1,66 @@
+import { createManyOperationFactory } from 'test/integration/graphql/utils/create-many-operation-factory.util';
+import { findOneOperationFactory } from 'test/integration/graphql/utils/find-one-operation-factory.util';
+import { makeGraphqlApiRequest } from 'test/integration/graphql/utils/make-graphql-api-request.util';
+import { mergeManyOperationFactory } from 'test/integration/graphql/utils/merge-many-operation-factory.util';
+import { deleteRecordsByIds } from 'test/integration/utils/delete-records-by-ids';
+import { waitForTimelineActivities } from 'test/integration/utils/wait-for-timeline-activities.util';
+
+const OPPORTUNITY_GQL_FIELDS = `
+ id
+ name
+`;
+
+describe('opportunities merge resolvers (integration)', () => {
+ let createdOpportunityIds: string[] = [];
+
+ afterEach(async () => {
+ await deleteRecordsByIds('opportunity', createdOpportunityIds);
+ createdOpportunityIds = [];
+ });
+
+ it('should merge records of an object without duplicate criteria', async () => {
+ const createResponse = await makeGraphqlApiRequest(
+ createManyOperationFactory({
+ objectMetadataSingularName: 'opportunity',
+ objectMetadataPluralName: 'opportunities',
+ gqlFields: OPPORTUNITY_GQL_FIELDS,
+ data: [{ name: 'Deal A' }, { name: 'Deal B' }],
+ }),
+ );
+
+ const [opportunityA, opportunityB] =
+ createResponse.body.data.createOpportunities;
+
+ createdOpportunityIds.push(opportunityA.id, opportunityB.id);
+
+ await waitForTimelineActivities('targetOpportunityId', [
+ opportunityA.id,
+ opportunityB.id,
+ ]);
+
+ const mergeResponse = await makeGraphqlApiRequest(
+ mergeManyOperationFactory({
+ objectMetadataPluralName: 'opportunities',
+ gqlFields: OPPORTUNITY_GQL_FIELDS,
+ ids: [opportunityA.id, opportunityB.id],
+ conflictPriorityIndex: 0,
+ }),
+ );
+
+ expect(mergeResponse.body.errors).toBeUndefined();
+ expect(mergeResponse.body.data.mergeOpportunities).toMatchObject({
+ id: opportunityA.id,
+ name: 'Deal A',
+ });
+
+ const findMergedAwayResponse = await makeGraphqlApiRequest(
+ findOneOperationFactory({
+ objectMetadataSingularName: 'opportunity',
+ gqlFields: OPPORTUNITY_GQL_FIELDS,
+ filter: { id: { eq: opportunityB.id } },
+ }),
+ );
+
+ expect(findMergedAwayResponse.body.data.opportunity).toBeNull();
+ });
+});
diff --git a/packages/twenty-server/test/integration/utils/wait-for-timeline-activities.util.ts b/packages/twenty-server/test/integration/utils/wait-for-timeline-activities.util.ts
index f17f642995b..fc846a12bdb 100644
--- a/packages/twenty-server/test/integration/utils/wait-for-timeline-activities.util.ts
+++ b/packages/twenty-server/test/integration/utils/wait-for-timeline-activities.util.ts
@@ -5,7 +5,10 @@ const TEST_SCHEMA_NAME = 'workspace_1wgvd1injqtife6y4rvfbu3h5';
// Timeline activities are inserted by listeners after the mutation resolves;
// mutating a record while its activities are still in flight races those inserts.
export const waitForTimelineActivities = async (
- targetColumnName: 'targetCompanyId' | 'targetPersonId',
+ targetColumnName:
+ | 'targetCompanyId'
+ | 'targetPersonId'
+ | 'targetOpportunityId',
recordIds: string[],
) => {
await expectEventually(async () => {