Skip to content

The open alternative to Salesforce, designed for AI.

Fix merge bugs: stale priority, hidden-field data loss, permission gating (#29029)

Félix Malfait482dd2aa26d3
diff --git a/packages/twenty-front/src/modules/object-record/hooks/useMergeManyRecords.ts b/packages/twenty-front/src/modules/object-record/hooks/useMergeManyRecords.ts
index f1baf3d2811..1540eec0213 100644
--- a/packages/twenty-front/src/modules/object-record/hooks/useMergeManyRecords.ts
+++ b/packages/twenty-front/src/modules/object-record/hooks/useMergeManyRecords.ts
@@ -89,10 +89,12 @@ export const useMergeManyRecords = <
...(preview && {
fetchPolicy: 'no-cache',
}),
- refetchQueries: [
- getOperationName(findOneRecordQuery) ?? '',
- getOperationName(findDuplicateRecordsQuery) ?? '',
- ].filter(Boolean),
+ refetchQueries: preview
+ ? []
+ : [
+ getOperationName(findOneRecordQuery) ?? '',
+ getOperationName(findDuplicateRecordsQuery) ?? '',
+ ].filter(Boolean),
});
setLoading(false);
diff --git a/packages/twenty-front/src/modules/object-record/record-merge/components/MergePrioritySettings.tsx b/packages/twenty-front/src/modules/object-record/record-merge/components/MergePrioritySettings.tsx
index 349d2a05db1..bf3beae391a 100644
--- a/packages/twenty-front/src/modules/object-record/record-merge/components/MergePrioritySettings.tsx
+++ b/packages/twenty-front/src/modules/object-record/record-merge/components/MergePrioritySettings.tsx
@@ -46,6 +46,11 @@ export const MergePrioritySettings = ({
return null;
}
+ // The server rejects an out-of-range index, so "no priority" is only shown, never offered
+ const isPriorityRecordMissing = !priorityOptions.some(
+ (option) => option.value === priorityRecordIndex,
+ );
+
return (
<StyledSectionContainer>
<Section.Root>
@@ -53,10 +58,14 @@ export const MergePrioritySettings = ({
dropdownId={dropdownId}
options={priorityOptions}
value={priorityRecordIndex}
- emptyOption={{
- value: MISSING_PRIORITY_RECORD_INDEX,
- label: t`No record holds priority`,
- }}
+ emptyOption={
+ isPriorityRecordMissing
+ ? {
+ value: MISSING_PRIORITY_RECORD_INDEX,
+ label: t`No record holds priority`,
+ }
+ : undefined
+ }
onChange={onPriorityRecordIndexChange}
label={t`Fields conflicts`}
disabled={disabled}
diff --git a/packages/twenty-front/src/modules/object-record/record-merge/hooks/useMergeRecordsActions.ts b/packages/twenty-front/src/modules/object-record/record-merge/hooks/useMergeRecordsActions.ts
index 18cb701ecbc..10a00c1ca1a 100644
--- a/packages/twenty-front/src/modules/object-record/record-merge/hooks/useMergeRecordsActions.ts
+++ b/packages/twenty-front/src/modules/object-record/record-merge/hooks/useMergeRecordsActions.ts
@@ -1,5 +1,6 @@
import { useLingui } from '@lingui/react/macro';
+import { getToastOptionsFromError } from '@/error-handler/utils/getToastOptionsFromError';
import { useMergeManyRecords } from '@/object-record/hooks/useMergeManyRecords';
import { useMergeRecordsSelectedRecords } from '@/object-record/record-merge/hooks/useMergeRecordsSelectedRecords';
import { isMergeInProgressState } from '@/object-record/record-merge/states/mergeInProgressState';
@@ -59,13 +60,7 @@ export const useMergeRecordsActions = ({
objectRecordId: mergedRecord.id,
});
} catch (error) {
- enqueueToast({
- status: 'error',
- children:
- error instanceof Error
- ? error.message
- : t`Failed to merge records. Please try again.`,
- });
+ enqueueToast(getToastOptionsFromError({ error }));
} finally {
setIsMergeInProgress(false);
}
diff --git a/packages/twenty-front/src/modules/side-panel/hooks/useOpenMergeRecordsPageInSidePanel.tsx b/packages/twenty-front/src/modules/side-panel/hooks/useOpenMergeRecordsPageInSidePanel.tsx
index c2caf97ebd5..fb6ab94d344 100644
--- a/packages/twenty-front/src/modules/side-panel/hooks/useOpenMergeRecordsPageInSidePanel.tsx
+++ b/packages/twenty-front/src/modules/side-panel/hooks/useOpenMergeRecordsPageInSidePanel.tsx
@@ -3,6 +3,7 @@ import { useNavigateSidePanel } from '@/side-panel/hooks/useNavigateSidePanel';
import { contextStoreCurrentObjectMetadataItemIdComponentState } from '@/context-store/states/contextStoreCurrentObjectMetadataItemIdComponentState';
import { useObjectMetadataItem } from '@/object-metadata/hooks/useObjectMetadataItem';
import { useLazyFindManyRecords } from '@/object-record/hooks/useLazyFindManyRecords';
+import { mergeSettingsState } from '@/object-record/record-merge/states/mergeSettingsState';
import { useUpsertRecordsInStore } from '@/object-record/record-store/hooks/useUpsertRecordsInStore';
import { SidePanelPages } from 'twenty-shared/types';
@@ -51,6 +52,8 @@ export const useOpenMergeRecordsPageInSidePanel = ({
objectMetadataItem.id,
);
+ store.set(mergeSettingsState.atom, { conflictPriorityIndex: 0 });
+
await updateSidePanelNavigationMorphItemsByPage({
pageId,
objectMetadataId: objectMetadataItem.id,
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 59445d67639..449bc40d26d 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
@@ -4,6 +4,7 @@ import { WorkspaceIteratorModule } from 'src/database/commands/command-runners/w
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 { GateMergeCommandOnRecordPermissionsCommand } from 'src/database/commands/upgrade-version-command/2-53/2-53-workspace-command-1793183175063-gate-merge-command-on-record-permissions.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';
@@ -19,6 +20,7 @@ import { WorkspaceMigrationModule } from 'src/engine/workspace-manager/workspace
AddChatAssistantParticipationCommand,
MoveApplicationAndSystemAccessToDisabledActionsCommand,
UngateMergeFromDuplicateCriteriaCommand,
+ GateMergeCommandOnRecordPermissionsCommand,
],
})
export class V2_53_UpgradeVersionCommandModule {}
diff --git a/packages/twenty-server/src/database/commands/upgrade-version-command/2-53/2-53-workspace-command-1793183175063-gate-merge-command-on-record-permissions.command.ts b/packages/twenty-server/src/database/commands/upgrade-version-command/2-53/2-53-workspace-command-1793183175063-gate-merge-command-on-record-permissions.command.ts
new file mode 100644
index 00000000000..8743c320abb
--- /dev/null
+++ b/packages/twenty-server/src/database/commands/upgrade-version-command/2-53/2-53-workspace-command-1793183175063-gate-merge-command-on-record-permissions.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 { isNonEmptyArray } 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 { buildMergeCommandRecordPermissionAvailabilityUpdates } from 'src/database/commands/upgrade-version-command/2-53/utils/build-merge-command-record-permission-availability-updates.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', 1793183175063)
+@Command({
+ name: 'upgrade:2-53:gate-merge-command-on-record-permissions',
+ description:
+ 'Hide the merge command when a selected record cannot be updated or deleted',
+})
+export class GateMergeCommandOnRecordPermissionsCommand 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 commandMenuItemsToUpdate =
+ buildMergeCommandRecordPermissionAvailabilityUpdates({
+ flatCommandMenuItemMaps,
+ direction,
+ now: new Date().toISOString(),
+ });
+
+ if (!isNonEmptyArray(commandMenuItemsToUpdate)) {
+ return;
+ }
+
+ this.logger.log(
+ `${options.dryRun ? '[DRY RUN] ' : ''}Workspace ${workspaceId}: updating merge command availability`,
+ );
+
+ if (options.dryRun) {
+ return;
+ }
+
+ const result =
+ await this.workspaceMigrationValidateBuildAndRunService.validateBuildAndRunLegacyWorkspaceMigration(
+ {
+ workspaceId,
+ isSystemBuild: true,
+ applicationUniversalIdentifier:
+ TWENTY_STANDARD_APPLICATION_UNIVERSAL_IDENTIFIER,
+ allFlatEntityOperationByMetadataName: {
+ commandMenuItem: {
+ flatEntityToCreate: [],
+ flatEntityToDelete: [],
+ flatEntityToUpdate: commandMenuItemsToUpdate,
+ },
+ },
+ },
+ );
+
+ 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-merge-command-record-permission-availability-updates.util.spec.ts b/packages/twenty-server/src/database/commands/upgrade-version-command/2-53/utils/__tests__/build-merge-command-record-permission-availability-updates.util.spec.ts
new file mode 100644
index 00000000000..19b6f47adbd
--- /dev/null
+++ b/packages/twenty-server/src/database/commands/upgrade-version-command/2-53/utils/__tests__/build-merge-command-record-permission-availability-updates.util.spec.ts
@@ -0,0 +1,124 @@
+import { TWENTY_STANDARD_APPLICATION_UNIVERSAL_IDENTIFIER } from 'twenty-shared/application';
+import { CommandMenuItemAvailabilityType } from 'twenty-shared/types';
+
+import { UNGATED_MERGE_AVAILABILITY_EXPRESSION } from 'src/database/commands/upgrade-version-command/2-53/utils/build-ungate-merge-command-menu-item-update.util';
+import { buildMergeCommandRecordPermissionAvailabilityUpdates } from 'src/database/commands/upgrade-version-command/2-53/utils/build-merge-command-record-permission-availability-updates.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 MERGE_UNIVERSAL_IDENTIFIER =
+ STANDARD_COMMAND_MENU_ITEMS.mergeMultipleRecords.universalIdentifier;
+const PREVIOUS_EXPRESSION = UNGATED_MERGE_AVAILABILITY_EXPRESSION;
+const CURRENT_EXPRESSION =
+ STANDARD_COMMAND_MENU_ITEMS.mergeMultipleRecords
+ .conditionalAvailabilityExpression;
+
+const MERGE_COMMAND: FlatCommandMenuItem = {
+ workspaceId: '20202020-1111-4111-8111-111111111111',
+ applicationId: '20202020-2222-4222-8222-222222222222',
+ applicationUniversalIdentifier:
+ TWENTY_STANDARD_APPLICATION_UNIVERSAL_IDENTIFIER,
+ createdAt: '2026-10-21T12:00:00.000Z',
+ updatedAt: '2026-10-21T12:00:00.000Z',
+ id: 'merge-id',
+ universalIdentifier: MERGE_UNIVERSAL_IDENTIFIER,
+ label: 'Merge records',
+ shortLabel: 'Merge',
+ icon: 'IconArrowMerge',
+ position: 12,
+ isPinned: false,
+ isActive: true,
+ isSystemSideEffect: false,
+ engineComponentKey: EngineComponentKey.MERGE_MULTIPLE_RECORDS,
+ availabilityType: CommandMenuItemAvailabilityType.RECORD_SELECTION,
+ conditionalAvailabilityExpression: PREVIOUS_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: { [MERGE_UNIVERSAL_IDENTIFIER]: commandMenuItem },
+});
+
+describe('buildMergeCommandRecordPermissionAvailabilityUpdates', () => {
+ it('should require record permissions on upgrade, matching the standard definition', () => {
+ const updates = buildMergeCommandRecordPermissionAvailabilityUpdates({
+ flatCommandMenuItemMaps: buildMaps(MERGE_COMMAND),
+ direction: 'up',
+ now: NOW,
+ });
+
+ expect(updates).toEqual([
+ {
+ ...MERGE_COMMAND,
+ conditionalAvailabilityExpression: CURRENT_EXPRESSION,
+ updatedAt: NOW,
+ },
+ ]);
+ });
+
+ it('should restore the previous expression on downgrade', () => {
+ const updates = buildMergeCommandRecordPermissionAvailabilityUpdates({
+ flatCommandMenuItemMaps: buildMaps({
+ ...MERGE_COMMAND,
+ conditionalAvailabilityExpression: CURRENT_EXPRESSION,
+ }),
+ direction: 'down',
+ now: NOW,
+ });
+
+ expect(updates).toEqual([
+ {
+ ...MERGE_COMMAND,
+ conditionalAvailabilityExpression: PREVIOUS_EXPRESSION,
+ updatedAt: NOW,
+ },
+ ]);
+ });
+
+ it('should be a no-op once already upgraded', () => {
+ const updates = buildMergeCommandRecordPermissionAvailabilityUpdates({
+ flatCommandMenuItemMaps: buildMaps({
+ ...MERGE_COMMAND,
+ conditionalAvailabilityExpression: CURRENT_EXPRESSION,
+ }),
+ direction: 'up',
+ now: NOW,
+ });
+
+ expect(updates).toEqual([]);
+ });
+
+ it('should leave a customized expression untouched', () => {
+ const updates = buildMergeCommandRecordPermissionAvailabilityUpdates({
+ flatCommandMenuItemMaps: buildMaps({
+ ...MERGE_COMMAND,
+ conditionalAvailabilityExpression: 'numberOfSelectedRecords >= 2',
+ }),
+ direction: 'up',
+ now: NOW,
+ });
+
+ expect(updates).toEqual([]);
+ });
+});
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
index 20d289ac848..483ab1baee1 100644
--- 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
@@ -62,10 +62,10 @@ const buildMaps = (
});
describe('buildUngateMergeCommandMenuItemUpdate', () => {
- it('should target the standard merge command and its current expression', () => {
+ // The later record-permission command extends this expression, so only the target is shared with the constant
+ it('should target the standard merge command', () => {
expect(STANDARD_COMMAND_MENU_ITEMS.mergeMultipleRecords).toMatchObject({
universalIdentifier: MERGE_MULTIPLE_RECORDS_UNIVERSAL_IDENTIFIER,
- conditionalAvailabilityExpression: UNGATED_MERGE_AVAILABILITY_EXPRESSION,
});
});
diff --git a/packages/twenty-server/src/database/commands/upgrade-version-command/2-53/utils/build-merge-command-record-permission-availability-updates.util.ts b/packages/twenty-server/src/database/commands/upgrade-version-command/2-53/utils/build-merge-command-record-permission-availability-updates.util.ts
new file mode 100644
index 00000000000..8f1cb49ae18
--- /dev/null
+++ b/packages/twenty-server/src/database/commands/upgrade-version-command/2-53/utils/build-merge-command-record-permission-availability-updates.util.ts
@@ -0,0 +1,50 @@
+import { TWENTY_STANDARD_APPLICATION_UNIVERSAL_IDENTIFIER } from 'twenty-shared/application';
+import { isDefined } from 'twenty-shared/utils';
+
+import { UNGATED_MERGE_AVAILABILITY_EXPRESSION } from 'src/database/commands/upgrade-version-command/2-53/utils/build-ungate-merge-command-menu-item-update.util';
+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';
+import { STANDARD_COMMAND_MENU_ITEMS } from 'src/engine/workspace-manager/twenty-standard-application/constants/standard-command-menu-item.constant';
+
+// Runs after the 2.53 ungate command, so it starts from the ungated expression
+const PREVIOUS_MERGE_AVAILABILITY_EXPRESSION =
+ UNGATED_MERGE_AVAILABILITY_EXPRESSION;
+const MERGE_AVAILABILITY_EXPRESSION = `${PREVIOUS_MERGE_AVAILABILITY_EXPRESSION} and noneEquals(selectedRecords, "recordPermissions.canUpdate", false) and noneEquals(selectedRecords, "recordPermissions.canDelete", false)`;
+
+export const buildMergeCommandRecordPermissionAvailabilityUpdates = ({
+ flatCommandMenuItemMaps,
+ direction,
+ now,
+}: {
+ flatCommandMenuItemMaps: FlatEntityMaps<FlatCommandMenuItem>;
+ direction: 'up' | 'down';
+ now: string;
+}): FlatCommandMenuItem[] => {
+ const mergeCommandMenuItem =
+ flatCommandMenuItemMaps.byUniversalIdentifier[
+ STANDARD_COMMAND_MENU_ITEMS.mergeMultipleRecords.universalIdentifier
+ ];
+
+ const [fromExpression, toExpression] =
+ direction === 'up'
+ ? [PREVIOUS_MERGE_AVAILABILITY_EXPRESSION, MERGE_AVAILABILITY_EXPRESSION]
+ : [MERGE_AVAILABILITY_EXPRESSION, PREVIOUS_MERGE_AVAILABILITY_EXPRESSION];
+
+ // An expression edited since the previous release is left as the workspace set it
+ if (
+ !isDefined(mergeCommandMenuItem) ||
+ mergeCommandMenuItem.applicationUniversalIdentifier !==
+ TWENTY_STANDARD_APPLICATION_UNIVERSAL_IDENTIFIER ||
+ mergeCommandMenuItem.conditionalAvailabilityExpression !== fromExpression
+ ) {
+ return [];
+ }
+
+ 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 415d1b8d281..6dc812c435b 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
@@ -24,6 +24,7 @@ import {
} from 'src/engine/api/common/common-query-runners/errors/common-query-runner.exception';
import { STANDARD_ERROR_MESSAGE } from 'src/engine/api/common/common-query-runners/errors/standard-error-message.constant';
import { computeDuplicateKeyColumnGroupsForJoinColumn } from 'src/engine/api/common/common-query-runners/utils/compute-duplicate-key-column-groups-for-join-column.util';
+import { findRecordKeysChangedByMerge } from 'src/engine/api/common/common-query-runners/utils/find-record-keys-changed-by-merge.util';
import { splitRelatedRecordIdsToMigrateAndSoftDelete } from 'src/engine/api/common/common-query-runners/utils/split-related-record-ids-to-migrate-and-soft-delete.util';
import { CommonBaseQueryRunnerContext } from 'src/engine/api/common/types/common-base-query-runner-context.type';
import { CommonExtendedQueryRunnerContext } from 'src/engine/api/common/types/common-extended-query-runner-context.type';
@@ -76,6 +77,12 @@ export class CommonMergeManyQueryRunnerService extends CommonBaseQueryRunnerServ
args.conflictPriorityIndex,
);
+ await this.assertMergeKeepsUnreadableFieldValuesOrThrow({
+ queryRunnerContext,
+ ids: args.ids,
+ priorityRecordId: priorityRecord.id,
+ });
+
const mergedData = this.performDeepMerge(
recordsToMerge,
priorityRecord.id,
@@ -189,6 +196,111 @@ export class CommonMergeManyQueryRunnerService extends CommonBaseQueryRunnerServ
return priorityRecord;
}
+ // Unreadable fields are left out of the merge, so a value only a deleted record holds would vanish unseen
+ private async assertMergeKeepsUnreadableFieldValuesOrThrow({
+ queryRunnerContext,
+ ids,
+ priorityRecordId,
+ }: {
+ queryRunnerContext: CommonExtendedQueryRunnerContext;
+ ids: string[];
+ priorityRecordId: string;
+ }): Promise<void> {
+ const {
+ flatObjectMetadata,
+ flatFieldMetadataMaps,
+ repository,
+ transactionScope,
+ } = queryRunnerContext;
+
+ const restrictedFields =
+ repository.objectRecordsPermissions?.[flatObjectMetadata.id]
+ ?.restrictedFields ?? {};
+
+ const unreadableFieldIds = new Set(
+ Object.entries(restrictedFields)
+ .filter(([, fieldPermissions]) => fieldPermissions.canRead === false)
+ .map(([fieldMetadataId]) => fieldMetadataId),
+ );
+
+ if (unreadableFieldIds.size === 0) {
+ return;
+ }
+
+ const { fieldIdByName, fieldIdByJoinColumnName } =
+ buildFieldMapsFromFlatObjectMetadata(
+ flatFieldMetadataMaps,
+ flatObjectMetadata,
+ );
+
+ const unreadableRecordKeys = Object.entries({
+ ...fieldIdByName,
+ ...fieldIdByJoinColumnName,
+ })
+ .filter(([, fieldMetadataId]) => unreadableFieldIds.has(fieldMetadataId))
+ .map(([recordKey]) => recordKey);
+
+ const bypassPermissionConfig = {
+ shouldBypassPermissionChecks: true,
+ } as const;
+
+ const unrestrictedRepository = isDefined(transactionScope)
+ ? transactionScope.getRepository<ObjectRecord>(
+ flatObjectMetadata.nameSingular,
+ bypassPermissionConfig,
+ )
+ : this.workspaceOrmManager.getRepository<ObjectRecord>(
+ flatObjectMetadata.nameSingular,
+ bypassPermissionConfig,
+ );
+
+ const fullRecords = await unrestrictedRepository.find({
+ where: { id: In(ids) },
+ select: getAllSelectableColumnNames({
+ restrictedFields: {},
+ objectMetadata: {
+ objectMetadataMapItem: flatObjectMetadata,
+ flatFieldMetadataMaps,
+ },
+ }),
+ });
+
+ const fullPriorityRecord = fullRecords.find(
+ (record) => record.id === priorityRecordId,
+ );
+
+ if (!isDefined(fullPriorityRecord)) {
+ return;
+ }
+
+ // Priority first, so array unions only differ when another record adds a value
+ const fullyMergedData = this.performDeepMerge(
+ [
+ fullPriorityRecord,
+ ...fullRecords.filter((record) => record.id !== priorityRecordId),
+ ],
+ priorityRecordId,
+ flatObjectMetadata,
+ flatFieldMetadataMaps,
+ );
+
+ const changedUnreadableRecordKeys = findRecordKeysChangedByMerge({
+ mergedData: fullyMergedData,
+ priorityRecord: fullPriorityRecord,
+ recordKeys: unreadableRecordKeys,
+ });
+
+ if (changedUnreadableRecordKeys.length > 0) {
+ throw new CommonQueryRunnerException(
+ `Merge would drop values in fields the requester cannot read: ${changedUnreadableRecordKeys.join(', ')}`,
+ CommonQueryRunnerExceptionCode.INVALID_QUERY_INPUT,
+ {
+ userFriendlyMessage: msg`These records hold data in fields your role cannot see. Ask someone with access to those fields to merge them.`,
+ },
+ );
+ }
+ }
+
private performDeepMerge(
recordsToMerge: ObjectRecord[],
priorityRecordId: string,
@@ -198,10 +310,14 @@ export class CommonMergeManyQueryRunnerService extends CommonBaseQueryRunnerServ
): Partial<ObjectRecord> {
const mergedResult: Partial<ObjectRecord> = {};
- const { fieldIdByName } = buildFieldMapsFromFlatObjectMetadata(
- flatFieldMetadataMaps,
- flatObjectMetadata,
- );
+ const { fieldIdByName, fieldIdByJoinColumnName } =
+ buildFieldMapsFromFlatObjectMetadata(
+ flatFieldMetadataMaps,
+ flatObjectMetadata,
+ );
+
+ // Records carry many-to-one relations under their join column (companyId), not the field name
+ const fieldIdByRecordKey = { ...fieldIdByName, ...fieldIdByJoinColumnName };
const allFieldNames = new Set<string>();
@@ -210,7 +326,7 @@ export class CommonMergeManyQueryRunnerService extends CommonBaseQueryRunnerServ
if (
!this.shouldExcludeFieldFromMerge(
fieldName,
- fieldIdByName,
+ fieldIdByRecordKey,
flatFieldMetadataMaps,
)
) {
@@ -236,7 +352,7 @@ export class CommonMergeManyQueryRunnerService extends CommonBaseQueryRunnerServ
mergedResult[fieldName] = recordsWithValues[0].value;
} else {
const fieldMetadata = findFlatEntityByIdInFlatEntityMaps({
- flatEntityId: fieldIdByName[fieldName],
+ flatEntityId: fieldIdByRecordKey[fieldName],
flatEntityMaps: flatFieldMetadataMaps,
});
@@ -266,11 +382,11 @@ export class CommonMergeManyQueryRunnerService extends CommonBaseQueryRunnerServ
private shouldExcludeFieldFromMerge(
fieldName: string,
- fieldIdByName: Record<string, string>,
+ fieldIdByRecordKey: Record<string, string>,
flatFieldMetadataMaps: FlatEntityMaps<OrmFlatFieldMetadata>,
): boolean {
const fieldMetadata = findFlatEntityByIdInFlatEntityMaps({
- flatEntityId: fieldIdByName[fieldName],
+ flatEntityId: fieldIdByRecordKey[fieldName],
flatEntityMaps: flatFieldMetadataMaps,
});
diff --git a/packages/twenty-server/src/engine/api/common/common-query-runners/utils/__tests__/find-record-keys-changed-by-merge.util.spec.ts b/packages/twenty-server/src/engine/api/common/common-query-runners/utils/__tests__/find-record-keys-changed-by-merge.util.spec.ts
new file mode 100644
index 00000000000..afa4b4b0644
--- /dev/null
+++ b/packages/twenty-server/src/engine/api/common/common-query-runners/utils/__tests__/find-record-keys-changed-by-merge.util.spec.ts
@@ -0,0 +1,78 @@
+import { findRecordKeysChangedByMerge } from 'src/engine/api/common/common-query-runners/utils/find-record-keys-changed-by-merge.util';
+
+describe('findRecordKeysChangedByMerge', () => {
+ it('should return the keys whose merged value differs from the priority record', () => {
+ const result = findRecordKeysChangedByMerge({
+ mergedData: { salary: 120000, jobTitle: 'CEO' },
+ priorityRecord: { id: 'priority', salary: null, jobTitle: 'CEO' },
+ recordKeys: ['salary', 'jobTitle'],
+ });
+
+ expect(result).toEqual(['salary']);
+ });
+
+ it('should compare composite values deeply', () => {
+ const result = findRecordKeysChangedByMerge({
+ mergedData: {
+ emails: {
+ primaryEmail: '[email protected]',
+ additionalEmails: ['[email protected]'],
+ },
+ phones: { primaryPhoneNumber: '123', additionalPhones: null },
+ },
+ priorityRecord: {
+ id: 'priority',
+ emails: { primaryEmail: '[email protected]', additionalEmails: null },
+ phones: { primaryPhoneNumber: '123', additionalPhones: null },
+ },
+ recordKeys: ['emails', 'phones'],
+ });
+
+ expect(result).toEqual(['emails']);
+ });
+
+ it('should treat empty arrays and null sub-fields as the same value', () => {
+ const result = findRecordKeysChangedByMerge({
+ mergedData: {
+ phones: {
+ primaryPhoneNumber: '123456789',
+ primaryPhoneCountryCode: 'FR',
+ primaryPhoneCallingCode: '+33',
+ additionalPhones: null,
+ },
+ },
+ priorityRecord: {
+ id: 'priority',
+ phones: {
+ primaryPhoneNumber: '123456789',
+ primaryPhoneCountryCode: 'FR',
+ primaryPhoneCallingCode: '+33',
+ additionalPhones: [],
+ },
+ },
+ recordKeys: ['phones'],
+ });
+
+ expect(result).toEqual([]);
+ });
+
+ it('should detect a date the priority record does not hold', () => {
+ const result = findRecordKeysChangedByMerge({
+ mergedData: { birthday: new Date('2026-01-15T10:00:00.000Z') },
+ priorityRecord: { id: 'priority', birthday: null },
+ recordKeys: ['birthday'],
+ });
+
+ expect(result).toEqual(['birthday']);
+ });
+
+ it('should ignore keys the merge leaves untouched', () => {
+ const result = findRecordKeysChangedByMerge({
+ mergedData: {},
+ priorityRecord: { id: 'priority', salary: 120000 },
+ recordKeys: ['salary'],
+ });
+
+ expect(result).toEqual([]);
+ });
+});
diff --git a/packages/twenty-server/src/engine/api/common/common-query-runners/utils/find-record-keys-changed-by-merge.util.ts b/packages/twenty-server/src/engine/api/common/common-query-runners/utils/find-record-keys-changed-by-merge.util.ts
new file mode 100644
index 00000000000..07f8b6a3dc3
--- /dev/null
+++ b/packages/twenty-server/src/engine/api/common/common-query-runners/utils/find-record-keys-changed-by-merge.util.ts
@@ -0,0 +1,45 @@
+import isEqual from 'lodash.isequal';
+import { type ObjectRecord } from 'twenty-shared/types';
+import { isPlainObject } from 'twenty-shared/utils';
+
+import { hasRecordFieldValue } from 'src/engine/api/graphql/graphql-query-runner/utils/has-record-field-value.util';
+
+// Reads return [] for empty composite sub-fields where merge utils return null
+const normalizeEmptyValues = (value: unknown): unknown => {
+ if (!hasRecordFieldValue(value)) {
+ return null;
+ }
+
+ if (Array.isArray(value)) {
+ return value.map(normalizeEmptyValues);
+ }
+
+ if (isPlainObject(value)) {
+ return Object.fromEntries(
+ Object.entries(value).map(([key, subValue]) => [
+ key,
+ normalizeEmptyValues(subValue),
+ ]),
+ );
+ }
+
+ return value;
+};
+
+export const findRecordKeysChangedByMerge = ({
+ mergedData,
+ priorityRecord,
+ recordKeys,
+}: {
+ mergedData: Partial<ObjectRecord>;
+ priorityRecord: ObjectRecord;
+ recordKeys: string[];
+}): string[] =>
+ recordKeys.filter(
+ (recordKey) =>
+ recordKey in mergedData &&
+ !isEqual(
+ normalizeEmptyValues(mergedData[recordKey]),
+ normalizeEmptyValues(priorityRecord[recordKey]),
+ ),
+ );
diff --git a/packages/twenty-server/src/engine/api/graphql/graphql-query-runner/utils/__tests__/default-merge-field-value.util.spec.ts b/packages/twenty-server/src/engine/api/graphql/graphql-query-runner/utils/__tests__/default-merge-field-value.util.spec.ts
index 209d65f6ca7..504ad9d6765 100644
--- a/packages/twenty-server/src/engine/api/graphql/graphql-query-runner/utils/__tests__/default-merge-field-value.util.spec.ts
+++ b/packages/twenty-server/src/engine/api/graphql/graphql-query-runner/utils/__tests__/default-merge-field-value.util.spec.ts
@@ -18,6 +18,20 @@ describe('defaultMergeFieldValue', () => {
expect(result).toBe('priority value');
});
+ it('should keep a date held only by a non-priority record', () => {
+ const date = new Date('2026-01-15T10:00:00.000Z');
+
+ const result = defaultMergeFieldValue(
+ [
+ { recordId: '1', value: null },
+ { recordId: '2', value: date },
+ ],
+ '1',
+ );
+
+ expect(result).toBe(date);
+ });
+
it('should fall back to first record with value when priority record not found', () => {
const recordsWithValues = [
{
diff --git a/packages/twenty-server/src/engine/api/graphql/graphql-query-runner/utils/has-record-field-value.util.ts b/packages/twenty-server/src/engine/api/graphql/graphql-query-runner/utils/has-record-field-value.util.ts
index f28f6ed582f..451da610d35 100644
--- a/packages/twenty-server/src/engine/api/graphql/graphql-query-runner/utils/has-record-field-value.util.ts
+++ b/packages/twenty-server/src/engine/api/graphql/graphql-query-runner/utils/has-record-field-value.util.ts
@@ -19,6 +19,10 @@ export const hasRecordFieldValue = (value: unknown): boolean => {
return value.length > 0;
}
+ if (value instanceof Date) {
+ return !isNaN(value.getTime());
+ }
+
if (typeof value === 'object') {
const objectValue = value as Record<string, unknown>;
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 36ed637cce2..ed027f932c7 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 not objectMetadataItem.isSystem and objectMetadataItem.nameSingular != "workflow" and objectMetadataItem.nameSingular != "dashboard" 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 and noneEquals(selectedRecords, "recordPermissions.canUpdate", false) and noneEquals(selectedRecords, "recordPermissions.canDelete", false)',
availabilityObjectMetadataUniversalIdentifier: null,
frontComponentUniversalIdentifier: null,
engineComponentKey: EngineComponentKey.MERGE_MULTIPLE_RECORDS,
diff --git a/packages/twenty-server/test/integration/graphql/suites/object-generated/people-merge-many-field-permissions.integration-spec.ts b/packages/twenty-server/test/integration/graphql/suites/object-generated/people-merge-many-field-permissions.integration-spec.ts
new file mode 100644
index 00000000000..591af786a44
--- /dev/null
+++ b/packages/twenty-server/test/integration/graphql/suites/object-generated/people-merge-many-field-permissions.integration-spec.ts
@@ -0,0 +1,310 @@
+import request from 'supertest';
+import { createCustomRoleWithObjectPermissions } from 'test/integration/graphql/utils/create-custom-role-with-object-permissions.util';
+import { createManyOperationFactory } from 'test/integration/graphql/utils/create-many-operation-factory.util';
+import { createOneOperationFactory } from 'test/integration/graphql/utils/create-one-operation-factory.util';
+import { deleteRole } from 'test/integration/graphql/utils/delete-one-role.util';
+import { findManyOperationFactory } from 'test/integration/graphql/utils/find-many-operation-factory.util';
+import { makeGraphqlApiRequestWithMemberRole } from 'test/integration/graphql/utils/make-graphql-api-request-with-member-role.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 { updateWorkspaceMemberRole } from 'test/integration/graphql/utils/update-workspace-member-role.util';
+import { upsertFieldPermissions } from 'test/integration/graphql/utils/upsert-field-permissions.util';
+import { createOneFieldMetadata } from 'test/integration/metadata/suites/field-metadata/utils/create-one-field-metadata.util';
+import { deleteOneFieldMetadata } from 'test/integration/metadata/suites/field-metadata/utils/delete-one-field-metadata.util';
+import { updateOneFieldMetadata } from 'test/integration/metadata/suites/field-metadata/utils/update-one-field-metadata.util';
+import { findManyObjectMetadata } from 'test/integration/metadata/suites/object-metadata/utils/find-many-object-metadata.util';
+import { findOneRoleByLabel } from 'test/integration/metadata/suites/role/utils/find-one-role-by-label.util';
+import { deleteRecordsByIds } from 'test/integration/utils/delete-records-by-ids';
+import { FieldMetadataType } from 'twenty-shared/types';
+import { assertIsDefinedOrThrow } from 'twenty-shared/utils';
+
+import { WORKSPACE_MEMBER_DATA_SEED_IDS } from 'src/engine/workspace-manager/dev-seeder/data/constants/workspace-member-data-seeds.constant';
+
+const client = request(`http://localhost:${APP_PORT}`);
+
+const HIDDEN_DATE_FIELD_NAME = 'mergeHiddenDate';
+const HIDDEN_DATE = '2026-01-15T10:00:00.000Z';
+const UNREADABLE_FIELDS_ERROR =
+ 'These records hold data in fields your role cannot see. Ask someone with access to those fields to merge them.';
+
+type PersonNode = {
+ id: string;
+ jobTitle: string;
+ companyId: string | null;
+ [HIDDEN_DATE_FIELD_NAME]: string | null;
+};
+
+describe('people merge with unreadable fields (integration)', () => {
+ let customRoleId: string;
+ let originalMemberRoleId: string;
+ let hiddenDateFieldId: string;
+ let companyId: string;
+ let createdPersonIdsForCleaning: string[] = [];
+
+ const createPeople = async (
+ people: Record<string, unknown>[],
+ ): Promise<string[]> => {
+ const response = await makeGraphqlApiRequest(
+ createManyOperationFactory({
+ objectMetadataSingularName: 'person',
+ objectMetadataPluralName: 'people',
+ gqlFields: 'id',
+ data: people.map((person, index) => ({
+ name: { firstName: 'Unreadable', lastName: `Person ${index}` },
+ ...person,
+ })),
+ }),
+ );
+
+ expect(response.body.errors).toBeUndefined();
+
+ const ids: string[] = response.body.data.createPeople.map(
+ ({ id }: { id: string }) => id,
+ );
+
+ createdPersonIdsForCleaning.push(...ids);
+
+ return ids;
+ };
+
+ const findPeopleByIds = async (ids: string[]): Promise<PersonNode[]> => {
+ const response = await makeGraphqlApiRequest(
+ findManyOperationFactory({
+ objectMetadataSingularName: 'person',
+ objectMetadataPluralName: 'people',
+ gqlFields: `id jobTitle companyId ${HIDDEN_DATE_FIELD_NAME}`,
+ filter: { id: { in: ids } },
+ }),
+ );
+
+ return response.body.data.people.edges.map(
+ ({ node }: { node: PersonNode }) => node,
+ );
+ };
+
+ const buildMergeOperation = (ids: string[]) =>
+ mergeManyOperationFactory({
+ objectMetadataPluralName: 'people',
+ gqlFields: 'id',
+ ids,
+ conflictPriorityIndex: 0,
+ });
+
+ beforeAll(async () => {
+ originalMemberRoleId = (await findOneRoleByLabel({ label: 'Member' })).id;
+
+ const { objects } = await findManyObjectMetadata({
+ input: { filter: {}, paging: { first: 100 } },
+ gqlFields: 'id nameSingular fieldsList { id name }',
+ expectToFail: false,
+ });
+ const personObject = objects.find(
+ (object) => object.nameSingular === 'person',
+ );
+
+ assertIsDefinedOrThrow(personObject);
+
+ const findPersonFieldId = (fieldName: string) => {
+ const field = personObject.fieldsList?.find(
+ ({ name }) => name === fieldName,
+ );
+
+ assertIsDefinedOrThrow(field);
+
+ return field.id;
+ };
+
+ const { data: hiddenDateFieldData } = await createOneFieldMetadata({
+ input: {
+ objectMetadataId: personObject.id,
+ name: HIDDEN_DATE_FIELD_NAME,
+ label: 'Merge hidden date',
+ type: FieldMetadataType.DATE_TIME,
+ },
+ gqlFields: 'id',
+ expectToFail: false,
+ });
+
+ hiddenDateFieldId = hiddenDateFieldData.createOneField.id;
+
+ const companyResponse = await makeGraphqlApiRequest(
+ createOneOperationFactory({
+ objectMetadataSingularName: 'company',
+ gqlFields: 'id',
+ data: { name: 'Merge hidden company' },
+ }),
+ );
+
+ companyId = companyResponse.body.data.createCompany.id;
+
+ const { roleId } = await createCustomRoleWithObjectPermissions({
+ label: 'MergeUnreadableFieldsRole',
+ });
+
+ customRoleId = roleId;
+
+ await upsertFieldPermissions({
+ roleId: customRoleId,
+ fieldPermissions: [
+ 'jobTitle',
+ 'phones',
+ 'company',
+ HIDDEN_DATE_FIELD_NAME,
+ ].map((fieldName) => ({
+ objectMetadataId: personObject.id,
+ fieldMetadataId:
+ fieldName === HIDDEN_DATE_FIELD_NAME
+ ? hiddenDateFieldId
+ : findPersonFieldId(fieldName),
+ canReadFieldValue: false,
+ canUpdateFieldValue: false,
+ })),
+ });
+
+ await updateWorkspaceMemberRole({
+ client,
+ roleId: customRoleId,
+ workspaceMemberId: WORKSPACE_MEMBER_DATA_SEED_IDS.JONY,
+ });
+ });
+
+ afterEach(async () => {
+ await deleteRecordsByIds('person', createdPersonIdsForCleaning);
+ createdPersonIdsForCleaning = [];
+ });
+
+ afterAll(async () => {
+ await updateWorkspaceMemberRole({
+ client,
+ roleId: originalMemberRoleId,
+ workspaceMemberId: WORKSPACE_MEMBER_DATA_SEED_IDS.JONY,
+ });
+
+ await deleteRole(client, customRoleId);
+
+ await deleteRecordsByIds('company', [companyId]);
+
+ await updateOneFieldMetadata({
+ input: {
+ idToUpdate: hiddenDateFieldId,
+ updatePayload: { isActive: false },
+ },
+ expectToFail: false,
+ });
+
+ await deleteOneFieldMetadata({
+ input: { idToDelete: hiddenDateFieldId },
+ expectToFail: false,
+ });
+ });
+
+ it('should refuse a merge that would drop a value the role cannot read', async () => {
+ const ids = await createPeople([
+ { jobTitle: '' },
+ { jobTitle: 'Hidden job title' },
+ ]);
+
+ const response = await makeGraphqlApiRequestWithMemberRole(
+ buildMergeOperation(ids),
+ );
+
+ expect(response.body.errors?.[0]?.extensions?.userFriendlyMessage).toBe(
+ UNREADABLE_FIELDS_ERROR,
+ );
+ expect(await findPeopleByIds(ids)).toHaveLength(2);
+ });
+
+ it('should merge when the priority record already keeps the unreadable value', async () => {
+ const [priorityId, duplicateId] = await createPeople([
+ { jobTitle: 'Kept job title' },
+ { jobTitle: 'Overridden job title' },
+ ]);
+
+ const response = await makeGraphqlApiRequestWithMemberRole(
+ buildMergeOperation([priorityId, duplicateId]),
+ );
+
+ expect(response.body.errors).toBeUndefined();
+ expect(response.body.data.mergePeople.id).toBe(priorityId);
+
+ const people = await findPeopleByIds([priorityId, duplicateId]);
+
+ expect(people).toHaveLength(1);
+ expect(people[0]).toMatchObject({
+ id: priorityId,
+ jobTitle: 'Kept job title',
+ });
+ });
+
+ it('should merge when records hold the same value in an unreadable composite field', async () => {
+ const sharedPhones = {
+ primaryPhoneNumber: '123456789',
+ primaryPhoneCallingCode: '+33',
+ primaryPhoneCountryCode: 'FR',
+ additionalPhones: [],
+ };
+ const [priorityId, duplicateId] = await createPeople([
+ { phones: sharedPhones },
+ { phones: sharedPhones },
+ ]);
+
+ const response = await makeGraphqlApiRequestWithMemberRole(
+ buildMergeOperation([priorityId, duplicateId]),
+ );
+
+ expect(response.body.errors).toBeUndefined();
+ expect(response.body.data.mergePeople.id).toBe(priorityId);
+ });
+
+ it('should refuse a merge that would drop an unreadable date only a duplicate holds', async () => {
+ const ids = await createPeople([
+ {},
+ { [HIDDEN_DATE_FIELD_NAME]: HIDDEN_DATE },
+ ]);
+
+ const response = await makeGraphqlApiRequestWithMemberRole(
+ buildMergeOperation(ids),
+ );
+
+ expect(response.body.errors?.[0]?.extensions?.userFriendlyMessage).toBe(
+ UNREADABLE_FIELDS_ERROR,
+ );
+ expect(await findPeopleByIds(ids)).toHaveLength(2);
+ });
+
+ it('should refuse a merge that would drop an unreadable relation two duplicates hold', async () => {
+ const ids = await createPeople([{}, { companyId }, { companyId }]);
+
+ const response = await makeGraphqlApiRequestWithMemberRole(
+ buildMergeOperation(ids),
+ );
+
+ expect(response.body.errors?.[0]?.extensions?.userFriendlyMessage).toBe(
+ UNREADABLE_FIELDS_ERROR,
+ );
+ expect(await findPeopleByIds(ids)).toHaveLength(3);
+ });
+
+ it('should carry a date and a relation held only by duplicates when every field is readable', async () => {
+ const [priorityId, ...duplicateIds] = await createPeople([
+ {},
+ { companyId, [HIDDEN_DATE_FIELD_NAME]: HIDDEN_DATE },
+ { companyId },
+ ]);
+
+ const response = await makeGraphqlApiRequest(
+ buildMergeOperation([priorityId, ...duplicateIds]),
+ );
+
+ expect(response.body.errors).toBeUndefined();
+
+ const people = await findPeopleByIds([priorityId, ...duplicateIds]);
+
+ expect(people).toHaveLength(1);
+ expect(people[0]).toMatchObject({
+ id: priorityId,
+ companyId,
+ [HIDDEN_DATE_FIELD_NAME]: HIDDEN_DATE,
+ });
+ });
+});
diff --git a/packages/twenty-server/test/integration/metadata/suites/application-default-role/successful-workspace-custom-application-token-role.integration-spec.ts b/packages/twenty-server/test/integration/metadata/suites/application-default-role/successful-workspace-custom-application-token-role.integration-spec.ts
index 8b818d76a4d..9be3f1188c9 100644
--- a/packages/twenty-server/test/integration/metadata/suites/application-default-role/successful-workspace-custom-application-token-role.integration-spec.ts
+++ b/packages/twenty-server/test/integration/metadata/suites/application-default-role/successful-workspace-custom-application-token-role.integration-spec.ts
@@ -1,12 +1,15 @@
import gql from 'graphql-tag';
+import { createOneOperationFactory } from 'test/integration/graphql/utils/create-one-operation-factory.util';
import { findWorkspaceCustomApplicationId } from 'test/integration/metadata/suites/application-default-role/utils/find-application-default-role.util';
import { makeGraphqlApiRequest } from 'test/integration/graphql/utils/make-graphql-api-request.util';
+import { deleteRecordsByIds } from 'test/integration/utils/delete-records-by-ids';
import { generateApplicationTokenPair } from 'test/integration/utils/generate-application-token-pair.util';
import { SEED_APPLE_WORKSPACE_ID } from 'src/engine/workspace-manager/dev-seeder/core/constants/seeder-workspaces.constant';
describe('The workspace custom application acts with its own default role', () => {
let customApplicationToken: string;
+ let companyId: string;
beforeAll(async () => {
const { applicationAccessToken } = await generateApplicationTokenPair({
@@ -15,14 +18,29 @@ describe('The workspace custom application acts with its own default role', () =
});
customApplicationToken = applicationAccessToken.token;
+
+ // Other suites wipe every company, so the seeded ones may be gone by now
+ const createCompanyResponse = await makeGraphqlApiRequest(
+ createOneOperationFactory({
+ objectMetadataSingularName: 'company',
+ gqlFields: 'id',
+ data: { name: 'Custom application token role company' },
+ }),
+ );
+
+ companyId = createCompanyResponse.body.data.createCompany.id;
+ });
+
+ afterAll(async () => {
+ await deleteRecordsByIds('company', [companyId]);
});
it('reads records with its own application token, as a workspace logic function does', async () => {
const response = await makeGraphqlApiRequest(
{
query: gql`
- query Companies {
- companies(first: 5) {
+ query Companies($companyId: UUID!) {
+ companies(filter: { id: { eq: $companyId } }) {
edges {
node {
id
@@ -31,11 +49,14 @@ describe('The workspace custom application acts with its own default role', () =
}
}
`,
+ variables: { companyId },
},
customApplicationToken,
);
expect(response.body.errors).toBeUndefined();
- expect(response.body.data.companies.edges.length).toBeGreaterThan(0);
+ expect(response.body.data.companies.edges).toEqual([
+ { node: { id: companyId } },
+ ]);
});
});