The open alternative to Salesforce, designed for AI.
TypeScript crmcrm-systemcustomergood-first-issuegraphqlhacktoberfestjavascriptmarketingmonoreponestjsopen-sourcepostgresqlreactreactjssalestypescriptweb
feat(server): route create, upsert and merge through the ORM v2 write path (#24145)
Charles Bochetbbf584a5f238
diff --git a/.github/workflows/ci-server.yaml b/.github/workflows/ci-server.yamlindex d3021d2d234..626f87b1ecc 100644--- a/.github/workflows/ci-server.yaml+++ b/.github/workflows/ci-server.yaml@@ -277,6 +277,10 @@ jobs:orm-v2: true- shard: 3orm-v2: true+ - shard: 4+ orm-v2: true+ - shard: 5+ orm-v2: trueservices:postgres:image: postgres:18@@ -316,10 +320,10 @@ jobs:# The flagged run keeps every suite in one process (jest maxWorkers is 1)# and its heap grows across suites, so it shards on suite count, not on# the 16-way split the unflagged shards use.- ORM_V2_SHARD_COUNTER: 3+ ORM_V2_SHARD_COUNTER: 5AUTH_COOKIE_SESSIONS_ENABLED: ${{ contains(github.event.pull_request.labels.*.name, 'ci:auth-cookie-sessions') }}TEST_FORCED_FEATURE_FLAGS: ${{ matrix.orm-v2 && 'IS_ORM_V2_READ_PATH_ENABLED' || '' }}- ORM_V2_TEST_PATH_PATTERN: '(find-many|find-one|find-duplicates|group-by|composite-field-pagination|filter-by-relation-field|order-by-relation-field|nested-relation|soft-deleted-relation|relation-join-rls|object-records-permissions|merge-many|mutate-by-relation-field|mutation-relation-filter-rls)'+ ORM_V2_TEST_PATH_PATTERN: '(find-many|find-one|find-duplicates|group-by|composite-field-pagination|filter-by-relation-field|order-by-relation-field|nested-relation|soft-deleted-relation|relation-join-rls|object-records-permissions|merge-many|mutate-by-relation-field|mutation-relation-filter-rls|upsert|unique-field|object-generated|files-field)'steps:- name: Fetch custom Github Actions and base branch historyuses: actions/checkout@34e114876b0b11c390a56381ad16ebd13914f8d5 # v4.3.1diff --git a/packages/twenty-server/src/engine/api/common/common-query-runners/common-base-query-runner.service.ts b/packages/twenty-server/src/engine/api/common/common-query-runners/common-base-query-runner.service.tsindex 71333f28591..18c6d6c393e 100644--- a/packages/twenty-server/src/engine/api/common/common-query-runners/common-base-query-runner.service.ts+++ b/packages/twenty-server/src/engine/api/common/common-query-runners/common-base-query-runner.service.ts@@ -1,7 +1,12 @@import { Inject, Injectable } from '@nestjs/common';import { type PermissionFlagType } from 'twenty-shared/constants';-import { FeatureFlagKey, type ObjectRecord } from 'twenty-shared/types';+import {+ FeatureFlagKey,+ FieldMetadataType,+ type ObjectRecord,+} from 'twenty-shared/types';+import { isDefined } from 'twenty-shared/utils';import { type ObjectLiteral } from 'typeorm';import { type ObjectRecordFilter } from 'src/engine/api/graphql/workspace-query-builder/interfaces/object-record.interface';@@ -22,7 +27,6 @@ import {import { STANDARD_ERROR_MESSAGE } from 'src/engine/api/common/common-query-runners/errors/standard-error-message.constant';import { buildMutationQueryBuilder } from 'src/engine/api/common/common-query-runners/utils/build-mutation-query-builder.util';import { buildMutationQueryBuilderV2 } from 'src/engine/api/common/common-query-runners/utils/build-mutation-query-builder-v2.util';-import { updateDataIsSupportedByOrmV2 } from 'src/engine/api/common/common-query-runners/utils/update-data-is-supported-by-orm-v2.util';import { CommonResultGettersService } from 'src/engine/api/common/common-result-getters/common-result-getters.service';import { CommonBaseQueryRunnerContext } from 'src/engine/api/common/types/common-base-query-runner-context.type';import { CommonExtendedQueryRunnerContext } from 'src/engine/api/common/types/common-extended-query-runner-context.type';@@ -53,7 +57,9 @@ import { ThrottlerException } from 'src/engine/core-modules/throttler/throttler.import { ThrottlerService } from 'src/engine/core-modules/throttler/throttler.service';import { TwentyConfigService } from 'src/engine/core-modules/twenty-config/twenty-config.service';import { 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 { FlatFieldMetadata } from 'src/engine/metadata-modules/flat-field-metadata/types/flat-field-metadata.type';+import { buildFieldMapsFromFlatObjectMetadata } from 'src/engine/metadata-modules/flat-field-metadata/utils/build-field-maps-from-flat-object-metadata.util';import { FlatObjectMetadata } from 'src/engine/metadata-modules/flat-object-metadata/types/flat-object-metadata.type';import {PermissionsException,@@ -61,6 +67,7 @@ import {PermissionsExceptionMessage,} from 'src/engine/metadata-modules/permissions/permissions.exception';import { PermissionsService } from 'src/engine/metadata-modules/permissions/permissions.service';+import { RelationNestedQueries } from 'src/engine/twenty-orm/field-operations/relation-nested-queries/relation-nested-queries';import { GlobalWorkspaceOrmManager } from 'src/engine/twenty-orm/global-workspace-datasource/global-workspace-orm.manager';import { type WorkspaceRepository } from 'src/engine/twenty-orm/repository/workspace.repository';import { getWorkspaceContext } from 'src/engine/twenty-orm/storage/orm-workspace-context.storage';@@ -432,24 +439,28 @@ export abstract class CommonBaseQueryRunnerService<const {repository,flatObjectMetadata,- flatFieldMetadataMaps,commonQueryParser,featureFlagsMap,} = queryRunnerContext;const alias = flatObjectMetadata.nameSingular;const ormV2CanHandle =- featureFlagsMap[FeatureFlagKey.IS_ORM_V2_READ_PATH_ENABLED] &&- (kind !== 'update' ||- updateDataIsSupportedByOrmV2({- data: data ?? {},- flatObjectMetadata,- flatFieldMetadataMaps,- }));+ featureFlagsMap[FeatureFlagKey.IS_ORM_V2_READ_PATH_ENABLED];if (ormV2CanHandle) {const writeRepository = this.getWriteRepository(queryRunnerContext);+ const resolvedData =+ kind === 'update' && isDefined(data)+ ? (+ await this.resolveNestedRelationsForOrmV2({+ records: [data],+ queryRunnerContext,+ writeRepository,+ })+ )[0]+ : data;+const { selectQueryBuilder, rowLevelPermissionsApplied } =buildMutationQueryBuilderV2({repository: writeRepository,@@ -463,7 +474,7 @@ export abstract class CommonBaseQueryRunnerService<rowLevelPermissionsApplied,kind,columnsToReturn,- data,+ data: resolvedData,});}@@ -498,6 +509,66 @@ export abstract class CommonBaseQueryRunnerService<return result.generatedMaps as ObjectRecord[];}+ protected async resolveNestedRelationsForOrmV2({+ records,+ queryRunnerContext,+ writeRepository,+ }: {+ records: Partial<ObjectRecord>[];+ queryRunnerContext: CommonExtendedQueryRunnerContext;+ writeRepository: WorkspaceRepositoryV2;+ }): Promise<Partial<ObjectRecord>[]> {+ const { repository, flatObjectMetadata, flatFieldMetadataMaps } =+ queryRunnerContext;+ const nameSingular = flatObjectMetadata.nameSingular;++ const relationNestedQueries = new RelationNestedQueries(+ writeRepository.getInternalContext(),+ );++ const relationNestedConfig =+ relationNestedQueries.prepareNestedRelationQueries(records, nameSingular);++ if (!isDefined(relationNestedConfig)) {+ return records;+ }++ const resolvedRecords =+ await relationNestedQueries.processRelationNestedQueries({+ entities: records,+ relationNestedConfig,+ queryBuilder: repository.createQueryBuilder(nameSingular),+ });++ const { fieldIdByName } = buildFieldMapsFromFlatObjectMetadata(+ flatFieldMetadataMaps,+ flatObjectMetadata,+ );++ return resolvedRecords.map((record) => {+ const columnKeyedRecord: Partial<ObjectRecord> = {};++ for (const [fieldName, value] of Object.entries(record)) {+ const fieldMetadata = findFlatEntityByIdInFlatEntityMaps({+ flatEntityId: fieldIdByName[fieldName],+ flatEntityMaps: flatFieldMetadataMaps,+ });++ if (+ isDefined(fieldMetadata) &&+ (fieldMetadata.type === FieldMetadataType.RELATION ||+ fieldMetadata.type === FieldMetadataType.MORPH_RELATION)+ ) {+ continue;+ }++ columnKeyedRecord[fieldName] = value;+ }++ return columnKeyedRecord;+ });+ }+protected getNestedRelationsReadPathOptions({featureFlagsMap,}: Pick<diff --git a/packages/twenty-server/src/engine/api/common/common-query-runners/common-create-many-query-runner/common-create-many-query-runner.service.ts b/packages/twenty-server/src/engine/api/common/common-query-runners/common-create-many-query-runner/common-create-many-query-runner.service.tsindex 9eac478deda..365264c39cd 100644--- a/packages/twenty-server/src/engine/api/common/common-query-runners/common-create-many-query-runner/common-create-many-query-runner.service.ts+++ b/packages/twenty-server/src/engine/api/common/common-query-runners/common-create-many-query-runner/common-create-many-query-runner.service.ts@@ -2,7 +2,7 @@ import { Injectable } from '@nestjs/common';import { msg } from '@lingui/core/macro';import { QUERY_MAX_RECORDS } from 'twenty-shared/constants';-import { ObjectRecord } from 'twenty-shared/types';+import { FeatureFlagKey, ObjectRecord } from 'twenty-shared/types';import { isDefined } from 'twenty-shared/utils';import { FindOptionsRelations, In, InsertResult, ObjectLiteral } from 'typeorm';@@ -96,6 +96,7 @@ export class CommonCreateManyQueryRunnerService extends CommonBaseQueryRunnerSerflatIndexMaps,args,workspaceId: authContext.workspace.id,+ queryRunnerContext,});const upsertedRecords = await this.fetchUpsertedRecords({@@ -213,6 +214,7 @@ export class CommonCreateManyQueryRunnerService extends CommonBaseQueryRunnerSerflatIndexMaps,args,workspaceId,+ queryRunnerContext,}: {repository: WorkspaceRepository<ObjectLiteral>;flatObjectMetadata: FlatObjectMetadata;@@ -221,6 +223,7 @@ export class CommonCreateManyQueryRunnerService extends CommonBaseQueryRunnerSerflatIndexMaps: FlatEntityMaps<FlatIndexMetadata>;args: CommonExtendedInput<CreateManyQueryArgs>;workspaceId: string;+ queryRunnerContext: CommonExtendedQueryRunnerContext;}): Promise<InsertResult> {const { selectedFieldsResult } = args;@@ -233,6 +236,24 @@ export class CommonCreateManyQueryRunnerService extends CommonBaseQueryRunnerSerflatFieldMetadataMaps,});+ const ormV2CanHandle =+ queryRunnerContext.featureFlagsMap[+ FeatureFlagKey.IS_ORM_V2_READ_PATH_ENABLED+ ];++ if (ormV2CanHandle) {+ const writeRepository = this.getWriteRepository(queryRunnerContext);++ return writeRepository.runInsert({+ records: await this.resolveNestedRelationsForOrmV2({+ records: args.data,+ queryRunnerContext,+ writeRepository,+ }),+ columnsToReturn: selectedColumns,+ });+ }+return await repository.insert(args.data, undefined, selectedColumns);}@@ -245,6 +266,7 @@ export class CommonCreateManyQueryRunnerService extends CommonBaseQueryRunnerSerargs,selectedFieldsResult,workspaceId,+ queryRunnerContext,});}@@ -257,6 +279,7 @@ export class CommonCreateManyQueryRunnerService extends CommonBaseQueryRunnerSerargs,selectedFieldsResult,workspaceId,+ queryRunnerContext,}: {repository: WorkspaceRepository<ObjectLiteral>;flatObjectMetadata: FlatObjectMetadata;@@ -266,6 +289,7 @@ export class CommonCreateManyQueryRunnerService extends CommonBaseQueryRunnerSerargs: CreateManyQueryArgs;selectedFieldsResult: CommonSelectedFieldsResult;workspaceId: string;+ queryRunnerContext: CommonExtendedQueryRunnerContext;}): Promise<InsertResult> {const conflictingFieldGroups = getConflictingFields(flatObjectMetadata,@@ -315,6 +339,7 @@ export class CommonCreateManyQueryRunnerService extends CommonBaseQueryRunnerSerflatFieldMetadataMaps,result,columnsToReturn,+ queryRunnerContext,});}@@ -323,6 +348,7 @@ export class CommonCreateManyQueryRunnerService extends CommonBaseQueryRunnerSerrepository,result,columnsToReturn,+ queryRunnerContext,});return result;@@ -417,6 +443,7 @@ export class CommonCreateManyQueryRunnerService extends CommonBaseQueryRunnerSerflatFieldMetadataMaps,result,columnsToReturn,+ queryRunnerContext,}: {partialRecordsToUpdate: PartialObjectRecordWithId[];repository: WorkspaceRepository<ObjectLiteral>;@@ -424,24 +451,53 @@ export class CommonCreateManyQueryRunnerService extends CommonBaseQueryRunnerSerflatFieldMetadataMaps: FlatEntityMaps<FlatFieldMetadata>;result: InsertResult;columnsToReturn: string[];+ queryRunnerContext: CommonExtendedQueryRunnerContext;}): Promise<void> {- const partialRecordsToUpdateWithoutCreatedByUpdate =- partialRecordsToUpdate.map((record) =>+ const updateInputs = partialRecordsToUpdate+ .map((record) =>this.getRecordWithoutCreatedBy(record,flatObjectMetadata,flatFieldMetadataMaps,),- );+ )+ .map((record) => ({+ id: record.id,+ data: { ...record, deletedAt: null },+ }));++ const ormV2CanHandle =+ queryRunnerContext.featureFlagsMap[+ FeatureFlagKey.IS_ORM_V2_READ_PATH_ENABLED+ ];++ let savedRecords;++ if (ormV2CanHandle) {+ const writeRepository = this.getWriteRepository(queryRunnerContext);+ const resolvedData = await this.resolveNestedRelationsForOrmV2({+ records: updateInputs.map((input) => input.data),+ queryRunnerContext,+ writeRepository,+ });- const savedRecords = await repository.updateMany(- partialRecordsToUpdateWithoutCreatedByUpdate.map((record) => ({- criteria: record.id,- partialEntity: { ...record, deletedAt: null },- })),- undefined,- columnsToReturn,- );+ savedRecords = await writeRepository.runBatchUpdate({+ inputs: updateInputs.map((input, index) => ({+ id: input.id,+ data: resolvedData[index],+ })),+ columnsToReturn,+ });+ } else {+ savedRecords = await repository.updateMany(+ updateInputs.map((input) => ({+ criteria: input.id,+ partialEntity: input.data,+ })),+ undefined,+ columnsToReturn,+ );+ }result.identifiers.push(...savedRecords.generatedMaps.map((record) => ({ id: record.id })),@@ -456,23 +512,47 @@ export class CommonCreateManyQueryRunnerService extends CommonBaseQueryRunnerSerrepository,result,columnsToReturn,+ queryRunnerContext,}: {recordsToInsert: Partial<ObjectRecord>[];repository: WorkspaceRepository<ObjectLiteral>;result: InsertResult;columnsToReturn: string[];+ queryRunnerContext: CommonExtendedQueryRunnerContext;}): Promise<void> {- if (recordsToInsert.length > 0) {- const insertResult = await repository.insert(+ if (recordsToInsert.length === 0) {+ return;+ }++ const ormV2CanHandle =+ queryRunnerContext.featureFlagsMap[+ FeatureFlagKey.IS_ORM_V2_READ_PATH_ENABLED+ ];++ let insertResult;++ if (ormV2CanHandle) {+ const writeRepository = this.getWriteRepository(queryRunnerContext);++ insertResult = await writeRepository.runInsert({+ records: await this.resolveNestedRelationsForOrmV2({+ records: recordsToInsert,+ queryRunnerContext,+ writeRepository,+ }),+ columnsToReturn,+ });+ } else {+ insertResult = await repository.insert(recordsToInsert,undefined,columnsToReturn,);-- result.identifiers.push(...insertResult.identifiers);- result.generatedMaps.push(...insertResult.generatedMaps);- result.raw.push(...insertResult.raw);}++ result.identifiers.push(...insertResult.identifiers);+ result.generatedMaps.push(...insertResult.generatedMaps);+ result.raw.push(...insertResult.raw);}private async fetchUpsertedRecords({diff --git a/packages/twenty-server/src/engine/api/common/common-query-runners/common-merge-many-query-runner.service.ts b/packages/twenty-server/src/engine/api/common/common-query-runners/common-merge-many-query-runner.service.tsindex dc5d33c313d..1e0590bca49 100644--- a/packages/twenty-server/src/engine/api/common/common-query-runners/common-merge-many-query-runner.service.ts+++ b/packages/twenty-server/src/engine/api/common/common-query-runners/common-merge-many-query-runner.service.ts@@ -6,6 +6,7 @@ import {QUERY_MAX_RECORDS_FROM_RELATION,} from 'twenty-shared/constants';import {+ FeatureFlagKey,FieldMetadataSettingsMapping,FieldMetadataType,ObjectRecord,@@ -34,6 +35,7 @@ import { buildColumnsToSelect } from 'src/engine/api/graphql/graphql-query-runneimport { hasRecordFieldValue } from 'src/engine/api/graphql/graphql-query-runner/utils/has-record-field-value.util';import { mergeFieldValues } from 'src/engine/api/graphql/graphql-query-runner/utils/merge-field-values.util';import { WorkspaceAuthContext } from 'src/engine/core-modules/auth/types/workspace-auth-context.type';+import { MetricsKeys } from 'src/engine/core-modules/metrics/types/metrics-keys.type';import { computeMorphOrRelationFieldJoinColumnName } from 'src/engine/metadata-modules/field-metadata/utils/compute-morph-or-relation-field-join-column-name.util';import { 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';@@ -83,17 +85,26 @@ export class CommonMergeManyQueryRunnerService extends CommonBaseQueryRunnerServconst idsToDelete = args.ids.filter((id) => id !== priorityRecord.id);- const updatedRecord =- await queryRunnerContext.workspaceDataSource.transaction(- (transactionManager: WorkspaceEntityManager) =>- this.executeMergeWithinTransaction(transactionManager, {- args,- queryRunnerContext,- idsToDelete,- priorityRecordId: priorityRecord.id,- mergedData,- }),- );+ const updatedRecord = queryRunnerContext.featureFlagsMap[+ FeatureFlagKey.IS_ORM_V2_READ_PATH_ENABLED+ ]+ ? await this.executeMergeWithinTransactionV2({+ args,+ queryRunnerContext,+ idsToDelete,+ priorityRecordId: priorityRecord.id,+ mergedData,+ })+ : await queryRunnerContext.workspaceDataSource.transaction(+ (transactionManager: WorkspaceEntityManager) =>+ this.executeMergeWithinTransaction(transactionManager, {+ args,+ queryRunnerContext,+ idsToDelete,+ priorityRecordId: priorityRecord.id,+ mergedData,+ }),+ );await this.processNestedRelations({args,@@ -388,21 +399,18 @@ export class CommonMergeManyQueryRunnerService extends CommonBaseQueryRunnerServreturn updatedRecord;}- private async migrateRelatedRecords(- transactionManager: WorkspaceEntityManager,+ private getRelationFieldsPointingToCurrentObject(context: CommonExtendedQueryRunnerContext,- fromIds: string[],- toId: string,- ): Promise<void> {+ ): Array<{ objectMetadata: FlatObjectMetadata; joinColumnName: string }> {const {flatObjectMetadataMaps,flatFieldMetadataMaps,flatObjectMetadata,} = context;- const relationFieldsPointingToCurrentObject: Array<{+ const relationFields: Array<{objectMetadata: FlatObjectMetadata;- joinColumnName: string | undefined;+ joinColumnName: string;}> = [];for (const field of Object.values(@@ -434,7 +442,7 @@ export class CommonMergeManyQueryRunnerService extends CommonBaseQueryRunnerServcontinue;}- relationFieldsPointingToCurrentObject.push({+ relationFields.push({objectMetadata: objMetadata,joinColumnName: computeMorphOrRelationFieldJoinColumnName({name: field.name,@@ -442,18 +450,24 @@ export class CommonMergeManyQueryRunnerService extends CommonBaseQueryRunnerServ});}- for (const relationField of relationFieldsPointingToCurrentObject) {- if (!relationField.joinColumnName) {- continue;- }+ return relationFields;+ }+ private async migrateRelatedRecords(+ transactionManager: WorkspaceEntityManager,+ context: CommonExtendedQueryRunnerContext,+ fromIds: string[],+ toId: string,+ ): Promise<void> {+ for (const relationField of this.getRelationFieldsPointingToCurrentObject(+ context,+ )) {const repository = transactionManager.getRepository(relationField.objectMetadata.nameSingular,context.rolePermissionConfig,context.authContext,);- // repository.update() runs outside the transaction; build from the transaction-scoped repository so the migration rolls back with the merge.await repository.createQueryBuilder(relationField.objectMetadata.nameSingular).update()@@ -464,6 +478,105 @@ export class CommonMergeManyQueryRunnerService extends CommonBaseQueryRunnerServ}}+ private async executeMergeWithinTransactionV2({+ args,+ queryRunnerContext,+ idsToDelete,+ priorityRecordId,+ mergedData,+ }: {+ args: CommonExtendedInput<MergeManyQueryArgs>;+ queryRunnerContext: CommonExtendedQueryRunnerContext;+ idsToDelete: string[];+ priorityRecordId: string;+ mergedData: Partial<ObjectRecord>;+ }): Promise<ObjectRecord> {+ const {+ flatObjectMetadata,+ flatObjectMetadataMaps,+ flatFieldMetadataMaps,+ rolePermissionConfig,+ } = queryRunnerContext;+ const alias = flatObjectMetadata.nameSingular;++ const columnsToReturn = buildColumnsToReturn({+ select: args.selectedFieldsResult.select,+ relations: args.selectedFieldsResult.relations,+ flatObjectMetadata,+ flatObjectMetadataMaps,+ flatFieldMetadataMaps,+ });++ this.metricsService.incrementCounterBy({+ key: MetricsKeys.OrmV2WritePathUsed,+ amount: 1,+ attributes: { operation: this.operationName },+ });++ return this.workspaceDataSourceV2Service+ .getDataSource({ useReplica: false })+ .transaction(async (transactionScope) => {+ for (const relationField of this.getRelationFieldsPointingToCurrentObject(+ queryRunnerContext,+ )) {+ const relatedRepository = transactionScope.getRepository(+ relationField.objectMetadata.nameSingular,+ rolePermissionConfig,+ );++ await relatedRepository.runMutation({+ selectQueryBuilder: relatedRepository+ .createQueryBuilder(relationField.objectMetadata.nameSingular)+ .where({ [relationField.joinColumnName]: In(idsToDelete) }),+ rowLevelPermissionsApplied: false,+ kind: 'update',+ columnsToReturn: ['id'],+ data: { [relationField.joinColumnName]: priorityRecordId },+ });+ }++ const objectRepository = transactionScope.getRepository(+ alias,+ rolePermissionConfig,+ );++ await objectRepository.runMutation({+ selectQueryBuilder: objectRepository+ .createQueryBuilder(alias)+ .where({ id: In(idsToDelete) }),+ rowLevelPermissionsApplied: false,+ kind: 'delete',+ columnsToReturn,+ });++ const [resolvedMergedData] = await this.resolveNestedRelationsForOrmV2({+ records: [mergedData],+ queryRunnerContext,+ writeRepository: objectRepository,+ });++ const updatedRecords = await objectRepository.runMutation({+ selectQueryBuilder: objectRepository+ .createQueryBuilder(alias)+ .where({ id: priorityRecordId }),+ rowLevelPermissionsApplied: false,+ kind: 'update',+ columnsToReturn,+ data: resolvedMergedData,+ });++ if (!isDefined(updatedRecords[0])) {+ throw new CommonQueryRunnerException(+ 'Failed to update record',+ CommonQueryRunnerExceptionCode.RECORD_NOT_FOUND,+ { userFriendlyMessage: STANDARD_ERROR_MESSAGE },+ );+ }++ return updatedRecords[0];+ });+ }+private async processNestedRelations({args,queryRunnerContext,diff --git a/packages/twenty-server/src/engine/api/common/common-query-runners/utils/__tests__/update-data-is-supported-by-orm-v2.util.spec.ts b/packages/twenty-server/src/engine/api/common/common-query-runners/utils/__tests__/update-data-is-supported-by-orm-v2.util.spec.tsdeleted file mode 100644index c23de1ffed2..00000000000--- a/packages/twenty-server/src/engine/api/common/common-query-runners/utils/__tests__/update-data-is-supported-by-orm-v2.util.spec.ts+++ /dev/null@@ -1,84 +0,0 @@-import { FieldMetadataType, type ObjectRecord } from 'twenty-shared/types';--import { updateDataIsSupportedByOrmV2 } from 'src/engine/api/common/common-query-runners/utils/update-data-is-supported-by-orm-v2.util';-import { findFlatEntityByIdInFlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/utils/find-flat-entity-by-id-in-flat-entity-maps.util';-import { buildFieldMapsFromFlatObjectMetadata } from 'src/engine/metadata-modules/flat-field-metadata/utils/build-field-maps-from-flat-object-metadata.util';--jest.mock(- 'src/engine/metadata-modules/flat-field-metadata/utils/build-field-maps-from-flat-object-metadata.util',-);-jest.mock(- 'src/engine/metadata-modules/flat-entity/utils/find-flat-entity-by-id-in-flat-entity-maps.util',-);--const fieldTypeById: Record<string, FieldMetadataType> = {- 'field-jobTitle': FieldMetadataType.TEXT,- 'field-name': FieldMetadataType.FULL_NAME,- 'field-company': FieldMetadataType.RELATION,- 'field-owner': FieldMetadataType.MORPH_RELATION,- 'field-attachments': FieldMetadataType.FILES,-};--beforeEach(() => {- jest.mocked(buildFieldMapsFromFlatObjectMetadata).mockReturnValue({- fieldIdByName: {- jobTitle: 'field-jobTitle',- name: 'field-name',- company: 'field-company',- owner: 'field-owner',- attachments: 'field-attachments',- },- fieldIdByJoinColumnName: { companyId: 'field-company' },- });-- jest- .mocked(findFlatEntityByIdInFlatEntityMaps)- .mockImplementation(({ flatEntityId }) =>- flatEntityId !== undefined && flatEntityId in fieldTypeById- ? ({ type: fieldTypeById[flatEntityId] } as never)- : undefined,- );-});--const callWith = (data: Partial<ObjectRecord>) =>- updateDataIsSupportedByOrmV2({- data,- flatObjectMetadata: {} as never,- flatFieldMetadataMaps: {} as never,- });--describe('updateDataIsSupportedByOrmV2', () => {- it('should return true for empty data', () => {- expect(callWith({})).toBe(true);- });-- it('should return true for scalar and composite fields', () => {- expect(callWith({ jobTitle: 'Tech Lead', name: { firstName: 'A' } })).toBe(- true,- );- });-- it('should return false when a relation field is set', () => {- expect(callWith({ company: { connect: { where: { id: 'x' } } } })).toBe(- false,- );- });-- it('should return false when a morph relation field is set', () => {- expect(callWith({ owner: { connect: { where: { id: 'x' } } } })).toBe(- false,- );- });-- it('should return false when a files field is set', () => {- expect(callWith({ attachments: [] })).toBe(false);- });-- it('should resolve a relation set through its join column name', () => {- expect(callWith({ companyId: 'company-id' })).toBe(false);- });-- it('should return false for an unknown field', () => {- expect(callWith({ doesNotExist: 'x' })).toBe(false);- });-});diff --git a/packages/twenty-server/src/engine/api/common/common-query-runners/utils/update-data-is-supported-by-orm-v2.util.ts b/packages/twenty-server/src/engine/api/common/common-query-runners/utils/update-data-is-supported-by-orm-v2.util.tsdeleted file mode 100644index 18da8923649..00000000000--- a/packages/twenty-server/src/engine/api/common/common-query-runners/utils/update-data-is-supported-by-orm-v2.util.ts+++ /dev/null@@ -1,42 +0,0 @@-import { FieldMetadataType, type ObjectRecord } from 'twenty-shared/types';-import { isDefined } from 'twenty-shared/utils';--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 { type FlatFieldMetadata } from 'src/engine/metadata-modules/flat-field-metadata/types/flat-field-metadata.type';-import { buildFieldMapsFromFlatObjectMetadata } from 'src/engine/metadata-modules/flat-field-metadata/utils/build-field-maps-from-flat-object-metadata.util';-import { type FlatObjectMetadata } from 'src/engine/metadata-modules/flat-object-metadata/types/flat-object-metadata.type';--export const updateDataIsSupportedByOrmV2 = ({- data,- flatObjectMetadata,- flatFieldMetadataMaps,-}: {- data: Partial<ObjectRecord>;- flatObjectMetadata: FlatObjectMetadata;- flatFieldMetadataMaps: FlatEntityMaps<FlatFieldMetadata>;-}): boolean => {- const { fieldIdByName, fieldIdByJoinColumnName } =- buildFieldMapsFromFlatObjectMetadata(- flatFieldMetadataMaps,- flatObjectMetadata,- );-- return Object.keys(data).every((fieldName) => {- const fieldMetadata = findFlatEntityByIdInFlatEntityMaps({- flatEntityId:- fieldIdByName[fieldName] ?? fieldIdByJoinColumnName[fieldName],- flatEntityMaps: flatFieldMetadataMaps,- });-- if (!isDefined(fieldMetadata)) {- return false;- }-- return (- fieldMetadata.type !== FieldMetadataType.RELATION &&- fieldMetadata.type !== FieldMetadataType.MORPH_RELATION &&- fieldMetadata.type !== FieldMetadataType.FILES- );- });-};diff --git a/packages/twenty-server/src/engine/api/graphql/graphql-query-runner/group-by/services/group-by-with-records-v2.service.ts b/packages/twenty-server/src/engine/api/graphql/graphql-query-runner/group-by/services/group-by-with-records-v2.service.tsindex acdd8969a96..344b9d92b36 100644--- a/packages/twenty-server/src/engine/api/graphql/graphql-query-runner/group-by/services/group-by-with-records-v2.service.ts+++ b/packages/twenty-server/src/engine/api/graphql/graphql-query-runner/group-by/services/group-by-with-records-v2.service.ts@@ -17,7 +17,6 @@ import { type CommonGroupByOutputItem } from 'src/engine/api/common/types/commonimport { CommonSelectedFieldsResult } from 'src/engine/api/common/types/common-selected-fields-result.type';import { type NestedRelationsReadPathOptions } from 'src/engine/api/common/types/nested-relations-read-path-options.type';import { GraphqlQueryParser } from 'src/engine/api/graphql/graphql-query-runner/graphql-query-parsers/graphql-query.parser';-import { addRelationJoinAliasToQueryBuilder } from 'src/engine/api/graphql/graphql-query-runner/graphql-query-parsers/utils/add-relation-join-alias.util';import { formatResultWithGroupByDimensionValues } from 'src/engine/api/graphql/graphql-query-runner/group-by/resolvers/utils/format-result-with-group-by-dimension-values.util';import {RECORDS_PER_GROUP_LIMIT,@@ -278,11 +277,12 @@ export class GroupByWithRecordsV2Service {}for (const joinInfo of relationJoins) {- addRelationJoinAliasToQueryBuilder({- queryBuilder: subQueryBuilder,- parentAlias: flatObjectMetadata.nameSingular,- relationName: joinInfo.joinAlias,- });+ subQueryBuilder.leftJoin(+ `${flatObjectMetadata.nameSingular}.${joinInfo.joinAlias}`,+ joinInfo.joinAlias,+ undefined,+ { allowToManyJoin: true },+ );}return `ROW_NUMBER() OVER (PARTITION BY ${partitionBy} ${orderByRawSQL})`;diff --git a/packages/twenty-server/src/engine/twenty-orm-v2/README.md b/packages/twenty-server/src/engine/twenty-orm-v2/README.mdindex ad33e6353bb..a6d87cb9685 100644--- a/packages/twenty-server/src/engine/twenty-orm-v2/README.md+++ b/packages/twenty-server/src/engine/twenty-orm-v2/README.md@@ -142,11 +142,26 @@ soft ones, `UPDATED` then `UPSERTED` for update. `getWriteRepository` on the baspins the primary and counts `orm-v2/write-path-used`.Update flattens its input with the shared `formatData` (composite fields to columns) and-validates the field-level write permission over the resulting column set. It carves back-to v1 for one case: data that sets a relation (`{connect}` / `{disconnect}`) or a files-field, because that input is resolved by `RelationNestedQueries` / `FilesFieldSync`, which-are coupled to the TypeORM builder and not yet reproduced here. `updateDataIsSupportedByOrmV2`-makes that call; both branches match their v1 counterpart byte for byte.+validates the field-level write permission over the resulting column set. Relation+`{connect}` / `{disconnect}` input is resolved to plain join-column values before the write+by `resolveNestedRelationsForOrmV2` on the base runner, which runs the unchanged v1+`RelationNestedQueries` (its lookup select stays on v1) and then drops the relation+field-name keys it leaves behind so only columns reach the v2 statement. Files-field input+is synced through the same v1 `FilesFieldSync` the write query builders use: the repository+computes the file diff against the before-image, enriches the record, and re-points the+`File` rows after the statement runs. `FilesFieldSync` only needs the object name and the+`coreDataSource`, both already on the v2 repository's `internalContext`, so no TypeORM entity+is built. Nothing on the write path carves back to v1 any more: with the flag on, every+create / update / upsert / delete / merge runs entirely on v2 regardless of the field types+it touches.++Row-level security is enforced on two layers, matching v1: the WHERE predicate (same+resolver and renderer as the read path) bounds which rows a mutation can touch, and the+shared `validateRLSPredicatesForRecords` re-checks the written image in JS so a create+cannot insert, nor an update move a row into, a state the role's predicate forbids. Insert+validates the formatted input image, update the projected after-image (before-image merged+with the SET values), exactly as `WorkspaceInsertQueryBuilder` / `WorkspaceUpdateQueryBuilder`+do.Deliberate choices, the SQL ones asserted by exact-SQL unit tests:@@ -169,21 +184,73 @@ Deliberate choices, the SQL ones asserted by exact-SQL unit tests:user-input error the read path already produces (v2 refuses to render a to-many join),rather than the row-multiplying join v1 would emit.-Insert and upsert still keep `repository` (v1), as does update with relation/files input.+## Writes: create (non-upsert insert) routes through v2++`createMany` (and `createOne`) route their non-upsert insert through+`WorkspaceRepositoryV2.runInsert`: records flatten through `formatData`, insert with+`buildInsertStatement` (a multi-row `INSERT ... VALUES ... RETURNING`, `DEFAULT` for the+columns a given row omits so Postgres column defaults apply), validate the insert+permission over the inserted columns, and emit `CREATED` then `UPSERTED` from an+all-columns re-select of the inserted ids — matching the v1 insert builder. Relation+`{connect}` / `{disconnect}` input is resolved to join columns by+`resolveNestedRelationsForOrmV2` before the write, and files-field input is synced through+`FilesFieldSync` inside `runInsert`, exactly as on the update path.++## Transactions and merge++`WorkspaceDataSourceV2.transaction(work)` checks a client out of the pool, wraps `work` in+`BEGIN` / `COMMIT` (rolling back and rethrowing on error), and hands `work` a scope whose+`getRepository` returns repositories bound to that client through a `ClientQueryExecutor`,+so every statement and event snapshot inside runs on the one connection.++`mergeMany` routes through it with the flag on, always: `executeMergeWithinTransactionV2`+re-points the losing records' foreign keys to the survivor across each related object,+hard-deletes the losers, and updates the survivor with the merged data — each step a+`runMutation` on a transaction-scoped repository, so the same `UPDATED`/`DESTROYED`/+`UPSERTED` events fire as v1. Before the survivor update the merged data goes through+`resolveNestedRelationsForOrmV2`, the same relation resolution the other write paths use, so+a relation set by name resolves to its join column instead of forcing v1. In practice the+merged data only ever carries columns and join columns: the write path selects columns+(`buildColumnsToSelect` maps relations to their join columns) and loads relations by name+only on the dry-run branch, so the resolution is a no-op on real merges and the old+`isMergeSupportedByOrmV2` carve-out was dead. Its object-literal `where` support grew to+cover scalar equality, `Equal`, and `IS NULL` alongside `In`.++## Upsert++`createMany` with `upsert: true` reads the existing records by their conflict fields,+splits the input into inserts and updates, then inserts the new records and updates the+matched ones. The insert half routes through `runInsert`; the update half through+`runBatchUpdate`, which runs each per-id update as its own statement but emits one batch+`UPDATED` + `UPSERTED` over the collected before/after images, matching v1's `updateMany`.+Both halves resolve relation `{connect}` / `{disconnect}` input to join columns through+`resolveNestedRelationsForOrmV2` first, just like the plain create and update paths. The+read-then-split and conflict-target derivation are unchanged.++## Coverage++Every write the API layer can reach runs entirely on v2 when the flag is on — create,+update, upsert, delete, and merge — whatever field types it touches (scalars, composites,+relation join columns, relation `{connect}` / `{disconnect}`, and files fields). Nothing on+the write path falls back to v1 on the value of its input.++`WorkspaceSelectQueryBuilderV2.leftJoin` can render a to-many join when the caller passes+`allowToManyJoin`. It renders as a `DISTINCT ON (foreignKey)` derived table ordered by+`foreignKey, id`, so each parent keeps exactly one representative child row (its lowest-id+live child) and the join never multiplies parent rows — record ranking and paging stay+correct. The soft-delete predicate runs inside that derived table, before the row is picked.+Only group-by "with records" record-ordering opts in; every other join site (filter+traversal, relation loading) leaves it off, so a to-many relation there still surfaces the+standard `UNSUPPORTED_OPERATION` error. This capability is currently latent: the GraphQL+order-by input excludes to-many relations (`generateSimpleRelationFieldOrderByInputType`+returns `{}` for `ONE_TO_MANY`), so no API query can order by one today. The join is+unit-tested against its exact SQL and activates automatically if that input is ever exposed.## Not covered yet-- Insert and upsert. `INSERT` and `ON CONFLICT` still go through v1, which is where the- column defaults and conflict-target derivation live.-- Relation connect/disconnect and files-field input on writes, resolved by- `RelationNestedQueries` / `FilesFieldSync`. Update carves these back to v1; create and- upsert stay on v1 entirely until this input machinery has a v2 form.- `find` / `findOne` / `findBy` and the rest of the repository surface used by`src/modules`.-- Transactions and DDL.-- Ordering group-by "with records" by a to-many relation: v2 refuses to-many joins, so- it surfaces the standard "unsupported" user error rather than the row-multiplying join- v1 would emit.+- DDL.- The read runners hand the v2 builder to the shared parsers with a cast, because theyare typed against the TypeORM class rather than an interface. Giving the parsers astructural `SelectQueryBuilderLike` type removes it and is the next cleanup.diff --git a/packages/twenty-server/src/engine/twenty-orm-v2/datasource/workspace-data-source-v2.ts b/packages/twenty-server/src/engine/twenty-orm-v2/datasource/workspace-data-source-v2.tsindex 87255bcbc54..21a00de6b68 100644--- a/packages/twenty-server/src/engine/twenty-orm-v2/datasource/workspace-data-source-v2.ts+++ b/packages/twenty-server/src/engine/twenty-orm-v2/datasource/workspace-data-source-v2.ts@@ -8,7 +8,9 @@ import { findFlatEntityByIdInFlatEntityMapsOrThrow } from 'src/engine/metadata-mimport { type FlatObjectMetadata } from 'src/engine/metadata-modules/flat-object-metadata/types/flat-object-metadata.type';import { type WorkspaceInternalContext } from 'src/engine/twenty-orm/interfaces/workspace-internal-context.interface';import { type RolePermissionConfig } from 'src/engine/twenty-orm/types/role-permission-config';+import { ClientQueryExecutor } from 'src/engine/twenty-orm-v2/executor/client-query-executor';import { PoolQueryExecutor } from 'src/engine/twenty-orm-v2/executor/pool-query-executor';+import { type QueryExecutorV2 } from 'src/engine/twenty-orm-v2/executor/types/query-executor-v2.type';import {TwentyOrmV2Exception,TwentyOrmV2ExceptionCode,@@ -23,6 +25,13 @@ const tableShapeCacheByFlatObjectMetadataMaps = new WeakMap<Map<string, WorkspaceTableShape>>();+export type WorkspaceTransactionScopeV2 = {+ getRepository: (+ nameSingular: string,+ rolePermissionConfig?: RolePermissionConfig,+ ) => WorkspaceRepositoryV2;+};+export class WorkspaceDataSourceV2 {private readonly pool: Pool;private readonly internalContext: WorkspaceInternalContext;@@ -50,6 +59,54 @@ export class WorkspaceDataSourceV2 {nameSingular: string,rolePermissionConfig?: RolePermissionConfig,): WorkspaceRepositoryV2 {+ return this.buildRepository({+ nameSingular,+ rolePermissionConfig,+ executor: new PoolQueryExecutor({ pool: this.pool }),+ });+ }++ async transaction<T>(+ work: (transactionScope: WorkspaceTransactionScopeV2) => Promise<T>,+ ): Promise<T> {+ const client = await this.pool.connect();++ try {+ await client.query('BEGIN');++ const executor = new ClientQueryExecutor({ client });+ const transactionScope: WorkspaceTransactionScopeV2 = {+ getRepository: (nameSingular, rolePermissionConfig) =>+ this.buildRepository({+ nameSingular,+ rolePermissionConfig,+ executor,+ }),+ };++ const result = await work(transactionScope);++ await client.query('COMMIT');++ return result;+ } catch (error) {+ await client.query('ROLLBACK');++ throw error;+ } finally {+ client.release();+ }+ }++ private buildRepository({+ nameSingular,+ rolePermissionConfig,+ executor,+ }: {+ nameSingular: string;+ rolePermissionConfig?: RolePermissionConfig;+ executor: QueryExecutorV2;+ }): WorkspaceRepositoryV2 {const objectMetadataId =this.internalContext.objectIdByNameSingular[nameSingular];@@ -74,7 +131,7 @@ export class WorkspaceDataSourceV2 {flatObjectMetadata,internalContext: this.internalContext,authContext: this.authContext,- executor: new PoolQueryExecutor({ pool: this.pool }),+ executor,objectRecordsPermissions,shouldBypassPermissionChecks,tableShapeByObjectMetadataId: (targetObjectMetadataId) =>diff --git a/packages/twenty-server/src/engine/twenty-orm-v2/executor/client-query-executor.ts b/packages/twenty-server/src/engine/twenty-orm-v2/executor/client-query-executor.tsnew file mode 100644index 00000000000..79fc2a2d2c6--- /dev/null+++ b/packages/twenty-server/src/engine/twenty-orm-v2/executor/client-query-executor.ts@@ -0,0 +1,23 @@+import { type PoolClient } from 'pg';++import { type CompiledStatement } from 'src/engine/twenty-orm-v2/sql/utils/compile-named-parameters.util';+import { type QueryExecutorV2 } from 'src/engine/twenty-orm-v2/executor/types/query-executor-v2.type';++export class ClientQueryExecutor implements QueryExecutorV2 {+ private readonly client: PoolClient;++ constructor({ client }: { client: PoolClient }) {+ this.client = client;+ }++ async execute(+ statement: CompiledStatement,+ ): Promise<Record<string, unknown>[]> {+ const result = await this.client.query({+ text: statement.text,+ values: statement.values,+ });++ return result.rows as Record<string, unknown>[];+ }+}diff --git a/packages/twenty-server/src/engine/twenty-orm-v2/query-builder/__tests__/workspace-select-query-builder-v2.spec.ts b/packages/twenty-server/src/engine/twenty-orm-v2/query-builder/__tests__/workspace-select-query-builder-v2.spec.tsindex 41642633a3a..8cc585b0b9f 100644--- a/packages/twenty-server/src/engine/twenty-orm-v2/query-builder/__tests__/workspace-select-query-builder-v2.spec.ts+++ b/packages/twenty-server/src/engine/twenty-orm-v2/query-builder/__tests__/workspace-select-query-builder-v2.spec.ts@@ -1,5 +1,5 @@import { FieldMetadataType } from 'twenty-shared/types';-import { In, LessThan } from 'typeorm';+import { Equal, In, LessThan } from 'typeorm';import { RelationType } from 'src/engine/metadata-modules/field-metadata/interfaces/relation-type.interface';import { type CompiledStatement } from 'src/engine/twenty-orm-v2/sql/utils/compile-named-parameters.util';@@ -34,7 +34,16 @@ const companyTableShape: WorkspaceTableShape = {deletedAt: buildColumn('deletedAt'),},columnNames: ['id', 'name', 'deletedAt'],- relationShapeByFieldName: {},+ relationShapeByFieldName: {+ person: {+ fieldName: 'person',+ fieldMetadataId: 'field-company',+ relationType: RelationType.MANY_TO_ONE,+ targetObjectMetadataId: 'person-object-id',+ targetFieldMetadataId: 'field-people',+ joinColumnName: 'personId',+ },+ },hasDeletedAtColumn: true,};@@ -173,6 +182,23 @@ describe('WorkspaceSelectQueryBuilderV2', () => {expect(() => queryBuilder.getQuery()).toThrow(TwentyOrmV2Exception);});+ it('should render a deduped to-many join on the inverse foreign key when the caller opts in', () => {+ const { queryBuilder } = buildQueryBuilder();++ queryBuilder.setFindOptions({ select: { id: true } });+ queryBuilder.leftJoin('person.people', 'people', undefined, {+ allowToManyJoin: true,+ });++ expect(queryBuilder.getQuery()).toContain(+ `LEFT JOIN (SELECT DISTINCT ON ("personId") * ` ++ `FROM "${SCHEMA_NAME}"."company" ` ++ `WHERE "deletedAt" IS NULL ` ++ `ORDER BY "personId", "id") AS "people" ` ++ 'ON ("people"."personId" = "person"."id")',+ );+ });+it('should emit a plain parameterised LIMIT, with no distinct sub-select', () => {const { queryBuilder } = buildQueryBuilder();@@ -622,12 +648,40 @@ describe('WorkspaceSelectQueryBuilderV2', () => {);});- it('should reject a plain value in an object-literal where', () => {+ it('should treat a plain value in an object-literal where as equality', () => {const { queryBuilder } = buildQueryBuilder();- expect(() => queryBuilder.where({ companyId: 'company-1' })).toThrow(- TwentyOrmV2Exception,- );+ queryBuilder+ .setFindOptions({ select: { id: true } })+ .where({ companyId: 'company-1' });++ const [text, values] = queryBuilder.getQueryAndParameters();++ expect(text).toContain('("person"."companyId" = $1)');+ expect(values).toEqual(['company-1']);+ });++ it('should treat the Equal operator in an object-literal where as equality', () => {+ const { queryBuilder } = buildQueryBuilder();++ queryBuilder+ .setFindOptions({ select: { id: true } })+ .where({ companyId: Equal('company-1') });++ const [text, values] = queryBuilder.getQueryAndParameters();++ expect(text).toContain('("person"."companyId" = $1)');+ expect(values).toEqual(['company-1']);+ });++ it('should treat a null value in an object-literal where as IS NULL', () => {+ const { queryBuilder } = buildQueryBuilder();++ queryBuilder+ .setFindOptions({ select: { id: true } })+ .where({ companyId: null });++ expect(queryBuilder.getQuery()).toContain('("person"."companyId" IS NULL)');});it('should emit a GROUP BY with aggregate and grouped columns', () => {diff --git a/packages/twenty-server/src/engine/twenty-orm-v2/query-builder/workspace-mutation-query-builder-v2.ts b/packages/twenty-server/src/engine/twenty-orm-v2/query-builder/workspace-mutation-query-builder-v2.tsindex e441c9b2f26..af47966f03e 100644--- a/packages/twenty-server/src/engine/twenty-orm-v2/query-builder/workspace-mutation-query-builder-v2.ts+++ b/packages/twenty-server/src/engine/twenty-orm-v2/query-builder/workspace-mutation-query-builder-v2.ts@@ -11,6 +11,7 @@ import {type WhereClause,} from 'src/engine/twenty-orm-v2/sql/utils/build-select-statement.util';import { compileNamedParameters } from 'src/engine/twenty-orm-v2/sql/utils/compile-named-parameters.util';+import { serializeJsonbWriteValue } from 'src/engine/twenty-orm-v2/sql/utils/serialize-jsonb-write-value.util';import {buildMutationStatement,type MutationKind,@@ -168,7 +169,10 @@ export class WorkspaceMutationQueryBuilderV2 {parameterName = `ormV2Set_${mutationSetParameterSequence++}`;}- parameters[parameterName] = value;+ parameters[parameterName] = serializeJsonbWriteValue(+ this.tableShape.columnShapeByColumnName[columnName],+ value,+ );setClauses.push({ columnName, valueExpression: `:${parameterName}` });}diff --git a/packages/twenty-server/src/engine/twenty-orm-v2/query-builder/workspace-select-query-builder-v2.ts b/packages/twenty-server/src/engine/twenty-orm-v2/query-builder/workspace-select-query-builder-v2.tsindex ab35e566f72..8116e4ddc53 100644--- a/packages/twenty-server/src/engine/twenty-orm-v2/query-builder/workspace-select-query-builder-v2.ts+++ b/packages/twenty-server/src/engine/twenty-orm-v2/query-builder/workspace-select-query-builder-v2.ts@@ -250,7 +250,12 @@ export class WorkspaceSelectQueryBuilderV2 implements WhereExpressionLike {return this;}- leftJoin(relationPath: string, alias: string, condition?: string): this {+ leftJoin(+ relationPath: string,+ alias: string,+ condition?: string,+ options?: { allowToManyJoin?: boolean },+ ): this {const [parentAlias, relationFieldName] = relationPath.split('.');if (!isDefined(relationFieldName)) {@@ -280,9 +285,21 @@ export class WorkspaceSelectQueryBuilderV2 implements WhereExpressionLike {const joinColumnName = relationShape.joinColumnName;- // A to-many join has no renderable condition, but it is still recorded so the shared- // to-one guard rejects it with the same error the TypeORM path produces. Reaching SQL- // generation with one of these means the guard was bypassed, which throws there.+ // A to-one relation carries its join column on the current table, so the condition+ // is always renderable. A to-many relation carries the foreign key on the target+ // table; it is only built when the caller opts in (group-by "with records" ordering)+ // and renders as a DISTINCT ON derived table so it stays one row per parent.+ // Otherwise the condition is left undefined and the shared to-one guard rejects it.+ const toManyJoin =+ options?.allowToManyJoin === true+ ? this.buildToManyJoin({+ parentAlias,+ alias,+ targetTableShape,+ targetFieldMetadataId: relationShape.targetFieldMetadataId,+ })+ : undefined;+this.joinClauses.push({alias,targetTableShape,@@ -290,13 +307,48 @@ export class WorkspaceSelectQueryBuilderV2 implements WhereExpressionLike {condition: isDefined(joinColumnName)? (condition ??`${this.quoteColumn(parentAlias, joinColumnName)} = ${this.quoteColumn(alias, 'id')}`)- : undefined,+ : (condition ?? toManyJoin?.condition),+ toManyForeignKeyColumnName: toManyJoin?.foreignKeyColumnName,additionalOnConditions: [],});return this;}+ private buildToManyJoin({+ parentAlias,+ alias,+ targetTableShape,+ targetFieldMetadataId,+ }: {+ parentAlias: string;+ alias: string;+ targetTableShape: WorkspaceTableShape;+ targetFieldMetadataId: string | null;+ }): { condition: string; foreignKeyColumnName: string } | undefined {+ if (!isDefined(targetFieldMetadataId)) {+ return undefined;+ }++ const inverseRelationShape = Object.values(+ targetTableShape.relationShapeByFieldName,+ ).find(+ (relationShape) =>+ relationShape.fieldMetadataId === targetFieldMetadataId,+ );++ const foreignKeyColumnName = inverseRelationShape?.joinColumnName;++ if (!isDefined(foreignKeyColumnName)) {+ return undefined;+ }++ return {+ condition: `${this.quoteColumn(alias, foreignKeyColumnName)} = ${this.quoteColumn(parentAlias, 'id')}`,+ foreignKeyColumnName,+ };+ }+withDeleted(): this {this.includeDeleted = true;@@ -566,19 +618,36 @@ export class WorkspaceSelectQueryBuilderV2 implements WhereExpressionLike {);}- if (!(value instanceof FindOperator) || value.type !== 'in') {+ const quotedColumn = quoteColumn(this.alias, columnName);++ if (value === null) {+ conditions.push(`${quotedColumn} IS NULL`);+ continue;+ }++ const parameterName = `ormV2ObjectWhere_${objectWhereParameterSequence++}`;++ if (value instanceof FindOperator) {+ if (value.type === 'in') {+ conditions.push(`${quotedColumn} IN (:...${parameterName})`);+ parameters[parameterName] = value.value;+ continue;+ }++ if (value.type === 'equal') {+ conditions.push(`${quotedColumn} = :${parameterName}`);+ parameters[parameterName] = value.value;+ continue;+ }+throw new TwentyOrmV2Exception(- `Object where only supports the "in" operator on "${columnName}"`,+ `Object where supports only the "in" and "equal" operators on "${columnName}"`,TwentyOrmV2ExceptionCode.UNSUPPORTED_OPERATION,);}- const parameterName = `ormV2ObjectWhere_${objectWhereParameterSequence++}`;-- conditions.push(- `${quoteColumn(this.alias, columnName)} IN (:...${parameterName})`,- );- parameters[parameterName] = value.value;+ conditions.push(`${quotedColumn} = :${parameterName}`);+ parameters[parameterName] = value;}return { sql: conditions.join(' AND '), parameters };diff --git a/packages/twenty-server/src/engine/twenty-orm-v2/repository/workspace-repository-v2.ts b/packages/twenty-server/src/engine/twenty-orm-v2/repository/workspace-repository-v2.tsindex 4c8117162ff..99fbf068ab6 100644--- a/packages/twenty-server/src/engine/twenty-orm-v2/repository/workspace-repository-v2.ts+++ b/packages/twenty-server/src/engine/twenty-orm-v2/repository/workspace-repository-v2.ts@@ -1,14 +1,17 @@import { msg } from '@lingui/core/macro';+import { isNonEmptyString } from '@sniptt/guards';import { QUERY_MAX_RECORDS } from 'twenty-shared/constants';import {type ObjectRecord,type ObjectsPermissions,} from 'twenty-shared/types';import { isDefined } from 'twenty-shared/utils';+import { In } from 'typeorm';import { DatabaseEventAction } from 'src/engine/api/graphql/graphql-query-runner/enums/database-event-action';import { type WorkspaceAuthContext } from 'src/engine/core-modules/auth/types/workspace-auth-context.type';import { type FlatObjectMetadata } from 'src/engine/metadata-modules/flat-object-metadata/types/flat-object-metadata.type';+import { FilesFieldSync } from 'src/engine/twenty-orm/field-operations/files-field-sync/files-field-sync';import { validateOperationIsPermittedOrThrow } from 'src/engine/twenty-orm/repository/permissions.utils';import { type WorkspaceInternalContext } from 'src/engine/twenty-orm/interfaces/workspace-internal-context.interface';import { formatData } from 'src/engine/twenty-orm/utils/format-data.util';@@ -16,14 +19,20 @@ import { formatResult } from 'src/engine/twenty-orm/utils/format-result.util';import { formatTwentyOrmEventToDatabaseBatchEvent } from 'src/engine/twenty-orm/utils/format-twenty-orm-event-to-database-batch-event.util';import { renderRowLevelPermissionFilterToSql } from 'src/engine/twenty-orm/utils/render-row-level-permission-filter-to-sql.util';import { resolveRowLevelPermissionRecordFilter } from 'src/engine/twenty-orm/utils/resolve-row-level-permission-record-filter.util';+import { validateRLSPredicatesForRecords } from 'src/engine/twenty-orm/utils/validate-rls-predicates-for-records.util';import {TwentyOrmV2Exception,TwentyOrmV2ExceptionCode,} from 'src/engine/twenty-orm-v2/exceptions/twenty-orm-v2.exception';import { type QueryExecutorV2 } from 'src/engine/twenty-orm-v2/executor/types/query-executor-v2.type';+import {+ buildInsertStatement,+ type InsertRowValue,+} from 'src/engine/twenty-orm-v2/sql/utils/build-insert-statement.util';import { type MutationKind } from 'src/engine/twenty-orm-v2/sql/utils/build-mutation-statement.util';import { WorkspaceSelectQueryBuilderV2 } from 'src/engine/twenty-orm-v2/query-builder/workspace-select-query-builder-v2';import { compileNamedParameters } from 'src/engine/twenty-orm-v2/sql/utils/compile-named-parameters.util';+import { serializeJsonbWriteValue } from 'src/engine/twenty-orm-v2/sql/utils/serialize-jsonb-write-value.util';import { type WorkspaceTableShape } from 'src/engine/twenty-orm-v2/table-shape/types/workspace-table-shape.type';const MUTATION_EVENT_ACTIONS_BY_KIND: Record<@@ -57,11 +66,19 @@ export class WorkspaceRepositoryV2 {private readonly options: WorkspaceRepositoryV2Options;+ private _filesFieldSync?: FilesFieldSync;+constructor(options: WorkspaceRepositoryV2Options) {this.options = options;this.objectRecordsPermissions = options.objectRecordsPermissions;}+ private get filesFieldSync(): FilesFieldSync {+ return (this._filesFieldSync ??= new FilesFieldSync(+ this.options.internalContext,+ ));+ }+async executeRaw<T extends Record<string, unknown>>(sql: string,parameters: Record<string, unknown>,@@ -100,6 +117,325 @@ export class WorkspaceRepositoryV2 {this.applyRowLevelPermissionPredicates(queryBuilder);}+ getInternalContext(): WorkspaceInternalContext {+ return this.options.internalContext;+ }++ async runInsert({+ records,+ columnsToReturn,+ }: {+ records: Partial<ObjectRecord>[];+ columnsToReturn: string[];+ }): Promise<{+ identifiers: { id: string }[];+ generatedMaps: ObjectRecord[];+ raw: ObjectRecord[];+ }> {+ if (records.length === 0) {+ return { identifiers: [], generatedMaps: [], raw: [] };+ }++ const filesFieldDiff =+ this.filesFieldSync.computeFilesFieldDiffBeforeInsert(+ records,+ this.options.tableShape.nameSingular,+ );++ let filesFieldFileIds = null;+ let recordsToInsert = records;++ if (isDefined(filesFieldDiff)) {+ const enriched = await this.filesFieldSync.enrichFilesFields({+ entities: records,+ filesFieldDiffByEntityIndex: filesFieldDiff,+ workspaceId: this.options.internalContext.workspaceId,+ target: this.options.tableShape.nameSingular,+ });++ filesFieldFileIds = enriched.fileIds;+ recordsToInsert = enriched.entities as Partial<ObjectRecord>[];+ }++ const { columnNames, rows, parameters, insertedColumns, formattedRecords } =+ this.buildInsertRows(recordsToInsert);++ this.validateWriteIsPermitted({+ operationType: 'insert',+ columnsToReturn,+ updatedColumns: insertedColumns,+ });++ this.validateRLSPredicatesForWrittenRecords(+ this.formatResult<ObjectRecord[]>(formattedRecords),+ );++ const sql = buildInsertStatement({+ tableShape: this.options.tableShape,+ columnNames,+ rows,+ returningColumns: columnsToReturn,+ });++ const rawRows = await this.executeRaw<ObjectRecord>(sql, parameters);++ if (isDefined(filesFieldFileIds)) {+ await this.filesFieldSync.updateFileEntityRecords(filesFieldFileIds);+ }++ const generatedMaps = this.formatResult<ObjectRecord[]>(rawRows);+ const insertedIds = rawRows.map((row) => row.id).filter(isNonEmptyString);++ await this.emitCreateEvents(insertedIds);++ return {+ identifiers: insertedIds.map((id) => ({ id })),+ generatedMaps,+ raw: rawRows,+ };+ }++ async runBatchUpdate({+ inputs,+ columnsToReturn,+ }: {+ inputs: { id: string; data: Partial<ObjectRecord> }[];+ columnsToReturn: string[];+ }): Promise<{+ identifiers: { id: string }[];+ generatedMaps: ObjectRecord[];+ raw: ObjectRecord[];+ }> {+ if (inputs.length === 0) {+ return { identifiers: [], generatedMaps: [], raw: [] };+ }++ const recordsBefore: ObjectRecord[] = [];+ const recordsAfter: ObjectRecord[] = [];+ const generatedMaps: ObjectRecord[] = [];++ const rawBeforeByInputIndex: ObjectRecord[][] = [];+ const existingRecordsMapById: Record<string, ObjectRecord> = {};++ for (const input of inputs) {+ const rawBefore = await this.buildIdsEventSnapshotQueryBuilder([+ input.id,+ ]).getMany<ObjectRecord>({ noFormatting: true });++ rawBeforeByInputIndex.push(rawBefore);++ for (const formattedRecord of this.formatResult<ObjectRecord[]>(+ rawBefore,+ )) {+ if (isDefined(formattedRecord.id)) {+ existingRecordsMapById[formattedRecord.id] = formattedRecord;+ }+ }+ }++ let dataByInputIndex = inputs.map((input) => input.data);+ let filesFieldFileIds = null;++ const filesFieldDiff =+ this.filesFieldSync.computeFilesFieldDiffBeforeUpsert(+ dataByInputIndex,+ this.options.tableShape.nameSingular,+ existingRecordsMapById,+ );++ if (isDefined(filesFieldDiff)) {+ const enriched = await this.filesFieldSync.enrichFilesFields({+ entities: dataByInputIndex,+ filesFieldDiffByEntityIndex: filesFieldDiff,+ workspaceId: this.options.internalContext.workspaceId,+ target: this.options.tableShape.nameSingular,+ });++ filesFieldFileIds = enriched.fileIds;+ dataByInputIndex = enriched.entities as Partial<ObjectRecord>[];+ }++ for (const [index, input] of inputs.entries()) {+ const { id: _id, ...setColumns } = formatData(+ dataByInputIndex[index],+ this.options.flatObjectMetadata,+ this.options.internalContext.flatFieldMetadataMaps,+ );++ this.validateWriteIsPermitted({+ operationType: 'update',+ columnsToReturn,+ updatedColumns: Object.keys(setColumns),+ });++ const rawBeforeForInput = rawBeforeByInputIndex[index];++ recordsBefore.push(...rawBeforeForInput);++ this.validateRLSPredicatesForWrittenRecords(+ this.formatResult<ObjectRecord[]>(+ rawBeforeForInput.map((record) => ({ ...record, ...setColumns })),+ ),+ 'Updated record does not satisfy row-level security constraints of your current role',+ );++ const selectQueryBuilder = this.createQueryBuilder().where({+ id: input.id,+ });++ this.applyRowLevelPermissionPredicates(selectQueryBuilder);++ const result = await selectQueryBuilder+ .update()+ .set(setColumns)+ .returning(columnsToReturn)+ .execute();++ generatedMaps.push(...(result.generatedMaps as ObjectRecord[]));++ recordsAfter.push(+ ...(await this.buildIdsEventSnapshotQueryBuilder([+ input.id,+ ]).getMany<ObjectRecord>({+ noFormatting: true,+ })),+ );+ }++ if (isDefined(filesFieldFileIds)) {+ await this.filesFieldSync.updateFileEntityRecords(filesFieldFileIds);+ }++ this.emitMutationEvent({ kind: 'update', recordsBefore, recordsAfter });++ return {+ identifiers: generatedMaps.map((record) => ({ id: String(record.id) })),+ generatedMaps,+ raw: generatedMaps,+ };+ }++ private buildInsertRows(records: Partial<ObjectRecord>[]): {+ columnNames: string[];+ rows: InsertRowValue[][];+ parameters: Record<string, unknown>;+ insertedColumns: string[];+ formattedRecords: Record<string, unknown>[];+ } {+ const formattedRecords = records.map((record) =>+ formatData(+ record,+ this.options.flatObjectMetadata,+ this.options.internalContext.flatFieldMetadataMaps,+ ),+ );++ const columnNameSet = new Set<string>();++ for (const record of formattedRecords) {+ for (const columnName of Object.keys(record)) {+ if (+ !isDefined(+ this.options.tableShape.columnShapeByColumnName[columnName],+ )+ ) {+ throw new TwentyOrmV2Exception(+ `Column "${columnName}" does not exist on "${this.options.tableShape.nameSingular}"`,+ TwentyOrmV2ExceptionCode.UNKNOWN_COLUMN,+ );+ }+ columnNameSet.add(columnName);+ }+ }++ const columnNames = [...columnNameSet];+ const parameters: Record<string, unknown> = {};+ let parameterSequence = 0;++ const rows = formattedRecords.map((record) => {+ const valueByColumnName: Record<string, unknown> = { ...record };++ return columnNames.map((columnName): InsertRowValue => {+ if (!(columnName in valueByColumnName)) {+ return { kind: 'default' };+ }++ const parameterName = `ormV2Insert_${parameterSequence++}`;++ parameters[parameterName] = serializeJsonbWriteValue(+ this.options.tableShape.columnShapeByColumnName[columnName],+ valueByColumnName[columnName],+ );++ return { kind: 'parameter', parameterName };+ });+ });++ return {+ columnNames,+ rows,+ parameters,+ insertedColumns: columnNames,+ formattedRecords,+ };+ }++ private async emitCreateEvents(insertedIds: string[]): Promise<void> {+ if (insertedIds.length === 0) {+ return;+ }++ const recordsAfter = await this.buildIdsEventSnapshotQueryBuilder(+ insertedIds,+ ).getMany<ObjectRecord>({ noFormatting: true });++ const formattedAfter = this.formatResult<ObjectRecord[]>(recordsAfter);++ for (const action of [+ DatabaseEventAction.CREATED,+ DatabaseEventAction.UPSERTED,+ ]) {+ const event = formatTwentyOrmEventToDatabaseBatchEvent({+ action,+ objectMetadataItem: this.options.flatObjectMetadata,+ flatFieldMetadataMaps:+ this.options.internalContext.flatFieldMetadataMaps,+ workspaceId: this.options.internalContext.workspaceId,+ recordsAfter: formattedAfter,+ authContext: this.options.authContext,+ });++ if (isDefined(event)) {+ this.options.internalContext.eventEmitterService.emitDatabaseBatchEvent(+ event,+ );+ }+ }+ }++ private buildBypassingEventSelectQueryBuilder(+ alias: string,+ ): WorkspaceSelectQueryBuilderV2 {+ return new WorkspaceSelectQueryBuilderV2(alias, {+ tableShape: this.options.tableShape,+ executor: this.options.executor,+ objectRecordsPermissions: this.options.objectRecordsPermissions,+ tableShapeByObjectMetadataId: this.options.tableShapeByObjectMetadataId,+ onBeforeExecute: () => undefined,+ formatResult: (records) => this.formatResult(records),+ });+ }++ private buildIdsEventSnapshotQueryBuilder(+ ids: string[],+ ): WorkspaceSelectQueryBuilderV2 {+ return this.buildBypassingEventSelectQueryBuilder(+ this.options.tableShape.nameSingular,+ )+ .where({ id: In(ids) })+ .withDeleted();+ }+async runMutation({selectQueryBuilder,rowLevelPermissionsApplied,@@ -117,21 +453,6 @@ export class WorkspaceRepositoryV2 {this.applyRowLevelPermissionPredicates(selectQueryBuilder);}- const setColumns =- kind === 'update' && isDefined(data)- ? formatData(- data,- this.options.flatObjectMetadata,- this.options.internalContext.flatFieldMetadataMaps,- )- : undefined;-- this.validateWriteIsPermitted({- operationType: kind,- columnsToReturn,- updatedColumns: isDefined(setColumns) ? Object.keys(setColumns) : [],- });-const eventSelectQueryBuilder =this.buildEventSnapshotQueryBuilder(selectQueryBuilder);@@ -154,6 +475,55 @@ export class WorkspaceRepositoryV2 {);}+ let filesFieldFileIds = null;+ let dataToWrite = data;++ if (kind === 'update' && isDefined(data)) {+ const formattedBefore = this.formatResult<ObjectRecord[]>(recordsBefore);+ const filesFieldDiff =+ this.filesFieldSync.computeFilesFieldDiffBeforeUpdateOne(+ data,+ this.options.tableShape.nameSingular,+ formattedBefore,+ );++ if (isDefined(filesFieldDiff)) {+ const enriched = await this.filesFieldSync.enrichFilesFields({+ entities: formattedBefore.map(() => data),+ filesFieldDiffByEntityIndex: filesFieldDiff,+ workspaceId: this.options.internalContext.workspaceId,+ target: this.options.tableShape.nameSingular,+ });++ filesFieldFileIds = enriched.fileIds;+ dataToWrite = enriched.entities[0] as Partial<ObjectRecord>;+ }+ }++ const setColumns =+ kind === 'update' && isDefined(dataToWrite)+ ? formatData(+ dataToWrite,+ this.options.flatObjectMetadata,+ this.options.internalContext.flatFieldMetadataMaps,+ )+ : undefined;++ this.validateWriteIsPermitted({+ operationType: kind,+ columnsToReturn,+ updatedColumns: isDefined(setColumns) ? Object.keys(setColumns) : [],+ });++ if (kind === 'update' && isDefined(setColumns)) {+ this.validateRLSPredicatesForWrittenRecords(+ this.formatResult<ObjectRecord[]>(+ recordsBefore.map((record) => ({ ...record, ...setColumns })),+ ),+ 'Updated record does not satisfy row-level security constraints of your current role',+ );+ }+const mutationResult = await this.morphAndExecute({selectQueryBuilder,kind,@@ -161,6 +531,10 @@ export class WorkspaceRepositoryV2 {setColumns,});+ if (isDefined(filesFieldFileIds)) {+ await this.filesFieldSync.updateFileEntityRecords(filesFieldFileIds);+ }+const recordsAfter =kind === 'delete'? undefined@@ -205,19 +579,9 @@ export class WorkspaceRepositoryV2 {private buildEventSnapshotQueryBuilder(source: WorkspaceSelectQueryBuilderV2,): WorkspaceSelectQueryBuilderV2 {- const eventSelectQueryBuilder = new WorkspaceSelectQueryBuilderV2(- source.alias,- {- tableShape: this.options.tableShape,- executor: this.options.executor,- objectRecordsPermissions: this.options.objectRecordsPermissions,- tableShapeByObjectMetadataId: this.options.tableShapeByObjectMetadataId,- onBeforeExecute: () => undefined,- formatResult: (records) => this.formatResult(records),- },- );-- return eventSelectQueryBuilder.copyWhereFrom(source).withDeleted();+ return this.buildBypassingEventSelectQueryBuilder(source.alias)+ .copyWhereFrom(source)+ .withDeleted();}private validateWriteIsPermitted({@@ -225,7 +589,7 @@ export class WorkspaceRepositoryV2 {columnsToReturn,updatedColumns,}: {- operationType: MutationKind;+ operationType: MutationKind | 'insert';columnsToReturn: string[];updatedColumns: string[];}): void {@@ -248,6 +612,20 @@ export class WorkspaceRepositoryV2 {});}+ private validateRLSPredicatesForWrittenRecords(+ records: ObjectRecord[],+ errorMessage?: string,+ ): void {+ validateRLSPredicatesForRecords({+ records,+ objectMetadata: this.options.flatObjectMetadata,+ internalContext: this.options.internalContext,+ authContext: this.options.authContext,+ shouldBypassPermissionChecks: this.options.shouldBypassPermissionChecks,+ ...(isDefined(errorMessage) ? { errorMessage } : {}),+ });+ }+private emitMutationEvent({kind,recordsBefore,diff --git a/packages/twenty-server/src/engine/twenty-orm-v2/sql/utils/__tests__/build-insert-statement.util.spec.ts b/packages/twenty-server/src/engine/twenty-orm-v2/sql/utils/__tests__/build-insert-statement.util.spec.tsnew file mode 100644index 00000000000..4b7a64213a1--- /dev/null+++ b/packages/twenty-server/src/engine/twenty-orm-v2/sql/utils/__tests__/build-insert-statement.util.spec.ts@@ -0,0 +1,99 @@+import { FieldMetadataType } from 'twenty-shared/types';++import { TwentyOrmV2Exception } from 'src/engine/twenty-orm-v2/exceptions/twenty-orm-v2.exception';+import { buildInsertStatement } from 'src/engine/twenty-orm-v2/sql/utils/build-insert-statement.util';+import { type WorkspaceTableShape } from 'src/engine/twenty-orm-v2/table-shape/types/workspace-table-shape.type';++const SCHEMA_NAME = 'workspace_1wgvd1injqtife6y4rvfbu3h5';++const buildColumn = (columnName: string) => ({+ columnName,+ fieldMetadataId: `field-${columnName}`,+ fieldName: columnName,+ fieldMetadataType: FieldMetadataType.TEXT,+});++const personTableShape: WorkspaceTableShape = {+ objectMetadataId: 'person-object-id',+ nameSingular: 'person',+ schemaName: SCHEMA_NAME,+ tableName: 'person',+ columnShapeByColumnName: {+ id: buildColumn('id'),+ nameFirstName: buildColumn('nameFirstName'),+ jobTitle: buildColumn('jobTitle'),+ },+ columnNames: ['id', 'nameFirstName', 'jobTitle'],+ relationShapeByFieldName: {},+ hasDeletedAtColumn: false,+};++describe('buildInsertStatement', () => {+ it('should build a single-row insert with RETURNING', () => {+ expect(+ buildInsertStatement({+ tableShape: personTableShape,+ columnNames: ['id', 'jobTitle'],+ rows: [+ [+ { kind: 'parameter', parameterName: 'ormV2Insert_0' },+ { kind: 'parameter', parameterName: 'ormV2Insert_1' },+ ],+ ],+ returningColumns: ['id', 'jobTitle'],+ }),+ ).toBe(+ `INSERT INTO "${SCHEMA_NAME}"."person" ("id", "jobTitle") ` ++ 'VALUES (:ormV2Insert_0, :ormV2Insert_1) ' ++ 'RETURNING "id", "jobTitle"',+ );+ });++ it('should emit DEFAULT for columns a row omits', () => {+ expect(+ buildInsertStatement({+ tableShape: personTableShape,+ columnNames: ['id', 'jobTitle'],+ rows: [+ [+ { kind: 'parameter', parameterName: 'ormV2Insert_0' },+ { kind: 'parameter', parameterName: 'ormV2Insert_1' },+ ],+ [+ { kind: 'parameter', parameterName: 'ormV2Insert_2' },+ { kind: 'default' },+ ],+ ],+ returningColumns: ['id'],+ }),+ ).toBe(+ `INSERT INTO "${SCHEMA_NAME}"."person" ("id", "jobTitle") ` ++ 'VALUES (:ormV2Insert_0, :ormV2Insert_1), (:ormV2Insert_2, DEFAULT) ' ++ 'RETURNING "id"',+ );+ });++ it('should omit RETURNING when no columns are requested', () => {+ expect(+ buildInsertStatement({+ tableShape: personTableShape,+ columnNames: ['id'],+ rows: [[{ kind: 'parameter', parameterName: 'ormV2Insert_0' }]],+ returningColumns: [],+ }),+ ).toBe(+ `INSERT INTO "${SCHEMA_NAME}"."person" ("id") VALUES (:ormV2Insert_0)`,+ );+ });++ it('should reject an insert with no rows', () => {+ expect(() =>+ buildInsertStatement({+ tableShape: personTableShape,+ columnNames: ['id'],+ rows: [],+ returningColumns: ['id'],+ }),+ ).toThrow(TwentyOrmV2Exception);+ });+});diff --git a/packages/twenty-server/src/engine/twenty-orm-v2/sql/utils/__tests__/serialize-jsonb-write-value.util.spec.ts b/packages/twenty-server/src/engine/twenty-orm-v2/sql/utils/__tests__/serialize-jsonb-write-value.util.spec.tsnew file mode 100644index 00000000000..52a4847ac30--- /dev/null+++ b/packages/twenty-server/src/engine/twenty-orm-v2/sql/utils/__tests__/serialize-jsonb-write-value.util.spec.ts@@ -0,0 +1,68 @@+import { FieldMetadataType } from 'twenty-shared/types';++import { serializeJsonbWriteValue } from 'src/engine/twenty-orm-v2/sql/utils/serialize-jsonb-write-value.util';+import { type WorkspaceColumnShape } from 'src/engine/twenty-orm-v2/table-shape/types/workspace-table-shape.type';++const columnShape = (+ fieldMetadataType: FieldMetadataType,+): WorkspaceColumnShape => ({+ columnName: 'someColumn',+ fieldMetadataId: 'field-id',+ fieldName: 'someField',+ fieldMetadataType,+});++describe('serializeJsonbWriteValue', () => {+ it('stringifies an array value for a RAW_JSON column', () => {+ const value = [{ url: 'https://twenty.com', label: 'Twenty' }];++ expect(+ serializeJsonbWriteValue(columnShape(FieldMetadataType.RAW_JSON), value),+ ).toBe('[{"url":"https://twenty.com","label":"Twenty"}]');+ });++ it('stringifies an array value for a FILES column', () => {+ const value = [{ fileId: 'file-1', label: 'doc.pdf' }];++ expect(+ serializeJsonbWriteValue(columnShape(FieldMetadataType.FILES), value),+ ).toBe('[{"fileId":"file-1","label":"doc.pdf"}]');+ });++ it('stringifies an object value for a jsonb column', () => {+ expect(+ serializeJsonbWriteValue(columnShape(FieldMetadataType.RAW_JSON), {+ a: 1,+ }),+ ).toBe('{"a":1}');+ });++ it('passes null through for a jsonb column so it binds SQL NULL', () => {+ expect(+ serializeJsonbWriteValue(columnShape(FieldMetadataType.RAW_JSON), null),+ ).toBeNull();+ });++ it('leaves a non-jsonb text value untouched', () => {+ expect(+ serializeJsonbWriteValue(columnShape(FieldMetadataType.TEXT), 'hello'),+ ).toBe('hello');+ });++ it('leaves a MULTI_SELECT array untouched so pg renders a Postgres array literal', () => {+ const value = ['A', 'B'];++ expect(+ serializeJsonbWriteValue(+ columnShape(FieldMetadataType.MULTI_SELECT),+ value,+ ),+ ).toBe(value);+ });++ it('returns the value unchanged when the column shape is unknown', () => {+ const value = [1, 2, 3];++ expect(serializeJsonbWriteValue(undefined, value)).toBe(value);+ });+});diff --git a/packages/twenty-server/src/engine/twenty-orm-v2/sql/utils/build-insert-statement.util.ts b/packages/twenty-server/src/engine/twenty-orm-v2/sql/utils/build-insert-statement.util.tsnew file mode 100644index 00000000000..f17e111019b--- /dev/null+++ b/packages/twenty-server/src/engine/twenty-orm-v2/sql/utils/build-insert-statement.util.ts@@ -0,0 +1,63 @@+import { escapeIdentifier } from 'src/engine/workspace-manager/workspace-migration/utils/remove-sql-injection.util';+import {+ TwentyOrmV2Exception,+ TwentyOrmV2ExceptionCode,+} from 'src/engine/twenty-orm-v2/exceptions/twenty-orm-v2.exception';+import { type WorkspaceTableShape } from 'src/engine/twenty-orm-v2/table-shape/types/workspace-table-shape.type';++export type InsertRowValue =+ | { kind: 'parameter'; parameterName: string }+ | { kind: 'default' };++export type InsertStatementState = {+ tableShape: WorkspaceTableShape;+ columnNames: string[];+ rows: InsertRowValue[][];+ returningColumns: string[];+};++const buildReturningClause = (returningColumns: string[]): string => {+ if (returningColumns.length === 0) {+ return '';+ }++ const expressions = returningColumns.map((columnName) =>+ escapeIdentifier(columnName),+ );++ return `RETURNING ${expressions.join(', ')}`;+};++export const buildInsertStatement = (state: InsertStatementState): string => {+ if (state.columnNames.length === 0 || state.rows.length === 0) {+ throw new TwentyOrmV2Exception(+ `An INSERT on "${state.tableShape.nameSingular}" needs at least one column and one row`,+ TwentyOrmV2ExceptionCode.INVALID_QUERY,+ );+ }++ const columnList = state.columnNames+ .map((columnName) => escapeIdentifier(columnName))+ .join(', ');++ const valuesList = state.rows+ .map(+ (row) =>+ `(${row+ .map((value) =>+ value.kind === 'default' ? 'DEFAULT' : `:${value.parameterName}`,+ )+ .join(', ')})`,+ )+ .join(', ');++ return [+ `INSERT INTO ${escapeIdentifier(state.tableShape.schemaName)}.${escapeIdentifier(+ state.tableShape.tableName,+ )} (${columnList})`,+ `VALUES ${valuesList}`,+ buildReturningClause(state.returningColumns),+ ]+ .filter((part) => part.length > 0)+ .join(' ');+};diff --git a/packages/twenty-server/src/engine/twenty-orm-v2/sql/utils/build-select-statement.util.ts b/packages/twenty-server/src/engine/twenty-orm-v2/sql/utils/build-select-statement.util.tsindex af66061ec73..86ff880a922 100644--- a/packages/twenty-server/src/engine/twenty-orm-v2/sql/utils/build-select-statement.util.ts+++ b/packages/twenty-server/src/engine/twenty-orm-v2/sql/utils/build-select-statement.util.ts@@ -1,6 +1,6 @@import { isDefined } from 'twenty-shared/utils';-import { type RelationType } from 'src/engine/metadata-modules/field-metadata/interfaces/relation-type.interface';+import { RelationType } from 'src/engine/metadata-modules/field-metadata/interfaces/relation-type.interface';import { escapeIdentifier } from 'src/engine/workspace-manager/workspace-migration/utils/remove-sql-injection.util';import { buildColumnResultAlias } from 'src/engine/twenty-orm-v2/sql/utils/build-column-result-alias.util';@@ -21,6 +21,7 @@ export type JoinClause = {targetTableShape: WorkspaceTableShape;relationType: RelationType;condition?: string;+ toManyForeignKeyColumnName?: string;additionalOnConditions: string[];};@@ -150,6 +151,23 @@ export const buildFromClause = (state: SelectStatementState): string =>state.tableShape.tableName,)} AS ${escapeIdentifier(state.alias)}`;+const buildToManyDedupedJoinSource = ({+ tableExpression,+ foreignKeyColumnName,+ includeSoftDeleteFilter,+}: {+ tableExpression: string;+ foreignKeyColumnName: string;+ includeSoftDeleteFilter: boolean;+}): string => {+ const foreignKey = escapeIdentifier(foreignKeyColumnName);+ const whereClause = includeSoftDeleteFilter+ ? ` WHERE ${escapeIdentifier('deletedAt')} IS NULL`+ : '';++ return `(SELECT DISTINCT ON (${foreignKey}) * FROM ${tableExpression}${whereClause} ORDER BY ${foreignKey}, ${escapeIdentifier('id')})`;+};+export const buildJoinClause = (state: SelectStatementState): string =>state.joinClauses.map((joinClause) => {@@ -160,27 +178,46 @@ export const buildJoinClause = (state: SelectStatementState): string =>);}+ const softDeletePredicateApplies =+ !state.includeDeleted && joinClause.targetTableShape.hasDeletedAtColumn;++ const toManyForeignKeyColumnName =+ joinClause.relationType === RelationType.ONE_TO_MANY+ ? joinClause.toManyForeignKeyColumnName+ : undefined;+const onConditions = [joinClause.condition,...joinClause.additionalOnConditions,];+ // A to-one join filters soft-deleted rows in its ON clause. The deduped+ // to-many join picks one representative row per parent, so its soft-delete+ // filter runs inside the derived table before that pick.if (- !state.includeDeleted &&- joinClause.targetTableShape.hasDeletedAtColumn+ softDeletePredicateApplies &&+ !isDefined(toManyForeignKeyColumnName)) {onConditions.push(`${quoteColumn(joinClause.alias, 'deletedAt')} IS NULL`,);}- return `LEFT JOIN ${escapeIdentifier(+ const tableExpression = `${escapeIdentifier(joinClause.targetTableShape.schemaName,- )}.${escapeIdentifier(- joinClause.targetTableShape.tableName,- )} AS ${escapeIdentifier(joinClause.alias)} ON ${onConditions- .map((condition) => `(${condition})`)- .join(' AND ')}`;+ )}.${escapeIdentifier(joinClause.targetTableShape.tableName)}`;++ const joinSource = isDefined(toManyForeignKeyColumnName)+ ? buildToManyDedupedJoinSource({+ tableExpression,+ foreignKeyColumnName: toManyForeignKeyColumnName,+ includeSoftDeleteFilter: softDeletePredicateApplies,+ })+ : tableExpression;++ return `LEFT JOIN ${joinSource} AS ${escapeIdentifier(+ joinClause.alias,+ )} ON ${onConditions.map((condition) => `(${condition})`).join(' AND ')}`;}).join(' ');diff --git a/packages/twenty-server/src/engine/twenty-orm-v2/sql/utils/serialize-jsonb-write-value.util.ts b/packages/twenty-server/src/engine/twenty-orm-v2/sql/utils/serialize-jsonb-write-value.util.tsnew file mode 100644index 00000000000..90e051fe359--- /dev/null+++ b/packages/twenty-server/src/engine/twenty-orm-v2/sql/utils/serialize-jsonb-write-value.util.ts@@ -0,0 +1,28 @@+import { FieldMetadataType } from 'twenty-shared/types';+import { isDefined } from 'twenty-shared/utils';++import { type WorkspaceColumnShape } from 'src/engine/twenty-orm-v2/table-shape/types/workspace-table-shape.type';++const isJsonbFieldMetadataType = (+ fieldMetadataType: FieldMetadataType,+): boolean =>+ fieldMetadataType === FieldMetadataType.RAW_JSON ||+ fieldMetadataType === FieldMetadataType.FILES;++// TypeORM's jsonb column transformer JSON.stringify-ed values on write. The v2+// path binds straight to `pg`, which stringifies a plain object but encodes a JS+// array as a Postgres array literal — invalid for jsonb. Mirror the transformer+// so composite array sub-columns (secondaryLinks, additionalEmails, ...) and+// FILES values reach jsonb columns as JSON text.+export const serializeJsonbWriteValue = (+ columnShape: WorkspaceColumnShape | undefined,+ value: unknown,+): unknown => {+ if (!isDefined(columnShape) || !isDefined(value)) {+ return value;+ }++ return isJsonbFieldMetadataType(columnShape.fieldMetadataType)+ ? JSON.stringify(value)+ : value;+};