Skip to content

The open alternative to Salesforce, designed for AI.

perf: reduce relation assignment and ORM hydration overhead (#27060)

Félix Malfaitbe7ff289682b
diff --git a/packages/twenty-server/src/engine/api/common/common-nested-relations-processor/process-nested-relations.helper.ts b/packages/twenty-server/src/engine/api/common/common-nested-relations-processor/process-nested-relations.helper.ts
index 008ff9b85ef..26b74bb793d 100644
--- a/packages/twenty-server/src/engine/api/common/common-nested-relations-processor/process-nested-relations.helper.ts
+++ b/packages/twenty-server/src/engine/api/common/common-nested-relations-processor/process-nested-relations.helper.ts
@@ -11,6 +11,8 @@ import {
type ConcurrencyLimiter,
createConcurrencyLimiter,
} from 'src/engine/api/common/common-nested-relations-processor/utils/create-concurrency-limiter.util';
+import { assignManyToOneRelationRecords } from 'src/engine/api/common/common-nested-relations-processor/utils/assign-many-to-one-relation-records.util';
+import { assignOneToManyRelationRecords } from 'src/engine/api/common/common-nested-relations-processor/utils/assign-one-to-many-relation-records.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 {
@@ -215,8 +217,8 @@ export class ProcessNestedRelationsHelper {
relationResults: [],
relationAggregatedFieldsResult: {},
sourceFieldName,
- joinField: 'id',
- joinColumnName: computeMorphOrRelationFieldJoinColumnName({
+ relatedRecordJoinColumnName: 'id',
+ parentRecordJoinColumnName: computeMorphOrRelationFieldJoinColumnName({
name: sourceFieldName,
}),
relationType,
@@ -305,11 +307,11 @@ export class ProcessNestedRelationsHelper {
relationResults,
relationAggregatedFieldsResult,
sourceFieldName,
- joinField:
+ relatedRecordJoinColumnName:
relationType === RelationType.ONE_TO_MANY
? `${fieldMetadataTargetRelationColumnName}`
: 'id',
- joinColumnName,
+ parentRecordJoinColumnName: joinColumnName,
relationType,
selectedFields,
});
@@ -543,8 +545,8 @@ export class ProcessNestedRelationsHelper {
relationResults,
relationAggregatedFieldsResult,
sourceFieldName,
- joinField,
- joinColumnName,
+ relatedRecordJoinColumnName,
+ parentRecordJoinColumnName,
relationType,
selectedFields,
}: {
@@ -556,37 +558,27 @@ export class ProcessNestedRelationsHelper {
// oxlint-disable-next-line typescript/no-explicit-any
relationAggregatedFieldsResult: Record<string, any>;
sourceFieldName: string;
- joinField: string;
- joinColumnName: string;
+ relatedRecordJoinColumnName: string;
+ parentRecordJoinColumnName: string;
relationType: RelationType;
selectedFields: Record<string, unknown>;
}): void {
- parentRecords.forEach((item) => {
- if (relationType === RelationType.ONE_TO_MANY) {
- item[sourceFieldName] = relationResults.filter(
- (rel) => rel[joinField] === item.id,
- );
- } else {
- const matchedRelation = relationResults.find(
- (rel) => rel.id === item[joinColumnName],
- );
-
- if (isDefined(matchedRelation?.deletedAt)) {
- item[sourceFieldName] = null;
- item[joinColumnName] = null;
- } else if (isDefined(matchedRelation)) {
- if (selectedFields?.deletedAt !== true) {
- const { deletedAt: _, ...rest } = matchedRelation;
-
- item[sourceFieldName] = rest;
- } else {
- item[sourceFieldName] = matchedRelation;
- }
- } else {
- item[sourceFieldName] = null;
- }
- }
- });
+ if (relationType === RelationType.ONE_TO_MANY) {
+ assignOneToManyRelationRecords({
+ parentRecords,
+ relationRecords: relationResults,
+ sourceFieldName,
+ relatedRecordJoinColumnName,
+ });
+ } else {
+ assignManyToOneRelationRecords({
+ parentRecords,
+ relationRecords: relationResults,
+ sourceFieldName,
+ parentRecordJoinColumnName,
+ selectedFields,
+ });
+ }
parentObjectRecordsAggregatedValues[sourceFieldName] =
relationAggregatedFieldsResult;
diff --git a/packages/twenty-server/src/engine/api/common/common-nested-relations-processor/utils/__tests__/assign-relation-records.util.spec.ts b/packages/twenty-server/src/engine/api/common/common-nested-relations-processor/utils/__tests__/assign-relation-records.util.spec.ts
new file mode 100644
index 00000000000..edba9b7b702
--- /dev/null
+++ b/packages/twenty-server/src/engine/api/common/common-nested-relations-processor/utils/__tests__/assign-relation-records.util.spec.ts
@@ -0,0 +1,134 @@
+import { type ObjectRecord } from 'twenty-shared/types';
+
+import { assignManyToOneRelationRecords } from 'src/engine/api/common/common-nested-relations-processor/utils/assign-many-to-one-relation-records.util';
+import { assignOneToManyRelationRecords } from 'src/engine/api/common/common-nested-relations-processor/utils/assign-one-to-many-relation-records.util';
+
+const assignActivities = (
+ parentRecords: ObjectRecord[],
+ relationRecords: ObjectRecord[],
+) =>
+ assignOneToManyRelationRecords({
+ parentRecords,
+ relationRecords,
+ sourceFieldName: 'activities',
+ relatedRecordJoinColumnName: 'opportunityId',
+ });
+
+const assignCompanies = (
+ parentRecords: ObjectRecord[],
+ relationRecords: ObjectRecord[],
+ selectedFields: Record<string, unknown> = {},
+) =>
+ assignManyToOneRelationRecords({
+ parentRecords,
+ relationRecords,
+ sourceFieldName: 'company',
+ parentRecordJoinColumnName: 'companyId',
+ selectedFields,
+ });
+
+describe('relation record assignment', () => {
+ it('attaches only matching children in their original order', () => {
+ const parents = [{ id: 'first' }, { id: 'second' }, { id: 'empty' }];
+ const children = [
+ { id: 'activity-1', opportunityId: 'second' },
+ { id: 'activity-2', opportunityId: 'first' },
+ { id: 'activity-3', opportunityId: 'other' },
+ { id: 'activity-4', opportunityId: 'second' },
+ { id: 'activity-5', opportunityId: null },
+ ];
+
+ assignActivities(parents, children);
+
+ expect(parents).toEqual([
+ { id: 'first', activities: [children[1]] },
+ { id: 'second', activities: [children[0], children[3]] },
+ { id: 'empty', activities: [] },
+ ]);
+ });
+
+ it('gives each parent its own collection, including repeated parent IDs', () => {
+ const parents: ObjectRecord[] = [
+ { id: 'first' },
+ { id: 'first' },
+ { id: 'empty-1' },
+ { id: 'empty-2' },
+ ];
+ const child = { id: 'activity', opportunityId: 'first' };
+
+ assignActivities(parents, [child]);
+ parents[0].activities.push({ id: 'new' });
+ parents[2].activities.push({ id: 'another' });
+
+ expect(parents[1].activities).toEqual([child]);
+ expect(parents[3].activities).toEqual([]);
+ });
+
+ it('returns empty collections when no related records are available', () => {
+ const parents = [{ id: 'first' }, { id: 'second' }];
+
+ assignActivities(parents, []);
+
+ expect(parents).toEqual([
+ { id: 'first', activities: [] },
+ { id: 'second', activities: [] },
+ ]);
+ });
+
+ it('matches shared to-one records and retains the first duplicate result', () => {
+ const parents = [
+ { id: 'first', companyId: 'company' },
+ { id: 'second', companyId: 'company' },
+ ];
+ const company = { id: 'company', name: 'Original', deletedAt: null };
+
+ assignCompanies(parents, [company, { id: 'company', name: 'Duplicate' }]);
+
+ expect(parents).toEqual([
+ {
+ id: 'first',
+ companyId: 'company',
+ company: { id: 'company', name: 'Original' },
+ },
+ {
+ id: 'second',
+ companyId: 'company',
+ company: { id: 'company', name: 'Original' },
+ },
+ ]);
+ expect(company.deletedAt).toBeNull();
+ });
+
+ it('keeps an explicitly selected deletedAt field on an active relation', () => {
+ const parents = [{ id: 'first', companyId: 'company' }];
+ const company = { id: 'company', deletedAt: null };
+
+ assignCompanies(parents, [company], { deletedAt: true });
+
+ expect(parents).toEqual([{ id: 'first', companyId: 'company', company }]);
+ });
+
+ it('clears both the relation and foreign key for a deleted related record', () => {
+ const parents = [{ id: 'first', companyId: 'company' }];
+
+ assignCompanies(parents, [{ id: 'company', deletedAt: '2026-01-01' }]);
+
+ expect(parents).toEqual([{ id: 'first', companyId: null, company: null }]);
+ });
+
+ it('keeps missing foreign keys intact while returning null relations', () => {
+ const parents = [
+ { id: 'first', companyId: 'missing' },
+ { id: 'second', companyId: null },
+ { id: 'third' },
+ ];
+
+ assignCompanies(parents, [{ id: 'other' }]);
+
+ expect(parents).toEqual([
+ { id: 'first', companyId: 'missing', company: null },
+ { id: 'second', companyId: null, company: null },
+ { id: 'third', company: null },
+ ]);
+ });
+});
diff --git a/packages/twenty-server/src/engine/api/common/common-nested-relations-processor/utils/assign-many-to-one-relation-records.util.ts b/packages/twenty-server/src/engine/api/common/common-nested-relations-processor/utils/assign-many-to-one-relation-records.util.ts
new file mode 100644
index 00000000000..e1b347cb71a
--- /dev/null
+++ b/packages/twenty-server/src/engine/api/common/common-nested-relations-processor/utils/assign-many-to-one-relation-records.util.ts
@@ -0,0 +1,55 @@
+import { type ObjectRecord } from 'twenty-shared/types';
+import { isDefined } from 'twenty-shared/utils';
+
+export const assignManyToOneRelationRecords = ({
+ parentRecords,
+ relationRecords,
+ sourceFieldName,
+ parentRecordJoinColumnName,
+ selectedFields,
+}: {
+ parentRecords: ObjectRecord[];
+ relationRecords: ObjectRecord[];
+ sourceFieldName: string;
+ parentRecordJoinColumnName: string;
+ selectedFields: Record<string, unknown>;
+}): void => {
+ const relationRecordById = new Map<unknown, ObjectRecord>();
+
+ for (const relationRecord of relationRecords) {
+ if (relationRecordById.has(relationRecord.id)) {
+ continue;
+ }
+
+ relationRecordById.set(relationRecord.id, relationRecord);
+ }
+
+ for (const parentRecord of parentRecords) {
+ const matchedRelation = relationRecordById.get(
+ parentRecord[parentRecordJoinColumnName],
+ );
+
+ if (!isDefined(matchedRelation)) {
+ parentRecord[sourceFieldName] = null;
+
+ continue;
+ }
+
+ if (isDefined(matchedRelation.deletedAt)) {
+ parentRecord[sourceFieldName] = null;
+ parentRecord[parentRecordJoinColumnName] = null;
+
+ continue;
+ }
+
+ if (selectedFields?.deletedAt === true) {
+ parentRecord[sourceFieldName] = matchedRelation;
+
+ continue;
+ }
+
+ const { deletedAt: _, ...relationWithoutDeletedAt } = matchedRelation;
+
+ parentRecord[sourceFieldName] = relationWithoutDeletedAt;
+ }
+};
diff --git a/packages/twenty-server/src/engine/api/common/common-nested-relations-processor/utils/assign-one-to-many-relation-records.util.ts b/packages/twenty-server/src/engine/api/common/common-nested-relations-processor/utils/assign-one-to-many-relation-records.util.ts
new file mode 100644
index 00000000000..711fb707dd8
--- /dev/null
+++ b/packages/twenty-server/src/engine/api/common/common-nested-relations-processor/utils/assign-one-to-many-relation-records.util.ts
@@ -0,0 +1,29 @@
+import { type ObjectRecord } from 'twenty-shared/types';
+
+export const assignOneToManyRelationRecords = ({
+ parentRecords,
+ relationRecords,
+ sourceFieldName,
+ relatedRecordJoinColumnName,
+}: {
+ parentRecords: ObjectRecord[];
+ relationRecords: ObjectRecord[];
+ sourceFieldName: string;
+ relatedRecordJoinColumnName: string;
+}): void => {
+ const relationRecordsByParentId = new Map<unknown, ObjectRecord[]>();
+
+ for (const relationRecord of relationRecords) {
+ const parentId = relationRecord[relatedRecordJoinColumnName];
+ const records = relationRecordsByParentId.get(parentId) ?? [];
+
+ records.push(relationRecord);
+ relationRecordsByParentId.set(parentId, records);
+ }
+
+ for (const parentRecord of parentRecords) {
+ parentRecord[sourceFieldName] = [
+ ...(relationRecordsByParentId.get(parentRecord.id) ?? []),
+ ];
+ }
+};
diff --git a/packages/twenty-server/src/engine/twenty-orm/query-builder/workspace-mutation-query-builder.ts b/packages/twenty-server/src/engine/twenty-orm/query-builder/workspace-mutation-query-builder.ts
index dfb41c1b86e..d9da1da30f8 100644
--- a/packages/twenty-server/src/engine/twenty-orm/query-builder/workspace-mutation-query-builder.ts
+++ b/packages/twenty-server/src/engine/twenty-orm/query-builder/workspace-mutation-query-builder.ts
@@ -7,7 +7,7 @@ import {
import { type QueryExecutor } from 'src/engine/twenty-orm/executor/types/query-executor.type';
import {
buildColumnNameByResultAlias,
- mapRowToEntity,
+ createRowToEntityMapper,
type WhereClause,
} from 'src/engine/twenty-orm/sql/utils/build-select-statement.util';
import { compileNamedParameters } from 'src/engine/twenty-orm/sql/utils/compile-named-parameters.util';
@@ -103,9 +103,8 @@ export class WorkspaceMutationQueryBuilder {
this.alias,
this.returningColumns,
);
- const entities = rows.map((row) =>
- mapRowToEntity(row, columnNameByResultAlias),
- );
+ const mapRowToEntity = createRowToEntityMapper(columnNameByResultAlias);
+ const entities = rows.map(mapRowToEntity);
return {
generatedMaps: this.context.formatResult(entities),
diff --git a/packages/twenty-server/src/engine/twenty-orm/query-builder/workspace-select-query-builder.ts b/packages/twenty-server/src/engine/twenty-orm/query-builder/workspace-select-query-builder.ts
index 622a551102b..596f4ae4ac9 100644
--- a/packages/twenty-server/src/engine/twenty-orm/query-builder/workspace-select-query-builder.ts
+++ b/packages/twenty-server/src/engine/twenty-orm/query-builder/workspace-select-query-builder.ts
@@ -34,7 +34,7 @@ import {
buildSelectStatement,
buildWhereExpression,
collectStatementAliases,
- mapRowToEntity,
+ createRowToEntityMapper,
normaliseColumnExpression,
quoteColumn,
quoteQualifiedAliasReferences,
@@ -562,7 +562,9 @@ export class WorkspaceSelectQueryBuilder implements WhereExpressionLike {
): T[] {
const columnNameByResultAlias = this.buildColumnNameByResultAlias();
- return rows.map((row) => mapRowToEntity<T>(row, columnNameByResultAlias));
+ const mapRowToEntity = createRowToEntityMapper<T>(columnNameByResultAlias);
+
+ return rows.map(mapRowToEntity);
}
async getMany<T extends ObjectLiteral>(options?: {
diff --git a/packages/twenty-server/src/engine/twenty-orm/sql/utils/__tests__/create-row-to-entity-mapper.util.spec.ts b/packages/twenty-server/src/engine/twenty-orm/sql/utils/__tests__/create-row-to-entity-mapper.util.spec.ts
new file mode 100644
index 00000000000..a0c16834b9c
--- /dev/null
+++ b/packages/twenty-server/src/engine/twenty-orm/sql/utils/__tests__/create-row-to-entity-mapper.util.spec.ts
@@ -0,0 +1,83 @@
+import { createRowToEntityMapper } from 'src/engine/twenty-orm/sql/utils/build-select-statement.util';
+
+describe('createRowToEntityMapper', () => {
+ it('maps selected flat columns and preserves null and undefined values', () => {
+ const mapRow = createRowToEntityMapper({
+ person_id: 'id',
+ person_name: 'name',
+ person_deletedAt: 'deletedAt',
+ person_missing: 'missing',
+ });
+
+ expect(
+ mapRow({
+ person_id: 'first',
+ person_name: undefined,
+ person_deletedAt: null,
+ extra: 'ignored',
+ }),
+ ).toStrictEqual({
+ id: 'first',
+ name: undefined,
+ deletedAt: null,
+ });
+ expect(mapRow({ person_id: 'second', person_name: 'Name' })).toStrictEqual({
+ id: 'second',
+ name: 'Name',
+ });
+ });
+
+ it('reuses the mapping without sharing nested values across rows', () => {
+ const mapRow = createRowToEntityMapper({
+ person_id: 'id',
+ company_id: 'company.id',
+ company_name: 'company.name',
+ owner_id: 'company.owner.id',
+ owner_name: 'company.owner.name',
+ });
+ const first = mapRow({
+ person_id: 'first',
+ company_id: 'company-1',
+ company_name: 'First',
+ owner_id: 'owner-1',
+ owner_name: 'Alice',
+ });
+ const second = mapRow({
+ person_id: 'second',
+ company_id: 'company-2',
+ company_name: 'Second',
+ owner_id: null,
+ owner_name: null,
+ });
+ const unmatched = mapRow({
+ person_id: 'third',
+ company_id: null,
+ company_name: null,
+ owner_id: null,
+ owner_name: null,
+ });
+
+ expect(first).toStrictEqual({
+ id: 'first',
+ company: {
+ id: 'company-1',
+ name: 'First',
+ owner: { id: 'owner-1', name: 'Alice' },
+ },
+ });
+ expect(second).toStrictEqual({
+ id: 'second',
+ company: { id: 'company-2', name: 'Second', owner: null },
+ });
+ expect(unmatched).toStrictEqual({ id: 'third', company: null });
+ });
+
+ it('keeps a partial joined object without an ID, even when its value is null', () => {
+ const mapRow = createRowToEntityMapper({ company_name: 'company.name' });
+
+ expect(mapRow({ company_name: null })).toStrictEqual({
+ company: { name: null },
+ });
+ expect(mapRow({})).toStrictEqual({});
+ });
+});
diff --git a/packages/twenty-server/src/engine/twenty-orm/sql/utils/build-select-statement.util.ts b/packages/twenty-server/src/engine/twenty-orm/sql/utils/build-select-statement.util.ts
index 864a0edb172..24a515bd0a6 100644
--- a/packages/twenty-server/src/engine/twenty-orm/sql/utils/build-select-statement.util.ts
+++ b/packages/twenty-server/src/engine/twenty-orm/sql/utils/build-select-statement.util.ts
@@ -610,42 +610,46 @@ const buildRelationValue = (leaves: RelationColumnLeaf[]): unknown => {
return relationValue;
};
-export const mapRowToEntity = <T extends ObjectLiteral>(
- row: Record<string, unknown>,
+export const createRowToEntityMapper = <TRecord extends ObjectLiteral>(
columnNameByResultAlias: Record<string, string>,
-): T => {
- const entity: Record<string, unknown> = {};
- const relationLeavesByProperty = new Map<string, RelationColumnLeaf[]>();
-
- for (const [resultAlias, propertyPath] of Object.entries(
- columnNameByResultAlias,
- )) {
- if (!(resultAlias in row)) {
- continue;
- }
+): ((row: Record<string, unknown>) => TRecord) => {
+ const columns = Object.entries(columnNameByResultAlias).map(
+ ([resultAlias, propertyPath]) => {
+ const [propertyName, ...remainingSegments] = propertyPath.split('.');
- const propertySegments = propertyPath.split('.');
+ return { resultAlias, propertyName, remainingSegments };
+ },
+ );
- if (propertySegments.length === 1) {
- entity[propertyPath] = row[resultAlias];
- continue;
- }
+ return (row) => {
+ const entity: Record<string, unknown> = {};
+ const relationLeavesByProperty = new Map<string, RelationColumnLeaf[]>();
- const [relationProperty, ...remainingSegments] = propertySegments;
- const relationLeaves = relationLeavesByProperty.get(relationProperty) ?? [];
+ for (const { resultAlias, propertyName, remainingSegments } of columns) {
+ if (!(resultAlias in row)) {
+ continue;
+ }
- relationLeaves.push({
- propertySegments: remainingSegments,
- value: row[resultAlias],
- });
- relationLeavesByProperty.set(relationProperty, relationLeaves);
- }
+ if (remainingSegments.length === 0) {
+ entity[propertyName] = row[resultAlias];
+ continue;
+ }
- for (const [relationProperty, relationLeaves] of relationLeavesByProperty) {
- entity[relationProperty] = buildRelationValue(relationLeaves);
- }
+ const relationLeaves = relationLeavesByProperty.get(propertyName) ?? [];
+
+ relationLeaves.push({
+ propertySegments: remainingSegments,
+ value: row[resultAlias],
+ });
+ relationLeavesByProperty.set(propertyName, relationLeaves);
+ }
+
+ for (const [relationProperty, relationLeaves] of relationLeavesByProperty) {
+ entity[relationProperty] = buildRelationValue(relationLeaves);
+ }
- return entity as T;
+ return entity as TRecord;
+ };
};
export const buildColumnNameByResultAlias = (