Skip to content

The open alternative to Salesforce, designed for AI.

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.yaml
index d3021d2d234..626f87b1ecc 100644
--- a/.github/workflows/ci-server.yaml
+++ b/.github/workflows/ci-server.yaml
@@ -277,6 +277,10 @@ jobs:
orm-v2: true
- shard: 3
orm-v2: true
+ - shard: 4
+ orm-v2: true
+ - shard: 5
+ orm-v2: true
services:
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: 5
AUTH_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 history
uses: actions/checkout@34e114876b0b11c390a56381ad16ebd13914f8d5 # v4.3.1
diff --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.ts
index 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.ts
index 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 CommonBaseQueryRunnerSer
flatIndexMaps,
args,
workspaceId: authContext.workspace.id,
+ queryRunnerContext,
});
const upsertedRecords = await this.fetchUpsertedRecords({
@@ -213,6 +214,7 @@ export class CommonCreateManyQueryRunnerService extends CommonBaseQueryRunnerSer
flatIndexMaps,
args,
workspaceId,
+ queryRunnerContext,
}: {
repository: WorkspaceRepository<ObjectLiteral>;
flatObjectMetadata: FlatObjectMetadata;
@@ -221,6 +223,7 @@ export class CommonCreateManyQueryRunnerService extends CommonBaseQueryRunnerSer
flatIndexMaps: FlatEntityMaps<FlatIndexMetadata>;
args: CommonExtendedInput<CreateManyQueryArgs>;
workspaceId: string;
+ queryRunnerContext: CommonExtendedQueryRunnerContext;
}): Promise<InsertResult> {
const { selectedFieldsResult } = args;
@@ -233,6 +236,24 @@ export class CommonCreateManyQueryRunnerService extends CommonBaseQueryRunnerSer
flatFieldMetadataMaps,
});
+ 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 CommonBaseQueryRunnerSer
args,
selectedFieldsResult,
workspaceId,
+ queryRunnerContext,
});
}
@@ -257,6 +279,7 @@ export class CommonCreateManyQueryRunnerService extends CommonBaseQueryRunnerSer
args,
selectedFieldsResult,
workspaceId,
+ queryRunnerContext,
}: {
repository: WorkspaceRepository<ObjectLiteral>;
flatObjectMetadata: FlatObjectMetadata;
@@ -266,6 +289,7 @@ export class CommonCreateManyQueryRunnerService extends CommonBaseQueryRunnerSer
args: CreateManyQueryArgs;
selectedFieldsResult: CommonSelectedFieldsResult;
workspaceId: string;
+ queryRunnerContext: CommonExtendedQueryRunnerContext;
}): Promise<InsertResult> {
const conflictingFieldGroups = getConflictingFields(
flatObjectMetadata,
@@ -315,6 +339,7 @@ export class CommonCreateManyQueryRunnerService extends CommonBaseQueryRunnerSer
flatFieldMetadataMaps,
result,
columnsToReturn,
+ queryRunnerContext,
});
}
@@ -323,6 +348,7 @@ export class CommonCreateManyQueryRunnerService extends CommonBaseQueryRunnerSer
repository,
result,
columnsToReturn,
+ queryRunnerContext,
});
return result;
@@ -417,6 +443,7 @@ export class CommonCreateManyQueryRunnerService extends CommonBaseQueryRunnerSer
flatFieldMetadataMaps,
result,
columnsToReturn,
+ queryRunnerContext,
}: {
partialRecordsToUpdate: PartialObjectRecordWithId[];
repository: WorkspaceRepository<ObjectLiteral>;
@@ -424,24 +451,53 @@ export class CommonCreateManyQueryRunnerService extends CommonBaseQueryRunnerSer
flatFieldMetadataMaps: 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 CommonBaseQueryRunnerSer
repository,
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.ts
index 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-runne
import { 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 CommonBaseQueryRunnerServ
const 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 CommonBaseQueryRunnerServ
return 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 CommonBaseQueryRunnerServ
continue;
}
- 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.ts
deleted file mode 100644
index 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.ts
deleted file mode 100644
index 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.ts
index 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/common
import { 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.md
index 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 bas
pins 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 they
are typed against the TypeORM class rather than an interface. Giving the parsers a
structural `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.ts
index 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-m
import { 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.ts
new file mode 100644
index 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.ts
index 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.ts
index 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.ts
index 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.ts
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
index 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.ts
new file mode 100644
index 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;
+};