Skip to content

The open alternative to Salesforce, designed for AI.

Fix app-scoped schema generation for relations targeting another application's object (#26436)

Paul Rastoin64fd5ddf57aa
diff --git a/packages/twenty-server/src/engine/api/graphql/workspace-graphql-schema-sdl/utils/__tests__/compute-application-schema-scope-flat-entity-ids.util.spec.ts b/packages/twenty-server/src/engine/api/graphql/workspace-graphql-schema-sdl/utils/__tests__/compute-application-schema-scope-flat-entity-ids.util.spec.ts
new file mode 100644
index 00000000000..3cea17d64fa
--- /dev/null
+++ b/packages/twenty-server/src/engine/api/graphql/workspace-graphql-schema-sdl/utils/__tests__/compute-application-schema-scope-flat-entity-ids.util.spec.ts
@@ -0,0 +1,324 @@
+import { FieldMetadataType } from 'twenty-shared/types';
+import { isDefined } from 'twenty-shared/utils';
+
+import { computeApplicationSchemaScopeFlatEntityIds } from 'src/engine/api/graphql/workspace-graphql-schema-sdl/utils/compute-application-schema-scope-flat-entity-ids.util';
+import { createEmptyFlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/constant/create-empty-flat-entity-maps.constant';
+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 { addFlatEntityToFlatEntityMapsOrThrow } from 'src/engine/metadata-modules/flat-entity/utils/add-flat-entity-to-flat-entity-maps-or-throw.util';
+import { getFlatFieldMetadataMock } from 'src/engine/metadata-modules/flat-field-metadata/__mocks__/get-flat-field-metadata.mock';
+import { type FlatFieldMetadata } from 'src/engine/metadata-modules/flat-field-metadata/types/flat-field-metadata.type';
+import { getFlatIndexMetadataMock } from 'src/engine/metadata-modules/flat-index-metadata/__mocks__/get-flat-index-metadata.mock';
+import { type FlatIndexMetadata } from 'src/engine/metadata-modules/flat-index-metadata/types/flat-index-metadata.type';
+import { getFlatObjectMetadataMock } from 'src/engine/metadata-modules/flat-object-metadata/__mocks__/get-flat-object-metadata.mock';
+import { type FlatObjectMetadata } from 'src/engine/metadata-modules/flat-object-metadata/types/flat-object-metadata.type';
+
+const STANDARD_APPLICATION_ID = 'standard-application-id';
+const APP_A_ID = 'app-a-id';
+const APP_B_ID = 'app-b-id';
+const APP_C_ID = 'app-c-id';
+
+const STANDARD_OBJECT_ID = 'standard-object';
+const APP_A_OBJECT_ID = 'app-a-object';
+const APP_A_OTHER_OBJECT_ID = 'app-a-other-object';
+const APP_B_OBJECT_ID = 'app-b-object';
+const APP_C_OBJECT_ID = 'app-c-object';
+
+type ObjectFixture = { id: string; applicationId: string };
+
+const OBJECTS: ObjectFixture[] = [
+ { id: STANDARD_OBJECT_ID, applicationId: STANDARD_APPLICATION_ID },
+ { id: APP_A_OBJECT_ID, applicationId: APP_A_ID },
+ { id: APP_A_OTHER_OBJECT_ID, applicationId: APP_A_ID },
+ { id: APP_B_OBJECT_ID, applicationId: APP_B_ID },
+ { id: APP_C_OBJECT_ID, applicationId: APP_C_ID },
+];
+
+const buildField = ({
+ id,
+ applicationId,
+ objectMetadataId,
+ relationTargetObjectMetadataId,
+}: {
+ id: string;
+ applicationId: string;
+ objectMetadataId: string;
+ relationTargetObjectMetadataId?: string;
+}): FlatFieldMetadata =>
+ getFlatFieldMetadataMock({
+ id,
+ universalIdentifier: `${id}-universal-identifier`,
+ type: isDefined(relationTargetObjectMetadataId)
+ ? FieldMetadataType.RELATION
+ : FieldMetadataType.TEXT,
+ applicationId,
+ objectMetadataId,
+ relationTargetObjectMetadataId: relationTargetObjectMetadataId ?? null,
+ });
+
+const buildIndex = ({
+ id,
+ applicationId,
+ objectMetadataId,
+}: {
+ id: string;
+ applicationId: string;
+ objectMetadataId: string;
+}): FlatIndexMetadata =>
+ getFlatIndexMetadataMock({
+ id,
+ universalIdentifier: `${id}-universal-identifier`,
+ applicationId,
+ applicationUniversalIdentifier: `${applicationId}-universal-identifier`,
+ objectMetadataId,
+ objectMetadataUniversalIdentifier: `${objectMetadataId}-universal-identifier`,
+ });
+
+const buildFlatEntityMaps = <T extends SyncableFlatEntity>(
+ flatEntities: T[],
+): FlatEntityMaps<T> =>
+ flatEntities.reduce<FlatEntityMaps<T>>(
+ (flatEntityMaps, flatEntity) =>
+ addFlatEntityToFlatEntityMapsOrThrow({ flatEntity, flatEntityMaps }),
+ createEmptyFlatEntityMaps(),
+ );
+
+const buildMaps = ({
+ fields,
+ indexes = [],
+}: {
+ fields: FlatFieldMetadata[];
+ indexes?: FlatIndexMetadata[];
+}) => ({
+ flatObjectMetadataMaps: buildFlatEntityMaps<FlatObjectMetadata>(
+ OBJECTS.map(({ id, applicationId }) =>
+ getFlatObjectMetadataMock({
+ id,
+ universalIdentifier: `${id}-universal-identifier`,
+ applicationId,
+ fieldIds: fields
+ .filter((field) => field.objectMetadataId === id)
+ .map((field) => field.id),
+ indexMetadataIds: indexes
+ .filter((index) => index.objectMetadataId === id)
+ .map((index) => index.id),
+ }),
+ ),
+ ),
+ flatFieldMetadataMaps: buildFlatEntityMaps(fields),
+ flatIndexMaps: buildFlatEntityMaps(indexes),
+});
+
+const APP_A_NAME_FIELD = buildField({
+ id: 'app-a-name',
+ applicationId: APP_A_ID,
+ objectMetadataId: APP_A_OBJECT_ID,
+});
+
+const APP_A_OTHER_NAME_FIELD = buildField({
+ id: 'app-a-other-name',
+ applicationId: APP_A_ID,
+ objectMetadataId: APP_A_OTHER_OBJECT_ID,
+});
+
+const APP_C_FIELD_ON_APP_A_OBJECT = buildField({
+ id: 'app-c-field-on-app-a-object',
+ applicationId: APP_C_ID,
+ objectMetadataId: APP_A_OBJECT_ID,
+});
+
+const APP_C_NAME_FIELD = buildField({
+ id: 'app-c-name',
+ applicationId: APP_C_ID,
+ objectMetadataId: APP_C_OBJECT_ID,
+});
+
+const APP_B_TO_APP_A_FIELD = buildField({
+ id: 'app-b-to-app-a',
+ applicationId: APP_B_ID,
+ objectMetadataId: APP_B_OBJECT_ID,
+ relationTargetObjectMetadataId: APP_A_OBJECT_ID,
+});
+
+const APP_B_INVERSE_ON_APP_A_OBJECT_FIELD = buildField({
+ id: 'app-b-inverse-on-app-a-object',
+ applicationId: APP_B_ID,
+ objectMetadataId: APP_A_OBJECT_ID,
+ relationTargetObjectMetadataId: APP_B_OBJECT_ID,
+});
+
+const computeForAppB = (
+ maps: ReturnType<typeof buildMaps>,
+): ReturnType<typeof computeApplicationSchemaScopeFlatEntityIds> =>
+ computeApplicationSchemaScopeFlatEntityIds({
+ applicationId: APP_B_ID,
+ twentyStandardApplicationId: STANDARD_APPLICATION_ID,
+ ...maps,
+ });
+
+describe('computeApplicationSchemaScopeFlatEntityIds', () => {
+ it('keeps the standard and requesting application entities when no relation leaves the scope', () => {
+ const result = computeForAppB(
+ buildMaps({
+ fields: [
+ APP_A_NAME_FIELD,
+ buildField({
+ id: 'app-b-to-standard',
+ applicationId: APP_B_ID,
+ objectMetadataId: APP_B_OBJECT_ID,
+ relationTargetObjectMetadataId: STANDARD_OBJECT_ID,
+ }),
+ ],
+ }),
+ );
+
+ expect(result.flatObjectMetadataIds.sort()).toEqual(
+ [APP_B_OBJECT_ID, STANDARD_OBJECT_ID].sort(),
+ );
+ expect(result.flatFieldMetadataIds).toEqual(['app-b-to-standard']);
+ expect(result.flatIndexMetadataIds).toEqual([]);
+ });
+
+ it('pulls in a relation target object with the fields its own application defines on it', () => {
+ const result = computeForAppB(
+ buildMaps({
+ fields: [
+ APP_A_NAME_FIELD,
+ APP_A_OTHER_NAME_FIELD,
+ APP_C_FIELD_ON_APP_A_OBJECT,
+ APP_B_TO_APP_A_FIELD,
+ APP_B_INVERSE_ON_APP_A_OBJECT_FIELD,
+ ],
+ }),
+ );
+
+ expect(result.flatObjectMetadataIds.sort()).toEqual(
+ [APP_A_OBJECT_ID, APP_B_OBJECT_ID, STANDARD_OBJECT_ID].sort(),
+ );
+ expect(result.flatFieldMetadataIds.sort()).toEqual(
+ ['app-a-name', 'app-b-inverse-on-app-a-object', 'app-b-to-app-a'].sort(),
+ );
+ });
+
+ it('follows a relation the requesting application declares on a standard object', () => {
+ const result = computeForAppB(
+ buildMaps({
+ fields: [
+ APP_A_NAME_FIELD,
+ buildField({
+ id: 'standard-to-app-a',
+ applicationId: APP_B_ID,
+ objectMetadataId: STANDARD_OBJECT_ID,
+ relationTargetObjectMetadataId: APP_A_OBJECT_ID,
+ }),
+ ],
+ }),
+ );
+
+ expect(result.flatObjectMetadataIds.sort()).toEqual(
+ [APP_A_OBJECT_ID, APP_B_OBJECT_ID, STANDARD_OBJECT_ID].sort(),
+ );
+ expect(result.flatFieldMetadataIds.sort()).toEqual(
+ ['app-a-name', 'standard-to-app-a'].sort(),
+ );
+ });
+
+ it('follows the relations of pulled-in objects transitively', () => {
+ const result = computeForAppB(
+ buildMaps({
+ fields: [
+ APP_A_NAME_FIELD,
+ APP_C_NAME_FIELD,
+ APP_B_TO_APP_A_FIELD,
+ buildField({
+ id: 'app-a-to-app-c',
+ applicationId: APP_A_ID,
+ objectMetadataId: APP_A_OBJECT_ID,
+ relationTargetObjectMetadataId: APP_C_OBJECT_ID,
+ }),
+ ],
+ }),
+ );
+
+ expect(result.flatObjectMetadataIds.sort()).toEqual(
+ [
+ APP_A_OBJECT_ID,
+ APP_B_OBJECT_ID,
+ APP_C_OBJECT_ID,
+ STANDARD_OBJECT_ID,
+ ].sort(),
+ );
+ expect(result.flatFieldMetadataIds.sort()).toEqual(
+ ['app-a-name', 'app-a-to-app-c', 'app-b-to-app-a', 'app-c-name'].sort(),
+ );
+ });
+
+ it('seeds the walk from the requesting application relations only', () => {
+ const result = computeForAppB(
+ buildMaps({
+ fields: [
+ APP_C_NAME_FIELD,
+ buildField({
+ id: 'standard-owned-to-app-c',
+ applicationId: STANDARD_APPLICATION_ID,
+ objectMetadataId: STANDARD_OBJECT_ID,
+ relationTargetObjectMetadataId: APP_C_OBJECT_ID,
+ }),
+ ],
+ }),
+ );
+
+ expect(result.flatObjectMetadataIds.sort()).toEqual(
+ [APP_B_OBJECT_ID, STANDARD_OBJECT_ID].sort(),
+ );
+ expect(result.flatFieldMetadataIds).toEqual(['standard-owned-to-app-c']);
+ });
+
+ it('selects the indexes of each in-scope object owned by the scope or by the object application', () => {
+ const result = computeForAppB(
+ buildMaps({
+ fields: [APP_A_NAME_FIELD, APP_B_TO_APP_A_FIELD],
+ indexes: [
+ buildIndex({
+ id: 'standard-index',
+ applicationId: STANDARD_APPLICATION_ID,
+ objectMetadataId: STANDARD_OBJECT_ID,
+ }),
+ buildIndex({
+ id: 'app-b-index-on-standard-object',
+ applicationId: APP_B_ID,
+ objectMetadataId: STANDARD_OBJECT_ID,
+ }),
+ buildIndex({
+ id: 'app-c-index-on-standard-object',
+ applicationId: APP_C_ID,
+ objectMetadataId: STANDARD_OBJECT_ID,
+ }),
+ buildIndex({
+ id: 'app-a-index',
+ applicationId: APP_A_ID,
+ objectMetadataId: APP_A_OBJECT_ID,
+ }),
+ buildIndex({
+ id: 'app-c-index-on-app-a-object',
+ applicationId: APP_C_ID,
+ objectMetadataId: APP_A_OBJECT_ID,
+ }),
+ buildIndex({
+ id: 'app-c-index',
+ applicationId: APP_C_ID,
+ objectMetadataId: APP_C_OBJECT_ID,
+ }),
+ ],
+ }),
+ );
+
+ expect(result.flatIndexMetadataIds.sort()).toEqual(
+ [
+ 'app-a-index',
+ 'app-b-index-on-standard-object',
+ 'standard-index',
+ ].sort(),
+ );
+ });
+});
diff --git a/packages/twenty-server/src/engine/api/graphql/workspace-graphql-schema-sdl/utils/compute-application-schema-scope-flat-entity-ids.util.ts b/packages/twenty-server/src/engine/api/graphql/workspace-graphql-schema-sdl/utils/compute-application-schema-scope-flat-entity-ids.util.ts
new file mode 100644
index 00000000000..308d4dc5290
--- /dev/null
+++ b/packages/twenty-server/src/engine/api/graphql/workspace-graphql-schema-sdl/utils/compute-application-schema-scope-flat-entity-ids.util.ts
@@ -0,0 +1,135 @@
+import { isDefined } from 'twenty-shared/utils';
+
+import { type FlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/types/flat-entity-maps.type';
+import { findFlatEntitiesByApplicationId } from 'src/engine/metadata-modules/flat-entity/utils/find-flat-entities-by-application-id.util';
+import { findFlatEntityByIdInFlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/utils/find-flat-entity-by-id-in-flat-entity-maps.util';
+import { findManyFlatEntityByIdInFlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/utils/find-many-flat-entity-by-id-in-flat-entity-maps.util';
+import { type FlatFieldMetadata } from 'src/engine/metadata-modules/flat-field-metadata/types/flat-field-metadata.type';
+import { isMorphOrRelationFlatFieldMetadata } from 'src/engine/metadata-modules/flat-field-metadata/utils/is-morph-or-relation-flat-field-metadata.util';
+import { type FlatIndexMetadata } from 'src/engine/metadata-modules/flat-index-metadata/types/flat-index-metadata.type';
+import { type FlatObjectMetadata } from 'src/engine/metadata-modules/flat-object-metadata/types/flat-object-metadata.type';
+
+export type ApplicationSchemaScopeFlatEntityIds = {
+ flatObjectMetadataIds: string[];
+ flatFieldMetadataIds: string[];
+ flatIndexMetadataIds: string[];
+};
+
+export const computeApplicationSchemaScopeFlatEntityIds = ({
+ applicationId,
+ twentyStandardApplicationId,
+ flatObjectMetadataMaps,
+ flatFieldMetadataMaps,
+ flatIndexMaps,
+}: {
+ applicationId: string;
+ twentyStandardApplicationId?: string;
+ flatObjectMetadataMaps: FlatEntityMaps<FlatObjectMetadata>;
+ flatFieldMetadataMaps: FlatEntityMaps<FlatFieldMetadata>;
+ flatIndexMaps?: FlatEntityMaps<FlatIndexMetadata>;
+}): ApplicationSchemaScopeFlatEntityIds => {
+ const scopeApplicationIds = isDefined(twentyStandardApplicationId)
+ ? [twentyStandardApplicationId, applicationId]
+ : [applicationId];
+
+ const flatObjectMetadataIds = new Set(
+ scopeApplicationIds.flatMap((scopeApplicationId) =>
+ findFlatEntitiesByApplicationId({
+ applicationId: scopeApplicationId,
+ flatEntityMaps: flatObjectMetadataMaps,
+ }).map((flatObjectMetadata) => flatObjectMetadata.id),
+ ),
+ );
+
+ const flatFieldMetadataIds = new Set(
+ scopeApplicationIds.flatMap((scopeApplicationId) =>
+ findFlatEntitiesByApplicationId({
+ applicationId: scopeApplicationId,
+ flatEntityMaps: flatFieldMetadataMaps,
+ }).map((flatFieldMetadata) => flatFieldMetadata.id),
+ ),
+ );
+
+ const relationFlatFieldMetadatasToVisit = findFlatEntitiesByApplicationId({
+ applicationId,
+ flatEntityMaps: flatFieldMetadataMaps,
+ }).filter(isMorphOrRelationFlatFieldMetadata);
+
+ while (relationFlatFieldMetadatasToVisit.length > 0) {
+ const relationFlatFieldMetadata = relationFlatFieldMetadatasToVisit.pop();
+
+ if (!isDefined(relationFlatFieldMetadata)) {
+ break;
+ }
+
+ const { relationTargetObjectMetadataId } = relationFlatFieldMetadata;
+
+ if (
+ !isDefined(relationTargetObjectMetadataId) ||
+ flatObjectMetadataIds.has(relationTargetObjectMetadataId)
+ ) {
+ continue;
+ }
+
+ const targetFlatObjectMetadata = findFlatEntityByIdInFlatEntityMaps({
+ flatEntityId: relationTargetObjectMetadataId,
+ flatEntityMaps: flatObjectMetadataMaps,
+ });
+
+ if (!isDefined(targetFlatObjectMetadata)) {
+ continue;
+ }
+
+ flatObjectMetadataIds.add(targetFlatObjectMetadata.id);
+
+ const targetOwnerFlatFieldMetadatas =
+ findManyFlatEntityByIdInFlatEntityMaps({
+ flatEntityIds: targetFlatObjectMetadata.fieldIds,
+ flatEntityMaps: flatFieldMetadataMaps,
+ }).filter(
+ (flatFieldMetadata) =>
+ flatFieldMetadata.applicationId ===
+ targetFlatObjectMetadata.applicationId &&
+ !flatFieldMetadataIds.has(flatFieldMetadata.id),
+ );
+
+ for (const targetOwnerFlatFieldMetadata of targetOwnerFlatFieldMetadatas) {
+ flatFieldMetadataIds.add(targetOwnerFlatFieldMetadata.id);
+
+ if (isMorphOrRelationFlatFieldMetadata(targetOwnerFlatFieldMetadata)) {
+ relationFlatFieldMetadatasToVisit.push(targetOwnerFlatFieldMetadata);
+ }
+ }
+ }
+
+ const flatIndexMetadataIds = isDefined(flatIndexMaps)
+ ? [...flatObjectMetadataIds].flatMap((flatObjectMetadataId) => {
+ const flatObjectMetadata = findFlatEntityByIdInFlatEntityMaps({
+ flatEntityId: flatObjectMetadataId,
+ flatEntityMaps: flatObjectMetadataMaps,
+ });
+
+ if (!isDefined(flatObjectMetadata)) {
+ return [];
+ }
+
+ return findManyFlatEntityByIdInFlatEntityMaps({
+ flatEntityIds: flatObjectMetadata.indexMetadataIds,
+ flatEntityMaps: flatIndexMaps,
+ })
+ .filter(
+ (flatIndexMetadata) =>
+ scopeApplicationIds.includes(flatIndexMetadata.applicationId) ||
+ flatIndexMetadata.applicationId ===
+ flatObjectMetadata.applicationId,
+ )
+ .map((flatIndexMetadata) => flatIndexMetadata.id);
+ })
+ : [];
+
+ return {
+ flatObjectMetadataIds: [...flatObjectMetadataIds],
+ flatFieldMetadataIds: [...flatFieldMetadataIds],
+ flatIndexMetadataIds,
+ };
+};
diff --git a/packages/twenty-server/src/engine/api/graphql/workspace-graphql-schema-sdl/workspace-graphql-schema-sdl.service.ts b/packages/twenty-server/src/engine/api/graphql/workspace-graphql-schema-sdl/workspace-graphql-schema-sdl.service.ts
index ea277cab207..17bee67b28a 100644
--- a/packages/twenty-server/src/engine/api/graphql/workspace-graphql-schema-sdl/workspace-graphql-schema-sdl.service.ts
+++ b/packages/twenty-server/src/engine/api/graphql/workspace-graphql-schema-sdl/workspace-graphql-schema-sdl.service.ts
@@ -7,6 +7,7 @@ import { isDefined } from 'twenty-shared/utils';
import { ScalarsExplorerService } from 'src/engine/api/graphql/services/scalars-explorer.service';
import { CORE_WORKFLOW_APP_OPERATIONS_SDL_APPENDER } from 'src/engine/api/graphql/workspace-graphql-schema-sdl/core-workflow-app-operations-sdl.constants';
import { type CoreWorkflowAppOperationsSdlAppender } from 'src/engine/api/graphql/workspace-graphql-schema-sdl/types/core-workflow-app-operations-sdl-appender.type';
+import { computeApplicationSchemaScopeFlatEntityIds } from 'src/engine/api/graphql/workspace-graphql-schema-sdl/utils/compute-application-schema-scope-flat-entity-ids.util';
import { type SchemaGenerationContext } from 'src/engine/api/graphql/workspace-schema-builder/types/schema-generation-context.type';
import { WorkspaceGraphQLSchemaGenerator } from 'src/engine/api/graphql/workspace-schema-builder/workspace-graphql-schema.factory';
import { FlatWorkspace } from 'src/engine/core-modules/workspace/types/flat-workspace.type';
@@ -16,7 +17,7 @@ import {
} from 'src/engine/metadata-modules/flat-entity/exceptions/flat-entity-maps.exception';
import { WorkspaceManyOrAllFlatEntityMapsCacheService } from 'src/engine/metadata-modules/flat-entity/services/workspace-many-or-all-flat-entity-maps-cache.service';
import { type FlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/types/flat-entity-maps.type';
-import { getSubFlatEntityMapsByApplicationIdsOrThrow } from 'src/engine/metadata-modules/flat-entity/utils/get-sub-flat-entity-maps-by-application-ids-or-throw.util';
+import { getSubFlatEntityByIdsMapsOrThrow } from 'src/engine/metadata-modules/flat-entity/utils/get-sub-flat-entity-by-ids-maps-or-throw.util';
import { type FlatFieldMetadata } from 'src/engine/metadata-modules/flat-field-metadata/types/flat-field-metadata.type';
import { type FlatIndexMetadata } from 'src/engine/metadata-modules/flat-index-metadata/types/flat-index-metadata.type';
import { type FlatObjectMetadata } from 'src/engine/metadata-modules/flat-object-metadata/types/flat-object-metadata.type';
@@ -92,18 +93,26 @@ export class WorkspaceGraphqlSchemaSDLService {
TWENTY_STANDARD_APPLICATION.universalIdentifier
];
- const applicationIds = isDefined(twentyStandardApplicationId)
- ? [twentyStandardApplicationId, applicationId]
- : [applicationId];
+ const {
+ flatObjectMetadataIds,
+ flatFieldMetadataIds,
+ flatIndexMetadataIds,
+ } = computeApplicationSchemaScopeFlatEntityIds({
+ applicationId,
+ twentyStandardApplicationId,
+ flatObjectMetadataMaps: allFlatObjectMetadataMaps,
+ flatFieldMetadataMaps: allFlatFieldMetadataMaps,
+ flatIndexMaps: allFlatIndexMaps,
+ });
- flatObjectMetadataMaps = this.filterFlatEntityMapsByApplicationIds(
- allFlatObjectMetadataMaps,
- applicationIds,
- );
- flatFieldMetadataMaps = this.filterFlatEntityMapsByApplicationIds(
- allFlatFieldMetadataMaps,
- applicationIds,
- );
+ flatObjectMetadataMaps = getSubFlatEntityByIdsMapsOrThrow({
+ flatEntityIds: flatObjectMetadataIds,
+ flatEntityMaps: allFlatObjectMetadataMaps,
+ });
+ flatFieldMetadataMaps = getSubFlatEntityByIdsMapsOrThrow({
+ flatEntityIds: flatFieldMetadataIds,
+ flatEntityMaps: allFlatFieldMetadataMaps,
+ });
flatObjectMetadataMaps =
this.reconcileObjectFieldIdsWithFilteredFieldMaps(
@@ -112,10 +121,10 @@ export class WorkspaceGraphqlSchemaSDLService {
);
if (isDefined(allFlatIndexMaps)) {
- flatIndexMaps = this.filterFlatEntityMapsByApplicationIds(
- allFlatIndexMaps,
- applicationIds,
- );
+ flatIndexMaps = getSubFlatEntityByIdsMapsOrThrow({
+ flatEntityIds: flatIndexMetadataIds,
+ flatEntityMaps: allFlatIndexMaps,
+ });
}
}
@@ -228,16 +237,4 @@ export class WorkspaceGraphqlSchemaSDLService {
byUniversalIdentifier: reconciledByUniversalIdentifier,
};
}
-
- private filterFlatEntityMapsByApplicationIds<
- T extends FlatObjectMetadata | FlatFieldMetadata | FlatIndexMetadata,
- >(
- flatEntityMaps: FlatEntityMaps<T>,
- applicationIds: string[],
- ): FlatEntityMaps<T> {
- return getSubFlatEntityMapsByApplicationIdsOrThrow({
- applicationIds,
- flatEntityMaps,
- });
- }
}
diff --git a/packages/twenty-server/test/integration/metadata/suites/application/successful-sync-application-cross-app-relation-field.integration-spec.ts b/packages/twenty-server/test/integration/metadata/suites/application/successful-sync-application-cross-app-relation-field.integration-spec.ts
new file mode 100644
index 00000000000..f6c1b24739b
--- /dev/null
+++ b/packages/twenty-server/test/integration/metadata/suites/application/successful-sync-application-cross-app-relation-field.integration-spec.ts
@@ -0,0 +1,243 @@
+import { findManyApplications } from 'test/integration/graphql/utils/find-many-applications.util';
+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 {
+ type FieldManifest,
+ type Manifest,
+ type ObjectManifest,
+} from 'twenty-shared/application';
+import {
+ FieldMetadataType,
+ RelationOnDeleteAction,
+ RelationType,
+} from 'twenty-shared/types';
+import { isDefined } from 'twenty-shared/utils';
+import { v4 as uuidv4 } from 'uuid';
+
+const APP_A_ID = uuidv4();
+const APP_A_ROLE_ID = uuidv4();
+const APP_A_OBJECT_ID = uuidv4();
+const APP_A_NAME_FIELD_ID = uuidv4();
+const APP_A_TARGET_RELATION_FIELD_ID = uuidv4();
+const APP_A_SOURCES_RELATION_FIELD_ID = uuidv4();
+
+const APP_B_ID = uuidv4();
+const APP_B_ROLE_ID = uuidv4();
+const APP_B_OBJECT_ID = uuidv4();
+const APP_B_NAME_FIELD_ID = uuidv4();
+
+const APP_A_NAME_FIELD: ObjectManifest['fields'][number] = {
+ universalIdentifier: APP_A_NAME_FIELD_ID,
+ type: FieldMetadataType.TEXT,
+ name: 'name',
+ label: 'Name',
+};
+
+const APP_B_NAME_FIELD: ObjectManifest['fields'][number] = {
+ universalIdentifier: APP_B_NAME_FIELD_ID,
+ type: FieldMetadataType.TEXT,
+ name: 'name',
+ label: 'Name',
+};
+
+const APP_A_TARGET_RELATION_FIELD: ObjectManifest['fields'][number] = {
+ universalIdentifier: APP_A_TARGET_RELATION_FIELD_ID,
+ type: FieldMetadataType.RELATION,
+ name: 'target',
+ label: 'Target',
+ relationTargetFieldMetadataUniversalIdentifier:
+ APP_A_SOURCES_RELATION_FIELD_ID,
+ relationTargetObjectMetadataUniversalIdentifier: APP_B_OBJECT_ID,
+ universalSettings: {
+ relationType: RelationType.MANY_TO_ONE,
+ joinColumnName: 'targetId',
+ onDelete: RelationOnDeleteAction.SET_NULL,
+ },
+};
+
+const APP_A_SOURCES_RELATION_FIELD: FieldManifest = {
+ universalIdentifier: APP_A_SOURCES_RELATION_FIELD_ID,
+ type: FieldMetadataType.RELATION,
+ name: 'crossAppRelationSources',
+ label: 'Cross App Relation Sources',
+ objectUniversalIdentifier: APP_B_OBJECT_ID,
+ relationTargetFieldMetadataUniversalIdentifier:
+ APP_A_TARGET_RELATION_FIELD_ID,
+ relationTargetObjectMetadataUniversalIdentifier: APP_A_OBJECT_ID,
+ universalSettings: {
+ relationType: RelationType.ONE_TO_MANY,
+ },
+};
+
+const buildAppBManifest = (): Manifest =>
+ buildBaseManifest({
+ appId: APP_B_ID,
+ roleId: APP_B_ROLE_ID,
+ overrides: {
+ roles: [
+ {
+ universalIdentifier: APP_B_ROLE_ID,
+ label: 'App B Cross App Relation Role',
+ description: 'Role owned by App B',
+ },
+ ],
+ objects: [
+ buildDefaultObjectManifest({
+ applicationUniversalIdentifier: APP_B_ID,
+ universalIdentifier: APP_B_OBJECT_ID,
+ nameSingular: 'crossAppRelationTarget',
+ namePlural: 'crossAppRelationTargets',
+ labelSingular: 'Cross App Relation Target',
+ labelPlural: 'Cross App Relation Targets',
+ labelIdentifierFieldMetadataUniversalIdentifier: APP_B_NAME_FIELD_ID,
+ additionalFields: [APP_B_NAME_FIELD],
+ }),
+ ],
+ },
+ });
+
+const buildAppAManifest = (): Manifest =>
+ buildBaseManifest({
+ appId: APP_A_ID,
+ roleId: APP_A_ROLE_ID,
+ overrides: {
+ roles: [
+ {
+ universalIdentifier: APP_A_ROLE_ID,
+ label: 'App A Cross App Relation Role',
+ description: 'Role owned by App A',
+ },
+ ],
+ objects: [
+ buildDefaultObjectManifest({
+ applicationUniversalIdentifier: APP_A_ID,
+ universalIdentifier: APP_A_OBJECT_ID,
+ nameSingular: 'crossAppRelationSource',
+ namePlural: 'crossAppRelationSources',
+ labelSingular: 'Cross App Relation Source',
+ labelPlural: 'Cross App Relation Sources',
+ labelIdentifierFieldMetadataUniversalIdentifier: APP_A_NAME_FIELD_ID,
+ additionalFields: [APP_A_NAME_FIELD, APP_A_TARGET_RELATION_FIELD],
+ }),
+ ],
+ fields: [APP_A_SOURCES_RELATION_FIELD],
+ },
+ });
+
+const findApplicationIdByUniversalIdentifier = async (
+ applicationUniversalIdentifier: string,
+) => {
+ const { data } = await findManyApplications({ expectToFail: false });
+
+ return data.findManyApplications.find(
+ (application) =>
+ application.universalIdentifier === applicationUniversalIdentifier,
+ )?.id;
+};
+
+const findObjectsByUniversalIdentifier = async () => {
+ const objects = await findManyObjectMetadataWithIndexes({
+ expectToFail: false,
+ });
+
+ return {
+ appAObject: objects.find(
+ (objectMetadata) =>
+ objectMetadata.universalIdentifier === APP_A_OBJECT_ID,
+ ),
+ appBObject: objects.find(
+ (objectMetadata) =>
+ objectMetadata.universalIdentifier === APP_B_OBJECT_ID,
+ ),
+ };
+};
+
+describe('Sync application should succeed when App A declares a RELATION between its own object and an App B object', () => {
+ beforeAll(async () => {
+ await setupApplicationForSync({
+ applicationUniversalIdentifier: APP_B_ID,
+ name: 'App B',
+ description: 'App owning the relation target object',
+ sourcePath: 'test-cross-app-relation-field-app-b',
+ });
+
+ await setupApplicationForSync({
+ applicationUniversalIdentifier: APP_A_ID,
+ name: 'App A',
+ description: 'App relating its own object to an App B object',
+ sourcePath: 'test-cross-app-relation-field-app-a',
+ });
+
+ await syncApplication({
+ manifest: buildAppBManifest(),
+ expectToFail: false,
+ });
+ }, 60000);
+
+ afterAll(async () => {
+ await cleanupApplicationAndAppRegistration({
+ applicationUniversalIdentifier: APP_A_ID,
+ });
+ await cleanupApplicationAndAppRegistration({
+ applicationUniversalIdentifier: APP_B_ID,
+ });
+ }, 60000);
+
+ it('syncs App A with a relation field on its own object and its inverse on the App B object', async () => {
+ const { errors } = await syncApplication({
+ manifest: buildAppAManifest(),
+ expectToFail: false,
+ });
+
+ expect(isDefined(errors)).toBe(false);
+
+ const appAApplicationId =
+ await findApplicationIdByUniversalIdentifier(APP_A_ID);
+ const { appAObject, appBObject } = await findObjectsByUniversalIdentifier();
+
+ expect(appAApplicationId).toBeDefined();
+ expect(appAObject).toBeDefined();
+ expect(appBObject).toBeDefined();
+
+ const targetField = appAObject?.fieldsList.find(
+ (field) => field.universalIdentifier === APP_A_TARGET_RELATION_FIELD_ID,
+ );
+
+ expect(targetField).toBeDefined();
+ expect(targetField?.applicationId).toBe(appAApplicationId);
+ expect(targetField?.relation?.type).toBe(RelationType.MANY_TO_ONE);
+ expect(targetField?.relation?.targetObjectMetadata.id).toBe(appBObject?.id);
+
+ const sourcesField = appBObject?.fieldsList.find(
+ (field) => field.universalIdentifier === APP_A_SOURCES_RELATION_FIELD_ID,
+ );
+
+ expect(sourcesField).toBeDefined();
+ expect(sourcesField?.applicationId).toBe(appAApplicationId);
+ expect(sourcesField?.relation?.type).toBe(RelationType.ONE_TO_MANY);
+ expect(sourcesField?.relation?.targetObjectMetadata.id).toBe(
+ appAObject?.id,
+ );
+ expect(sourcesField?.relation?.targetFieldMetadata.id).toBe(
+ targetField?.id,
+ );
+ }, 60000);
+
+ it('re-syncs App A with the same manifest without error', async () => {
+ await syncApplication({
+ manifest: buildAppAManifest(),
+ expectToFail: false,
+ });
+
+ const { errors } = await syncApplication({
+ manifest: buildAppAManifest(),
+ expectToFail: false,
+ });
+
+ expect(isDefined(errors)).toBe(false);
+ }, 60000);
+});