Skip to content

The open alternative to Salesforce, designed for AI.

fix(server): resolve morph join column when walking relations to person (#24298)

Thomas Trompette3f6c99d54da6
diff --git a/packages/twenty-server/src/engine/core-modules/related-person-ids/utils/__tests__/find-relation-paths-to-person.util.spec.ts b/packages/twenty-server/src/engine/core-modules/related-person-ids/utils/__tests__/find-relation-paths-to-person.util.spec.ts
index d07eac2cc96..c486c52b9cc 100644
--- a/packages/twenty-server/src/engine/core-modules/related-person-ids/utils/__tests__/find-relation-paths-to-person.util.spec.ts
+++ b/packages/twenty-server/src/engine/core-modules/related-person-ids/utils/__tests__/find-relation-paths-to-person.util.spec.ts
@@ -1,30 +1,62 @@
+import { FieldMetadataType } from 'twenty-shared/types';
+import { isDefined } from 'twenty-shared/utils';
+
import { RelationType } from 'src/engine/metadata-modules/field-metadata/interfaces/relation-type.interface';
import { type FlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/types/flat-entity-maps.type';
import { type FlatFieldMetadata } from 'src/engine/metadata-modules/flat-field-metadata/types/flat-field-metadata.type';
-import { resolveRelationFromFlatFieldMetadata } from 'src/engine/metadata-modules/flat-field-metadata/utils/resolve-relation-from-flat-field-metadata.util';
import { type FlatObjectMetadata } from 'src/engine/metadata-modules/flat-object-metadata/types/flat-object-metadata.type';
import { findRelationPathsToPerson } from 'src/engine/core-modules/related-person-ids/utils/find-relation-paths-to-person.util';
-jest.mock(
- 'src/engine/metadata-modules/flat-field-metadata/utils/resolve-relation-from-flat-field-metadata.util',
-);
-
-const resolveRelationMock = jest.mocked(resolveRelationFromFlatFieldMetadata);
-
type RelationSpec = {
fieldName: string;
relationType: RelationType;
targetObjectNameSingular: string;
inverseFieldName: string;
+ morphId?: string;
};
+const fieldId = (objectNameSingular: string, fieldName: string) =>
+ `${objectNameSingular}.${fieldName}`;
+
+const invertRelationType = (relationType: RelationType) =>
+ relationType === RelationType.MANY_TO_ONE
+ ? RelationType.ONE_TO_MANY
+ : RelationType.MANY_TO_ONE;
+
const buildGraphFixtures = (
graph: Record<string, RelationSpec[]>,
options: { systemObjectNames?: string[] } = {},
) => {
const systemObjectNames = options.systemObjectNames ?? [];
- const fieldId = (objectNameSingular: string, fieldName: string) =>
- `${objectNameSingular}.${fieldName}`;
+ const specsByObjectNameSingular = Object.fromEntries(
+ Object.entries(graph).map(([objectNameSingular, relationSpecs]) => [
+ objectNameSingular,
+ [...relationSpecs],
+ ]),
+ );
+
+ for (const [objectNameSingular, relationSpecs] of Object.entries(graph)) {
+ for (const spec of relationSpecs) {
+ const inverseSpecs =
+ specsByObjectNameSingular[spec.targetObjectNameSingular];
+
+ if (
+ !isDefined(inverseSpecs) ||
+ inverseSpecs.some(
+ (inverseSpec) => inverseSpec.fieldName === spec.inverseFieldName,
+ )
+ ) {
+ continue;
+ }
+
+ inverseSpecs.push({
+ fieldName: spec.inverseFieldName,
+ relationType: invertRelationType(spec.relationType),
+ targetObjectNameSingular: objectNameSingular,
+ inverseFieldName: spec.fieldName,
+ });
+ }
+ }
const flatObjectMetadataMaps = {
byUniversalIdentifier: {},
@@ -36,15 +68,15 @@ const buildGraphFixtures = (
universalIdentifierById: {},
} as unknown as FlatEntityMaps<FlatFieldMetadata>;
- const relationSpecByFieldId = new Map<
- string,
- { sourceObjectNameSingular: string; spec: RelationSpec }
- >();
-
- for (const [objectNameSingular, relationSpecs] of Object.entries(graph)) {
+ for (const [objectNameSingular, relationSpecs] of Object.entries(
+ specsByObjectNameSingular,
+ )) {
flatObjectMetadataMaps.byUniversalIdentifier[objectNameSingular] = {
id: objectNameSingular,
+ universalIdentifier: objectNameSingular,
nameSingular: objectNameSingular,
+ namePlural: `${objectNameSingular}s`,
+ isSystem: systemObjectNames.includes(objectNameSingular),
fieldIds: relationSpecs.map((spec) =>
fieldId(objectNameSingular, spec.fieldName),
),
@@ -57,49 +89,29 @@ const buildGraphFixtures = (
flatFieldMetadataMaps.byUniversalIdentifier[id] = {
id,
- type: 'RELATION',
+ universalIdentifier: id,
+ name: spec.fieldName,
+ objectMetadataId: objectNameSingular,
+ type: isDefined(spec.morphId)
+ ? FieldMetadataType.MORPH_RELATION
+ : FieldMetadataType.RELATION,
+ morphId: spec.morphId ?? null,
+ isActive: true,
+ isSystem: false,
+ relationTargetFieldMetadataId: fieldId(
+ spec.targetObjectNameSingular,
+ spec.inverseFieldName,
+ ),
+ settings: { relationType: spec.relationType },
+ universalSettings: { relationType: spec.relationType },
} as unknown as FlatFieldMetadata;
flatFieldMetadataMaps.universalIdentifierById[id] = id;
-
- relationSpecByFieldId.set(id, {
- sourceObjectNameSingular: objectNameSingular,
- spec,
- });
}
}
- resolveRelationMock.mockImplementation(({ sourceFlatFieldMetadata }) => {
- const resolved = relationSpecByFieldId.get(sourceFlatFieldMetadata.id);
-
- if (resolved === undefined) {
- return null;
- }
-
- const { sourceObjectNameSingular, spec } = resolved;
-
- return {
- type: spec.relationType,
- sourceObjectMetadata: {
- id: sourceObjectNameSingular,
- nameSingular: sourceObjectNameSingular,
- },
- targetObjectMetadata: {
- id: spec.targetObjectNameSingular,
- nameSingular: spec.targetObjectNameSingular,
- isSystem: systemObjectNames.includes(spec.targetObjectNameSingular),
- },
- sourceFieldMetadata: { name: spec.fieldName },
- targetFieldMetadata: { name: spec.inverseFieldName },
- } as ReturnType<typeof resolveRelationFromFlatFieldMetadata>;
- });
-
return { flatObjectMetadataMaps, flatFieldMetadataMaps };
};
-afterEach(() => {
- resolveRelationMock.mockReset();
-});
-
describe('findRelationPathsToPerson', () => {
it('returns the empty path for the person object itself', () => {
const { flatObjectMetadataMaps, flatFieldMetadataMaps } =
@@ -266,6 +278,62 @@ describe('findRelationPathsToPerson', () => {
]);
});
+ it('targets the morph field owning the join column rather than the morph group name', () => {
+ const { flatObjectMetadataMaps, flatFieldMetadataMaps } =
+ buildGraphFixtures({
+ note: [],
+ task: [],
+ person: [
+ {
+ fieldName: 'lastActivityItemNote',
+ relationType: RelationType.MANY_TO_ONE,
+ targetObjectNameSingular: 'note',
+ inverseFieldName: 'peopleWithLastActivityItem',
+ morphId: 'lastActivityItem',
+ },
+ {
+ fieldName: 'lastActivityItemTask',
+ relationType: RelationType.MANY_TO_ONE,
+ targetObjectNameSingular: 'task',
+ inverseFieldName: 'peopleWithLastActivityItem',
+ morphId: 'lastActivityItem',
+ },
+ ],
+ });
+
+ expect(
+ findRelationPathsToPerson({
+ rootObjectNameSingular: 'note',
+ flatObjectMetadataMaps,
+ flatFieldMetadataMaps,
+ }),
+ ).toEqual([
+ [
+ {
+ direction: RelationType.ONE_TO_MANY,
+ queryObjectNameSingular: 'person',
+ joinColumnName: 'lastActivityItemNoteId',
+ },
+ ],
+ ]);
+
+ expect(
+ findRelationPathsToPerson({
+ rootObjectNameSingular: 'task',
+ flatObjectMetadataMaps,
+ flatFieldMetadataMaps,
+ }),
+ ).toEqual([
+ [
+ {
+ direction: RelationType.ONE_TO_MANY,
+ queryObjectNameSingular: 'person',
+ joinColumnName: 'lastActivityItemTaskId',
+ },
+ ],
+ ]);
+ });
+
it('does not traverse system objects while looking for related people', () => {
const { flatObjectMetadataMaps, flatFieldMetadataMaps } =
buildGraphFixtures(
diff --git a/packages/twenty-server/src/engine/core-modules/related-person-ids/utils/find-relation-paths-to-person.util.ts b/packages/twenty-server/src/engine/core-modules/related-person-ids/utils/find-relation-paths-to-person.util.ts
index f948a006187..2656795a16a 100644
--- a/packages/twenty-server/src/engine/core-modules/related-person-ids/utils/find-relation-paths-to-person.util.ts
+++ b/packages/twenty-server/src/engine/core-modules/related-person-ids/utils/find-relation-paths-to-person.util.ts
@@ -5,6 +5,7 @@ import { RelationType } from 'src/engine/metadata-modules/field-metadata/interfa
import { computeMorphOrRelationFieldJoinColumnName } from 'src/engine/metadata-modules/field-metadata/utils/compute-morph-or-relation-field-join-column-name.util';
import { type FlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/types/flat-entity-maps.type';
import { findFlatEntityByIdInFlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/utils/find-flat-entity-by-id-in-flat-entity-maps.util';
+import { findFlatEntityByIdInFlatEntityMapsOrThrow } from 'src/engine/metadata-modules/flat-entity/utils/find-flat-entity-by-id-in-flat-entity-maps-or-throw.util';
import { type FlatFieldMetadata } from 'src/engine/metadata-modules/flat-field-metadata/types/flat-field-metadata.type';
import { isFlatFieldMetadataOfType } from 'src/engine/metadata-modules/flat-field-metadata/utils/is-flat-field-metadata-of-type.util';
import { resolveRelationFromFlatFieldMetadata } from 'src/engine/metadata-modules/flat-field-metadata/utils/resolve-relation-from-flat-field-metadata.util';
@@ -84,24 +85,26 @@ export const findRelationPathsToPerson = ({
continue;
}
- const joinColumnOwner =
+ const joinColumnOwnerFlatFieldMetadata =
relation.type === RelationType.MANY_TO_ONE
- ? {
- object: relation.sourceObjectMetadata,
- field: relation.sourceFieldMetadata,
- }
- : {
- object: relation.targetObjectMetadata,
- field: relation.targetFieldMetadata,
- };
+ ? field
+ : findFlatEntityByIdInFlatEntityMapsOrThrow({
+ flatEntityId: field.relationTargetFieldMetadataId,
+ flatEntityMaps: flatFieldMetadataMaps,
+ });
+
+ const joinColumnOwnerObjectMetadata =
+ relation.type === RelationType.MANY_TO_ONE
+ ? relation.sourceObjectMetadata
+ : relation.targetObjectMetadata;
const nextPath: RelationPathToPerson = [
...path,
{
direction: relation.type,
- queryObjectNameSingular: joinColumnOwner.object.nameSingular,
+ queryObjectNameSingular: joinColumnOwnerObjectMetadata.nameSingular,
joinColumnName: computeMorphOrRelationFieldJoinColumnName({
- name: joinColumnOwner.field.name,
+ name: joinColumnOwnerFlatFieldMetadata.name,
}),
},
];