Skip to content

The open alternative to Salesforce, designed for AI.

feat(server): ORM v2 workspace repository read-family methods (#24170)

Charles Bochet9a1233d1cf27
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 18c6d6c393e..ba259455dd9 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
@@ -67,7 +67,10 @@ 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 {
+ type ConnectQueryRunner,
+ 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';
@@ -358,10 +361,19 @@ export abstract class CommonBaseQueryRunnerService<
? await this.globalWorkspaceOrmManager.getGlobalWorkspaceDataSourceReplica()
: await this.globalWorkspaceOrmManager.getGlobalWorkspaceDataSource();
- const repository = globalWorkspaceDataSource.getRepository(
- queryRunnerContext.flatObjectMetadata.nameSingular,
- rolePermissionConfig,
- );
+ const repository = context.featureFlagsMap[
+ FeatureFlagKey.IS_ORM_V2_READ_PATH_ENABLED
+ ]
+ ? (this.workspaceDataSourceV2Service
+ .getDataSource({ useReplica: this.isReadOnly })
+ .getRepository(
+ queryRunnerContext.flatObjectMetadata.nameSingular,
+ rolePermissionConfig,
+ ) as unknown as WorkspaceRepository<ObjectLiteral>)
+ : globalWorkspaceDataSource.getRepository(
+ queryRunnerContext.flatObjectMetadata.nameSingular,
+ rolePermissionConfig,
+ );
return {
...queryRunnerContext,
@@ -518,7 +530,7 @@ export abstract class CommonBaseQueryRunnerService<
queryRunnerContext: CommonExtendedQueryRunnerContext;
writeRepository: WorkspaceRepositoryV2;
}): Promise<Partial<ObjectRecord>[]> {
- const { repository, flatObjectMetadata, flatFieldMetadataMaps } =
+ const { flatObjectMetadata, flatFieldMetadataMaps, rolePermissionConfig } =
queryRunnerContext;
const nameSingular = flatObjectMetadata.nameSingular;
@@ -533,11 +545,37 @@ export abstract class CommonBaseQueryRunnerService<
return records;
}
+ const workspaceDataSource = this.workspaceDataSourceV2Service.getDataSource(
+ {
+ useReplica: false,
+ },
+ );
+
+ const connectQueryRunner: ConnectQueryRunner = async ({
+ connectQueryConfig,
+ clause,
+ parameters,
+ }) => {
+ const targetObjectName = connectQueryConfig.targetObjectName;
+ const targetQueryBuilder = workspaceDataSource
+ .getRepository(targetObjectName, rolePermissionConfig)
+ .createQueryBuilder(targetObjectName);
+
+ targetQueryBuilder.select([]);
+ targetQueryBuilder.addSelect(`"${targetObjectName}"."id"`, 'id');
+
+ for (const [field] of connectQueryConfig.recordToConnectConditions[0]) {
+ targetQueryBuilder.addSelect(`"${targetObjectName}"."${field}"`, field);
+ }
+
+ return targetQueryBuilder.where(clause, parameters).getRawMany();
+ };
+
const resolvedRecords =
await relationNestedQueries.processRelationNestedQueries({
entities: records,
relationNestedConfig,
- queryBuilder: repository.createQueryBuilder(nameSingular),
+ connectQueryRunner,
});
const { fieldIdByName } = buildFieldMapsFromFlatObjectMetadata(
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 365264c39cd..f9014677a8a 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
@@ -4,7 +4,13 @@ import { msg } from '@lingui/core/macro';
import { QUERY_MAX_RECORDS } from 'twenty-shared/constants';
import { FeatureFlagKey, ObjectRecord } from 'twenty-shared/types';
import { isDefined } from 'twenty-shared/utils';
-import { FindOptionsRelations, In, InsertResult, ObjectLiteral } from 'typeorm';
+import {
+ Brackets,
+ FindOptionsRelations,
+ In,
+ InsertResult,
+ ObjectLiteral,
+} from 'typeorm';
import { CommonBaseQueryRunnerService } from 'src/engine/api/common/common-query-runners/common-base-query-runner.service';
import { type ConflictingFieldGroup } from 'src/engine/api/common/common-query-runners/common-create-many-query-runner/types/conflicting-field-group.type';
@@ -302,6 +308,10 @@ export class CommonCreateManyQueryRunnerService extends CommonBaseQueryRunnerSer
flatFieldMetadataMaps,
args,
conflictingFieldGroups,
+ isOrmV2Enabled:
+ queryRunnerContext.featureFlagsMap[
+ FeatureFlagKey.IS_ORM_V2_READ_PATH_ENABLED
+ ],
});
const { recordsToUpdate, recordsToInsert } = categorizeRecords(
@@ -392,12 +402,14 @@ export class CommonCreateManyQueryRunnerService extends CommonBaseQueryRunnerSer
flatFieldMetadataMaps,
args,
conflictingFieldGroups,
+ isOrmV2Enabled,
}: {
repository: WorkspaceRepository<ObjectLiteral>;
flatObjectMetadata: FlatObjectMetadata;
flatFieldMetadataMaps: FlatEntityMaps<FlatFieldMetadata>;
args: CreateManyQueryArgs;
conflictingFieldGroups: ConflictingFieldGroup[];
+ isOrmV2Enabled: boolean;
}): Promise<PartialObjectRecordWithId[]> {
const queryBuilder = repository.createQueryBuilder(
flatObjectMetadata.nameSingular,
@@ -412,9 +424,23 @@ export class CommonCreateManyQueryRunnerService extends CommonBaseQueryRunnerSer
return [];
}
- whereConditions.forEach((condition) => {
- queryBuilder.orWhere(condition);
- });
+ if (isOrmV2Enabled) {
+ queryBuilder.andWhere(
+ new Brackets((qb) => {
+ whereConditions.forEach((condition, index) => {
+ if (index === 0) {
+ qb.where(condition);
+ } else {
+ qb.orWhere(condition);
+ }
+ });
+ }),
+ );
+ } else {
+ whereConditions.forEach((condition) => {
+ queryBuilder.orWhere(condition);
+ });
+ }
const restrictedFields =
repository.objectRecordsPermissions?.[flatObjectMetadata.id]
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 21a00de6b68..f2c9d11304e 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
@@ -117,6 +117,22 @@ export class WorkspaceDataSourceV2 {
);
}
+ return this.buildRepositoryForObjectMetadataId({
+ objectMetadataId,
+ rolePermissionConfig,
+ executor,
+ });
+ }
+
+ private buildRepositoryForObjectMetadataId({
+ objectMetadataId,
+ rolePermissionConfig,
+ executor,
+ }: {
+ objectMetadataId: string;
+ rolePermissionConfig?: RolePermissionConfig;
+ executor: QueryExecutorV2;
+ }): WorkspaceRepositoryV2 {
const flatObjectMetadata =
this.getFlatObjectMetadataOrThrow(objectMetadataId);
@@ -138,6 +154,12 @@ export class WorkspaceDataSourceV2 {
this.getTableShape(targetObjectMetadataId),
flatObjectMetadataByObjectMetadataId: (targetObjectMetadataId) =>
this.getFlatObjectMetadataOrThrow(targetObjectMetadataId),
+ getRepositoryForObjectMetadataId: (targetObjectMetadataId) =>
+ this.buildRepositoryForObjectMetadataId({
+ objectMetadataId: targetObjectMetadataId,
+ rolePermissionConfig,
+ executor,
+ }),
});
}
diff --git a/packages/twenty-server/src/engine/twenty-orm-v2/exceptions/twenty-orm-v2.exception.ts b/packages/twenty-server/src/engine/twenty-orm-v2/exceptions/twenty-orm-v2.exception.ts
index a7437c8dac5..f91901dc7da 100644
--- a/packages/twenty-server/src/engine/twenty-orm-v2/exceptions/twenty-orm-v2.exception.ts
+++ b/packages/twenty-server/src/engine/twenty-orm-v2/exceptions/twenty-orm-v2.exception.ts
@@ -14,6 +14,7 @@ export enum TwentyOrmV2ExceptionCode {
MISSING_ALIAS = 'MISSING_ALIAS',
INVALID_QUERY = 'INVALID_QUERY',
TOO_MANY_RECORDS_TO_UPDATE = 'TOO_MANY_RECORDS_TO_UPDATE',
+ ENTITY_NOT_FOUND = 'ENTITY_NOT_FOUND',
}
export class TwentyOrmV2Exception extends CustomException<TwentyOrmV2ExceptionCode> {
diff --git a/packages/twenty-server/src/engine/twenty-orm-v2/query-builder/utils/__tests__/apply-find-options.util.spec.ts b/packages/twenty-server/src/engine/twenty-orm-v2/query-builder/utils/__tests__/apply-find-options.util.spec.ts
new file mode 100644
index 00000000000..26425a0454d
--- /dev/null
+++ b/packages/twenty-server/src/engine/twenty-orm-v2/query-builder/utils/__tests__/apply-find-options.util.spec.ts
@@ -0,0 +1,144 @@
+import { FieldMetadataType } from 'twenty-shared/types';
+import { In } from 'typeorm';
+
+import { applyFindOptionsToQueryBuilder } from 'src/engine/twenty-orm-v2/query-builder/utils/apply-find-options.util';
+import { WorkspaceSelectQueryBuilderV2 } from 'src/engine/twenty-orm-v2/query-builder/workspace-select-query-builder-v2';
+import { type WorkspaceTableShape } from 'src/engine/twenty-orm-v2/table-shape/types/workspace-table-shape.type';
+
+const SCHEMA_NAME = 'workspace_test';
+
+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'),
+ name: buildColumn('name'),
+ companyId: buildColumn('companyId'),
+ deletedAt: buildColumn('deletedAt'),
+ },
+ columnNames: ['id', 'name', 'companyId', 'deletedAt'],
+ relationShapeByFieldName: {},
+ hasDeletedAtColumn: true,
+};
+
+const buildQueryBuilder = () =>
+ new WorkspaceSelectQueryBuilderV2('person', {
+ tableShape: personTableShape,
+ executor: { execute: async () => [] },
+ objectRecordsPermissions: {},
+ tableShapeByObjectMetadataId: () => personTableShape,
+ onBeforeExecute: () => undefined,
+ formatResult: (records) => records as never,
+ });
+
+describe('applyFindOptionsToQueryBuilder', () => {
+ it('returns the query builder unchanged when no options are given', () => {
+ const queryBuilder = buildQueryBuilder();
+
+ expect(applyFindOptionsToQueryBuilder(queryBuilder)).toBe(queryBuilder);
+ expect(queryBuilder.getQuery()).toContain(
+ `FROM "${SCHEMA_NAME}"."person" AS "person" WHERE "person"."deletedAt" IS NULL`,
+ );
+ });
+
+ it('applies an equality where as an AND condition', () => {
+ const queryBuilder = applyFindOptionsToQueryBuilder(buildQueryBuilder(), {
+ where: { name: 'Twenty' },
+ });
+
+ const [text, values] = queryBuilder.getQueryAndParameters();
+
+ expect(text).toContain('"person"."name" = $1');
+ expect(text).toContain('"person"."deletedAt" IS NULL');
+ expect(values).toContain('Twenty');
+ });
+
+ it('applies an In operator as an IN clause', () => {
+ const queryBuilder = applyFindOptionsToQueryBuilder(buildQueryBuilder(), {
+ where: { id: In(['a', 'b']) },
+ });
+
+ const [text, values] = queryBuilder.getQueryAndParameters();
+
+ expect(text).toContain('"person"."id" IN ($1, $2)');
+ expect(values).toEqual(expect.arrayContaining(['a', 'b']));
+ });
+
+ it('renders a null where value as IS NULL', () => {
+ const queryBuilder = applyFindOptionsToQueryBuilder(buildQueryBuilder(), {
+ where: { companyId: null },
+ });
+
+ expect(queryBuilder.getQuery()).toContain('"person"."companyId" IS NULL');
+ });
+
+ it('treats a where array as a bracketed OR so an ANDed predicate covers all branches', () => {
+ const queryBuilder = applyFindOptionsToQueryBuilder(buildQueryBuilder(), {
+ where: [{ name: 'A' }, { name: 'B' }],
+ });
+
+ const [text] = queryBuilder.getQueryAndParameters();
+
+ expect(text).toContain(
+ '((("person"."name" = $1) OR ("person"."name" = $2))) AND "person"."deletedAt" IS NULL',
+ );
+ });
+
+ it('normalizes an array select into the builder column map', () => {
+ const queryBuilder = applyFindOptionsToQueryBuilder(buildQueryBuilder(), {
+ select: ['id', 'name'],
+ });
+
+ expect(queryBuilder.getQuery()).toContain(
+ 'SELECT "person"."id" AS "person_id", "person"."name" AS "person_name"',
+ );
+ });
+
+ it('applies select, order, take and skip', () => {
+ const queryBuilder = applyFindOptionsToQueryBuilder(buildQueryBuilder(), {
+ select: { id: true, name: true },
+ order: { name: 'DESC' },
+ take: 10,
+ skip: 5,
+ });
+
+ const [text, values] = queryBuilder.getQueryAndParameters();
+
+ expect(text).toContain(
+ 'SELECT "person"."id" AS "person_id", "person"."name" AS "person_name"',
+ );
+ expect(text).toContain('ORDER BY "person"."name" DESC');
+ expect(text).toContain('LIMIT $');
+ expect(text).toContain('OFFSET $');
+ expect(values).toEqual(expect.arrayContaining([10, 5]));
+ });
+
+ it('drops the soft-delete predicate when withDeleted is set', () => {
+ const queryBuilder = applyFindOptionsToQueryBuilder(buildQueryBuilder(), {
+ withDeleted: true,
+ });
+
+ expect(queryBuilder.getQuery()).not.toContain(
+ '"person"."deletedAt" IS NULL',
+ );
+ });
+
+ it('ignores relations in the base query (the repository loads them separately)', () => {
+ const queryBuilder = applyFindOptionsToQueryBuilder(buildQueryBuilder(), {
+ where: { id: 'x' },
+ relations: { company: true },
+ });
+
+ expect(queryBuilder.getQuery()).not.toContain('JOIN');
+ expect(queryBuilder.getQuery()).toContain('"person"."id" =');
+ });
+});
diff --git a/packages/twenty-server/src/engine/twenty-orm-v2/query-builder/utils/__tests__/apply-mutation-criteria.util.spec.ts b/packages/twenty-server/src/engine/twenty-orm-v2/query-builder/utils/__tests__/apply-mutation-criteria.util.spec.ts
new file mode 100644
index 00000000000..d3feb7e88af
--- /dev/null
+++ b/packages/twenty-server/src/engine/twenty-orm-v2/query-builder/utils/__tests__/apply-mutation-criteria.util.spec.ts
@@ -0,0 +1,93 @@
+import { FieldMetadataType } from 'twenty-shared/types';
+
+import { TwentyOrmV2Exception } from 'src/engine/twenty-orm-v2/exceptions/twenty-orm-v2.exception';
+import { applyMutationCriteriaToQueryBuilder } from 'src/engine/twenty-orm-v2/query-builder/utils/apply-mutation-criteria.util';
+import { WorkspaceSelectQueryBuilderV2 } from 'src/engine/twenty-orm-v2/query-builder/workspace-select-query-builder-v2';
+import { type WorkspaceTableShape } from 'src/engine/twenty-orm-v2/table-shape/types/workspace-table-shape.type';
+
+const buildColumn = (columnName: string) => ({
+ columnName,
+ fieldMetadataId: `field-${columnName}`,
+ fieldName: columnName,
+ fieldMetadataType: FieldMetadataType.TEXT,
+});
+
+const personTableShape: WorkspaceTableShape = {
+ objectMetadataId: 'person-object-id',
+ nameSingular: 'person',
+ schemaName: 'workspace_test',
+ tableName: 'person',
+ columnShapeByColumnName: {
+ id: buildColumn('id'),
+ name: buildColumn('name'),
+ deletedAt: buildColumn('deletedAt'),
+ },
+ columnNames: ['id', 'name', 'deletedAt'],
+ relationShapeByFieldName: {},
+ hasDeletedAtColumn: true,
+};
+
+const buildQueryBuilder = () =>
+ new WorkspaceSelectQueryBuilderV2('person', {
+ tableShape: personTableShape,
+ executor: { execute: async () => [] },
+ objectRecordsPermissions: {},
+ tableShapeByObjectMetadataId: () => personTableShape,
+ onBeforeExecute: () => undefined,
+ formatResult: (records) => records as never,
+ });
+
+describe('applyMutationCriteriaToQueryBuilder', () => {
+ it('turns a bare id into an equality predicate', () => {
+ const [text, values] = applyMutationCriteriaToQueryBuilder(
+ buildQueryBuilder(),
+ 'record-id',
+ ).getQueryAndParameters();
+
+ expect(text).toContain('"person"."id" = $1');
+ expect(values).toContain('record-id');
+ });
+
+ it('turns a list of ids into an IN predicate', () => {
+ const [text, values] = applyMutationCriteriaToQueryBuilder(
+ buildQueryBuilder(),
+ ['a', 'b'],
+ ).getQueryAndParameters();
+
+ expect(text).toContain('"person"."id" IN ($1, $2)');
+ expect(values).toEqual(expect.arrayContaining(['a', 'b']));
+ });
+
+ it('applies a where object', () => {
+ const [text, values] = applyMutationCriteriaToQueryBuilder(
+ buildQueryBuilder(),
+ { name: 'Twenty' },
+ ).getQueryAndParameters();
+
+ expect(text).toContain('"person"."name" = $1');
+ expect(values).toContain('Twenty');
+ });
+
+ it('treats a where array as a bracketed OR', () => {
+ const [text] = applyMutationCriteriaToQueryBuilder(buildQueryBuilder(), [
+ { name: 'A' },
+ { name: 'B' },
+ ]).getQueryAndParameters();
+
+ expect(text).toContain(
+ '((("person"."name" = $1) OR ("person"."name" = $2)))',
+ );
+ });
+
+ it('throws on an empty criteria array', () => {
+ expect(() =>
+ applyMutationCriteriaToQueryBuilder(buildQueryBuilder(), []),
+ ).toThrow(TwentyOrmV2Exception);
+ });
+
+ it('throws on an empty-string id criterion', () => {
+ expect(() =>
+ applyMutationCriteriaToQueryBuilder(buildQueryBuilder(), ''),
+ ).toThrow(TwentyOrmV2Exception);
+ });
+});
diff --git a/packages/twenty-server/src/engine/twenty-orm-v2/query-builder/utils/apply-find-options.util.ts b/packages/twenty-server/src/engine/twenty-orm-v2/query-builder/utils/apply-find-options.util.ts
new file mode 100644
index 00000000000..79a59037728
--- /dev/null
+++ b/packages/twenty-server/src/engine/twenty-orm-v2/query-builder/utils/apply-find-options.util.ts
@@ -0,0 +1,93 @@
+import { isDefined } from 'twenty-shared/utils';
+
+import { type WorkspaceSelectQueryBuilderV2 } from 'src/engine/twenty-orm-v2/query-builder/workspace-select-query-builder-v2';
+import {
+ type FindOptionsSelectLike,
+ type ObjectWhereLike,
+ type OrderByConditionLike,
+} from 'src/engine/twenty-orm-v2/query-builder/types/query-builder-v2.type';
+
+export type FindOptionsRelationsV2 = {
+ [relationFieldName: string]: boolean | FindOptionsRelationsV2;
+};
+
+export type FindOptionsSelectV2 = FindOptionsSelectLike | string[];
+
+export type FindOptionsV2 = {
+ where?: ObjectWhereLike | ObjectWhereLike[];
+ select?: FindOptionsSelectV2;
+ order?: OrderByConditionLike;
+ take?: number;
+ skip?: number;
+ withDeleted?: boolean;
+ relations?: FindOptionsRelationsV2;
+};
+
+const normalizeSelect = (select: FindOptionsSelectV2): FindOptionsSelectLike =>
+ Array.isArray(select)
+ ? Object.fromEntries(select.map((columnName) => [columnName, true]))
+ : select;
+
+const applyWhere = (
+ queryBuilder: WorkspaceSelectQueryBuilderV2,
+ where: ObjectWhereLike | ObjectWhereLike[],
+): void => {
+ if (!Array.isArray(where)) {
+ queryBuilder.where(where);
+
+ return;
+ }
+
+ if (where.length === 1) {
+ queryBuilder.where(where[0]);
+
+ return;
+ }
+
+ queryBuilder.where({
+ whereFactory: (nestedQueryBuilder) => {
+ where.forEach((clause, index) => {
+ if (index === 0) {
+ nestedQueryBuilder.where(clause);
+ } else {
+ nestedQueryBuilder.orWhere(clause);
+ }
+ });
+ },
+ });
+};
+
+export const applyFindOptionsToQueryBuilder = (
+ queryBuilder: WorkspaceSelectQueryBuilderV2,
+ options?: FindOptionsV2,
+): WorkspaceSelectQueryBuilderV2 => {
+ if (!isDefined(options)) {
+ return queryBuilder;
+ }
+
+ if (options.withDeleted) {
+ queryBuilder.withDeleted();
+ }
+
+ if (isDefined(options.select)) {
+ queryBuilder.setFindOptions({ select: normalizeSelect(options.select) });
+ }
+
+ if (isDefined(options.where)) {
+ applyWhere(queryBuilder, options.where);
+ }
+
+ if (isDefined(options.order)) {
+ queryBuilder.orderBy(options.order);
+ }
+
+ if (isDefined(options.take)) {
+ queryBuilder.limit(options.take);
+ }
+
+ if (isDefined(options.skip)) {
+ queryBuilder.offset(options.skip);
+ }
+
+ return queryBuilder;
+};
diff --git a/packages/twenty-server/src/engine/twenty-orm-v2/query-builder/utils/apply-mutation-criteria.util.ts b/packages/twenty-server/src/engine/twenty-orm-v2/query-builder/utils/apply-mutation-criteria.util.ts
new file mode 100644
index 00000000000..8ecea74e517
--- /dev/null
+++ b/packages/twenty-server/src/engine/twenty-orm-v2/query-builder/utils/apply-mutation-criteria.util.ts
@@ -0,0 +1,77 @@
+import { In } from 'typeorm';
+
+import {
+ TwentyOrmV2Exception,
+ TwentyOrmV2ExceptionCode,
+} from 'src/engine/twenty-orm-v2/exceptions/twenty-orm-v2.exception';
+import { type WorkspaceSelectQueryBuilderV2 } from 'src/engine/twenty-orm-v2/query-builder/workspace-select-query-builder-v2';
+import { type ObjectWhereLike } from 'src/engine/twenty-orm-v2/query-builder/types/query-builder-v2.type';
+
+export type MutationCriteria =
+ | string
+ | string[]
+ | ObjectWhereLike
+ | ObjectWhereLike[];
+
+const isPlainObject = (value: unknown): value is ObjectWhereLike =>
+ typeof value === 'object' &&
+ value !== null &&
+ Object.getPrototypeOf(value) === Object.prototype;
+
+export const applyMutationCriteriaToQueryBuilder = (
+ queryBuilder: WorkspaceSelectQueryBuilderV2,
+ criteria: MutationCriteria,
+): WorkspaceSelectQueryBuilderV2 => {
+ if (typeof criteria === 'string') {
+ if (criteria.length === 0) {
+ throw new TwentyOrmV2Exception(
+ 'A mutation criteria id cannot be an empty string',
+ TwentyOrmV2ExceptionCode.INVALID_PARAMETER,
+ );
+ }
+
+ queryBuilder.where({ id: criteria });
+
+ return queryBuilder;
+ }
+
+ if (Array.isArray(criteria)) {
+ if (criteria.length === 0) {
+ throw new TwentyOrmV2Exception(
+ 'A mutation criteria array cannot be empty',
+ TwentyOrmV2ExceptionCode.INVALID_PARAMETER,
+ );
+ }
+
+ if (criteria.every((entry) => typeof entry === 'string')) {
+ queryBuilder.where({ id: In(criteria) });
+
+ return queryBuilder;
+ }
+
+ if (!criteria.every(isPlainObject)) {
+ throw new TwentyOrmV2Exception(
+ 'A mutation criteria array must be all ids or all where objects',
+ TwentyOrmV2ExceptionCode.INVALID_PARAMETER,
+ );
+ }
+
+ queryBuilder.where({
+ whereFactory: (nestedQueryBuilder) => {
+ criteria.forEach((entry, index) => {
+ if (index === 0) {
+ nestedQueryBuilder.where(entry);
+ } else {
+ nestedQueryBuilder.orWhere(entry);
+ }
+ });
+ },
+ });
+
+ return queryBuilder;
+ }
+
+ queryBuilder.where(criteria);
+
+ return queryBuilder;
+};
diff --git a/packages/twenty-server/src/engine/twenty-orm-v2/repository/utils/__tests__/attach-relations.util.spec.ts b/packages/twenty-server/src/engine/twenty-orm-v2/repository/utils/__tests__/attach-relations.util.spec.ts
new file mode 100644
index 00000000000..030b00b53da
--- /dev/null
+++ b/packages/twenty-server/src/engine/twenty-orm-v2/repository/utils/__tests__/attach-relations.util.spec.ts
@@ -0,0 +1,80 @@
+import { type ObjectRecord } from 'twenty-shared/types';
+
+import {
+ attachToManyRelationToRecords,
+ attachToOneRelationToRecords,
+ collectForeignKeys,
+ collectRecordIds,
+} from 'src/engine/twenty-orm-v2/repository/utils/attach-relations.util';
+
+const asRecords = (records: Record<string, unknown>[]): ObjectRecord[] =>
+ records as ObjectRecord[];
+
+describe('attach-relations util', () => {
+ describe('collectForeignKeys', () => {
+ it('returns unique non-empty foreign keys', () => {
+ const records = asRecords([
+ { id: '1', companyId: 'c1' },
+ { id: '2', companyId: 'c1' },
+ { id: '3', companyId: 'c2' },
+ { id: '4', companyId: null },
+ ]);
+
+ expect(collectForeignKeys(records, 'companyId')).toEqual(['c1', 'c2']);
+ });
+ });
+
+ describe('collectRecordIds', () => {
+ it('returns unique ids', () => {
+ const records = asRecords([{ id: 'a' }, { id: 'a' }, { id: 'b' }]);
+
+ expect(collectRecordIds(records)).toEqual(['a', 'b']);
+ });
+ });
+
+ describe('attachToOneRelationToRecords', () => {
+ it('attaches the matching target or null', () => {
+ const records = asRecords([
+ { id: '1', companyId: 'c1' },
+ { id: '2', companyId: 'c2' },
+ { id: '3', companyId: null },
+ ]);
+ const targets = asRecords([{ id: 'c1', name: 'Twenty' }]);
+
+ attachToOneRelationToRecords({
+ records,
+ fieldName: 'company',
+ joinColumnName: 'companyId',
+ targets,
+ });
+
+ expect(records[0].company).toEqual({ id: 'c1', name: 'Twenty' });
+ expect(records[1].company).toBeNull();
+ expect(records[2].company).toBeNull();
+ });
+ });
+
+ describe('attachToManyRelationToRecords', () => {
+ it('groups children under each parent and defaults to an empty array', () => {
+ const records = asRecords([{ id: 'c1' }, { id: 'c2' }]);
+ const children = asRecords([
+ { id: 'p1', companyId: 'c1' },
+ { id: 'p2', companyId: 'c1' },
+ { id: 'p3', companyId: 'cX' },
+ ]);
+
+ attachToManyRelationToRecords({
+ records,
+ fieldName: 'people',
+ inverseForeignKeyColumnName: 'companyId',
+ children,
+ });
+
+ expect(records[0].people).toEqual([
+ { id: 'p1', companyId: 'c1' },
+ { id: 'p2', companyId: 'c1' },
+ ]);
+ expect(records[1].people).toEqual([]);
+ });
+ });
+});
diff --git a/packages/twenty-server/src/engine/twenty-orm-v2/repository/utils/__tests__/resolve-save-and-upsert.util.spec.ts b/packages/twenty-server/src/engine/twenty-orm-v2/repository/utils/__tests__/resolve-save-and-upsert.util.spec.ts
new file mode 100644
index 00000000000..b34c46781a7
--- /dev/null
+++ b/packages/twenty-server/src/engine/twenty-orm-v2/repository/utils/__tests__/resolve-save-and-upsert.util.spec.ts
@@ -0,0 +1,77 @@
+import { type ObjectRecord } from 'twenty-shared/types';
+
+import {
+ buildConflictKey,
+ matchEntitiesForUpsert,
+ partitionEntitiesForSave,
+} from 'src/engine/twenty-orm-v2/repository/utils/resolve-save-and-upsert.util';
+
+describe('resolve-save-and-upsert util', () => {
+ describe('partitionEntitiesForSave', () => {
+ it('updates entities with an existing id and inserts the rest', () => {
+ const entities = [
+ { id: 'existing', name: 'A' },
+ { id: 'missing', name: 'B' },
+ { name: 'C' },
+ ];
+
+ const { toUpdate, toInsert } = partitionEntitiesForSave(
+ entities,
+ new Set(['existing']),
+ );
+
+ expect(toUpdate).toEqual([{ id: 'existing', name: 'A' }]);
+ expect(toInsert).toEqual([{ id: 'missing', name: 'B' }, { name: 'C' }]);
+ });
+ });
+
+ describe('buildConflictKey', () => {
+ it('is stable across entities with the same conflict values', () => {
+ expect(
+ buildConflictKey({ email: 'a', tenant: 't' }, ['email', 'tenant']),
+ ).toBe(
+ buildConflictKey({ email: 'a', tenant: 't', other: 'x' }, [
+ 'email',
+ 'tenant',
+ ]),
+ );
+ });
+ });
+
+ describe('matchEntitiesForUpsert', () => {
+ it('routes matches to update by existing id and the rest to insert', () => {
+ const entities = [
+ { email: '[email protected]', name: 'A' },
+ { email: '[email protected]', name: 'B' },
+ ];
+ const existing = [
+ { id: 'existing-a', email: '[email protected]' },
+ ] as ObjectRecord[];
+
+ const { toUpdate, toInsert } = matchEntitiesForUpsert(
+ entities,
+ existing,
+ ['email'],
+ );
+
+ expect(toUpdate).toEqual([
+ { id: 'existing-a', entity: { email: '[email protected]', name: 'A' } },
+ ]);
+ expect(toInsert).toEqual([{ email: '[email protected]', name: 'B' }]);
+ });
+
+ it('routes entities with a null conflict value to insert (NULL never conflicts)', () => {
+ const entities = [{ email: null, name: 'A' }];
+ const existing = [{ id: 'existing', email: null }] as ObjectRecord[];
+
+ const { toUpdate, toInsert } = matchEntitiesForUpsert(
+ entities,
+ existing,
+ ['email'],
+ );
+
+ expect(toUpdate).toEqual([]);
+ expect(toInsert).toEqual([{ email: null, name: 'A' }]);
+ });
+ });
+});
diff --git a/packages/twenty-server/src/engine/twenty-orm-v2/repository/utils/attach-relations.util.ts b/packages/twenty-server/src/engine/twenty-orm-v2/repository/utils/attach-relations.util.ts
new file mode 100644
index 00000000000..95d1a5804f2
--- /dev/null
+++ b/packages/twenty-server/src/engine/twenty-orm-v2/repository/utils/attach-relations.util.ts
@@ -0,0 +1,68 @@
+import { isNonEmptyString } from '@sniptt/guards';
+import { type ObjectRecord } from 'twenty-shared/types';
+
+export const collectForeignKeys = (
+ records: ObjectRecord[],
+ joinColumnName: string,
+): string[] => [
+ ...new Set(
+ records.map((record) => record[joinColumnName]).filter(isNonEmptyString),
+ ),
+];
+
+export const collectRecordIds = (records: ObjectRecord[]): string[] => [
+ ...new Set(records.map((record) => record.id).filter(isNonEmptyString)),
+];
+
+export const attachToOneRelationToRecords = ({
+ records,
+ fieldName,
+ joinColumnName,
+ targets,
+}: {
+ records: ObjectRecord[];
+ fieldName: string;
+ joinColumnName: string;
+ targets: ObjectRecord[];
+}): void => {
+ const targetById = new Map(targets.map((target) => [target.id, target]));
+
+ for (const record of records) {
+ const foreignKey = record[joinColumnName];
+
+ record[fieldName] = isNonEmptyString(foreignKey)
+ ? (targetById.get(foreignKey) ?? null)
+ : null;
+ }
+};
+
+export const attachToManyRelationToRecords = ({
+ records,
+ fieldName,
+ inverseForeignKeyColumnName,
+ children,
+}: {
+ records: ObjectRecord[];
+ fieldName: string;
+ inverseForeignKeyColumnName: string;
+ children: ObjectRecord[];
+}): void => {
+ const childrenByParentId = new Map<string, ObjectRecord[]>();
+
+ for (const child of children) {
+ const parentId = child[inverseForeignKeyColumnName];
+
+ if (!isNonEmptyString(parentId)) {
+ continue;
+ }
+
+ const siblings = childrenByParentId.get(parentId) ?? [];
+
+ siblings.push(child);
+ childrenByParentId.set(parentId, siblings);
+ }
+
+ for (const record of records) {
+ record[fieldName] = childrenByParentId.get(record.id) ?? [];
+ }
+};
diff --git a/packages/twenty-server/src/engine/twenty-orm-v2/repository/utils/resolve-save-and-upsert.util.ts b/packages/twenty-server/src/engine/twenty-orm-v2/repository/utils/resolve-save-and-upsert.util.ts
new file mode 100644
index 00000000000..498131a07b1
--- /dev/null
+++ b/packages/twenty-server/src/engine/twenty-orm-v2/repository/utils/resolve-save-and-upsert.util.ts
@@ -0,0 +1,80 @@
+import { isNonEmptyString } from '@sniptt/guards';
+import { type ObjectRecord } from 'twenty-shared/types';
+import { isDefined } from 'twenty-shared/utils';
+
+export type SavePartition = {
+ toUpdate: Partial<ObjectRecord>[];
+ toInsert: Partial<ObjectRecord>[];
+};
+
+export const partitionEntitiesForSave = (
+ entities: Partial<ObjectRecord>[],
+ existingIds: Set<string>,
+): SavePartition => {
+ const toUpdate: Partial<ObjectRecord>[] = [];
+ const toInsert: Partial<ObjectRecord>[] = [];
+
+ for (const entity of entities) {
+ const id = entity.id;
+
+ if (isNonEmptyString(id) && existingIds.has(id)) {
+ toUpdate.push(entity);
+ } else {
+ toInsert.push(entity);
+ }
+ }
+
+ return { toUpdate, toInsert };
+};
+
+export const buildConflictKey = (
+ entity: Partial<ObjectRecord>,
+ conflictPaths: string[],
+): string => JSON.stringify(conflictPaths.map((path) => entity[path] ?? null));
+
+const hasCompleteConflictKey = (
+ record: Partial<ObjectRecord>,
+ conflictPaths: string[],
+): boolean => conflictPaths.every((path) => isDefined(record[path]));
+
+export type UpsertPartition = {
+ toUpdate: { id: string; entity: Partial<ObjectRecord> }[];
+ toInsert: Partial<ObjectRecord>[];
+};
+
+export const matchEntitiesForUpsert = (
+ entities: Partial<ObjectRecord>[],
+ existingRecords: ObjectRecord[],
+ conflictPaths: string[],
+): UpsertPartition => {
+ const existingIdByConflictKey = new Map<string, string>();
+
+ for (const existingRecord of existingRecords) {
+ if (
+ isNonEmptyString(existingRecord.id) &&
+ hasCompleteConflictKey(existingRecord, conflictPaths)
+ ) {
+ existingIdByConflictKey.set(
+ buildConflictKey(existingRecord, conflictPaths),
+ existingRecord.id,
+ );
+ }
+ }
+
+ const toUpdate: { id: string; entity: Partial<ObjectRecord> }[] = [];
+ const toInsert: Partial<ObjectRecord>[] = [];
+
+ for (const entity of entities) {
+ const existingId = hasCompleteConflictKey(entity, conflictPaths)
+ ? existingIdByConflictKey.get(buildConflictKey(entity, conflictPaths))
+ : undefined;
+
+ if (isNonEmptyString(existingId)) {
+ toUpdate.push({ id: existingId, entity });
+ } else {
+ toInsert.push(entity);
+ }
+ }
+
+ return { toUpdate, toInsert };
+};
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 99fbf068ab6..0f38dae3cd2 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
@@ -6,7 +6,7 @@ import {
type ObjectsPermissions,
} from 'twenty-shared/types';
import { isDefined } from 'twenty-shared/utils';
-import { In } from 'typeorm';
+import { DeleteResult, In, InsertResult, UpdateResult } 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';
@@ -30,10 +30,34 @@ import {
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 { RelationType } from 'src/engine/metadata-modules/field-metadata/interfaces/relation-type.interface';
+import {
+ applyFindOptionsToQueryBuilder,
+ type FindOptionsRelationsV2,
+ type FindOptionsV2,
+} from 'src/engine/twenty-orm-v2/query-builder/utils/apply-find-options.util';
+import {
+ applyMutationCriteriaToQueryBuilder,
+ type MutationCriteria,
+} from 'src/engine/twenty-orm-v2/query-builder/utils/apply-mutation-criteria.util';
+import { type ObjectWhereLike } from 'src/engine/twenty-orm-v2/query-builder/types/query-builder-v2.type';
+import {
+ attachToManyRelationToRecords,
+ attachToOneRelationToRecords,
+ collectForeignKeys,
+ collectRecordIds,
+} from 'src/engine/twenty-orm-v2/repository/utils/attach-relations.util';
+import {
+ matchEntitiesForUpsert,
+ partitionEntitiesForSave,
+} from 'src/engine/twenty-orm-v2/repository/utils/resolve-save-and-upsert.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';
+import {
+ type WorkspaceRelationShape,
+ type WorkspaceTableShape,
+} from 'src/engine/twenty-orm-v2/table-shape/types/workspace-table-shape.type';
const MUTATION_EVENT_ACTIONS_BY_KIND: Record<
MutationKind,
@@ -59,6 +83,9 @@ type WorkspaceRepositoryV2Options = {
flatObjectMetadataByObjectMetadataId: (
objectMetadataId: string,
) => FlatObjectMetadata;
+ getRepositoryForObjectMetadataId: (
+ objectMetadataId: string,
+ ) => WorkspaceRepositoryV2;
};
export class WorkspaceRepositoryV2 {
@@ -121,6 +148,531 @@ export class WorkspaceRepositoryV2 {
return this.options.internalContext;
}
+ async find(options?: FindOptionsV2): Promise<ObjectRecord[]> {
+ const records = await applyFindOptionsToQueryBuilder(
+ this.createQueryBuilder(),
+ options,
+ ).getMany<ObjectRecord>();
+
+ if (isDefined(options?.relations)) {
+ await this.loadRelations(
+ records,
+ options.relations,
+ options.withDeleted ?? false,
+ );
+ }
+
+ return records;
+ }
+
+ async findBy(
+ where: ObjectWhereLike | ObjectWhereLike[],
+ ): Promise<ObjectRecord[]> {
+ return this.find({ where });
+ }
+
+ async findOne(options?: FindOptionsV2): Promise<ObjectRecord | null> {
+ if (!isDefined(options?.where)) {
+ throw new TwentyOrmV2Exception(
+ 'findOne requires a "where" condition',
+ TwentyOrmV2ExceptionCode.INVALID_PARAMETER,
+ );
+ }
+
+ const record = await applyFindOptionsToQueryBuilder(
+ this.createQueryBuilder(),
+ options,
+ ).getOne<ObjectRecord>();
+
+ if (isDefined(record) && isDefined(options?.relations)) {
+ await this.loadRelations(
+ [record],
+ options.relations,
+ options.withDeleted ?? false,
+ );
+ }
+
+ return record;
+ }
+
+ async findOneBy(
+ where: ObjectWhereLike | ObjectWhereLike[],
+ ): Promise<ObjectRecord | null> {
+ return this.findOne({ where });
+ }
+
+ async findOneOrFail(options?: FindOptionsV2): Promise<ObjectRecord> {
+ const record = await this.findOne(options);
+
+ if (!isDefined(record)) {
+ throw new TwentyOrmV2Exception(
+ `No "${this.options.tableShape.nameSingular}" record matches the given criteria`,
+ TwentyOrmV2ExceptionCode.ENTITY_NOT_FOUND,
+ );
+ }
+
+ return record;
+ }
+
+ async findOneByOrFail(
+ where: ObjectWhereLike | ObjectWhereLike[],
+ ): Promise<ObjectRecord> {
+ return this.findOneOrFail({ where });
+ }
+
+ async count(options?: FindOptionsV2): Promise<number> {
+ return applyFindOptionsToQueryBuilder(
+ this.createQueryBuilder(),
+ options,
+ ).getCount();
+ }
+
+ async countBy(where: ObjectWhereLike | ObjectWhereLike[]): Promise<number> {
+ return this.count({ where });
+ }
+
+ async exists(options?: FindOptionsV2): Promise<boolean> {
+ const queryBuilder = applyFindOptionsToQueryBuilder(
+ this.createQueryBuilder(),
+ {
+ where: options?.where,
+ withDeleted: options?.withDeleted,
+ },
+ );
+
+ queryBuilder.select(['id']);
+
+ return isDefined(await queryBuilder.getRawOne());
+ }
+
+ async existsBy(where: ObjectWhereLike | ObjectWhereLike[]): Promise<boolean> {
+ return this.exists({ where });
+ }
+
+ private async loadRelations(
+ records: ObjectRecord[],
+ relations: FindOptionsRelationsV2,
+ withDeleted: boolean,
+ ): Promise<void> {
+ if (records.length === 0) {
+ return;
+ }
+
+ for (const [fieldName, nested] of Object.entries(relations)) {
+ if (nested === false) {
+ continue;
+ }
+
+ const relationShape =
+ this.options.tableShape.relationShapeByFieldName[fieldName];
+
+ if (!isDefined(relationShape)) {
+ throw new TwentyOrmV2Exception(
+ `Relation "${fieldName}" does not exist on "${this.options.tableShape.nameSingular}"`,
+ TwentyOrmV2ExceptionCode.UNKNOWN_RELATION,
+ );
+ }
+
+ const nestedRelations = typeof nested === 'object' ? nested : undefined;
+ const targetRepository = this.options.getRepositoryForObjectMetadataId(
+ relationShape.targetObjectMetadataId,
+ );
+
+ if (relationShape.relationType === RelationType.MANY_TO_ONE) {
+ await this.attachToOneRelation({
+ records,
+ fieldName,
+ joinColumnName: relationShape.joinColumnName,
+ targetRepository,
+ nestedRelations,
+ });
+ } else if (relationShape.relationType === RelationType.ONE_TO_MANY) {
+ await this.attachToManyRelation({
+ records,
+ fieldName,
+ relationShape,
+ targetRepository,
+ nestedRelations,
+ withDeleted,
+ });
+ } else {
+ throw new TwentyOrmV2Exception(
+ `Loading "${relationShape.relationType}" relations through find is not supported yet`,
+ TwentyOrmV2ExceptionCode.UNSUPPORTED_OPERATION,
+ );
+ }
+ }
+ }
+
+ private async attachToOneRelation({
+ records,
+ fieldName,
+ joinColumnName,
+ targetRepository,
+ nestedRelations,
+ }: {
+ records: ObjectRecord[];
+ fieldName: string;
+ joinColumnName?: string;
+ targetRepository: WorkspaceRepositoryV2;
+ nestedRelations?: FindOptionsRelationsV2;
+ }): Promise<void> {
+ if (!isDefined(joinColumnName)) {
+ throw new TwentyOrmV2Exception(
+ `Relation "${fieldName}" has no join column to resolve`,
+ TwentyOrmV2ExceptionCode.UNKNOWN_RELATION,
+ );
+ }
+
+ const foreignKeys = collectForeignKeys(records, joinColumnName);
+
+ const targets =
+ foreignKeys.length > 0
+ ? await targetRepository.find({
+ where: { id: In(foreignKeys) },
+ withDeleted: true,
+ relations: nestedRelations,
+ })
+ : [];
+
+ attachToOneRelationToRecords({
+ records,
+ fieldName,
+ joinColumnName,
+ targets,
+ });
+ }
+
+ private async attachToManyRelation({
+ records,
+ fieldName,
+ relationShape,
+ targetRepository,
+ nestedRelations,
+ withDeleted,
+ }: {
+ records: ObjectRecord[];
+ fieldName: string;
+ relationShape: WorkspaceRelationShape;
+ targetRepository: WorkspaceRepositoryV2;
+ nestedRelations?: FindOptionsRelationsV2;
+ withDeleted: boolean;
+ }): Promise<void> {
+ const inverseForeignKeyColumnName =
+ this.resolveInverseForeignKeyColumnName(relationShape);
+
+ const parentIds = collectRecordIds(records);
+
+ const children =
+ parentIds.length > 0
+ ? await targetRepository.find({
+ where: { [inverseForeignKeyColumnName]: In(parentIds) },
+ relations: nestedRelations,
+ withDeleted,
+ })
+ : [];
+
+ attachToManyRelationToRecords({
+ records,
+ fieldName,
+ inverseForeignKeyColumnName,
+ children,
+ });
+ }
+
+ private resolveInverseForeignKeyColumnName(
+ relationShape: WorkspaceRelationShape,
+ ): string {
+ const targetTableShape = this.options.tableShapeByObjectMetadataId(
+ relationShape.targetObjectMetadataId,
+ );
+
+ const inverseRelationShape = Object.values(
+ targetTableShape.relationShapeByFieldName,
+ ).find(
+ (candidate) =>
+ candidate.fieldMetadataId === relationShape.targetFieldMetadataId,
+ );
+
+ if (!isDefined(inverseRelationShape?.joinColumnName)) {
+ throw new TwentyOrmV2Exception(
+ `Could not resolve the inverse foreign key for a to-many relation on "${this.options.tableShape.nameSingular}"`,
+ TwentyOrmV2ExceptionCode.UNKNOWN_RELATION,
+ );
+ }
+
+ return inverseRelationShape.joinColumnName;
+ }
+
+ async insert(
+ entityOrEntities: Partial<ObjectRecord> | Partial<ObjectRecord>[],
+ ): Promise<InsertResult> {
+ const records = Array.isArray(entityOrEntities)
+ ? entityOrEntities
+ : [entityOrEntities];
+
+ const { identifiers, generatedMaps, raw } = await this.runInsert({
+ records,
+ columnsToReturn: ['id'],
+ });
+
+ const insertResult = new InsertResult();
+
+ insertResult.identifiers = identifiers;
+ insertResult.generatedMaps = generatedMaps;
+ insertResult.raw = raw;
+
+ return insertResult;
+ }
+
+ async update(
+ criteria: MutationCriteria,
+ partialEntity: Partial<ObjectRecord>,
+ ): Promise<UpdateResult> {
+ const records = await this.runMutation({
+ selectQueryBuilder: applyMutationCriteriaToQueryBuilder(
+ this.createQueryBuilder(),
+ criteria,
+ ),
+ rowLevelPermissionsApplied: false,
+ kind: 'update',
+ columnsToReturn: ['id'],
+ data: partialEntity,
+ });
+
+ return this.buildUpdateResult(records);
+ }
+
+ async updateMany(
+ inputs: { criteria: string; partialEntity: Partial<ObjectRecord> }[],
+ ): Promise<UpdateResult> {
+ const { generatedMaps, raw } = await this.runBatchUpdate({
+ inputs: inputs.map((input) => ({
+ id: input.criteria,
+ data: input.partialEntity,
+ })),
+ columnsToReturn: ['id'],
+ });
+
+ const updateResult = new UpdateResult();
+
+ updateResult.raw = raw;
+ updateResult.affected = raw.length;
+ updateResult.generatedMaps = generatedMaps;
+
+ return updateResult;
+ }
+
+ async delete(criteria: MutationCriteria): Promise<DeleteResult> {
+ const records = await this.runMutation({
+ selectQueryBuilder: applyMutationCriteriaToQueryBuilder(
+ this.createQueryBuilder(),
+ criteria,
+ ),
+ rowLevelPermissionsApplied: false,
+ kind: 'delete',
+ columnsToReturn: ['id'],
+ });
+
+ const deleteResult = new DeleteResult();
+
+ deleteResult.raw = records;
+ deleteResult.affected = records.length;
+
+ return deleteResult;
+ }
+
+ async softDelete(criteria: MutationCriteria): Promise<UpdateResult> {
+ const records = await this.runMutation({
+ selectQueryBuilder: applyMutationCriteriaToQueryBuilder(
+ this.createQueryBuilder(),
+ criteria,
+ ),
+ rowLevelPermissionsApplied: false,
+ kind: 'soft-delete',
+ columnsToReturn: ['id'],
+ });
+
+ return this.buildUpdateResult(records);
+ }
+
+ async restore(criteria: MutationCriteria): Promise<UpdateResult> {
+ const records = await this.runMutation({
+ selectQueryBuilder: applyMutationCriteriaToQueryBuilder(
+ this.createQueryBuilder(),
+ criteria,
+ ),
+ rowLevelPermissionsApplied: false,
+ kind: 'restore',
+ columnsToReturn: ['id'],
+ });
+
+ return this.buildUpdateResult(records);
+ }
+
+ private buildUpdateResult(records: ObjectRecord[]): UpdateResult {
+ const updateResult = new UpdateResult();
+
+ updateResult.raw = records;
+ updateResult.affected = records.length;
+ updateResult.generatedMaps = records;
+
+ return updateResult;
+ }
+
+ async save(
+ entityOrEntities: Partial<ObjectRecord> | Partial<ObjectRecord>[],
+ ): Promise<ObjectRecord[]> {
+ const entities = Array.isArray(entityOrEntities)
+ ? entityOrEntities
+ : [entityOrEntities];
+
+ this.assertNoNestedRelationObjects(entities);
+
+ if (entities.length === 0) {
+ return [];
+ }
+
+ const idsToCheck = entities
+ .map((entity) => entity.id)
+ .filter(isNonEmptyString);
+
+ const existingIds =
+ idsToCheck.length > 0
+ ? new Set(
+ (await this.findBy({ id: In(idsToCheck) })).map(
+ (record) => record.id,
+ ),
+ )
+ : new Set<string>();
+
+ const { toUpdate, toInsert } = partitionEntitiesForSave(
+ entities,
+ existingIds,
+ );
+
+ const updatedIds = toUpdate
+ .map((entity) => entity.id)
+ .filter(isNonEmptyString);
+
+ if (updatedIds.length > 0) {
+ await this.runBatchUpdate({
+ inputs: toUpdate.flatMap((entity) =>
+ isNonEmptyString(entity.id) ? [{ id: entity.id, data: entity }] : [],
+ ),
+ columnsToReturn: ['id'],
+ });
+ }
+
+ const insertedIds =
+ toInsert.length > 0
+ ? (
+ await this.runInsert({
+ records: toInsert,
+ columnsToReturn: ['id'],
+ })
+ ).identifiers.map((identifier) => identifier.id)
+ : [];
+
+ const savedIds = [...updatedIds, ...insertedIds];
+
+ return savedIds.length > 0
+ ? this.find({ where: { id: In(savedIds) } })
+ : [];
+ }
+
+ async upsert(
+ entityOrEntities: Partial<ObjectRecord> | Partial<ObjectRecord>[],
+ conflictPathsOrOptions: string[] | { conflictPaths: string[] },
+ ): Promise<InsertResult> {
+ const entities = Array.isArray(entityOrEntities)
+ ? entityOrEntities
+ : [entityOrEntities];
+
+ this.assertNoNestedRelationObjects(entities);
+
+ const conflictPaths = Array.isArray(conflictPathsOrOptions)
+ ? conflictPathsOrOptions
+ : conflictPathsOrOptions.conflictPaths;
+
+ if (conflictPaths.length === 0) {
+ throw new TwentyOrmV2Exception(
+ 'upsert requires at least one conflict path',
+ TwentyOrmV2ExceptionCode.INVALID_PARAMETER,
+ );
+ }
+
+ const conflictWhere = entities.map((entity) =>
+ Object.fromEntries(
+ conflictPaths.map((path) => [path, entity[path] ?? null]),
+ ),
+ );
+
+ const existingRecords =
+ entities.length > 0
+ ? await this.find({ where: conflictWhere, withDeleted: true })
+ : [];
+
+ const { toUpdate, toInsert } = matchEntitiesForUpsert(
+ entities,
+ existingRecords,
+ conflictPaths,
+ );
+
+ const emptyOutcome = { identifiers: [], generatedMaps: [], raw: [] };
+
+ const updateOutcome =
+ toUpdate.length > 0
+ ? await this.runBatchUpdate({
+ inputs: toUpdate.map((match) => ({
+ id: match.id,
+ data: match.entity,
+ })),
+ columnsToReturn: ['id'],
+ })
+ : emptyOutcome;
+
+ const insertOutcome =
+ toInsert.length > 0
+ ? await this.runInsert({ records: toInsert, columnsToReturn: ['id'] })
+ : emptyOutcome;
+
+ const insertResult = new InsertResult();
+
+ insertResult.identifiers = [
+ ...updateOutcome.identifiers,
+ ...insertOutcome.identifiers,
+ ];
+ insertResult.generatedMaps = [
+ ...updateOutcome.generatedMaps,
+ ...insertOutcome.generatedMaps,
+ ];
+ insertResult.raw = [...updateOutcome.raw, ...insertOutcome.raw];
+
+ return insertResult;
+ }
+
+ private assertNoNestedRelationObjects(
+ entities: Partial<ObjectRecord>[],
+ ): void {
+ for (const entity of entities) {
+ for (const key of Object.keys(entity)) {
+ const value = entity[key];
+
+ if (
+ isDefined(this.options.tableShape.relationShapeByFieldName[key]) &&
+ typeof value === 'object' &&
+ value !== null
+ ) {
+ throw new TwentyOrmV2Exception(
+ `Writing nested relation "${key}" through the ORM v2 repository is not supported yet`,
+ TwentyOrmV2ExceptionCode.UNSUPPORTED_OPERATION,
+ );
+ }
+ }
+ }
+ }
+
async runInsert({
records,
columnsToReturn,
diff --git a/packages/twenty-server/src/engine/twenty-orm-v2/utils/twenty-orm-v2-to-user-input-error.util.ts b/packages/twenty-server/src/engine/twenty-orm-v2/utils/twenty-orm-v2-to-user-input-error.util.ts
index 12f415bb621..ea87a7c1eb1 100644
--- a/packages/twenty-server/src/engine/twenty-orm-v2/utils/twenty-orm-v2-to-user-input-error.util.ts
+++ b/packages/twenty-server/src/engine/twenty-orm-v2/utils/twenty-orm-v2-to-user-input-error.util.ts
@@ -13,6 +13,7 @@ export const isTwentyOrmV2UserInputError = (
case TwentyOrmV2ExceptionCode.UNKNOWN_RELATION:
case TwentyOrmV2ExceptionCode.UNSUPPORTED_OPERATION:
case TwentyOrmV2ExceptionCode.TOO_MANY_RECORDS_TO_UPDATE:
+ case TwentyOrmV2ExceptionCode.ENTITY_NOT_FOUND:
return true;
default:
return false;
diff --git a/packages/twenty-server/src/engine/twenty-orm/field-operations/relation-nested-queries/relation-nested-queries.ts b/packages/twenty-server/src/engine/twenty-orm/field-operations/relation-nested-queries/relation-nested-queries.ts
index 0ceac5109f1..8658129d4e1 100644
--- a/packages/twenty-server/src/engine/twenty-orm/field-operations/relation-nested-queries/relation-nested-queries.ts
+++ b/packages/twenty-server/src/engine/twenty-orm/field-operations/relation-nested-queries/relation-nested-queries.ts
@@ -28,6 +28,12 @@ import { getAssociatedRelationFieldName } from 'src/engine/twenty-orm/utils/get-
import { getObjectMetadataFromEntityTarget } from 'src/engine/twenty-orm/utils/get-object-metadata-from-entity-target.util';
import { getRecordToConnectFields } from 'src/engine/twenty-orm/utils/get-record-to-connect-fields.util';
+export type ConnectQueryRunner = (args: {
+ connectQueryConfig: RelationConnectQueryConfig;
+ clause: string;
+ parameters: Record<string, unknown>;
+}) => Promise<Record<string, unknown>[]>;
+
export class RelationNestedQueries {
private readonly internalContext: WorkspaceInternalContext;
@@ -88,6 +94,7 @@ export class RelationNestedQueries {
entities,
relationNestedConfig,
queryBuilder,
+ connectQueryRunner,
}: {
entities:
| QueryDeepPartialEntityWithNestedRelationFields<Entity>[]
@@ -96,9 +103,10 @@ export class RelationNestedQueries {
RelationConnectQueryConfig[],
RelationDisconnectQueryFieldsByEntityIndex,
];
- queryBuilder:
+ queryBuilder?:
| WorkspaceSelectQueryBuilder<Entity>
| SelectQueryBuilder<Entity>;
+ connectQueryRunner?: ConnectQueryRunner;
}): Promise<QueryDeepPartialEntity<Entity>[]> {
const entitiesArray = Array.isArray(entities) ? entities : [entities];
@@ -116,6 +124,7 @@ export class RelationNestedQueries {
entities: updatedEntitiesWithDisconnect,
relationConnectQueryConfigs,
queryBuilder,
+ connectQueryRunner,
});
return updatedEntitiesWithConnect;
@@ -125,18 +134,21 @@ export class RelationNestedQueries {
entities,
relationConnectQueryConfigs,
queryBuilder,
+ connectQueryRunner,
}: {
entities: QueryDeepPartialEntityWithNestedRelationFields<Entity>[];
relationConnectQueryConfigs: RelationConnectQueryConfig[];
- queryBuilder:
+ queryBuilder?:
| WorkspaceSelectQueryBuilder<Entity>
| SelectQueryBuilder<Entity>;
+ connectQueryRunner?: ConnectQueryRunner;
}): Promise<QueryDeepPartialEntity<Entity>[]> {
if (relationConnectQueryConfigs.length === 0) return entities;
const recordsToConnectWithConfig = await this.executeConnectQueries(
relationConnectQueryConfigs,
queryBuilder,
+ connectQueryRunner,
);
const updatedEntities = this.updateEntitiesWithRecordToConnectId<Entity>(
@@ -151,7 +163,9 @@ export class RelationNestedQueries {
relationConnectQueryConfigs: RelationConnectQueryConfig[],
queryBuilder:
| WorkspaceSelectQueryBuilder<Entity>
- | SelectQueryBuilder<Entity>,
+ | SelectQueryBuilder<Entity>
+ | undefined,
+ connectQueryRunner?: ConnectQueryRunner,
): Promise<[RelationConnectQueryConfig, Record<string, unknown>[]][]> {
const allRecordsToConnectWithConfig: [
RelationConnectQueryConfig,
@@ -164,17 +178,32 @@ export class RelationNestedQueries {
connectQueryConfig.targetObjectName,
);
- queryBuilder.expressionMap.aliases = [];
- queryBuilder.expressionMap.mainAlias = undefined;
-
- const recordsToConnect = await queryBuilder
- .select(getRecordToConnectFields(connectQueryConfig))
- .where(clause, parameters)
- .from(
- connectQueryConfig.targetObjectName,
- connectQueryConfig.targetObjectName,
- )
- .getRawMany();
+ let recordsToConnect: Record<string, unknown>[];
+
+ if (connectQueryRunner) {
+ recordsToConnect = await connectQueryRunner({
+ connectQueryConfig,
+ clause,
+ parameters,
+ });
+ } else if (queryBuilder) {
+ queryBuilder.expressionMap.aliases = [];
+ queryBuilder.expressionMap.mainAlias = undefined;
+
+ recordsToConnect = await queryBuilder
+ .select(getRecordToConnectFields(connectQueryConfig))
+ .where(clause, parameters)
+ .from(
+ connectQueryConfig.targetObjectName,
+ connectQueryConfig.targetObjectName,
+ )
+ .getRawMany();
+ } else {
+ throw new TwentyORMException(
+ 'A query builder or a connect query runner is required to resolve connect queries',
+ TwentyORMExceptionCode.INVALID_INPUT,
+ );
+ }
allRecordsToConnectWithConfig.push([
connectQueryConfig,