The open alternative to Salesforce, designed for AI.
TypeScript crmcrm-systemcustomergood-first-issuegraphqlhacktoberfestjavascriptmarketingmonoreponestjsopen-sourcepostgresqlreactreactjssalestypescriptweb
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.tsindex 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-anyrelationAggregatedFieldsResult: 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsindex 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.tsindex 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.tsnew file mode 100644index 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.tsindex 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 = (