The open alternative to Salesforce, designed for AI.
TypeScript crmcrm-systemcustomergood-first-issuegraphqlhacktoberfestjavascriptmarketingmonoreponestjsopen-sourcepostgresqlreactreactjssalestypescriptweb
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.tsindex 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.tsxindex 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.tsindex 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.tsxindex 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.tsindex 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/wimport { 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/workspaceAddChatAssistantParticipationCommand,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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsindex 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.tsnew file mode 100644index 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.tsindex 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 CommonBaseQueryRunnerServargs.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 CommonBaseQueryRunnerServreturn 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 CommonBaseQueryRunnerServif (!this.shouldExcludeFieldFromMerge(fieldName,- fieldIdByName,+ fieldIdByRecordKey,flatFieldMetadataMaps,)) {@@ -236,7 +352,7 @@ export class CommonMergeManyQueryRunnerService extends CommonBaseQueryRunnerServmergedResult[fieldName] = recordsWithValues[0].value;} else {const fieldMetadata = findFlatEntityByIdInFlatEntityMaps({- flatEntityId: fieldIdByName[fieldName],+ flatEntityId: fieldIdByRecordKey[fieldName],flatEntityMaps: flatFieldMetadataMaps,});@@ -266,11 +382,11 @@ export class CommonMergeManyQueryRunnerService extends CommonBaseQueryRunnerServprivate 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsindex 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.tsindex 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.tsindex 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.tsnew file mode 100644index 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.tsindex 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 } },+ ]);});});