The open alternative to Salesforce, designed for AI.
TypeScript crmcrm-systemcustomergood-first-issuegraphqlhacktoberfestjavascriptmarketingmonoreponestjsopen-sourcepostgresqlreactreactjssalestypescriptweb
Fix `getApplicationSubAllFlatEntityMaps` to prune unrelated appIds universal identifier aggregators (#21234)
Paul Rastoin0877ba2ffd1d
diff --git a/packages/twenty-server/src/engine/core-modules/application/application-manifest/utils/get-application-sub-all-flat-entity-maps.util.ts b/packages/twenty-server/src/engine/core-modules/application/application-manifest/utils/get-application-sub-all-flat-entity-maps.util.tsindex b9696e45e77..5354d1af570 100644--- a/packages/twenty-server/src/engine/core-modules/application/application-manifest/utils/get-application-sub-all-flat-entity-maps.util.ts+++ b/packages/twenty-server/src/engine/core-modules/application/application-manifest/utils/get-application-sub-all-flat-entity-maps.util.ts@@ -5,6 +5,7 @@ import { type AllFlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/import { type MetadataFlatEntity } from 'src/engine/metadata-modules/flat-entity/types/metadata-flat-entity.type';import { getMetadataFlatEntityMapsKey } from 'src/engine/metadata-modules/flat-entity/utils/get-metadata-flat-entity-maps-key.util';import { getSubFlatEntityMapsByApplicationIdsOrThrow } from 'src/engine/metadata-modules/flat-entity/utils/get-sub-flat-entity-maps-by-application-ids-or-throw.util';+import { pruneDanglingForeignKeyAggregatorsInAllFlatEntityMapsThroughMutation } from 'src/engine/metadata-modules/flat-entity/utils/prune-dangling-foreign-key-aggregators-in-all-flat-entity-maps-through-mutation.util';export const getApplicationSubAllFlatEntityMaps = ({applicationIds,@@ -31,5 +32,9 @@ export const getApplicationSubAllFlatEntityMaps = ({emptyAllFlatEntityMaps[flatEntityMapsKey] = applicationSubFlatEntityMaps;}+ pruneDanglingForeignKeyAggregatorsInAllFlatEntityMapsThroughMutation({+ allFlatEntityMapsToMutate: emptyAllFlatEntityMaps,+ });+return emptyAllFlatEntityMaps;};diff --git a/packages/twenty-server/src/engine/metadata-modules/flat-entity/utils/__tests__/prune-dangling-foreign-key-aggregators-in-all-flat-entity-maps-through-mutation.util.spec.ts b/packages/twenty-server/src/engine/metadata-modules/flat-entity/utils/__tests__/prune-dangling-foreign-key-aggregators-in-all-flat-entity-maps-through-mutation.util.spec.tsnew file mode 100644index 00000000000..db8cd49b082--- /dev/null+++ b/packages/twenty-server/src/engine/metadata-modules/flat-entity/utils/__tests__/prune-dangling-foreign-key-aggregators-in-all-flat-entity-maps-through-mutation.util.spec.ts@@ -0,0 +1,182 @@+import { createEmptyAllFlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/constant/create-empty-all-flat-entity-maps.constant';+import { type AllFlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/types/all-flat-entity-maps.type';+import { pruneDanglingForeignKeyAggregatorsInAllFlatEntityMapsThroughMutation } from 'src/engine/metadata-modules/flat-entity/utils/prune-dangling-foreign-key-aggregators-in-all-flat-entity-maps-through-mutation.util';+import { type FlatFieldMetadata } from 'src/engine/metadata-modules/flat-field-metadata/types/flat-field-metadata.type';+import { type FlatObjectMetadata } from 'src/engine/metadata-modules/flat-object-metadata/types/flat-object-metadata.type';+import { type FlatViewField } from 'src/engine/metadata-modules/flat-view-field/types/flat-view-field.type';+import { type FlatView } from 'src/engine/metadata-modules/flat-view/types/flat-view.type';++const buildFlatViewField = (universalIdentifier: string): FlatViewField =>+ ({+ id: universalIdentifier,+ universalIdentifier,+ }) as unknown as FlatViewField;++const buildFlatView = ({+ universalIdentifier,+ viewFieldUniversalIdentifiers,+}: {+ universalIdentifier: string;+ viewFieldUniversalIdentifiers: string[];+}): FlatView =>+ ({+ id: universalIdentifier,+ universalIdentifier,+ viewFieldUniversalIdentifiers,+ viewFilterUniversalIdentifiers: [],+ viewGroupUniversalIdentifiers: [],+ viewFilterGroupUniversalIdentifiers: [],+ viewFieldGroupUniversalIdentifiers: [],+ viewSortUniversalIdentifiers: [],+ }) as unknown as FlatView;++const buildAllFlatEntityMapsWithView = ({+ view,+ viewFields,+}: {+ view: FlatView;+ viewFields: FlatViewField[];+}): AllFlatEntityMaps => {+ const allFlatEntityMaps = createEmptyAllFlatEntityMaps();++ allFlatEntityMaps.flatViewMaps.byUniversalIdentifier[+ view.universalIdentifier+ ] = view;++ for (const viewField of viewFields) {+ allFlatEntityMaps.flatViewFieldMaps.byUniversalIdentifier[+ viewField.universalIdentifier+ ] = viewField;+ }++ return allFlatEntityMaps;+};++describe('pruneDanglingForeignKeyAggregatorsInAllFlatEntityMapsThroughMutation', () => {+ it('should drop references to children missing from the slice while keeping present ones', () => {+ const view = buildFlatView({+ universalIdentifier: 'view-body',+ viewFieldUniversalIdentifiers: ['vf-arm', 'vf-head', 'vf-leg'],+ });++ // vf-leg is owned by another application and therefore not part of the slice+ const allFlatEntityMaps = buildAllFlatEntityMapsWithView({+ view,+ viewFields: [buildFlatViewField('vf-arm'), buildFlatViewField('vf-head')],+ });++ pruneDanglingForeignKeyAggregatorsInAllFlatEntityMapsThroughMutation({+ allFlatEntityMapsToMutate: allFlatEntityMaps,+ });++ expect(+ allFlatEntityMaps.flatViewMaps.byUniversalIdentifier['view-body']+ ?.viewFieldUniversalIdentifiers,+ ).toEqual(['vf-arm', 'vf-head']);+ });++ it('should leave aggregators untouched when every reference is present in the slice', () => {+ const view = buildFlatView({+ universalIdentifier: 'view-body',+ viewFieldUniversalIdentifiers: ['vf-arm', 'vf-head'],+ });++ const allFlatEntityMaps = buildAllFlatEntityMapsWithView({+ view,+ viewFields: [buildFlatViewField('vf-arm'), buildFlatViewField('vf-head')],+ });++ pruneDanglingForeignKeyAggregatorsInAllFlatEntityMapsThroughMutation({+ allFlatEntityMapsToMutate: allFlatEntityMaps,+ });++ const prunedView =+ allFlatEntityMaps.flatViewMaps.byUniversalIdentifier['view-body'];++ expect(prunedView?.viewFieldUniversalIdentifiers).toEqual([+ 'vf-arm',+ 'vf-head',+ ]);+ // No dangling reference means the entity reference is preserved as-is+ expect(prunedView).toBe(view);+ });++ it('should drop all references when no children remain in the slice', () => {+ const view = buildFlatView({+ universalIdentifier: 'view-body',+ viewFieldUniversalIdentifiers: ['vf-arm', 'vf-head'],+ });++ const allFlatEntityMaps = buildAllFlatEntityMapsWithView({+ view,+ viewFields: [],+ });++ pruneDanglingForeignKeyAggregatorsInAllFlatEntityMapsThroughMutation({+ allFlatEntityMapsToMutate: allFlatEntityMaps,+ });++ expect(+ allFlatEntityMaps.flatViewMaps.byUniversalIdentifier['view-body']+ ?.viewFieldUniversalIdentifiers,+ ).toEqual([]);+ });++ it('should prune dangling references generically across entity types (objectMetadata fields)', () => {+ const allFlatEntityMaps = createEmptyAllFlatEntityMaps();++ allFlatEntityMaps.flatObjectMetadataMaps.byUniversalIdentifier['object-1'] =+ {+ id: 'object-1',+ universalIdentifier: 'object-1',+ fieldUniversalIdentifiers: ['field-present', 'field-missing'],+ viewUniversalIdentifiers: [],+ indexMetadataUniversalIdentifiers: [],+ objectPermissionUniversalIdentifiers: [],+ fieldPermissionUniversalIdentifiers: [],+ } as unknown as FlatObjectMetadata;++ allFlatEntityMaps.flatFieldMetadataMaps.byUniversalIdentifier[+ 'field-present'+ ] = {+ id: 'field-present',+ universalIdentifier: 'field-present',+ } as unknown as FlatFieldMetadata;++ pruneDanglingForeignKeyAggregatorsInAllFlatEntityMapsThroughMutation({+ allFlatEntityMapsToMutate: allFlatEntityMaps,+ });++ expect(+ allFlatEntityMaps.flatObjectMetadataMaps.byUniversalIdentifier['object-1']+ ?.fieldUniversalIdentifiers,+ ).toEqual(['field-present']);+ });++ it('should not mutate the shared parent entity object when pruning', () => {+ const view = buildFlatView({+ universalIdentifier: 'view-body',+ viewFieldUniversalIdentifiers: ['vf-arm', 'vf-leg'],+ });++ const allFlatEntityMaps = buildAllFlatEntityMapsWithView({+ view,+ viewFields: [buildFlatViewField('vf-arm')],+ });++ pruneDanglingForeignKeyAggregatorsInAllFlatEntityMapsThroughMutation({+ allFlatEntityMapsToMutate: allFlatEntityMaps,+ });++ // The map entry is swapped for a new pruned object, leaving the original+ // (shared with other slices/cache) entity untouched+ expect(view.viewFieldUniversalIdentifiers).toEqual(['vf-arm', 'vf-leg']);+ expect(+ allFlatEntityMaps.flatViewMaps.byUniversalIdentifier['view-body'],+ ).not.toBe(view);+ expect(+ allFlatEntityMaps.flatViewMaps.byUniversalIdentifier['view-body']+ ?.viewFieldUniversalIdentifiers,+ ).toEqual(['vf-arm']);+ });+});diff --git a/packages/twenty-server/src/engine/metadata-modules/flat-entity/utils/prune-dangling-foreign-key-aggregators-in-all-flat-entity-maps-through-mutation.util.ts b/packages/twenty-server/src/engine/metadata-modules/flat-entity/utils/prune-dangling-foreign-key-aggregators-in-all-flat-entity-maps-through-mutation.util.tsnew file mode 100644index 00000000000..18e486981f3--- /dev/null+++ b/packages/twenty-server/src/engine/metadata-modules/flat-entity/utils/prune-dangling-foreign-key-aggregators-in-all-flat-entity-maps-through-mutation.util.ts@@ -0,0 +1,121 @@+import {+ ALL_METADATA_NAME,+ type AllMetadataName,+} from 'twenty-shared/metadata';+import { isDefined } from 'twenty-shared/utils';++import { ALL_ONE_TO_MANY_METADATA_RELATIONS } from 'src/engine/metadata-modules/flat-entity/constant/all-one-to-many-metadata-relations.constant';+import { type AllFlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/types/all-flat-entity-maps.type';+import { type SyncableFlatEntity } from 'src/engine/metadata-modules/flat-entity/types/flat-entity-from.type';+import { type FlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/types/flat-entity-maps.type';+import { getMetadataFlatEntityMapsKey } from 'src/engine/metadata-modules/flat-entity/utils/get-metadata-flat-entity-maps-key.util';++type LooseAllFlatEntityMaps = Record<+ string,+ FlatEntityMaps<SyncableFlatEntity>+>;++type OneToManyRelation = {+ metadataName: AllMetadataName;+ universalFlatEntityForeignKeyAggregator: string;+} | null;++type OneToManyAggregatorWithChildIdentifiers = {+ aggregatorProperty: string;+ childUniversalIdentifiers: Set<string>;+};++const pruneFlatEntityForeignKeyAggregators = ({+ flatEntity,+ aggregatorsWithChildIdentifiers,+}: {+ flatEntity: SyncableFlatEntity;+ aggregatorsWithChildIdentifiers: OneToManyAggregatorWithChildIdentifiers[];+}): SyncableFlatEntity =>+ aggregatorsWithChildIdentifiers.reduce(+ (prunedFlatEntity, { aggregatorProperty, childUniversalIdentifiers }) => {+ const aggregatedUniversalIdentifiers = (+ prunedFlatEntity as Record<string, unknown>+ )[aggregatorProperty];++ if (+ !isDefined(aggregatedUniversalIdentifiers) ||+ !Array.isArray(aggregatedUniversalIdentifiers)+ ) {+ return prunedFlatEntity;+ }++ const prunedUniversalIdentifiers = aggregatedUniversalIdentifiers.filter(+ (childUniversalIdentifier: string) =>+ childUniversalIdentifiers.has(childUniversalIdentifier),+ );++ if (+ prunedUniversalIdentifiers.length ===+ aggregatedUniversalIdentifiers.length+ ) {+ return prunedFlatEntity;+ }++ return {+ ...prunedFlatEntity,+ [aggregatorProperty]: prunedUniversalIdentifiers,+ };+ },+ flatEntity,+ );++// Drops one-to-many aggregator references to children absent from the slice+// (e.g. an app-owned view referencing a view field owned by another+// application), keeping the slice a closed, internally consistent graph.+// Mutates the passed maps in place: the parent entry is replaced by a new+// pruned entity object, never mutating the shared entity referenced elsewhere.+export const pruneDanglingForeignKeyAggregatorsInAllFlatEntityMapsThroughMutation =+ ({+ allFlatEntityMapsToMutate,+ }: {+ allFlatEntityMapsToMutate: AllFlatEntityMaps;+ }): void => {+ const looseAllFlatEntityMaps =+ allFlatEntityMapsToMutate as unknown as LooseAllFlatEntityMaps;++ for (const metadataName of Object.values(ALL_METADATA_NAME)) {+ const oneToManyRelations = Object.values(+ ALL_ONE_TO_MANY_METADATA_RELATIONS[metadataName],+ ) as OneToManyRelation[];++ const aggregatorsWithChildIdentifiers: OneToManyAggregatorWithChildIdentifiers[] =+ oneToManyRelations.filter(isDefined).map((relation) => ({+ aggregatorProperty: relation.universalFlatEntityForeignKeyAggregator,+ childUniversalIdentifiers: new Set(+ Object.keys(+ looseAllFlatEntityMaps[+ getMetadataFlatEntityMapsKey(relation.metadataName)+ ].byUniversalIdentifier,+ ),+ ),+ }));++ if (aggregatorsWithChildIdentifiers.length === 0) {+ continue;+ }++ const flatEntityByUniversalIdentifier =+ looseAllFlatEntityMaps[getMetadataFlatEntityMapsKey(metadataName)]+ .byUniversalIdentifier;++ for (const [universalIdentifier, parentFlatEntity] of Object.entries(+ flatEntityByUniversalIdentifier,+ )) {+ if (!isDefined(parentFlatEntity)) {+ continue;+ }++ flatEntityByUniversalIdentifier[universalIdentifier] =+ pruneFlatEntityForeignKeyAggregators({+ flatEntity: parentFlatEntity,+ aggregatorsWithChildIdentifiers,+ });+ }+ }+ };diff --git a/packages/twenty-server/test/integration/metadata/suites/application/successful-resync-application-with-cross-app-owned-view-field.integration-spec.ts b/packages/twenty-server/test/integration/metadata/suites/application/successful-resync-application-with-cross-app-owned-view-field.integration-spec.tsnew file mode 100644index 00000000000..4a2fc3c2857--- /dev/null+++ b/packages/twenty-server/test/integration/metadata/suites/application/successful-resync-application-with-cross-app-owned-view-field.integration-spec.ts@@ -0,0 +1,229 @@+import { buildBaseManifest } from 'test/integration/metadata/suites/application/utils/build-base-manifest.util';+import { buildDefaultObjectManifest } from 'test/integration/metadata/suites/application/utils/build-default-object-manifest.util';+import { cleanupApplicationAndAppRegistration } from 'test/integration/metadata/suites/application/utils/cleanup-application-and-app-registration.util';+import { setupApplicationForSync } from 'test/integration/metadata/suites/application/utils/setup-application-for-sync.util';+import { syncApplication } from 'test/integration/metadata/suites/application/utils/sync-application.util';+import { findManyObjectMetadataWithIndexes } from 'test/integration/metadata/suites/object-metadata/utils/find-many-object-metadata-with-indexes.util';+import { createOneViewField } from 'test/integration/metadata/suites/view-field/utils/create-one-view-field.util';+import { findViewFields } from 'test/integration/metadata/suites/view-field/utils/find-view-fields.util';+import { findViews } from 'test/integration/metadata/suites/view/utils/find-views.util';+import { type Manifest } from 'twenty-shared/application';+import { FieldMetadataType } from 'twenty-shared/types';+import { isDefined } from 'twenty-shared/utils';+import { v4 as uuidv4 } from 'uuid';++const TEST_APP_ID = uuidv4();+const TEST_ROLE_ID = uuidv4();++const ARM_FIELD_ID = uuidv4();+const LEG_FIELD_ID = uuidv4();+const HEAD_FIELD_ID = uuidv4();+const TAIL_FIELD_ID = uuidv4();++const BODY_VIEW_ID = uuidv4();+const ARM_VIEW_FIELD_ID = uuidv4();+const HEAD_VIEW_FIELD_ID = uuidv4();+const TAIL_VIEW_FIELD_ID = uuidv4();++const HUMAN_OBJECT = buildDefaultObjectManifest({+ nameSingular: 'human',+ namePlural: 'humans',+ labelSingular: 'Human',+ labelPlural: 'Humans',+ description: 'A human being',+ icon: 'IconUser',+ additionalFields: [+ {+ universalIdentifier: ARM_FIELD_ID,+ type: FieldMetadataType.TEXT,+ name: 'arm',+ label: 'Arm',+ },+ {+ universalIdentifier: LEG_FIELD_ID,+ type: FieldMetadataType.TEXT,+ name: 'leg',+ label: 'Leg',+ },+ {+ universalIdentifier: HEAD_FIELD_ID,+ type: FieldMetadataType.TEXT,+ name: 'head',+ label: 'Head',+ },+ ],+});++const buildInitialManifest = (): Manifest =>+ buildBaseManifest({+ appId: TEST_APP_ID,+ roleId: TEST_ROLE_ID,+ overrides: {+ objects: [HUMAN_OBJECT],+ views: [+ {+ universalIdentifier: BODY_VIEW_ID,+ name: 'Body',+ objectUniversalIdentifier: HUMAN_OBJECT.universalIdentifier,+ fields: [+ {+ universalIdentifier: ARM_VIEW_FIELD_ID,+ fieldMetadataUniversalIdentifier: ARM_FIELD_ID,+ position: 0,+ },+ {+ universalIdentifier: HEAD_VIEW_FIELD_ID,+ fieldMetadataUniversalIdentifier: HEAD_FIELD_ID,+ position: 1,+ },+ ],+ },+ ],+ },+ });++const buildResyncManifest = (): Manifest =>+ buildBaseManifest({+ appId: TEST_APP_ID,+ roleId: TEST_ROLE_ID,+ overrides: {+ objects: [+ {+ ...HUMAN_OBJECT,+ fields: [+ ...HUMAN_OBJECT.fields,+ {+ universalIdentifier: TAIL_FIELD_ID,+ type: FieldMetadataType.TEXT,+ name: 'tail',+ label: 'Tail',+ },+ ],+ },+ ],+ views: [+ {+ universalIdentifier: BODY_VIEW_ID,+ name: 'Body',+ objectUniversalIdentifier: HUMAN_OBJECT.universalIdentifier,+ fields: [+ {+ universalIdentifier: ARM_VIEW_FIELD_ID,+ fieldMetadataUniversalIdentifier: ARM_FIELD_ID,+ position: 0,+ },+ {+ universalIdentifier: HEAD_VIEW_FIELD_ID,+ fieldMetadataUniversalIdentifier: HEAD_FIELD_ID,+ position: 1,+ },+ {+ universalIdentifier: TAIL_VIEW_FIELD_ID,+ fieldMetadataUniversalIdentifier: TAIL_FIELD_ID,+ position: 2,+ },+ ],+ },+ ],+ },+ });++const findHumanObject = async () => {+ const objects = await findManyObjectMetadataWithIndexes({+ expectToFail: false,+ });++ return objects.find(+ (objectMetadata) =>+ objectMetadata.universalIdentifier === HUMAN_OBJECT.universalIdentifier,+ );+};++describe('Successful re-sync of an application whose app-owned view references a cross-app-owned view field', () => {+ beforeAll(async () => {+ await setupApplicationForSync({+ applicationUniversalIdentifier: TEST_APP_ID,+ name: 'Human Application',+ description: 'App for testing view field ownership conflicts on re-sync',+ sourcePath: 'test-api-owned-view-field',+ });+ }, 60000);++ afterAll(async () => {+ await cleanupApplicationAndAppRegistration({+ applicationUniversalIdentifier: TEST_APP_ID,+ });+ });++ it('should re-sync successfully when the app-owned Body view carries a view field owned by another application', async () => {+ await syncApplication({+ manifest: buildInitialManifest(),+ expectToFail: false,+ });++ const humanObject = await findHumanObject();++ expect(humanObject).toBeDefined();++ const legField = humanObject?.fieldsList.find(+ (field) => field.name === 'leg',+ );++ expect(legField).toBeDefined();++ const { data: viewsData } = await findViews({+ objectMetadataId: humanObject?.id,+ expectToFail: false,+ });++ const bodyView = viewsData?.getViews.find((view) => view.name === 'Body');++ expect(bodyView).toBeDefined();++ const { data: createViewFieldData } = await createOneViewField({+ input: {+ fieldMetadataId: legField?.id ?? '',+ viewId: bodyView?.id ?? '',+ position: 2,+ },+ expectToFail: false,+ });++ const legViewFieldId = createViewFieldData?.createViewField.id;++ expect(isDefined(legViewFieldId)).toBe(true);++ const { errors } = await syncApplication({+ manifest: buildResyncManifest(),+ expectToFail: false,+ });++ expect(isDefined(errors)).toBe(false);++ const humanObjectAfterResync = await findHumanObject();+ const tailField = humanObjectAfterResync?.fieldsList.find(+ (field) => field.name === 'tail',+ );++ expect(tailField).toBeDefined();++ const { data: viewFieldsData } = await findViewFields({+ viewId: bodyView?.id ?? '',+ expectToFail: false,+ });++ const viewFieldFieldMetadataIds = (viewFieldsData?.getViewFields ?? []).map(+ (viewField) => viewField.fieldMetadataId,+ );++ expect(viewFieldFieldMetadataIds).toEqual(+ expect.arrayContaining([legField?.id, tailField?.id]),+ );++ const legViewFieldStillPresent = (viewFieldsData?.getViewFields ?? []).some(+ (viewField) => viewField.id === legViewFieldId,+ );++ expect(legViewFieldStillPresent).toBe(true);+ }, 120000);+});