Skip to content

The open alternative to Salesforce, designed for AI.

Collapse the ORM v1/v2 seams left after the v2 cutover (#24747)

Charles Bochete6ff527d05e4
diff --git a/packages/twenty-server/src/engine/api/common/common-nested-relations-processor/process-nested-relations-orm-v2.helper.ts b/packages/twenty-server/src/engine/api/common/common-nested-relations-processor/process-nested-relations-orm-v2.helper.ts
deleted file mode 100644
index f8ced6275a2..00000000000
--- a/packages/twenty-server/src/engine/api/common/common-nested-relations-processor/process-nested-relations-orm-v2.helper.ts
+++ /dev/null
@@ -1,579 +0,0 @@
-import { Injectable } from '@nestjs/common';
-
-import { FieldMetadataType, type ObjectRecord } from 'twenty-shared/types';
-import { isDefined, isValidUuid } from 'twenty-shared/utils';
-import { type FindOptionsRelations, type ObjectLiteral } from 'typeorm';
-
-import { computeMorphOrRelationFieldJoinColumnName } from 'src/engine/metadata-modules/field-metadata/utils/compute-morph-or-relation-field-join-column-name.util';
-import { RelationType } from 'src/engine/metadata-modules/field-metadata/interfaces/relation-type.interface';
-
-import {
- type ConcurrencyLimiter,
- createConcurrencyLimiter,
-} from 'src/engine/api/common/common-nested-relations-processor/utils/create-concurrency-limiter.util';
-import { getUniqueRelationIds } from 'src/engine/api/common/common-nested-relations-processor/utils/get-unique-relation-ids.util';
-import { STANDARD_ERROR_MESSAGE } from 'src/engine/api/common/common-query-runners/errors/standard-error-message.constant';
-import {
- GraphqlQueryRunnerException,
- GraphqlQueryRunnerExceptionCode,
-} from 'src/engine/api/graphql/graphql-query-runner/errors/graphql-query-runner.exception';
-import { ProcessAggregateHelper } from 'src/engine/api/graphql/graphql-query-runner/helpers/process-aggregate.helper';
-import { buildColumnsToSelect } from 'src/engine/api/graphql/graphql-query-runner/utils/build-columns-to-select';
-import { getTargetObjectMetadataOrThrow } from 'src/engine/api/graphql/graphql-query-runner/utils/get-target-object-metadata.util';
-import { type AggregationField } from 'src/engine/api/graphql/workspace-schema-builder/utils/get-available-aggregations-from-object-fields.util';
-import { type WorkspaceAuthContext } from 'src/engine/core-modules/auth/types/workspace-auth-context.type';
-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,
- type FieldMapsForObject,
-} 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 { type RolePermissionConfig } from 'src/engine/twenty-orm/types/role-permission-config';
-import { type WorkspaceDataSourceV2 } from 'src/engine/twenty-orm-v2/datasource/workspace-data-source-v2';
-import { WorkspaceDataSourceV2Service } from 'src/engine/twenty-orm-v2/datasource/workspace-data-source-v2.service';
-import { type WorkspaceSelectQueryBuilderV2 } from 'src/engine/twenty-orm-v2/query-builder/workspace-select-query-builder-v2';
-import { type WorkspaceRepositoryV2 } from 'src/engine/twenty-orm-v2/repository/workspace-repository-v2';
-import { isFieldMetadataEntityOfType } from 'src/engine/utils/is-field-metadata-of-type.util';
-
-const EMPTY_RELATION_SENTINEL_RECORD_ID =
- '00000000-0000-0000-0000-000000000000';
-const NESTED_RELATION_QUERY_MAX_CONCURRENCY = 4;
-
-type ProcessNestedRelationsOrmV2Args<T extends ObjectRecord = ObjectRecord> = {
- flatObjectMetadataMaps: FlatEntityMaps<FlatObjectMetadata>;
- flatFieldMetadataMaps: FlatEntityMaps<FlatFieldMetadata>;
- parentObjectMetadataItem: FlatObjectMetadata;
- parentObjectRecords: T[];
- // oxlint-disable-next-line typescript/no-explicit-any
- parentObjectRecordsAggregatedValues?: Record<string, any>;
- relations: Record<string, FindOptionsRelations<ObjectLiteral>>;
- aggregate?: Record<string, AggregationField>;
- limit: number;
- authContext: WorkspaceAuthContext;
- useReplica: boolean;
- rolePermissionConfig?: RolePermissionConfig;
- // oxlint-disable-next-line typescript/no-explicit-any
- selectedFields: Record<string, any>;
-};
-
-@Injectable()
-export class ProcessNestedRelationsOrmV2Helper {
- constructor(
- private readonly workspaceDataSourceV2Service: WorkspaceDataSourceV2Service,
- ) {}
-
- public async processNestedRelations<T extends ObjectRecord = ObjectRecord>(
- args: ProcessNestedRelationsOrmV2Args<T>,
- ): Promise<void> {
- const dataSource = this.workspaceDataSourceV2Service.getDataSource({
- useReplica: args.useReplica,
- });
-
- await this.processNestedRelationsWithLimiter(
- args,
- dataSource,
- createConcurrencyLimiter(NESTED_RELATION_QUERY_MAX_CONCURRENCY),
- );
- }
-
- private async processNestedRelationsWithLimiter<
- T extends ObjectRecord = ObjectRecord,
- >(
- {
- flatObjectMetadataMaps,
- flatFieldMetadataMaps,
- parentObjectMetadataItem,
- parentObjectRecords,
- parentObjectRecordsAggregatedValues = {},
- relations,
- aggregate = {},
- limit,
- authContext,
- useReplica,
- rolePermissionConfig,
- selectedFields,
- }: ProcessNestedRelationsOrmV2Args<T>,
- dataSource: WorkspaceDataSourceV2,
- relationQueryLimiter: ConcurrencyLimiter,
- ): Promise<void> {
- const processRelationTasks = Object.entries(relations).map(
- ([sourceFieldName, nestedRelations]) =>
- this.processRelation({
- flatObjectMetadataMaps,
- flatFieldMetadataMaps,
- parentObjectMetadataItem,
- parentObjectRecords,
- parentObjectRecordsAggregatedValues,
- sourceFieldName,
- nestedRelations,
- aggregate,
- limit,
- authContext,
- useReplica,
- dataSource,
- rolePermissionConfig,
- relationQueryLimiter,
- selectedFields:
- selectedFields[sourceFieldName] instanceof Object
- ? selectedFields[sourceFieldName]
- : undefined,
- }),
- );
-
- await Promise.all(processRelationTasks);
- }
-
- private async processRelation<T extends ObjectRecord = ObjectRecord>({
- flatObjectMetadataMaps,
- flatFieldMetadataMaps,
- parentObjectMetadataItem,
- parentObjectRecords,
- parentObjectRecordsAggregatedValues,
- sourceFieldName,
- nestedRelations,
- aggregate,
- limit,
- authContext,
- useReplica,
- dataSource,
- rolePermissionConfig,
- relationQueryLimiter,
- selectedFields,
- }: {
- flatObjectMetadataMaps: FlatEntityMaps<FlatObjectMetadata>;
- flatFieldMetadataMaps: FlatEntityMaps<FlatFieldMetadata>;
- parentObjectMetadataItem: FlatObjectMetadata;
- parentObjectRecords: T[];
- // oxlint-disable-next-line typescript/no-explicit-any
- parentObjectRecordsAggregatedValues: Record<string, any>;
- sourceFieldName: string;
- nestedRelations: FindOptionsRelations<ObjectLiteral>;
- aggregate: Record<string, AggregationField>;
- limit: number;
- authContext: WorkspaceAuthContext;
- useReplica: boolean;
- dataSource: WorkspaceDataSourceV2;
- rolePermissionConfig?: RolePermissionConfig;
- relationQueryLimiter: ConcurrencyLimiter;
- selectedFields: Record<string, unknown>;
- }): Promise<void> {
- const fieldMaps = buildFieldMapsFromFlatObjectMetadata(
- flatFieldMetadataMaps,
- parentObjectMetadataItem,
- );
-
- const sourceFieldMetadata = findFlatEntityByIdInFlatEntityMaps({
- flatEntityId: fieldMaps.fieldIdByName[sourceFieldName],
- flatEntityMaps: flatFieldMetadataMaps,
- });
-
- if (!sourceFieldMetadata) {
- return;
- }
-
- if (
- !isFieldMetadataEntityOfType(
- sourceFieldMetadata,
- FieldMetadataType.RELATION,
- ) &&
- !isFieldMetadataEntityOfType(
- sourceFieldMetadata,
- FieldMetadataType.MORPH_RELATION,
- )
- ) {
- return;
- }
-
- if (!sourceFieldMetadata.settings) {
- throw new GraphqlQueryRunnerException(
- `Relation settings not found for field ${sourceFieldName}`,
- GraphqlQueryRunnerExceptionCode.RELATION_SETTINGS_NOT_FOUND,
- { userFriendlyMessage: STANDARD_ERROR_MESSAGE },
- );
- }
-
- const relationType = sourceFieldMetadata.settings.relationType;
- const { targetRelationName, targetObjectMetadata, targetRelation } =
- this.getTargetObjectMetadata({
- flatObjectMetadataMaps,
- flatFieldMetadataMaps,
- parentObjectMetadataItem,
- sourceFieldName,
- fieldMaps,
- });
-
- const targetObjectRepository = dataSource.getRepository(
- targetObjectMetadata.nameSingular,
- rolePermissionConfig,
- );
-
- const targetObjectNameSingular = targetObjectMetadata.nameSingular;
-
- let targetObjectQueryBuilder = targetObjectRepository.createQueryBuilder(
- targetObjectNameSingular,
- );
-
- const columnsToSelect: Record<string, boolean> = buildColumnsToSelect({
- select: selectedFields,
- relations: nestedRelations,
- flatObjectMetadata: targetObjectMetadata,
- flatObjectMetadataMaps,
- flatFieldMetadataMaps,
- });
-
- if (relationType === RelationType.MANY_TO_ONE) {
- columnsToSelect.deletedAt = true;
- targetObjectQueryBuilder = targetObjectQueryBuilder.withDeleted();
- }
-
- targetObjectQueryBuilder = targetObjectQueryBuilder.setFindOptions({
- select: columnsToSelect,
- });
-
- const joinColumnName = computeMorphOrRelationFieldJoinColumnName({
- name: sourceFieldName,
- });
-
- const relationIds = getUniqueRelationIds({
- records: parentObjectRecords,
- idField:
- relationType === RelationType.ONE_TO_MANY ? 'id' : joinColumnName,
- });
-
- if (
- relationType === RelationType.ONE_TO_MANY &&
- !isDefined(targetRelationName)
- ) {
- throw new GraphqlQueryRunnerException(
- `Could not resolve target relation for one-to-many field ${sourceFieldName}`,
- GraphqlQueryRunnerExceptionCode.RELATION_TARGET_OBJECT_METADATA_NOT_FOUND,
- { userFriendlyMessage: STANDARD_ERROR_MESSAGE },
- );
- }
-
- const fieldMetadataTargetRelationColumnName =
- computeMorphOrRelationFieldJoinColumnName({
- name:
- targetRelation &&
- isFieldMetadataEntityOfType(
- targetRelation,
- FieldMetadataType.MORPH_RELATION,
- )
- ? targetRelation.name
- : (targetRelationName as string),
- });
-
- const { relationResults, relationAggregatedFieldsResult } =
- await relationQueryLimiter(() =>
- this.findRelations({
- referenceQueryBuilder: targetObjectQueryBuilder,
- targetObjectRepository,
- column:
- relationType === RelationType.ONE_TO_MANY
- ? `"${fieldMetadataTargetRelationColumnName}"`
- : 'id',
- ids: relationIds,
- relationType,
- perParentLimit: limit,
- parentRecordsCount: parentObjectRecords.length,
- aggregate,
- sourceFieldName,
- targetObjectNameSingular,
- }),
- );
-
- this.assignRelationResults({
- parentRecords: parentObjectRecords,
- parentObjectRecordsAggregatedValues,
- relationResults,
- relationAggregatedFieldsResult,
- sourceFieldName,
- joinField:
- relationType === RelationType.ONE_TO_MANY
- ? `${fieldMetadataTargetRelationColumnName}`
- : 'id',
- joinColumnName,
- relationType,
- selectedFields,
- });
-
- if (Object.keys(nestedRelations).length > 0) {
- await this.processNestedRelationsWithLimiter(
- {
- flatObjectMetadataMaps,
- flatFieldMetadataMaps,
- parentObjectMetadataItem: targetObjectMetadata,
- parentObjectRecords: relationResults as ObjectRecord[],
- parentObjectRecordsAggregatedValues: relationAggregatedFieldsResult,
- relations: nestedRelations as Record<
- string,
- FindOptionsRelations<ObjectLiteral>
- >,
- aggregate,
- limit,
- authContext,
- useReplica,
- rolePermissionConfig,
- selectedFields,
- },
- dataSource,
- relationQueryLimiter,
- );
- }
- }
-
- private getTargetObjectMetadata({
- flatObjectMetadataMaps,
- flatFieldMetadataMaps,
- parentObjectMetadataItem,
- sourceFieldName,
- fieldMaps,
- }: {
- flatObjectMetadataMaps: FlatEntityMaps<FlatObjectMetadata>;
- flatFieldMetadataMaps: FlatEntityMaps<FlatFieldMetadata>;
- parentObjectMetadataItem: FlatObjectMetadata;
- sourceFieldName: string;
- fieldMaps: FieldMapsForObject;
- }) {
- const targetFieldMetadata = findFlatEntityByIdInFlatEntityMaps({
- flatEntityId: fieldMaps.fieldIdByName[sourceFieldName],
- flatEntityMaps: flatFieldMetadataMaps,
- });
-
- if (!targetFieldMetadata) {
- throw new GraphqlQueryRunnerException(
- `Field ${sourceFieldName} not found on object ${parentObjectMetadataItem.nameSingular}`,
- GraphqlQueryRunnerExceptionCode.FIELD_NOT_FOUND,
- { userFriendlyMessage: STANDARD_ERROR_MESSAGE },
- );
- }
-
- const targetObjectMetadata = getTargetObjectMetadataOrThrow(
- targetFieldMetadata,
- flatObjectMetadataMaps,
- );
-
- if (
- !targetFieldMetadata.relationTargetObjectMetadataId ||
- !targetFieldMetadata.relationTargetFieldMetadataId
- ) {
- throw new GraphqlQueryRunnerException(
- `Relation target object metadata id or field metadata id not found for field ${sourceFieldName}`,
- GraphqlQueryRunnerExceptionCode.RELATION_TARGET_OBJECT_METADATA_NOT_FOUND,
- { userFriendlyMessage: STANDARD_ERROR_MESSAGE },
- );
- }
-
- const targetRelation = findFlatEntityByIdInFlatEntityMaps({
- flatEntityId: targetFieldMetadata.relationTargetFieldMetadataId,
- flatEntityMaps: flatFieldMetadataMaps,
- });
-
- const targetRelationName = targetRelation?.name;
-
- return { targetRelationName, targetObjectMetadata, targetRelation };
- }
-
- private async findRelations({
- referenceQueryBuilder,
- targetObjectRepository,
- column,
- ids,
- relationType,
- perParentLimit,
- parentRecordsCount,
- aggregate,
- sourceFieldName,
- targetObjectNameSingular,
- }: {
- referenceQueryBuilder: WorkspaceSelectQueryBuilderV2;
- targetObjectRepository: WorkspaceRepositoryV2;
- column: string;
- // oxlint-disable-next-line typescript/no-explicit-any
- ids: any[];
- relationType: RelationType;
- perParentLimit: number;
- parentRecordsCount: number;
- // oxlint-disable-next-line typescript/no-explicit-any
- aggregate: Record<string, any>;
- sourceFieldName: string;
- targetObjectNameSingular: string;
- // oxlint-disable-next-line typescript/no-explicit-any
- }): Promise<{ relationResults: any[]; relationAggregatedFieldsResult: any }> {
- if (ids.length === 0) {
- return { relationResults: [], relationAggregatedFieldsResult: {} };
- }
-
- const aggregateForRelation = aggregate[sourceFieldName];
- // oxlint-disable-next-line typescript/no-explicit-any
- let relationAggregatedFieldsResult: Record<string, any> = {};
-
- if (aggregateForRelation) {
- const aggregateQueryBuilder = referenceQueryBuilder.clone();
-
- ProcessAggregateHelper.addSelectedAggregatedFieldsQueriesToQueryBuilder({
- selectedAggregatedFields: aggregateForRelation,
- queryBuilder: aggregateQueryBuilder,
- objectMetadataNameSingular: targetObjectNameSingular,
- });
-
- const aggregatedFieldsValues = await aggregateQueryBuilder
- .addSelect(column, column.replace(/["']/g, ''))
- .where(`${column} IN (:...ids)`, { ids })
- .groupBy(column)
- .getRawMany();
-
- relationAggregatedFieldsResult = aggregatedFieldsValues.reduce<
- Record<string, unknown>
- >((acc, item) => {
- const columnWithoutQuotes = column.replace(/["']/g, '');
- const key = String(item[columnWithoutQuotes]);
- const { [column]: _, ...itemWithoutColumn } = item;
-
- acc[key] = itemWithoutColumn;
-
- return acc;
- }, {});
- }
-
- const queryBuilderOptions = referenceQueryBuilder.getFindOptions();
- const columnWithoutQuotes = column.replace(/["']/g, '');
-
- const findOptionsWithJoinColumn = {
- ...queryBuilderOptions,
- select: { ...queryBuilderOptions.select, [columnWithoutQuotes]: true },
- };
-
- if (relationType !== RelationType.ONE_TO_MANY) {
- const result = await referenceQueryBuilder
- .setFindOptions(findOptionsWithJoinColumn)
- .where(`${column} IN (:...ids)`, { ids })
- .take(perParentLimit * parentRecordsCount)
- .getMany();
-
- return { relationResults: result, relationAggregatedFieldsResult };
- }
-
- const allowedRelationRecordIds =
- await this.findRelationRecordIdsLimitedPerParent({
- targetObjectRepository,
- targetObjectNameSingular,
- column,
- ids,
- perParentLimit,
- });
-
- const recordIdsToHydrate =
- allowedRelationRecordIds.length > 0
- ? allowedRelationRecordIds
- : [EMPTY_RELATION_SENTINEL_RECORD_ID];
-
- const result = await referenceQueryBuilder
- .setFindOptions(findOptionsWithJoinColumn)
- .where(`id IN (:...recordIdsToHydrate)`, { recordIdsToHydrate })
- .getMany();
-
- return { relationResults: result, relationAggregatedFieldsResult };
- }
-
- private async findRelationRecordIdsLimitedPerParent({
- targetObjectRepository,
- targetObjectNameSingular,
- column,
- ids,
- perParentLimit,
- }: {
- targetObjectRepository: WorkspaceRepositoryV2;
- targetObjectNameSingular: string;
- column: string;
- ids: string[];
- perParentLimit: number;
- }): Promise<string[]> {
- const sanitizedIds = ids.filter(isValidUuid);
-
- if (sanitizedIds.length === 0) {
- return [];
- }
-
- const perParentRecordIdsQueryBuilder = targetObjectRepository
- .createQueryBuilder(targetObjectNameSingular)
- .select(`"${targetObjectNameSingular}"."id"`, 'id')
- .where(`${column} = "lateralParents"."parentId"`);
-
- perParentRecordIdsQueryBuilder.applyRowLevelPermissions();
-
- const perParentRecordIdsSql = `${perParentRecordIdsQueryBuilder.getQuery()} LIMIT ${Number(perParentLimit)}`;
-
- const parentValues = sanitizedIds.map((id) => `('${id}'::uuid)`).join(', ');
-
- const lateralSql =
- `SELECT "limited_relation_records"."id" AS "id" FROM (` +
- `SELECT "lateralRecords"."id" AS "id" ` +
- `FROM (VALUES ${parentValues}) AS "lateralParents"("parentId") ` +
- `CROSS JOIN LATERAL (${perParentRecordIdsSql}) AS "lateralRecords"` +
- `) AS "limited_relation_records"`;
-
- const limitedRecords = await targetObjectRepository.executeRaw<{
- id: string;
- }>(lateralSql, perParentRecordIdsQueryBuilder.getParameters());
-
- return limitedRecords.map((limitedRecord) => limitedRecord.id);
- }
-
- private assignRelationResults({
- parentRecords,
- parentObjectRecordsAggregatedValues,
- relationResults,
- relationAggregatedFieldsResult,
- sourceFieldName,
- joinField,
- joinColumnName,
- relationType,
- selectedFields,
- }: {
- parentRecords: ObjectRecord[];
- // oxlint-disable-next-line typescript/no-explicit-any
- parentObjectRecordsAggregatedValues: Record<string, any>;
- // oxlint-disable-next-line typescript/no-explicit-any
- relationResults: any[];
- // oxlint-disable-next-line typescript/no-explicit-any
- relationAggregatedFieldsResult: Record<string, any>;
- sourceFieldName: string;
- joinField: string;
- joinColumnName: string;
- relationType: RelationType;
- selectedFields: Record<string, unknown>;
- }): void {
- parentRecords.forEach((item) => {
- if (relationType === RelationType.ONE_TO_MANY) {
- item[sourceFieldName] = relationResults.filter(
- (rel) => rel[joinField] === item.id,
- );
- } else {
- const matchedRelation = relationResults.find(
- (rel) => rel.id === item[joinColumnName],
- );
-
- if (isDefined(matchedRelation?.deletedAt)) {
- item[sourceFieldName] = null;
- item[joinColumnName] = null;
- } else if (isDefined(matchedRelation)) {
- if (selectedFields?.deletedAt !== true) {
- const { deletedAt: _, ...rest } = matchedRelation;
-
- item[sourceFieldName] = rest;
- } else {
- item[sourceFieldName] = matchedRelation;
- }
- } else {
- item[sourceFieldName] = null;
- }
- }
- });
-
- parentObjectRecordsAggregatedValues[sourceFieldName] =
- relationAggregatedFieldsResult;
- }
-}
diff --git a/packages/twenty-server/src/engine/api/common/common-nested-relations-processor/process-nested-relations.helper.ts b/packages/twenty-server/src/engine/api/common/common-nested-relations-processor/process-nested-relations.helper.ts
index 174c869cfa7..725dc85f90e 100644
--- a/packages/twenty-server/src/engine/api/common/common-nested-relations-processor/process-nested-relations.helper.ts
+++ b/packages/twenty-server/src/engine/api/common/common-nested-relations-processor/process-nested-relations.helper.ts
@@ -1,64 +1,579 @@
import { Injectable } from '@nestjs/common';
-import { type ObjectRecord } from 'twenty-shared/types';
+import { FieldMetadataType, type ObjectRecord } from 'twenty-shared/types';
+import { isDefined, isValidUuid } from 'twenty-shared/utils';
import { type FindOptionsRelations, type ObjectLiteral } from 'typeorm';
-import { ProcessNestedRelationsOrmV2Helper } from 'src/engine/api/common/common-nested-relations-processor/process-nested-relations-orm-v2.helper';
-import { type NestedRelationsReadPathOptions } from 'src/engine/api/common/types/nested-relations-read-path-options.type';
+import { computeMorphOrRelationFieldJoinColumnName } from 'src/engine/metadata-modules/field-metadata/utils/compute-morph-or-relation-field-join-column-name.util';
+import { RelationType } from 'src/engine/metadata-modules/field-metadata/interfaces/relation-type.interface';
+
+import {
+ type ConcurrencyLimiter,
+ createConcurrencyLimiter,
+} from 'src/engine/api/common/common-nested-relations-processor/utils/create-concurrency-limiter.util';
+import { getUniqueRelationIds } from 'src/engine/api/common/common-nested-relations-processor/utils/get-unique-relation-ids.util';
+import { STANDARD_ERROR_MESSAGE } from 'src/engine/api/common/common-query-runners/errors/standard-error-message.constant';
+import {
+ GraphqlQueryRunnerException,
+ GraphqlQueryRunnerExceptionCode,
+} from 'src/engine/api/graphql/graphql-query-runner/errors/graphql-query-runner.exception';
+import { ProcessAggregateHelper } from 'src/engine/api/graphql/graphql-query-runner/helpers/process-aggregate.helper';
+import { buildColumnsToSelect } from 'src/engine/api/graphql/graphql-query-runner/utils/build-columns-to-select';
+import { getTargetObjectMetadataOrThrow } from 'src/engine/api/graphql/graphql-query-runner/utils/get-target-object-metadata.util';
import { type AggregationField } from 'src/engine/api/graphql/workspace-schema-builder/utils/get-available-aggregations-from-object-fields.util';
import { type WorkspaceAuthContext } from 'src/engine/core-modules/auth/types/workspace-auth-context.type';
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,
+ type FieldMapsForObject,
+} 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 { RolePermissionConfig } from 'src/engine/twenty-orm/types/role-permission-config';
+import { type RolePermissionConfig } from 'src/engine/twenty-orm/types/role-permission-config';
+import { type WorkspaceDataSourceV2 } from 'src/engine/twenty-orm-v2/datasource/workspace-data-source-v2';
+import { WorkspaceDataSourceV2Service } from 'src/engine/twenty-orm-v2/datasource/workspace-data-source-v2.service';
+import { type WorkspaceSelectQueryBuilderV2 } from 'src/engine/twenty-orm-v2/query-builder/workspace-select-query-builder-v2';
+import { type WorkspaceRepositoryV2 } from 'src/engine/twenty-orm-v2/repository/workspace-repository-v2';
+import { isFieldMetadataEntityOfType } from 'src/engine/utils/is-field-metadata-of-type.util';
+
+const EMPTY_RELATION_SENTINEL_RECORD_ID =
+ '00000000-0000-0000-0000-000000000000';
+const NESTED_RELATION_QUERY_MAX_CONCURRENCY = 4;
+
+type ProcessNestedRelationsArgs<T extends ObjectRecord = ObjectRecord> = {
+ flatObjectMetadataMaps: FlatEntityMaps<FlatObjectMetadata>;
+ flatFieldMetadataMaps: FlatEntityMaps<FlatFieldMetadata>;
+ parentObjectMetadataItem: FlatObjectMetadata;
+ parentObjectRecords: T[];
+ // oxlint-disable-next-line typescript/no-explicit-any
+ parentObjectRecordsAggregatedValues?: Record<string, any>;
+ relations: Record<string, FindOptionsRelations<ObjectLiteral>>;
+ aggregate?: Record<string, AggregationField>;
+ limit: number;
+ authContext: WorkspaceAuthContext;
+ useReplica?: boolean;
+ rolePermissionConfig?: RolePermissionConfig;
+ // oxlint-disable-next-line typescript/no-explicit-any
+ selectedFields: Record<string, any>;
+};
@Injectable()
export class ProcessNestedRelationsHelper {
constructor(
- private readonly processNestedRelationsOrmV2Helper: ProcessNestedRelationsOrmV2Helper,
+ private readonly workspaceDataSourceV2Service: WorkspaceDataSourceV2Service,
) {}
- public async processNestedRelations<T extends ObjectRecord = ObjectRecord>({
+ public async processNestedRelations<T extends ObjectRecord = ObjectRecord>(
+ args: ProcessNestedRelationsArgs<T>,
+ ): Promise<void> {
+ const dataSource = this.workspaceDataSourceV2Service.getDataSource({
+ useReplica: args.useReplica ?? false,
+ });
+
+ await this.processNestedRelationsWithLimiter(
+ args,
+ dataSource,
+ createConcurrencyLimiter(NESTED_RELATION_QUERY_MAX_CONCURRENCY),
+ );
+ }
+
+ private async processNestedRelationsWithLimiter<
+ T extends ObjectRecord = ObjectRecord,
+ >(
+ {
+ flatObjectMetadataMaps,
+ flatFieldMetadataMaps,
+ parentObjectMetadataItem,
+ parentObjectRecords,
+ parentObjectRecordsAggregatedValues = {},
+ relations,
+ aggregate = {},
+ limit,
+ authContext,
+ useReplica = false,
+ rolePermissionConfig,
+ selectedFields,
+ }: ProcessNestedRelationsArgs<T>,
+ dataSource: WorkspaceDataSourceV2,
+ relationQueryLimiter: ConcurrencyLimiter,
+ ): Promise<void> {
+ const processRelationTasks = Object.entries(relations).map(
+ ([sourceFieldName, nestedRelations]) =>
+ this.processRelation({
+ flatObjectMetadataMaps,
+ flatFieldMetadataMaps,
+ parentObjectMetadataItem,
+ parentObjectRecords,
+ parentObjectRecordsAggregatedValues,
+ sourceFieldName,
+ nestedRelations,
+ aggregate,
+ limit,
+ authContext,
+ useReplica,
+ dataSource,
+ rolePermissionConfig,
+ relationQueryLimiter,
+ selectedFields:
+ selectedFields[sourceFieldName] instanceof Object
+ ? selectedFields[sourceFieldName]
+ : undefined,
+ }),
+ );
+
+ await Promise.all(processRelationTasks);
+ }
+
+ private async processRelation<T extends ObjectRecord = ObjectRecord>({
flatObjectMetadataMaps,
flatFieldMetadataMaps,
parentObjectMetadataItem,
parentObjectRecords,
- parentObjectRecordsAggregatedValues = {},
- relations,
- aggregate = {},
+ parentObjectRecordsAggregatedValues,
+ sourceFieldName,
+ nestedRelations,
+ aggregate,
limit,
authContext,
+ useReplica,
+ dataSource,
rolePermissionConfig,
+ relationQueryLimiter,
selectedFields,
- useReplica = false,
}: {
flatObjectMetadataMaps: FlatEntityMaps<FlatObjectMetadata>;
flatFieldMetadataMaps: FlatEntityMaps<FlatFieldMetadata>;
parentObjectMetadataItem: FlatObjectMetadata;
parentObjectRecords: T[];
// oxlint-disable-next-line typescript/no-explicit-any
- parentObjectRecordsAggregatedValues?: Record<string, any>;
- relations: Record<string, FindOptionsRelations<ObjectLiteral>>;
- aggregate?: Record<string, AggregationField>;
+ parentObjectRecordsAggregatedValues: Record<string, any>;
+ sourceFieldName: string;
+ nestedRelations: FindOptionsRelations<ObjectLiteral>;
+ aggregate: Record<string, AggregationField>;
limit: number;
authContext: WorkspaceAuthContext;
+ useReplica: boolean;
+ dataSource: WorkspaceDataSourceV2;
rolePermissionConfig?: RolePermissionConfig;
- // oxlint-disable-next-line typescript/no-explicit-any
- selectedFields: Record<string, any>;
- } & Partial<NestedRelationsReadPathOptions>): Promise<void> {
- return this.processNestedRelationsOrmV2Helper.processNestedRelations({
- flatObjectMetadataMaps,
+ relationQueryLimiter: ConcurrencyLimiter;
+ selectedFields: Record<string, unknown>;
+ }): Promise<void> {
+ const fieldMaps = buildFieldMapsFromFlatObjectMetadata(
flatFieldMetadataMaps,
parentObjectMetadataItem,
- parentObjectRecords,
- parentObjectRecordsAggregatedValues,
- relations,
- aggregate,
- limit,
- authContext,
- useReplica,
+ );
+
+ const sourceFieldMetadata = findFlatEntityByIdInFlatEntityMaps({
+ flatEntityId: fieldMaps.fieldIdByName[sourceFieldName],
+ flatEntityMaps: flatFieldMetadataMaps,
+ });
+
+ if (!sourceFieldMetadata) {
+ return;
+ }
+
+ if (
+ !isFieldMetadataEntityOfType(
+ sourceFieldMetadata,
+ FieldMetadataType.RELATION,
+ ) &&
+ !isFieldMetadataEntityOfType(
+ sourceFieldMetadata,
+ FieldMetadataType.MORPH_RELATION,
+ )
+ ) {
+ return;
+ }
+
+ if (!sourceFieldMetadata.settings) {
+ throw new GraphqlQueryRunnerException(
+ `Relation settings not found for field ${sourceFieldName}`,
+ GraphqlQueryRunnerExceptionCode.RELATION_SETTINGS_NOT_FOUND,
+ { userFriendlyMessage: STANDARD_ERROR_MESSAGE },
+ );
+ }
+
+ const relationType = sourceFieldMetadata.settings.relationType;
+ const { targetRelationName, targetObjectMetadata, targetRelation } =
+ this.getTargetObjectMetadata({
+ flatObjectMetadataMaps,
+ flatFieldMetadataMaps,
+ parentObjectMetadataItem,
+ sourceFieldName,
+ fieldMaps,
+ });
+
+ const targetObjectRepository = dataSource.getRepository(
+ targetObjectMetadata.nameSingular,
rolePermissionConfig,
+ );
+
+ const targetObjectNameSingular = targetObjectMetadata.nameSingular;
+
+ let targetObjectQueryBuilder = targetObjectRepository.createQueryBuilder(
+ targetObjectNameSingular,
+ );
+
+ const columnsToSelect: Record<string, boolean> = buildColumnsToSelect({
+ select: selectedFields,
+ relations: nestedRelations,
+ flatObjectMetadata: targetObjectMetadata,
+ flatObjectMetadataMaps,
+ flatFieldMetadataMaps,
+ });
+
+ if (relationType === RelationType.MANY_TO_ONE) {
+ columnsToSelect.deletedAt = true;
+ targetObjectQueryBuilder = targetObjectQueryBuilder.withDeleted();
+ }
+
+ targetObjectQueryBuilder = targetObjectQueryBuilder.setFindOptions({
+ select: columnsToSelect,
+ });
+
+ const joinColumnName = computeMorphOrRelationFieldJoinColumnName({
+ name: sourceFieldName,
+ });
+
+ const relationIds = getUniqueRelationIds({
+ records: parentObjectRecords,
+ idField:
+ relationType === RelationType.ONE_TO_MANY ? 'id' : joinColumnName,
+ });
+
+ if (
+ relationType === RelationType.ONE_TO_MANY &&
+ !isDefined(targetRelationName)
+ ) {
+ throw new GraphqlQueryRunnerException(
+ `Could not resolve target relation for one-to-many field ${sourceFieldName}`,
+ GraphqlQueryRunnerExceptionCode.RELATION_TARGET_OBJECT_METADATA_NOT_FOUND,
+ { userFriendlyMessage: STANDARD_ERROR_MESSAGE },
+ );
+ }
+
+ const fieldMetadataTargetRelationColumnName =
+ computeMorphOrRelationFieldJoinColumnName({
+ name:
+ targetRelation &&
+ isFieldMetadataEntityOfType(
+ targetRelation,
+ FieldMetadataType.MORPH_RELATION,
+ )
+ ? targetRelation.name
+ : (targetRelationName as string),
+ });
+
+ const { relationResults, relationAggregatedFieldsResult } =
+ await relationQueryLimiter(() =>
+ this.findRelations({
+ referenceQueryBuilder: targetObjectQueryBuilder,
+ targetObjectRepository,
+ column:
+ relationType === RelationType.ONE_TO_MANY
+ ? `"${fieldMetadataTargetRelationColumnName}"`
+ : 'id',
+ ids: relationIds,
+ relationType,
+ perParentLimit: limit,
+ parentRecordsCount: parentObjectRecords.length,
+ aggregate,
+ sourceFieldName,
+ targetObjectNameSingular,
+ }),
+ );
+
+ this.assignRelationResults({
+ parentRecords: parentObjectRecords,
+ parentObjectRecordsAggregatedValues,
+ relationResults,
+ relationAggregatedFieldsResult,
+ sourceFieldName,
+ joinField:
+ relationType === RelationType.ONE_TO_MANY
+ ? `${fieldMetadataTargetRelationColumnName}`
+ : 'id',
+ joinColumnName,
+ relationType,
selectedFields,
});
+
+ if (Object.keys(nestedRelations).length > 0) {
+ await this.processNestedRelationsWithLimiter(
+ {
+ flatObjectMetadataMaps,
+ flatFieldMetadataMaps,
+ parentObjectMetadataItem: targetObjectMetadata,
+ parentObjectRecords: relationResults as ObjectRecord[],
+ parentObjectRecordsAggregatedValues: relationAggregatedFieldsResult,
+ relations: nestedRelations as Record<
+ string,
+ FindOptionsRelations<ObjectLiteral>
+ >,
+ aggregate,
+ limit,
+ authContext,
+ useReplica,
+ rolePermissionConfig,
+ selectedFields,
+ },
+ dataSource,
+ relationQueryLimiter,
+ );
+ }
+ }
+
+ private getTargetObjectMetadata({
+ flatObjectMetadataMaps,
+ flatFieldMetadataMaps,
+ parentObjectMetadataItem,
+ sourceFieldName,
+ fieldMaps,
+ }: {
+ flatObjectMetadataMaps: FlatEntityMaps<FlatObjectMetadata>;
+ flatFieldMetadataMaps: FlatEntityMaps<FlatFieldMetadata>;
+ parentObjectMetadataItem: FlatObjectMetadata;
+ sourceFieldName: string;
+ fieldMaps: FieldMapsForObject;
+ }) {
+ const targetFieldMetadata = findFlatEntityByIdInFlatEntityMaps({
+ flatEntityId: fieldMaps.fieldIdByName[sourceFieldName],
+ flatEntityMaps: flatFieldMetadataMaps,
+ });
+
+ if (!targetFieldMetadata) {
+ throw new GraphqlQueryRunnerException(
+ `Field ${sourceFieldName} not found on object ${parentObjectMetadataItem.nameSingular}`,
+ GraphqlQueryRunnerExceptionCode.FIELD_NOT_FOUND,
+ { userFriendlyMessage: STANDARD_ERROR_MESSAGE },
+ );
+ }
+
+ const targetObjectMetadata = getTargetObjectMetadataOrThrow(
+ targetFieldMetadata,
+ flatObjectMetadataMaps,
+ );
+
+ if (
+ !targetFieldMetadata.relationTargetObjectMetadataId ||
+ !targetFieldMetadata.relationTargetFieldMetadataId
+ ) {
+ throw new GraphqlQueryRunnerException(
+ `Relation target object metadata id or field metadata id not found for field ${sourceFieldName}`,
+ GraphqlQueryRunnerExceptionCode.RELATION_TARGET_OBJECT_METADATA_NOT_FOUND,
+ { userFriendlyMessage: STANDARD_ERROR_MESSAGE },
+ );
+ }
+
+ const targetRelation = findFlatEntityByIdInFlatEntityMaps({
+ flatEntityId: targetFieldMetadata.relationTargetFieldMetadataId,
+ flatEntityMaps: flatFieldMetadataMaps,
+ });
+
+ const targetRelationName = targetRelation?.name;
+
+ return { targetRelationName, targetObjectMetadata, targetRelation };
+ }
+
+ private async findRelations({
+ referenceQueryBuilder,
+ targetObjectRepository,
+ column,
+ ids,
+ relationType,
+ perParentLimit,
+ parentRecordsCount,
+ aggregate,
+ sourceFieldName,
+ targetObjectNameSingular,
+ }: {
+ referenceQueryBuilder: WorkspaceSelectQueryBuilderV2;
+ targetObjectRepository: WorkspaceRepositoryV2;
+ column: string;
+ // oxlint-disable-next-line typescript/no-explicit-any
+ ids: any[];
+ relationType: RelationType;
+ perParentLimit: number;
+ parentRecordsCount: number;
+ // oxlint-disable-next-line typescript/no-explicit-any
+ aggregate: Record<string, any>;
+ sourceFieldName: string;
+ targetObjectNameSingular: string;
+ // oxlint-disable-next-line typescript/no-explicit-any
+ }): Promise<{ relationResults: any[]; relationAggregatedFieldsResult: any }> {
+ if (ids.length === 0) {
+ return { relationResults: [], relationAggregatedFieldsResult: {} };
+ }
+
+ const aggregateForRelation = aggregate[sourceFieldName];
+ // oxlint-disable-next-line typescript/no-explicit-any
+ let relationAggregatedFieldsResult: Record<string, any> = {};
+
+ if (aggregateForRelation) {
+ const aggregateQueryBuilder = referenceQueryBuilder.clone();
+
+ ProcessAggregateHelper.addSelectedAggregatedFieldsQueriesToQueryBuilder({
+ selectedAggregatedFields: aggregateForRelation,
+ queryBuilder: aggregateQueryBuilder,
+ objectMetadataNameSingular: targetObjectNameSingular,
+ });
+
+ const aggregatedFieldsValues = await aggregateQueryBuilder
+ .addSelect(column, column.replace(/["']/g, ''))
+ .where(`${column} IN (:...ids)`, { ids })
+ .groupBy(column)
+ .getRawMany();
+
+ relationAggregatedFieldsResult = aggregatedFieldsValues.reduce<
+ Record<string, unknown>
+ >((acc, item) => {
+ const columnWithoutQuotes = column.replace(/["']/g, '');
+ const key = String(item[columnWithoutQuotes]);
+ const { [column]: _, ...itemWithoutColumn } = item;
+
+ acc[key] = itemWithoutColumn;
+
+ return acc;
+ }, {});
+ }
+
+ const queryBuilderOptions = referenceQueryBuilder.getFindOptions();
+ const columnWithoutQuotes = column.replace(/["']/g, '');
+
+ const findOptionsWithJoinColumn = {
+ ...queryBuilderOptions,
+ select: { ...queryBuilderOptions.select, [columnWithoutQuotes]: true },
+ };
+
+ if (relationType !== RelationType.ONE_TO_MANY) {
+ const result = await referenceQueryBuilder
+ .setFindOptions(findOptionsWithJoinColumn)
+ .where(`${column} IN (:...ids)`, { ids })
+ .take(perParentLimit * parentRecordsCount)
+ .getMany();
+
+ return { relationResults: result, relationAggregatedFieldsResult };
+ }
+
+ const allowedRelationRecordIds =
+ await this.findRelationRecordIdsLimitedPerParent({
+ targetObjectRepository,
+ targetObjectNameSingular,
+ column,
+ ids,
+ perParentLimit,
+ });
+
+ const recordIdsToHydrate =
+ allowedRelationRecordIds.length > 0
+ ? allowedRelationRecordIds
+ : [EMPTY_RELATION_SENTINEL_RECORD_ID];
+
+ const result = await referenceQueryBuilder
+ .setFindOptions(findOptionsWithJoinColumn)
+ .where(`id IN (:...recordIdsToHydrate)`, { recordIdsToHydrate })
+ .getMany();
+
+ return { relationResults: result, relationAggregatedFieldsResult };
+ }
+
+ private async findRelationRecordIdsLimitedPerParent({
+ targetObjectRepository,
+ targetObjectNameSingular,
+ column,
+ ids,
+ perParentLimit,
+ }: {
+ targetObjectRepository: WorkspaceRepositoryV2;
+ targetObjectNameSingular: string;
+ column: string;
+ ids: string[];
+ perParentLimit: number;
+ }): Promise<string[]> {
+ const sanitizedIds = ids.filter(isValidUuid);
+
+ if (sanitizedIds.length === 0) {
+ return [];
+ }
+
+ const perParentRecordIdsQueryBuilder = targetObjectRepository
+ .createQueryBuilder(targetObjectNameSingular)
+ .select(`"${targetObjectNameSingular}"."id"`, 'id')
+ .where(`${column} = "lateralParents"."parentId"`);
+
+ perParentRecordIdsQueryBuilder.applyRowLevelPermissions();
+
+ const perParentRecordIdsSql = `${perParentRecordIdsQueryBuilder.getQuery()} LIMIT ${Number(perParentLimit)}`;
+
+ const parentValues = sanitizedIds.map((id) => `('${id}'::uuid)`).join(', ');
+
+ const lateralSql =
+ `SELECT "limited_relation_records"."id" AS "id" FROM (` +
+ `SELECT "lateralRecords"."id" AS "id" ` +
+ `FROM (VALUES ${parentValues}) AS "lateralParents"("parentId") ` +
+ `CROSS JOIN LATERAL (${perParentRecordIdsSql}) AS "lateralRecords"` +
+ `) AS "limited_relation_records"`;
+
+ const limitedRecords = await targetObjectRepository.executeRaw<{
+ id: string;
+ }>(lateralSql, perParentRecordIdsQueryBuilder.getParameters());
+
+ return limitedRecords.map((limitedRecord) => limitedRecord.id);
+ }
+
+ private assignRelationResults({
+ parentRecords,
+ parentObjectRecordsAggregatedValues,
+ relationResults,
+ relationAggregatedFieldsResult,
+ sourceFieldName,
+ joinField,
+ joinColumnName,
+ relationType,
+ selectedFields,
+ }: {
+ parentRecords: ObjectRecord[];
+ // oxlint-disable-next-line typescript/no-explicit-any
+ parentObjectRecordsAggregatedValues: Record<string, any>;
+ // oxlint-disable-next-line typescript/no-explicit-any
+ relationResults: any[];
+ // oxlint-disable-next-line typescript/no-explicit-any
+ relationAggregatedFieldsResult: Record<string, any>;
+ sourceFieldName: string;
+ joinField: string;
+ joinColumnName: string;
+ relationType: RelationType;
+ selectedFields: Record<string, unknown>;
+ }): void {
+ parentRecords.forEach((item) => {
+ if (relationType === RelationType.ONE_TO_MANY) {
+ item[sourceFieldName] = relationResults.filter(
+ (rel) => rel[joinField] === item.id,
+ );
+ } else {
+ const matchedRelation = relationResults.find(
+ (rel) => rel.id === item[joinColumnName],
+ );
+
+ if (isDefined(matchedRelation?.deletedAt)) {
+ item[sourceFieldName] = null;
+ item[joinColumnName] = null;
+ } else if (isDefined(matchedRelation)) {
+ if (selectedFields?.deletedAt !== true) {
+ const { deletedAt: _, ...rest } = matchedRelation;
+
+ item[sourceFieldName] = rest;
+ } else {
+ item[sourceFieldName] = matchedRelation;
+ }
+ } else {
+ item[sourceFieldName] = null;
+ }
+ }
+ });
+
+ parentObjectRecordsAggregatedValues[sourceFieldName] =
+ relationAggregatedFieldsResult;
}
}
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 dde0acdce65..32aec8b8d8f 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
@@ -353,10 +353,10 @@ export abstract class CommonBaseQueryRunnerService<
const repository = this.workspaceDataSourceV2Service
.getDataSource({ useReplica: this.isReadOnly })
- .getRepository(
+ .getRepository<ObjectLiteral>(
queryRunnerContext.flatObjectMetadata.nameSingular,
rolePermissionConfig,
- ) as unknown as WorkspaceRepositoryV2<ObjectLiteral>;
+ );
return {
...queryRunnerContext,
diff --git a/packages/twenty-server/src/engine/api/common/common-query-runners/common-find-many-query-runner.service.ts b/packages/twenty-server/src/engine/api/common/common-query-runners/common-find-many-query-runner.service.ts
index 233b60e7dcc..1e8d9666f8c 100644
--- a/packages/twenty-server/src/engine/api/common/common-query-runners/common-find-many-query-runner.service.ts
+++ b/packages/twenty-server/src/engine/api/common/common-query-runners/common-find-many-query-runner.service.ts
@@ -2,12 +2,12 @@ import { Injectable } from '@nestjs/common';
import { msg } from '@lingui/core/macro';
-import { isDefined } from 'class-validator';
import {
QUERY_MAX_RECORDS,
QUERY_MAX_RECORDS_FROM_RELATION,
} from 'twenty-shared/constants';
import { ObjectRecord, OrderByDirection } from 'twenty-shared/types';
+import { isDefined } from 'twenty-shared/utils';
import { FindOptionsRelations, ObjectLiteral } from 'typeorm';
import {
@@ -35,7 +35,7 @@ import { buildCursorPage } from 'src/engine/api/utils/build-cursor-page.util';
import { getNonToOneJoinAliases } from 'src/engine/api/common/utils/get-non-to-one-join-aliases.util';
import { getPageInfo } from 'src/engine/api/common/utils/get-page-info.util';
import { ProcessAggregateHelper } from 'src/engine/api/graphql/graphql-query-runner/helpers/process-aggregate.helper';
-import { type ReadRecordQueryBuilder } from 'src/engine/api/graphql/graphql-query-runner/types/record-query-builder.type';
+import { type WorkspaceSelectQueryBuilderV2 } from 'src/engine/twenty-orm-v2/query-builder/workspace-select-query-builder-v2';
import { buildColumnsToSelect } from 'src/engine/api/graphql/graphql-query-runner/utils/build-columns-to-select';
import { buildOrderByColumnsToSelect } from 'src/engine/api/graphql/graphql-query-runner/utils/build-order-by-columns-to-select';
import { getCursor } from 'src/engine/api/graphql/graphql-query-runner/utils/cursors.util';
@@ -73,7 +73,7 @@ export class CommonFindManyQueryRunnerService extends CommonBaseQueryRunnerServi
const readRepository = this.getReadRepository(queryRunnerContext);
- const queryBuilder: ReadRecordQueryBuilder =
+ const queryBuilder: WorkspaceSelectQueryBuilderV2 =
readRepository.createQueryBuilder(flatObjectMetadata.nameSingular);
const aggregateQueryBuilder = queryBuilder.clone();
diff --git a/packages/twenty-server/src/engine/api/common/core-common-api.module.ts b/packages/twenty-server/src/engine/api/common/core-common-api.module.ts
index 5035847b7d3..4939437da9f 100644
--- a/packages/twenty-server/src/engine/api/common/core-common-api.module.ts
+++ b/packages/twenty-server/src/engine/api/common/core-common-api.module.ts
@@ -3,7 +3,6 @@ import { TypeOrmModule } from '@nestjs/typeorm';
import { CommonArgsProcessors } from 'src/engine/api/common/common-args-processors/common-args-processors';
import { GroupByArgProcessorService } from 'src/engine/api/common/common-args-processors/group-by-arg-processor/group-by-arg-processor.service';
-import { ProcessNestedRelationsOrmV2Helper } from 'src/engine/api/common/common-nested-relations-processor/process-nested-relations-orm-v2.helper';
import { ProcessNestedRelationsHelper } from 'src/engine/api/common/common-nested-relations-processor/process-nested-relations.helper';
import { CommonQueryRunners } from 'src/engine/api/common/common-query-runners/common-query-runners';
import { CommonResultGettersService } from 'src/engine/api/common/common-result-getters/common-result-getters.service';
@@ -51,7 +50,6 @@ import { WorkspaceCacheModule } from 'src/engine/workspace-cache/workspace-cache
],
providers: [
ProcessNestedRelationsHelper,
- ProcessNestedRelationsOrmV2Helper,
...CommonArgsProcessors,
ProcessAggregateHelper,
...CommonQueryRunners,
diff --git a/packages/twenty-server/src/engine/api/graphql/graphql-query-runner/graphql-query-parsers/graphql-query-filter/__tests__/graphql-query-filter-condition.parser.spec.ts b/packages/twenty-server/src/engine/api/graphql/graphql-query-runner/graphql-query-parsers/graphql-query-filter/__tests__/graphql-query-filter-condition.parser.spec.ts
index 8604cb21ab4..e6621672185 100644
--- a/packages/twenty-server/src/engine/api/graphql/graphql-query-runner/graphql-query-parsers/graphql-query-filter/__tests__/graphql-query-filter-condition.parser.spec.ts
+++ b/packages/twenty-server/src/engine/api/graphql/graphql-query-runner/graphql-query-parsers/graphql-query-filter/__tests__/graphql-query-filter-condition.parser.spec.ts
@@ -4,7 +4,7 @@ import {
} from 'test/utils/create-where-expression-recorder.util';
import { FieldMetadataType } from 'twenty-shared/types';
-import { type RecordQueryBuilder } from 'src/engine/api/graphql/graphql-query-runner/types/record-query-builder.type';
+import { type WorkspaceSelectQueryBuilderV2 } from 'src/engine/twenty-orm-v2/query-builder/workspace-select-query-builder-v2';
import { GraphqlQueryFilterConditionParser } from 'src/engine/api/graphql/graphql-query-runner/graphql-query-parsers/graphql-query-filter/graphql-query-filter-condition.parser';
import { type FlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/types/flat-entity-maps.type';
import { type FlatFieldMetadata } from 'src/engine/metadata-modules/flat-field-metadata/types/flat-field-metadata.type';
@@ -57,7 +57,7 @@ const flatFieldMetadataMaps: FlatEntityMaps<FlatFieldMetadata> = {
const outerQueryBuilder = {
objectRecordsPermissions: {},
-} as unknown as RecordQueryBuilder;
+} as unknown as WorkspaceSelectQueryBuilderV2;
const recordFilterEntries = (filter: Record<string, unknown>) => {
const recorder = createWhereExpressionRecorder();
diff --git a/packages/twenty-server/src/engine/api/graphql/graphql-query-runner/graphql-query-parsers/graphql-query-filter/graphql-query-filter-condition.parser.ts b/packages/twenty-server/src/engine/api/graphql/graphql-query-runner/graphql-query-parsers/graphql-query-filter/graphql-query-filter-condition.parser.ts
index 7f5aa6f834e..110f0052fb9 100644
--- a/packages/twenty-server/src/engine/api/graphql/graphql-query-runner/graphql-query-parsers/graphql-query-filter/graphql-query-filter-condition.parser.ts
+++ b/packages/twenty-server/src/engine/api/graphql/graphql-query-runner/graphql-query-parsers/graphql-query-filter/graphql-query-filter-condition.parser.ts
@@ -8,7 +8,7 @@ import { type FlatFieldMetadata } from 'src/engine/metadata-modules/flat-field-m
import { type FlatObjectMetadata } from 'src/engine/metadata-modules/flat-object-metadata/types/flat-object-metadata.type';
import { GraphqlQueryFilterFieldParser } from './graphql-query-filter-field.parser';
-import { type RecordQueryBuilder } from 'src/engine/api/graphql/graphql-query-runner/types/record-query-builder.type';
+import { type WorkspaceSelectQueryBuilderV2 } from 'src/engine/twenty-orm-v2/query-builder/workspace-select-query-builder-v2';
export class GraphqlQueryFilterConditionParser {
private queryFilterFieldParser: GraphqlQueryFilterFieldParser;
@@ -28,10 +28,10 @@ export class GraphqlQueryFilterConditionParser {
}
public parse(
- queryBuilder: RecordQueryBuilder,
+ queryBuilder: WorkspaceSelectQueryBuilderV2,
objectNameSingular: string,
filter: Partial<ObjectRecordFilter>,
- ): RecordQueryBuilder {
+ ): WorkspaceSelectQueryBuilderV2 {
if (!filter || Object.keys(filter).length === 0) {
return queryBuilder;
}
@@ -52,7 +52,7 @@ export class GraphqlQueryFilterConditionParser {
public applyFilterEntriesToWhereBrackets(
innerQueryBuilder: WhereExpressionBuilder,
- outerQueryBuilder: RecordQueryBuilder,
+ outerQueryBuilder: WorkspaceSelectQueryBuilderV2,
objectNameSingular: string,
filter: Partial<ObjectRecordFilter>,
): void {
diff --git a/packages/twenty-server/src/engine/api/graphql/graphql-query-runner/graphql-query-parsers/graphql-query-filter/graphql-query-filter-field.parser.ts b/packages/twenty-server/src/engine/api/graphql/graphql-query-runner/graphql-query-parsers/graphql-query-filter/graphql-query-filter-field.parser.ts
index deecfeea4e9..404a8b1d558 100644
--- a/packages/twenty-server/src/engine/api/graphql/graphql-query-runner/graphql-query-parsers/graphql-query-filter/graphql-query-filter-field.parser.ts
+++ b/packages/twenty-server/src/engine/api/graphql/graphql-query-runner/graphql-query-parsers/graphql-query-filter/graphql-query-filter-field.parser.ts
@@ -29,7 +29,7 @@ import {
} from 'src/engine/metadata-modules/permissions/permissions.exception';
import { GraphqlQueryFilterConditionParser } from './graphql-query-filter-condition.parser';
-import { type RecordQueryBuilder } from 'src/engine/api/graphql/graphql-query-runner/types/record-query-builder.type';
+import { type WorkspaceSelectQueryBuilderV2 } from 'src/engine/twenty-orm-v2/query-builder/workspace-select-query-builder-v2';
export class GraphqlQueryFilterFieldParser {
private flatObjectMetadata: FlatObjectMetadata;
@@ -61,7 +61,7 @@ export class GraphqlQueryFilterFieldParser {
public parse(
queryBuilder: WhereExpressionBuilder,
- outerQueryBuilder: RecordQueryBuilder,
+ outerQueryBuilder: WorkspaceSelectQueryBuilderV2,
objectNameSingular: string,
key: string,
// oxlint-disable-next-line typescript/no-explicit-any
@@ -144,7 +144,7 @@ export class GraphqlQueryFilterFieldParser {
private parseRelationSubFilter(
queryBuilder: WhereExpressionBuilder,
- outerQueryBuilder: RecordQueryBuilder,
+ outerQueryBuilder: WorkspaceSelectQueryBuilderV2,
parentAlias: string,
fieldMetadata: FlatFieldMetadata,
filterValue: Partial<ObjectRecordFilter>,
diff --git a/packages/twenty-server/src/engine/api/graphql/graphql-query-runner/graphql-query-parsers/graphql-query.parser.ts b/packages/twenty-server/src/engine/api/graphql/graphql-query-runner/graphql-query-parsers/graphql-query.parser.ts
index 3b6ffe1d848..1308029c78e 100644
--- a/packages/twenty-server/src/engine/api/graphql/graphql-query-runner/graphql-query-parsers/graphql-query.parser.ts
+++ b/packages/twenty-server/src/engine/api/graphql/graphql-query-runner/graphql-query-parsers/graphql-query.parser.ts
@@ -24,7 +24,7 @@ import { addRelationJoinAliasToQueryBuilder } from 'src/engine/api/graphql/graph
import { type FlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/types/flat-entity-maps.type';
import { type FlatFieldMetadata } from 'src/engine/metadata-modules/flat-field-metadata/types/flat-field-metadata.type';
import { type FlatObjectMetadata } from 'src/engine/metadata-modules/flat-object-metadata/types/flat-object-metadata.type';
-import { type RecordQueryBuilder } from 'src/engine/api/graphql/graphql-query-runner/types/record-query-builder.type';
+import { type WorkspaceSelectQueryBuilderV2 } from 'src/engine/twenty-orm-v2/query-builder/workspace-select-query-builder-v2';
export class GraphqlQueryParser {
private flatObjectMetadata: FlatObjectMetadata;
@@ -62,11 +62,11 @@ export class GraphqlQueryParser {
public applyFilterToBuilder(
// oxlint-disable-next-line typescript/no-explicit-any
- queryBuilder: RecordQueryBuilder,
+ queryBuilder: WorkspaceSelectQueryBuilderV2,
objectNameSingular: string,
recordFilter: Partial<ObjectRecordFilter>,
// oxlint-disable-next-line typescript/no-explicit-any
- ): RecordQueryBuilder {
+ ): WorkspaceSelectQueryBuilderV2 {
return this.filterConditionParser.parse(
queryBuilder,
objectNameSingular,
@@ -76,10 +76,10 @@ export class GraphqlQueryParser {
public applyDeletedAtToBuilder(
// oxlint-disable-next-line typescript/no-explicit-any
- queryBuilder: RecordQueryBuilder,
+ queryBuilder: WorkspaceSelectQueryBuilderV2,
recordFilter: Partial<ObjectRecordFilter>,
// oxlint-disable-next-line typescript/no-explicit-any
- ): RecordQueryBuilder {
+ ): WorkspaceSelectQueryBuilderV2 {
if (this.checkForDeletedAtFilter(recordFilter)) {
queryBuilder.withDeleted();
}
@@ -120,7 +120,7 @@ export class GraphqlQueryParser {
public applyOrderToBuilder(
// oxlint-disable-next-line typescript/no-explicit-any
- queryBuilder: RecordQueryBuilder,
+ queryBuilder: WorkspaceSelectQueryBuilderV2,
orderBy: ObjectRecordOrderBy | OrderByWithGroupBy,
objectNameSingular: string,
isForwardPagination = true,
@@ -148,7 +148,7 @@ export class GraphqlQueryParser {
public addRelationOrderColumnsToBuilder(
// oxlint-disable-next-line typescript/no-explicit-any
- queryBuilder: RecordQueryBuilder,
+ queryBuilder: WorkspaceSelectQueryBuilderV2,
parsedOrderBy: Record<string, OrderByClause>,
objectNameSingular: string,
columnsToSelect: Record<string, boolean>,
@@ -225,11 +225,11 @@ export class GraphqlQueryParser {
public applyGroupByOrderToBuilder(
// oxlint-disable-next-line typescript/no-explicit-any
- queryBuilder: RecordQueryBuilder,
+ queryBuilder: WorkspaceSelectQueryBuilderV2,
orderBy: ObjectRecordOrderBy | OrderByWithGroupBy,
groupByFields: GroupByField[],
// oxlint-disable-next-line typescript/no-explicit-any
- ): RecordQueryBuilder {
+ ): WorkspaceSelectQueryBuilderV2 {
const parsedOrderBys = this.orderGroupByParser.parse({
orderBy,
groupByFields,
diff --git a/packages/twenty-server/src/engine/api/graphql/graphql-query-runner/graphql-query-parsers/utils/add-relation-join-alias.util.ts b/packages/twenty-server/src/engine/api/graphql/graphql-query-runner/graphql-query-parsers/utils/add-relation-join-alias.util.ts
index 500c389aada..56aa52ad00d 100644
--- a/packages/twenty-server/src/engine/api/graphql/graphql-query-runner/graphql-query-parsers/utils/add-relation-join-alias.util.ts
+++ b/packages/twenty-server/src/engine/api/graphql/graphql-query-runner/graphql-query-parsers/utils/add-relation-join-alias.util.ts
@@ -1,7 +1,7 @@
-import { type RecordQueryBuilder } from 'src/engine/api/graphql/graphql-query-runner/types/record-query-builder.type';
+import { type WorkspaceSelectQueryBuilderV2 } from 'src/engine/twenty-orm-v2/query-builder/workspace-select-query-builder-v2';
type AddRelationJoinAliasToQueryBuilderArgs = {
- queryBuilder: RecordQueryBuilder;
+ queryBuilder: WorkspaceSelectQueryBuilderV2;
parentAlias: string;
relationName: string;
};
diff --git a/packages/twenty-server/src/engine/api/graphql/graphql-query-runner/graphql-query-parsers/utils/apply-filter-entries-to-where-expression.util.ts b/packages/twenty-server/src/engine/api/graphql/graphql-query-runner/graphql-query-parsers/utils/apply-filter-entries-to-where-expression.util.ts
index 58f579aa7ef..0fe9f1f4700 100644
--- a/packages/twenty-server/src/engine/api/graphql/graphql-query-runner/graphql-query-parsers/utils/apply-filter-entries-to-where-expression.util.ts
+++ b/packages/twenty-server/src/engine/api/graphql/graphql-query-runner/graphql-query-parsers/utils/apply-filter-entries-to-where-expression.util.ts
@@ -1,10 +1,10 @@
import { Brackets, NotBrackets, type WhereExpressionBuilder } from 'typeorm';
import { type GraphqlQueryFilterFieldParser } from 'src/engine/api/graphql/graphql-query-runner/graphql-query-parsers/graphql-query-filter/graphql-query-filter-field.parser';
-import { type RecordQueryBuilder } from 'src/engine/api/graphql/graphql-query-runner/types/record-query-builder.type';
+import { type WorkspaceSelectQueryBuilderV2 } from 'src/engine/twenty-orm-v2/query-builder/workspace-select-query-builder-v2';
type FilterWalkContext = {
- outerQueryBuilder: RecordQueryBuilder;
+ outerQueryBuilder: WorkspaceSelectQueryBuilderV2;
objectNameSingular: string;
fieldParser: GraphqlQueryFilterFieldParser;
useDirectTableReference: boolean;
@@ -19,7 +19,7 @@ export const applyFilterEntriesToWhereExpression = ({
useDirectTableReference = false,
}: {
whereExpression: WhereExpressionBuilder;
- outerQueryBuilder: RecordQueryBuilder;
+ outerQueryBuilder: WorkspaceSelectQueryBuilderV2;
objectNameSingular: string;
filter: Record<string, unknown>;
fieldParser: GraphqlQueryFilterFieldParser;
diff --git a/packages/twenty-server/src/engine/api/graphql/graphql-query-runner/graphql-query-runner.module.ts b/packages/twenty-server/src/engine/api/graphql/graphql-query-runner/graphql-query-runner.module.ts
index 07269c69b60..1c333dd62db 100644
--- a/packages/twenty-server/src/engine/api/graphql/graphql-query-runner/graphql-query-runner.module.ts
+++ b/packages/twenty-server/src/engine/api/graphql/graphql-query-runner/graphql-query-runner.module.ts
@@ -1,9 +1,8 @@
import { Module } from '@nestjs/common';
import { TypeOrmModule } from '@nestjs/typeorm';
-import { ProcessNestedRelationsOrmV2Helper } from 'src/engine/api/common/common-nested-relations-processor/process-nested-relations-orm-v2.helper';
-import { TwentyORMV2Module } from 'src/engine/twenty-orm-v2/twenty-orm-v2.module';
import { ProcessNestedRelationsHelper } from 'src/engine/api/common/common-nested-relations-processor/process-nested-relations.helper';
+import { TwentyORMV2Module } from 'src/engine/twenty-orm-v2/twenty-orm-v2.module';
import { ProcessAggregateHelper } from 'src/engine/api/graphql/graphql-query-runner/helpers/process-aggregate.helper';
import { WorkspaceQueryHookModule } from 'src/engine/api/graphql/workspace-query-runner/workspace-query-hook/workspace-query-hook.module';
import { WorkspaceQueryRunnerModule } from 'src/engine/api/graphql/workspace-query-runner/workspace-query-runner.module';
@@ -28,10 +27,6 @@ import { ViewModule } from 'src/engine/metadata-modules/view/view.module';
ViewFilterModule,
ViewFilterGroupModule,
],
- providers: [
- ProcessNestedRelationsHelper,
- ProcessNestedRelationsOrmV2Helper,
- ProcessAggregateHelper,
- ],
+ providers: [ProcessNestedRelationsHelper, ProcessAggregateHelper],
})
export class GraphqlQueryRunnerModule {}
diff --git a/packages/twenty-server/src/engine/api/graphql/graphql-query-runner/helpers/process-aggregate.helper.ts b/packages/twenty-server/src/engine/api/graphql/graphql-query-runner/helpers/process-aggregate.helper.ts
index ee85e2c38f5..5f69856ba9c 100644
--- a/packages/twenty-server/src/engine/api/graphql/graphql-query-runner/helpers/process-aggregate.helper.ts
+++ b/packages/twenty-server/src/engine/api/graphql/graphql-query-runner/helpers/process-aggregate.helper.ts
@@ -3,7 +3,7 @@ import { isDefined } from 'twenty-shared/utils';
import { type AggregationField } from 'src/engine/api/graphql/workspace-schema-builder/utils/get-available-aggregations-from-object-fields.util';
import { formatColumnNamesFromCompositeFieldAndSubfields } from 'src/engine/twenty-orm/utils/format-column-names-from-composite-field-and-subfield.util';
-import { type RecordQueryBuilder } from 'src/engine/api/graphql/graphql-query-runner/types/record-query-builder.type';
+import { type WorkspaceSelectQueryBuilderV2 } from 'src/engine/twenty-orm-v2/query-builder/workspace-select-query-builder-v2';
export class ProcessAggregateHelper {
public static addSelectedAggregatedFieldsQueriesToQueryBuilder = ({
@@ -13,7 +13,7 @@ export class ProcessAggregateHelper {
}: {
selectedAggregatedFields: Record<string, AggregationField>;
// oxlint-disable-next-line typescript/no-explicit-any
- queryBuilder: RecordQueryBuilder;
+ queryBuilder: WorkspaceSelectQueryBuilderV2;
objectMetadataNameSingular: string;
}) => {
queryBuilder.select([]);
diff --git a/packages/twenty-server/src/engine/api/graphql/graphql-query-runner/types/record-query-builder.type.ts b/packages/twenty-server/src/engine/api/graphql/graphql-query-runner/types/record-query-builder.type.ts
deleted file mode 100644
index 5ced7b397ae..00000000000
--- a/packages/twenty-server/src/engine/api/graphql/graphql-query-runner/types/record-query-builder.type.ts
+++ /dev/null
@@ -1,54 +0,0 @@
-import { type Brackets, type ObjectLiteral } from 'typeorm';
-import { type ObjectsPermissions } from 'twenty-shared/types';
-
-type WhereCondition = string | Brackets;
-
-// The slice of a query builder the shared parsers drive. Declared structurally rather
-// than against a class so both ORM implementations satisfy it without a cast.
-export type RecordQueryBuilder = {
- objectRecordsPermissions: ObjectsPermissions;
- expressionMap: {
- joinAttributes: {
- alias: { name: string };
- relation?: { isOneToMany: boolean; isManyToMany: boolean };
- }[];
- };
- where(condition: WhereCondition, parameters?: ObjectLiteral): unknown;
- andWhere(condition: WhereCondition, parameters?: ObjectLiteral): unknown;
- orWhere(condition: WhereCondition, parameters?: ObjectLiteral): unknown;
- select(selection?: string | string[], selectionAliasName?: string): unknown;
- addSelect(selection: string, selectionAliasName?: string): unknown;
- orderBy(
- sort?: string | Record<string, unknown>,
- order?: 'ASC' | 'DESC',
- nulls?: 'NULLS FIRST' | 'NULLS LAST',
- ): unknown;
- addOrderBy(
- sort: string,
- order?: 'ASC' | 'DESC',
- nulls?: 'NULLS FIRST' | 'NULLS LAST',
- ): unknown;
- leftJoin(
- entityOrProperty: string,
- alias: string,
- condition?: string,
- parameters?: ObjectLiteral,
- ): unknown;
- withDeleted(): unknown;
-};
-
-// What a read runner additionally needs to execute the query it just composed.
-export type ReadRecordQueryBuilder = RecordQueryBuilder & {
- clone(): ReadRecordQueryBuilder;
- setFindOptions(findOptions: { select?: Record<string, boolean> }): unknown;
- limit(count?: number): unknown;
- offset(count?: number): unknown;
- getMany(): Promise<ObjectLiteral[]>;
- getRawAndEntities(): Promise<{
- entities: ObjectLiteral[];
- raw: Record<string, unknown>[];
- }>;
- getRawOne<T extends Record<string, unknown> = ObjectLiteral>(): Promise<
- T | undefined
- >;
-};
diff --git a/packages/twenty-server/src/engine/subscriptions/subscriptions.module.ts b/packages/twenty-server/src/engine/subscriptions/subscriptions.module.ts
index e6469d89004..5dc989c7071 100644
--- a/packages/twenty-server/src/engine/subscriptions/subscriptions.module.ts
+++ b/packages/twenty-server/src/engine/subscriptions/subscriptions.module.ts
@@ -1,9 +1,8 @@
import { Global, Module } from '@nestjs/common';
import { TypeOrmModule } from '@nestjs/typeorm';
-import { ProcessNestedRelationsOrmV2Helper } from 'src/engine/api/common/common-nested-relations-processor/process-nested-relations-orm-v2.helper';
-import { TwentyORMV2Module } from 'src/engine/twenty-orm-v2/twenty-orm-v2.module';
import { ProcessNestedRelationsHelper } from 'src/engine/api/common/common-nested-relations-processor/process-nested-relations.helper';
+import { TwentyORMV2Module } from 'src/engine/twenty-orm-v2/twenty-orm-v2.module';
import { CommonSelectFieldsHelper } from 'src/engine/api/common/common-select-fields/common-select-fields-helper';
import { CacheLockModule } from 'src/engine/core-modules/cache-lock/cache-lock.module';
import { CacheStorageModule } from 'src/engine/core-modules/cache-storage/cache-storage.module';
@@ -51,7 +50,6 @@ import { WorkspaceCacheModule } from 'src/engine/workspace-cache/workspace-cache
MetadataEventsToDbListener,
WorkspaceEventBroadcaster,
ProcessNestedRelationsHelper,
- ProcessNestedRelationsOrmV2Helper,
CommonSelectFieldsHelper,
],
exports: [
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 cabcf94cd77..6ecf1c6b4cb 100644
--- a/packages/twenty-server/src/engine/twenty-orm-v2/README.md
+++ b/packages/twenty-server/src/engine/twenty-orm-v2/README.md
@@ -109,17 +109,17 @@ Wired into `CommonFindManyQueryRunnerService`, `CommonFindOneQueryRunnerService`
`CommonFindDuplicatesQueryRunnerService` and `CommonGroupByQueryRunnerService`. Other
runners keep `repository`.
-Nested relation loading also routes through v2 under the flag:
-`ProcessNestedRelationsOrmV2Helper` loads relations and relation aggregates on v2
+Nested relation loading also routes through v2:
+`ProcessNestedRelationsHelper` loads relations and relation aggregates on v2
repositories, and composes the per-parent-limit `CROSS JOIN LATERAL` as raw SQL run
-through `repository.executeRaw`. The shared `ProcessNestedRelationsHelper` flag-branches
-to it, so a flagged read now reads root rows and their relations through v2.
+through `repository.executeRaw`, so a read fetches root rows and their relations
+through v2.
group-by "with records" is the one path that is not a transparent swap: it wraps a
builder subquery in a table-less `FROM (subquery)` JSON_AGG query, which the
table-shape builder cannot represent. `GroupByWithRecordsV2Service` builds the inner
subquery with the v2 builder and runs the composed outer query through
-`repository.executeRaw`; the runner flag-branches between it and the v1 service.
+`repository.executeRaw`.
## Writes: delete, destroy, restore and (most) update route through v2
@@ -131,7 +131,7 @@ generator. The select builder morphs into it: `.update()` / `.delete()` / `.soft
the TypeORM surface the mutation runners already call.
`deleteMany`, `destroyMany`, `restoreMany` and `updateMany` (and their `...One` delegates)
-flag-branch to this path through the shared `runFilteredMutation` on the base runner. Each
+route to this path through the shared `runFilteredMutation` on the base runner. Each
builds the filtered v2 select builder with `buildMutationQueryBuilderV2` (which rewrites a
relation-traversal filter into an `id IN (subquery)` predicate, RLS inside the subquery)
and hands it to `WorkspaceRepositoryV2.runMutation`, which owns the choreography the v1
@@ -152,7 +152,7 @@ is synced through the same v1 `FilesFieldSync` the write query builders use: the
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
+is built. Nothing on the write path carves back to v1 any more: every
create / update / upsert / delete / merge runs entirely on v2 regardless of the field types
it touches.
@@ -179,8 +179,8 @@ Deliberate choices, the SQL ones asserted by exact-SQL unit tests:
soft-delete stamps `deletedAt` and `updatedAt`; restore clears `deletedAt` and stamps
`updatedAt`.
- Hard delete snapshots its before-image with `getOne`, so a `DESTROYED` event carries at
- most one record. This matches the v1 delete builder rather than fixing it here; changing
- it would change flag-off behaviour too and belongs in a separate change to both paths.
+ most one record. This matches what the v1 delete builder used to do rather than fixing it here;
+ changing it belongs in a separate change.
- A filter that traverses a to-many relation surfaces the same `UNSUPPORTED_OPERATION`
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.
@@ -204,7 +204,7 @@ all-columns re-select of the inserted ids — matching the v1 insert builder. Re
`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`
+`mergeMany` always routes through it: `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`/
@@ -230,7 +230,7 @@ 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,
+Every write the API layer can reach runs entirely on v2 — 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.
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 9613ba2510f..3ac108b12ab 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
@@ -1,7 +1,11 @@
import { type Pool } from 'pg';
import { isDefined } from 'twenty-shared/utils';
-import { type ObjectsPermissionsByRoleId } from 'twenty-shared/types';
+import {
+ type ObjectRecord,
+ type ObjectsPermissionsByRoleId,
+} from 'twenty-shared/types';
+import { type ObjectLiteral } from 'typeorm';
import { type WorkspaceAuthContext } from 'src/engine/core-modules/auth/types/workspace-auth-context.type';
import { findFlatEntityByIdInFlatEntityMapsOrThrow } from 'src/engine/metadata-modules/flat-entity/utils/find-flat-entity-by-id-in-flat-entity-maps-or-throw.util';
@@ -60,11 +64,11 @@ export class WorkspaceDataSourceV2 {
this.objectPermissionsByRoleId = objectPermissionsByRoleId;
}
- getRepository(
+ getRepository<T extends ObjectLiteral = ObjectRecord>(
nameSingular: string,
rolePermissionConfig?: RolePermissionConfig,
- ): WorkspaceRepositoryV2 {
- return this.buildRepository({
+ ): WorkspaceRepositoryV2<T> {
+ return this.buildRepository<T>({
nameSingular,
rolePermissionConfig,
executor: new PoolQueryExecutor({ pool: this.pool }),
@@ -98,7 +102,7 @@ export class WorkspaceDataSourceV2 {
});
}
- private buildRepository({
+ private buildRepository<T extends ObjectLiteral = ObjectRecord>({
nameSingular,
rolePermissionConfig,
executor,
@@ -108,7 +112,7 @@ export class WorkspaceDataSourceV2 {
rolePermissionConfig?: RolePermissionConfig;
executor: QueryExecutorV2;
isTransactional?: boolean;
- }): WorkspaceRepositoryV2 {
+ }): WorkspaceRepositoryV2<T> {
const objectMetadataId =
this.internalContext.objectIdByNameSingular[nameSingular];
@@ -119,7 +123,7 @@ export class WorkspaceDataSourceV2 {
);
}
- return this.buildRepositoryForObjectMetadataId({
+ return this.buildRepositoryForObjectMetadataId<T>({
objectMetadataId,
rolePermissionConfig,
executor,
@@ -127,7 +131,9 @@ export class WorkspaceDataSourceV2 {
});
}
- private buildRepositoryForObjectMetadataId({
+ private buildRepositoryForObjectMetadataId<
+ T extends ObjectLiteral = ObjectRecord,
+ >({
objectMetadataId,
rolePermissionConfig,
executor,
@@ -137,7 +143,7 @@ export class WorkspaceDataSourceV2 {
rolePermissionConfig?: RolePermissionConfig;
executor: QueryExecutorV2;
isTransactional?: boolean;
- }): WorkspaceRepositoryV2 {
+ }): WorkspaceRepositoryV2<T> {
const flatObjectMetadata =
this.getFlatObjectMetadataOrThrow(objectMetadataId);
@@ -147,7 +153,7 @@ export class WorkspaceDataSourceV2 {
objectPermissionsByRoleId: this.objectPermissionsByRoleId,
});
- return new WorkspaceRepositoryV2({
+ return new WorkspaceRepositoryV2<T>({
tableShape: this.getTableShape(objectMetadataId),
flatObjectMetadata,
internalContext: this.internalContext,
diff --git a/packages/twenty-server/src/engine/workspace-datasource/workspace-datasource.service.ts b/packages/twenty-server/src/engine/workspace-datasource/workspace-datasource.service.ts
index 684d71c26e1..601042d9723 100644
--- a/packages/twenty-server/src/engine/workspace-datasource/workspace-datasource.service.ts
+++ b/packages/twenty-server/src/engine/workspace-datasource/workspace-datasource.service.ts
@@ -2,7 +2,6 @@ import { Injectable } from '@nestjs/common';
import { InjectDataSource, InjectRepository } from '@nestjs/typeorm';
import { msg } from '@lingui/core/macro';
-import { isNonEmptyString } from '@sniptt/guards';
import { type DataSource, type EntityManager, Repository } from 'typeorm';
import { TwentyConfigService } from 'src/engine/core-modules/twenty-config/twenty-config.service';
@@ -37,15 +36,6 @@ export class WorkspaceDataSourceService {
}
}
- public async checkSchemaExists(workspaceId: string): Promise<boolean> {
- const workspace = await this.workspaceRepository.findOne({
- select: ['databaseSchema'],
- where: { id: workspaceId },
- });
-
- return isNonEmptyString(workspace?.databaseSchema);
- }
-
public async createWorkspaceDBSchema(workspaceId: string): Promise<string> {
this.assertDDLNotLocked();