Skip to content

The open alternative to Salesforce, designed for AI.

Skip relation queries for unset to-one join columns (#24270)

Félix Malfaite73bd7f67c76
diff --git a/packages/twenty-server/src/engine/api/common/common-nested-relations-processor/__tests__/process-nested-relations-v2.helper.spec.ts b/packages/twenty-server/src/engine/api/common/common-nested-relations-processor/__tests__/process-nested-relations-v2.helper.spec.ts
new file mode 100644
index 00000000000..656622b0c23
--- /dev/null
+++ b/packages/twenty-server/src/engine/api/common/common-nested-relations-processor/__tests__/process-nested-relations-v2.helper.spec.ts
@@ -0,0 +1,188 @@
+import {
+ FieldMetadataType,
+ RelationType,
+ type ObjectRecord,
+} from 'twenty-shared/types';
+import { capitalize } from 'twenty-shared/utils';
+
+import { ProcessNestedRelationsV2Helper } from 'src/engine/api/common/common-nested-relations-processor/process-nested-relations-v2.helper';
+import { type WorkspaceAuthContext } from 'src/engine/core-modules/auth/types/workspace-auth-context.type';
+import { type FlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/types/flat-entity-maps.type';
+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 { 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';
+import { type GlobalWorkspaceDataSource } from 'src/engine/twenty-orm/global-workspace-datasource/global-workspace-datasource';
+
+const MORPH_TARGET_NAMES = ['company', 'person', 'note', 'task'] as const;
+
+type MorphTargetName = (typeof MORPH_TARGET_NAMES)[number];
+
+const morphFieldName = (targetName: MorphTargetName) =>
+ `target${capitalize(targetName)}`;
+
+const buildFlatEntityMaps = <
+ TEntity extends FlatObjectMetadata | FlatFieldMetadata,
+>(
+ entities: TEntity[],
+): FlatEntityMaps<TEntity> => ({
+ byUniversalIdentifier: Object.fromEntries(
+ entities.map((entity) => [entity.universalIdentifier, entity]),
+ ),
+ universalIdentifierById: Object.fromEntries(
+ entities.map((entity) => [entity.id, entity.universalIdentifier]),
+ ),
+ universalIdentifiersByApplicationId: {},
+});
+
+const targetObjectByName = Object.fromEntries(
+ MORPH_TARGET_NAMES.map((targetName) => [
+ targetName,
+ getFlatObjectMetadataMock({
+ universalIdentifier: `${targetName}-object-universal-identifier`,
+ id: `${targetName}-object-id`,
+ nameSingular: targetName,
+ namePlural: `${targetName}s`,
+ }),
+ ]),
+) as Record<MorphTargetName, FlatObjectMetadata>;
+
+const timelineActivityObject = getFlatObjectMetadataMock({
+ universalIdentifier: 'timeline-activity-object-universal-identifier',
+ id: 'timeline-activity-object-id',
+ nameSingular: 'timelineActivity',
+ namePlural: 'timelineActivities',
+ fieldIds: MORPH_TARGET_NAMES.map((targetName) => `${targetName}-field-id`),
+});
+
+const morphFields = MORPH_TARGET_NAMES.map((targetName) =>
+ getFlatFieldMetadataMock({
+ universalIdentifier: `${targetName}-field-universal-identifier`,
+ id: `${targetName}-field-id`,
+ objectMetadataId: timelineActivityObject.id,
+ type: FieldMetadataType.MORPH_RELATION,
+ name: morphFieldName(targetName),
+ settings: {
+ relationType: RelationType.MANY_TO_ONE,
+ joinColumnName: `${morphFieldName(targetName)}Id`,
+ },
+ relationTargetObjectMetadataId: targetObjectByName[targetName].id,
+ relationTargetFieldMetadataId: `${targetName}-inverse-field-id`,
+ }),
+);
+
+const flatObjectMetadataMaps = buildFlatEntityMaps<FlatObjectMetadata>([
+ timelineActivityObject,
+ ...Object.values(targetObjectByName),
+]);
+const flatFieldMetadataMaps =
+ buildFlatEntityMaps<FlatFieldMetadata>(morphFields);
+
+const relations = Object.fromEntries(
+ MORPH_TARGET_NAMES.map((targetName) => [morphFieldName(targetName), {}]),
+);
+
+const selectedFields = Object.fromEntries(
+ MORPH_TARGET_NAMES.map((targetName) => [
+ morphFieldName(targetName),
+ { id: true },
+ ]),
+);
+
+// Records which target object each relation query is actually sent against, so a
+// test can assert on the number of round trips and not just on the returned data.
+const buildDataSourceSpy = () => {
+ const queriedObjectNames: string[] = [];
+
+ const workspaceDataSource = {
+ getRepository: (objectNameSingular: string) => ({
+ createQueryBuilder: () => {
+ const queryBuilder = {
+ setFindOptions: () => queryBuilder,
+ withDeleted: () => queryBuilder,
+ getFindOptions: () => ({ select: {} }),
+ where: () => queryBuilder,
+ take: () => queryBuilder,
+ getMany: async () => {
+ queriedObjectNames.push(objectNameSingular);
+
+ return [];
+ },
+ };
+
+ return queryBuilder;
+ },
+ }),
+ } as unknown as GlobalWorkspaceDataSource;
+
+ return { workspaceDataSource, queriedObjectNames };
+};
+
+const processNestedRelations = async (
+ parentObjectRecords: ObjectRecord[],
+): Promise<string[]> => {
+ const { workspaceDataSource, queriedObjectNames } = buildDataSourceSpy();
+
+ await new ProcessNestedRelationsV2Helper().processNestedRelations({
+ flatObjectMetadataMaps,
+ flatFieldMetadataMaps,
+ parentObjectMetadataItem: timelineActivityObject,
+ parentObjectRecords,
+ relations,
+ limit: 60,
+ authContext: {} as WorkspaceAuthContext,
+ workspaceDataSource,
+ selectedFields,
+ });
+
+ return queriedObjectNames.sort();
+};
+
+const buildParentRecord = (
+ id: string,
+ setTargets: Partial<Record<MorphTargetName, string>> = {},
+): ObjectRecord =>
+ ({
+ id,
+ ...Object.fromEntries(
+ MORPH_TARGET_NAMES.map((targetName) => [
+ `${morphFieldName(targetName)}Id`,
+ setTargets[targetName] ?? null,
+ ]),
+ ),
+ }) as unknown as ObjectRecord;
+
+describe('ProcessNestedRelationsV2Helper', () => {
+ it('should not query morph targets whose join column is null on every parent record', async () => {
+ const queriedObjectNames = await processNestedRelations([
+ buildParentRecord('record-1', { company: 'company-1' }),
+ buildParentRecord('record-2', { company: 'company-2' }),
+ ]);
+
+ expect(queriedObjectNames).toEqual(['company']);
+ });
+
+ it('should query every morph target that is set on at least one parent record', async () => {
+ const queriedObjectNames = await processNestedRelations([
+ buildParentRecord('record-1', { company: 'company-1' }),
+ buildParentRecord('record-2', { person: 'person-1' }),
+ ]);
+
+ expect(queriedObjectNames).toEqual(['company', 'person']);
+ });
+
+ it('should assign null to unset to-one relations rather than leaving them undefined', async () => {
+ const parentObjectRecords = [buildParentRecord('record-1')];
+
+ const queriedObjectNames =
+ await processNestedRelations(parentObjectRecords);
+
+ expect(queriedObjectNames).toEqual([]);
+ expect(parentObjectRecords[0]).toMatchObject({
+ targetCompany: null,
+ targetPerson: null,
+ targetNote: null,
+ targetTask: null,
+ });
+ });
+});
diff --git a/packages/twenty-server/src/engine/api/common/common-nested-relations-processor/process-nested-relations-orm-v2.helper.ts b/packages/twenty-server/src/engine/api/common/common-nested-relations-processor/process-nested-relations-orm-v2.helper.ts
index 5ce7bff44ce..f8ced6275a2 100644
--- a/packages/twenty-server/src/engine/api/common/common-nested-relations-processor/process-nested-relations-orm-v2.helper.ts
+++ b/packages/twenty-server/src/engine/api/common/common-nested-relations-processor/process-nested-relations-orm-v2.helper.ts
@@ -11,6 +11,7 @@ import {
type ConcurrencyLimiter,
createConcurrencyLimiter,
} from 'src/engine/api/common/common-nested-relations-processor/utils/create-concurrency-limiter.util';
+import { getUniqueRelationIds } from 'src/engine/api/common/common-nested-relations-processor/utils/get-unique-relation-ids.util';
import { STANDARD_ERROR_MESSAGE } from 'src/engine/api/common/common-query-runners/errors/standard-error-message.constant';
import {
GraphqlQueryRunnerException,
@@ -235,7 +236,7 @@ export class ProcessNestedRelationsOrmV2Helper {
name: sourceFieldName,
});
- const relationIds = this.getUniqueIds({
+ const relationIds = getUniqueRelationIds({
records: parentObjectRecords,
idField:
relationType === RelationType.ONE_TO_MANY ? 'id' : joinColumnName,
@@ -375,17 +376,6 @@ export class ProcessNestedRelationsOrmV2Helper {
return { targetRelationName, targetObjectMetadata, targetRelation };
}
- private getUniqueIds({
- records,
- idField,
- }: {
- records: ObjectRecord[];
- idField: string;
- // oxlint-disable-next-line typescript/no-explicit-any
- }): any[] {
- return [...new Set(records.map((item) => item[idField]))];
- }
-
private async findRelations({
referenceQueryBuilder,
targetObjectRepository,
diff --git a/packages/twenty-server/src/engine/api/common/common-nested-relations-processor/process-nested-relations-v2.helper.ts b/packages/twenty-server/src/engine/api/common/common-nested-relations-processor/process-nested-relations-v2.helper.ts
index adb2cb3aee9..a8ae248cbb9 100644
--- a/packages/twenty-server/src/engine/api/common/common-nested-relations-processor/process-nested-relations-v2.helper.ts
+++ b/packages/twenty-server/src/engine/api/common/common-nested-relations-processor/process-nested-relations-v2.helper.ts
@@ -11,6 +11,7 @@ import {
type ConcurrencyLimiter,
createConcurrencyLimiter,
} from 'src/engine/api/common/common-nested-relations-processor/utils/create-concurrency-limiter.util';
+import { getUniqueRelationIds } from 'src/engine/api/common/common-nested-relations-processor/utils/get-unique-relation-ids.util';
import { STANDARD_ERROR_MESSAGE } from 'src/engine/api/common/common-query-runners/errors/standard-error-message.constant';
import {
GraphqlQueryRunnerException,
@@ -224,7 +225,7 @@ export class ProcessNestedRelationsV2Helper {
name: sourceFieldName,
});
- const relationIds = this.getUniqueIds({
+ const relationIds = getUniqueRelationIds({
records: parentObjectRecords,
idField:
relationType === RelationType.ONE_TO_MANY ? 'id' : joinColumnName,
@@ -363,17 +364,6 @@ export class ProcessNestedRelationsV2Helper {
return { targetRelationName, targetObjectMetadata, targetRelation };
}
- private getUniqueIds({
- records,
- idField,
- }: {
- records: ObjectRecord[];
- idField: string;
- // oxlint-disable-next-line typescript/no-explicit-any
- }): any[] {
- return [...new Set(records.map((item) => item[idField]))];
- }
-
private async findRelations({
referenceQueryBuilder,
targetObjectRepository,
diff --git a/packages/twenty-server/src/engine/api/common/common-nested-relations-processor/utils/__tests__/get-unique-relation-ids.util.spec.ts b/packages/twenty-server/src/engine/api/common/common-nested-relations-processor/utils/__tests__/get-unique-relation-ids.util.spec.ts
new file mode 100644
index 00000000000..3e787b870a4
--- /dev/null
+++ b/packages/twenty-server/src/engine/api/common/common-nested-relations-processor/utils/__tests__/get-unique-relation-ids.util.spec.ts
@@ -0,0 +1,46 @@
+import { type ObjectRecord } from 'twenty-shared/types';
+
+import { getUniqueRelationIds } from 'src/engine/api/common/common-nested-relations-processor/utils/get-unique-relation-ids.util';
+
+const buildRecords = (
+ targetCompanyIds: (string | null | undefined)[],
+): ObjectRecord[] =>
+ targetCompanyIds.map((targetCompanyId, index) => ({
+ id: `record-${index}`,
+ targetCompanyId,
+ })) as unknown as ObjectRecord[];
+
+describe('getUniqueRelationIds', () => {
+ it('should drop nullish join column values', () => {
+ const relationIds = getUniqueRelationIds({
+ records: buildRecords(['company-1', null, undefined, 'company-2']),
+ idField: 'targetCompanyId',
+ });
+
+ expect(relationIds).toEqual(['company-1', 'company-2']);
+ });
+
+ it('should return no id when the join column is unset on every record', () => {
+ const relationIds = getUniqueRelationIds({
+ records: buildRecords([null, null, null]),
+ idField: 'targetCompanyId',
+ });
+
+ expect(relationIds).toEqual([]);
+ });
+
+ it('should deduplicate repeated ids', () => {
+ const relationIds = getUniqueRelationIds({
+ records: buildRecords(['company-1', 'company-1', 'company-2']),
+ idField: 'targetCompanyId',
+ });
+
+ expect(relationIds).toEqual(['company-1', 'company-2']);
+ });
+
+ it('should return no id for an empty record list', () => {
+ expect(
+ getUniqueRelationIds({ records: [], idField: 'targetCompanyId' }),
+ ).toEqual([]);
+ });
+});
diff --git a/packages/twenty-server/src/engine/api/common/common-nested-relations-processor/utils/get-unique-relation-ids.util.ts b/packages/twenty-server/src/engine/api/common/common-nested-relations-processor/utils/get-unique-relation-ids.util.ts
new file mode 100644
index 00000000000..8178438caa9
--- /dev/null
+++ b/packages/twenty-server/src/engine/api/common/common-nested-relations-processor/utils/get-unique-relation-ids.util.ts
@@ -0,0 +1,15 @@
+import { type ObjectRecord } from 'twenty-shared/types';
+import { isDefined } from 'twenty-shared/utils';
+
+type GetUniqueRelationIdsArgs = {
+ records: ObjectRecord[];
+ idField: string;
+};
+
+// Nullish join columns match nothing; keeping them issues a wasted `IN (NULL)` query per unset relation.
+export const getUniqueRelationIds = ({
+ records,
+ idField,
+}: GetUniqueRelationIdsArgs): string[] => [
+ ...new Set(records.map((record) => record[idField]).filter(isDefined)),
+];