feat: new relation in graphql-query-runner (#9883)

Fix https://github.com/twentyhq/core-team-issues/issues/300

Within GraphQLQueryRunner the new relation format will be used when the
feature flag `IsNewRelationEnabled` is set to true.

packages/twenty-server/src/engine/api/graphql/graphql-query-runner/errors/graphql-query-runner.exception.ts

@@ -21,4 +21,6 @@ export enum GraphqlQueryRunnerExceptionCode {
   INVALID_ARGS_LAST = 'INVALID_ARGS_LAST',
   METADATA_CACHE_VERSION_NOT_FOUND = 'METADATA_CACHE_VERSION_NOT_FOUND',
   METADATA_CACHE_FEATURE_FLAG_RECOMPUTATION_REQUIRED = 'METADATA_CACHE_FEATURE_FLAG_RECOMPUTATION_REQUIRED',
+  RELATION_SETTINGS_NOT_FOUND = 'RELATION_SETTINGS_NOT_FOUND',
+  RELATION_TARGET_OBJECT_METADATA_NOT_FOUND = 'RELATION_TARGET_OBJECT_METADATA_NOT_FOUND',
 }

packages/twenty-server/src/engine/api/graphql/graphql-query-runner/graphql-query-parsers/graphql-query-filter/graphql-query-filter-condition.parser.ts

@@ -6,6 +6,7 @@ import {
 } from 'typeorm';
 
 import { ObjectRecordFilter } from 'src/engine/api/graphql/workspace-query-builder/interfaces/object-record.interface';
+import { FeatureFlagMap } from 'src/engine/core-modules/feature-flag/interfaces/feature-flag-map.interface';
 
 import { FieldMetadataMap } from 'src/engine/metadata-modules/types/field-metadata-map';
 
@@ -15,10 +16,14 @@ export class GraphqlQueryFilterConditionParser {
   private fieldMetadataMapByName: FieldMetadataMap;
   private queryFilterFieldParser: GraphqlQueryFilterFieldParser;
 
-  constructor(fieldMetadataMapByName: FieldMetadataMap) {
+  constructor(
+    fieldMetadataMapByName: FieldMetadataMap,
+    featureFlagsMap: FeatureFlagMap,
+  ) {
     this.fieldMetadataMapByName = fieldMetadataMapByName;
     this.queryFilterFieldParser = new GraphqlQueryFilterFieldParser(
       this.fieldMetadataMapByName,
+      featureFlagsMap,
     );
   }
 

packages/twenty-server/src/engine/api/graphql/graphql-query-runner/graphql-query-parsers/graphql-query-filter/graphql-query-filter-field.parser.ts

@@ -1,6 +1,7 @@
 import { capitalize } from 'twenty-shared';
 import { WhereExpressionBuilder } from 'typeorm';
 
+import { FeatureFlagMap } from 'src/engine/core-modules/feature-flag/interfaces/feature-flag-map.interface';
 import { FieldMetadataInterface } from 'src/engine/metadata-modules/field-metadata/interfaces/field-metadata.interface';
 
 import {
@@ -17,9 +18,14 @@ const ARRAY_OPERATORS = ['in', 'contains', 'notContains'];
 
 export class GraphqlQueryFilterFieldParser {
   private fieldMetadataMapByName: FieldMetadataMap;
+  private featureFlagsMap: FeatureFlagMap;
 
-  constructor(fieldMetadataMapByName: FieldMetadataMap) {
+  constructor(
+    fieldMetadataMapByName: FieldMetadataMap,
+    featureFlagsMap: FeatureFlagMap,
+  ) {
     this.fieldMetadataMapByName = fieldMetadataMapByName;
+    this.featureFlagsMap = featureFlagsMap;
   }
 
   public parse(

packages/twenty-server/src/engine/api/graphql/graphql-query-runner/graphql-query-parsers/graphql-query-order/graphql-query-order.parser.ts

@@ -4,6 +4,7 @@ import {
   ObjectRecordOrderBy,
   OrderByDirection,
 } from 'src/engine/api/graphql/workspace-query-builder/interfaces/object-record.interface';
+import { FeatureFlagMap } from 'src/engine/core-modules/feature-flag/interfaces/feature-flag-map.interface';
 import { FieldMetadataInterface } from 'src/engine/metadata-modules/field-metadata/interfaces/field-metadata.interface';
 
 import {
@@ -16,9 +17,14 @@ import { FieldMetadataMap } from 'src/engine/metadata-modules/types/field-metada
 import { CompositeFieldMetadataType } from 'src/engine/metadata-modules/workspace-migration/factories/composite-column-action.factory';
 export class GraphqlQueryOrderFieldParser {
   private fieldMetadataMapByName: FieldMetadataMap;
+  private featureFlagsMap: FeatureFlagMap;
 
-  constructor(fieldMetadataMapByName: FieldMetadataMap) {
+  constructor(
+    fieldMetadataMapByName: FieldMetadataMap,
+    featureFlagsMap: FeatureFlagMap,
+  ) {
     this.fieldMetadataMapByName = fieldMetadataMapByName;
+    this.featureFlagsMap = featureFlagsMap;
   }
 
   parse(

packages/twenty-server/src/engine/api/graphql/graphql-query-runner/graphql-query-parsers/graphql-query-selected-fields/graphql-selected-fields-relation.parser.ts

@@ -1,3 +1,4 @@
+import { FeatureFlagMap } from 'src/engine/core-modules/feature-flag/interfaces/feature-flag-map.interface';
 import { FieldMetadataInterface } from 'src/engine/metadata-modules/field-metadata/interfaces/field-metadata.interface';
 
 import {
@@ -5,13 +6,20 @@ import {
   GraphqlQuerySelectedFieldsResult,
 } from 'src/engine/api/graphql/graphql-query-runner/graphql-query-parsers/graphql-query-selected-fields/graphql-selected-fields.parser';
 import { getRelationObjectMetadata } from 'src/engine/api/graphql/graphql-query-runner/utils/get-relation-object-metadata.util';
+import { getTargetObjectMetadataOrThrow } from 'src/engine/api/graphql/graphql-query-runner/utils/get-target-object-metadata.util';
+import { FeatureFlagKey } from 'src/engine/core-modules/feature-flag/enums/feature-flag-key.enum';
 import { ObjectMetadataMaps } from 'src/engine/metadata-modules/types/object-metadata-maps';
 
 export class GraphqlQuerySelectedFieldsRelationParser {
   private objectMetadataMaps: ObjectMetadataMaps;
+  private featureFlagsMap: FeatureFlagMap;
 
-  constructor(objectMetadataMaps: ObjectMetadataMaps) {
+  constructor(
+    objectMetadataMaps: ObjectMetadataMaps,
+    featureFlagsMap: FeatureFlagMap,
+  ) {
     this.objectMetadataMaps = objectMetadataMaps;
+    this.featureFlagsMap = featureFlagsMap;
   }
 
   parseRelationField(
@@ -26,16 +34,19 @@ export class GraphqlQuerySelectedFieldsRelationParser {
 
     accumulator.relations[fieldKey] = true;
 
-    const referencedObjectMetadata = getRelationObjectMetadata(
+    const isNewRelationEnabled =
-      fieldMetadata,
+      this.featureFlagsMap[FeatureFlagKey.IsNewRelationEnabled];
-      this.objectMetadataMaps,
-    );
 
-    const relationFields = referencedObjectMetadata.fieldsByName;
+    const targetObjectMetadata = isNewRelationEnabled
+      ? getTargetObjectMetadataOrThrow(fieldMetadata, this.objectMetadataMaps)
+      : getRelationObjectMetadata(fieldMetadata, this.objectMetadataMaps);
+
+    const targetFields = targetObjectMetadata.fieldsByName;
     const fieldParser = new GraphqlQuerySelectedFieldsParser(
       this.objectMetadataMaps,
+      this.featureFlagsMap,
     );
-    const relationAccumulator = fieldParser.parse(fieldValue, relationFields);
+    const relationAccumulator = fieldParser.parse(fieldValue, targetFields);
 
     accumulator.select[fieldKey] = {
       id: true,

packages/twenty-server/src/engine/api/graphql/graphql-query-runner/graphql-query-parsers/graphql-query-selected-fields/graphql-selected-fields.parser.ts

@@ -1,5 +1,6 @@
 import { capitalize } from 'twenty-shared';
 
+import { FeatureFlagMap } from 'src/engine/core-modules/feature-flag/interfaces/feature-flag-map.interface';
 import { FieldMetadataInterface } from 'src/engine/metadata-modules/field-metadata/interfaces/field-metadata.interface';
 
 import { GraphqlQuerySelectedFieldsAggregateParser } from 'src/engine/api/graphql/graphql-query-runner/graphql-query-parsers/graphql-query-selected-fields/graphql-selected-fields-aggregate.parser';
@@ -20,9 +21,15 @@ export class GraphqlQuerySelectedFieldsParser {
   private graphqlQuerySelectedFieldsRelationParser: GraphqlQuerySelectedFieldsRelationParser;
   private aggregateParser: GraphqlQuerySelectedFieldsAggregateParser;
 
-  constructor(objectMetadataMaps: ObjectMetadataMaps) {
+  constructor(
+    objectMetadataMaps: ObjectMetadataMaps,
+    featureFlagsMap: FeatureFlagMap,
+  ) {
     this.graphqlQuerySelectedFieldsRelationParser =
-      new GraphqlQuerySelectedFieldsRelationParser(objectMetadataMaps);
+      new GraphqlQuerySelectedFieldsRelationParser(
+        objectMetadataMaps,
+        featureFlagsMap,
+      );
     this.aggregateParser = new GraphqlQuerySelectedFieldsAggregateParser();
   }
 

packages/twenty-server/src/engine/api/graphql/graphql-query-runner/graphql-query-parsers/graphql-query.parser.ts

@@ -9,6 +9,7 @@ import {
   ObjectRecordFilter,
   ObjectRecordOrderBy,
 } from 'src/engine/api/graphql/workspace-query-builder/interfaces/object-record.interface';
+import { FeatureFlagMap } from 'src/engine/core-modules/feature-flag/interfaces/feature-flag-map.interface';
 
 import { GraphqlQueryFilterConditionParser } from 'src/engine/api/graphql/graphql-query-runner/graphql-query-parsers/graphql-query-filter/graphql-query-filter-condition.parser';
 import { GraphqlQueryOrderFieldParser } from 'src/engine/api/graphql/graphql-query-runner/graphql-query-parsers/graphql-query-order/graphql-query-order.parser';
@@ -26,18 +27,23 @@ export class GraphqlQueryParser {
   private objectMetadataMaps: ObjectMetadataMaps;
   private filterConditionParser: GraphqlQueryFilterConditionParser;
   private orderFieldParser: GraphqlQueryOrderFieldParser;
+  private featureFlagsMap: FeatureFlagMap;
 
   constructor(
     fieldMetadataMapByName: FieldMetadataMap,
     objectMetadataMaps: ObjectMetadataMaps,
+    featureFlagsMap: FeatureFlagMap,
   ) {
     this.objectMetadataMaps = objectMetadataMaps;
     this.fieldMetadataMapByName = fieldMetadataMapByName;
+    this.featureFlagsMap = featureFlagsMap;
     this.filterConditionParser = new GraphqlQueryFilterConditionParser(
       this.fieldMetadataMapByName,
+      featureFlagsMap,
     );
     this.orderFieldParser = new GraphqlQueryOrderFieldParser(
       this.fieldMetadataMapByName,
+      featureFlagsMap,
     );
   }
 
@@ -122,6 +128,7 @@ export class GraphqlQueryParser {
 
     const selectedFieldsParser = new GraphqlQuerySelectedFieldsParser(
       this.objectMetadataMaps,
+      this.featureFlagsMap,
     );
 
     return selectedFieldsParser.parse(graphqlSelectedFields, parentFields);

packages/twenty-server/src/engine/api/graphql/graphql-query-runner/graphql-query-runner.module.ts

@@ -1,5 +1,8 @@
 import { Module } from '@nestjs/common';
 
+import { ProcessAggregateHelper } from 'src/engine/api/graphql/graphql-query-runner/helpers/process-aggregate.helper';
+import { ProcessNestedRelationsV2Helper } from 'src/engine/api/graphql/graphql-query-runner/helpers/process-nested-relations-v2.helper';
+import { ProcessNestedRelationsHelper } from 'src/engine/api/graphql/graphql-query-runner/helpers/process-nested-relations.helper';
 import { GraphqlQueryCreateManyResolverService } from 'src/engine/api/graphql/graphql-query-runner/resolvers/graphql-query-create-many-resolver.service';
 import { GraphqlQueryCreateOneResolverService } from 'src/engine/api/graphql/graphql-query-runner/resolvers/graphql-query-create-one-resolver.service';
 import { GraphqlQueryDeleteManyResolverService } from 'src/engine/api/graphql/graphql-query-runner/resolvers/graphql-query-delete-many-resolver.service';
@@ -42,7 +45,13 @@ const graphqlQueryResolvers = [
     WorkspaceQueryRunnerModule,
     FeatureFlagModule,
   ],
-  providers: [ApiEventEmitterService, ...graphqlQueryResolvers],
+  providers: [
+    ApiEventEmitterService,
+    ProcessNestedRelationsHelper,
+    ProcessNestedRelationsV2Helper,
+    ProcessAggregateHelper,
+    ...graphqlQueryResolvers,
+  ],
   exports: [...graphqlQueryResolvers],
 })
 export class GraphqlQueryRunnerModule {}

packages/twenty-server/src/engine/api/graphql/graphql-query-runner/helpers/object-records-to-graphql-connection.helper.ts

@@ -5,6 +5,7 @@ import {
   ObjectRecordOrderBy,
 } from 'src/engine/api/graphql/workspace-query-builder/interfaces/object-record.interface';
 import { IConnection } from 'src/engine/api/graphql/workspace-query-runner/interfaces/connection.interface';
+import { FeatureFlagMap } from 'src/engine/core-modules/feature-flag/interfaces/feature-flag-map.interface';
 import { FieldMetadataInterface } from 'src/engine/metadata-modules/field-metadata/interfaces/field-metadata.interface';
 
 import { CONNECTION_MAX_DEPTH } from 'src/engine/api/graphql/graphql-query-runner/constants/connection-max-depth.constant';
@@ -14,7 +15,9 @@ import {
 } from 'src/engine/api/graphql/graphql-query-runner/errors/graphql-query-runner.exception';
 import { encodeCursor } from 'src/engine/api/graphql/graphql-query-runner/utils/cursors.util';
 import { getRelationObjectMetadata } from 'src/engine/api/graphql/graphql-query-runner/utils/get-relation-object-metadata.util';
+import { getTargetObjectMetadataOrThrow } from 'src/engine/api/graphql/graphql-query-runner/utils/get-target-object-metadata.util';
 import { AggregationField } from 'src/engine/api/graphql/workspace-schema-builder/utils/get-available-aggregations-from-object-fields.util';
+import { FeatureFlagKey } from 'src/engine/core-modules/feature-flag/enums/feature-flag-key.enum';
 import { compositeTypeDefinitions } from 'src/engine/metadata-modules/field-metadata/composite-types';
 import { isCompositeFieldMetadataType } from 'src/engine/metadata-modules/field-metadata/utils/is-composite-field-metadata-type.util';
 import { ObjectMetadataMaps } from 'src/engine/metadata-modules/types/object-metadata-maps';
@@ -26,9 +29,14 @@ import { isPlainObject } from 'src/utils/is-plain-object';
 
 export class ObjectRecordsToGraphqlConnectionHelper {
   private objectMetadataMaps: ObjectMetadataMaps;
+  private featureFlagsMap: FeatureFlagMap;
 
-  constructor(objectMetadataMaps: ObjectMetadataMaps) {
+  constructor(
+    objectMetadataMaps: ObjectMetadataMaps,
+    featureFlagsMap: FeatureFlagMap,
+  ) {
     this.objectMetadataMaps = objectMetadataMaps;
+    this.featureFlagsMap = featureFlagsMap;
   }
 
   public createConnection<T extends ObjectRecord = ObjectRecord>({
@@ -146,6 +154,9 @@ export class ObjectRecordsToGraphqlConnectionHelper {
       );
     }
 
+    const isNewRelationEnabled =
+      this.featureFlagsMap[FeatureFlagKey.IsNewRelationEnabled];
+
     const objectMetadata = getObjectMetadataMapItemByNameSingular(
       this.objectMetadataMaps,
       objectName,
@@ -170,6 +181,13 @@ export class ObjectRecordsToGraphqlConnectionHelper {
 
       if (isRelationFieldMetadataType(fieldMetadata.type)) {
         if (Array.isArray(value)) {
+          const targetObjectMetadata = isNewRelationEnabled
+            ? getTargetObjectMetadataOrThrow(
+                fieldMetadata,
+                this.objectMetadataMaps,
+              )
+            : getRelationObjectMetadata(fieldMetadata, this.objectMetadataMaps);
+
           processedObjectRecord[key] = this.createConnection({
             objectRecords: value,
             parentObjectRecord: objectRecord,
@@ -177,10 +195,7 @@ export class ObjectRecordsToGraphqlConnectionHelper {
               objectRecordsAggregatedValues[fieldMetadata.name],
             selectedAggregatedFields:
               selectedAggregatedFields[fieldMetadata.name],
-            objectName: getRelationObjectMetadata(
+            objectName: targetObjectMetadata.nameSingular,
-              fieldMetadata,
-              this.objectMetadataMaps,
-            ).nameSingular,
             take,
             totalCount:
               objectRecordsAggregatedValues[fieldMetadata.name]?.totalCount ??
@@ -191,16 +206,20 @@ export class ObjectRecordsToGraphqlConnectionHelper {
             depth: depth + 1,
           });
         } else if (isPlainObject(value)) {
+          const targetObjectMetadata = isNewRelationEnabled
+            ? getTargetObjectMetadataOrThrow(
+                fieldMetadata,
+                this.objectMetadataMaps,
+              )
+            : getRelationObjectMetadata(fieldMetadata, this.objectMetadataMaps);
+
           processedObjectRecord[key] = this.processRecord({
             objectRecord: value,
             objectRecordsAggregatedValues:
               objectRecordsAggregatedValues[fieldMetadata.name],
             selectedAggregatedFields:
               selectedAggregatedFields[fieldMetadata.name],
-            objectName: getRelationObjectMetadata(
+            objectName: targetObjectMetadata.nameSingular,
-              fieldMetadata,
-              this.objectMetadataMaps,
-            ).nameSingular,
             take,
             totalCount,
             order,

packages/twenty-server/src/engine/api/graphql/graphql-query-runner/helpers/process-aggregate.helper.ts

@@ -1,3 +1,5 @@
+import { Injectable } from '@nestjs/common';
+
 import { SelectQueryBuilder } from 'typeorm';
 
 import { AGGREGATE_OPERATIONS } from 'src/engine/api/graphql/graphql-query-runner/constants/aggregate-operations.constant';
@@ -5,6 +7,7 @@ import { AggregationField } from 'src/engine/api/graphql/workspace-schema-builde
 import { formatColumnNamesFromCompositeFieldAndSubfields } from 'src/engine/twenty-orm/utils/format-column-names-from-composite-field-and-subfield.util';
 import { isDefined } from 'src/utils/is-defined';
 
+@Injectable()
 export class ProcessAggregateHelper {
   public addSelectedAggregatedFieldsQueriesToQueryBuilder = ({
     selectedAggregatedFields,

packages/twenty-server/src/engine/api/graphql/graphql-query-runner/helpers/process-nested-relations-v2.helper.ts

@@ -0,0 +1,347 @@
+import { Injectable } from '@nestjs/common';
+
+import {
+  DataSource,
+  FindOptionsRelations,
+  ObjectLiteral,
+  SelectQueryBuilder,
+} from 'typeorm';
+
+import { ObjectRecord } from 'src/engine/api/graphql/workspace-query-builder/interfaces/object-record.interface';
+import { RelationType } from 'src/engine/metadata-modules/field-metadata/interfaces/relation-type.interface';
+
+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 { getTargetObjectMetadataOrThrow } from 'src/engine/api/graphql/graphql-query-runner/utils/get-target-object-metadata.util';
+import { AggregationField } from 'src/engine/api/graphql/workspace-schema-builder/utils/get-available-aggregations-from-object-fields.util';
+import { AuthContext } from 'src/engine/core-modules/auth/types/auth-context.type';
+import { ObjectMetadataItemWithFieldMaps } from 'src/engine/metadata-modules/types/object-metadata-item-with-field-maps';
+import { ObjectMetadataMaps } from 'src/engine/metadata-modules/types/object-metadata-maps';
+import { getObjectMetadataMapItemByNameSingular } from 'src/engine/metadata-modules/utils/get-object-metadata-map-item-by-name-singular.util';
+import { formatResult } from 'src/engine/twenty-orm/utils/format-result.util';
+import { isRelationFieldMetadata } from 'src/engine/utils/is-relation-field-metadata.util';
+
+@Injectable()
+export class ProcessNestedRelationsV2Helper {
+  constructor(
+    private readonly processAggregateHelper: ProcessAggregateHelper,
+  ) {}
+
+  public async processNestedRelations<T extends ObjectRecord = ObjectRecord>({
+    objectMetadataMaps,
+    parentObjectMetadataItem,
+    parentObjectRecords,
+    parentObjectRecordsAggregatedValues = {},
+    relations,
+    aggregate = {},
+    limit,
+    authContext,
+    dataSource,
+  }: {
+    objectMetadataMaps: ObjectMetadataMaps;
+    parentObjectMetadataItem: ObjectMetadataItemWithFieldMaps;
+    parentObjectRecords: T[];
+    parentObjectRecordsAggregatedValues?: Record<string, any>;
+    relations: Record<string, FindOptionsRelations<ObjectLiteral>>;
+    aggregate?: Record<string, AggregationField>;
+    limit: number;
+    authContext: AuthContext;
+    dataSource: DataSource;
+  }): Promise<void> {
+    const processRelationTasks = Object.entries(relations).map(
+      ([sourceFieldName, nestedRelations]) =>
+        this.processRelation({
+          objectMetadataMaps,
+          parentObjectMetadataItem,
+          parentObjectRecords,
+          parentObjectRecordsAggregatedValues,
+          sourceFieldName,
+          nestedRelations,
+          aggregate,
+          limit,
+          authContext,
+          dataSource,
+        }),
+    );
+
+    await Promise.all(processRelationTasks);
+  }
+
+  private async processRelation<T extends ObjectRecord = ObjectRecord>({
+    objectMetadataMaps,
+    parentObjectMetadataItem,
+    parentObjectRecords,
+    parentObjectRecordsAggregatedValues,
+    sourceFieldName,
+    nestedRelations,
+    aggregate,
+    limit,
+    authContext,
+    dataSource,
+  }: {
+    objectMetadataMaps: ObjectMetadataMaps;
+    parentObjectMetadataItem: ObjectMetadataItemWithFieldMaps;
+    parentObjectRecords: T[];
+    parentObjectRecordsAggregatedValues: Record<string, any>;
+    sourceFieldName: string;
+    nestedRelations: FindOptionsRelations<ObjectLiteral>;
+    aggregate: Record<string, AggregationField>;
+    limit: number;
+    authContext: AuthContext;
+    dataSource: DataSource;
+  }): Promise<void> {
+    const sourceFieldMetadata =
+      parentObjectMetadataItem.fieldsByName[sourceFieldName];
+
+    if (!isRelationFieldMetadata(sourceFieldMetadata)) {
+      // TODO: Maybe we should throw an error here ?
+      return;
+    }
+
+    if (!sourceFieldMetadata.settings) {
+      throw new GraphqlQueryRunnerException(
+        `Relation settings not found for field ${sourceFieldName}`,
+        GraphqlQueryRunnerExceptionCode.RELATION_SETTINGS_NOT_FOUND,
+      );
+    }
+
+    const relationType = sourceFieldMetadata.settings?.relationType;
+    const { targetRelationName, targetObjectMetadata } =
+      this.getTargetObjectMetadata({
+        objectMetadataMaps,
+        parentObjectMetadataItem,
+        sourceFieldName,
+      });
+
+    const targetObjectRepository = dataSource.getRepository(
+      targetObjectMetadata.nameSingular,
+    );
+    const targetObjectQueryBuilder = targetObjectRepository.createQueryBuilder(
+      targetObjectMetadata.nameSingular,
+    );
+
+    const relationIds = this.getUniqueIds({
+      records: parentObjectRecords,
+      idField:
+        relationType === RelationType.ONE_TO_MANY
+          ? 'id'
+          : `${sourceFieldName}Id`,
+    });
+
+    const { relationResults, relationAggregatedFieldsResult } =
+      await this.findRelations({
+        referenceQueryBuilder: targetObjectQueryBuilder,
+        column:
+          relationType === RelationType.ONE_TO_MANY
+            ? `"${targetRelationName}Id"`
+            : 'id',
+        ids: relationIds,
+        limit,
+        objectMetadataMaps,
+        targetObjectMetadata,
+        aggregate,
+        sourceFieldName,
+      });
+
+    this.assignRelationResults({
+      parentRecords: parentObjectRecords,
+      parentObjectRecordsAggregatedValues,
+      relationResults,
+      relationAggregatedFieldsResult,
+      sourceFieldName,
+      joinField:
+        relationType === RelationType.ONE_TO_MANY
+          ? `${targetRelationName}Id`
+          : 'id',
+      relationType,
+    });
+
+    const targetObjectMetadataItemWithFieldsMaps =
+      getObjectMetadataMapItemByNameSingular(
+        objectMetadataMaps,
+        targetObjectMetadata.nameSingular,
+      );
+
+    if (!targetObjectMetadataItemWithFieldsMaps) {
+      throw new GraphqlQueryRunnerException(
+        `Object ${targetObjectMetadata.nameSingular} not found`,
+        GraphqlQueryRunnerExceptionCode.OBJECT_METADATA_NOT_FOUND,
+      );
+    }
+
+    if (Object.keys(nestedRelations).length > 0) {
+      await this.processNestedRelations({
+        objectMetadataMaps,
+        parentObjectMetadataItem: targetObjectMetadataItemWithFieldsMaps,
+        parentObjectRecords: relationResults as ObjectRecord[],
+        parentObjectRecordsAggregatedValues: relationAggregatedFieldsResult,
+        relations: nestedRelations as Record<
+          string,
+          FindOptionsRelations<ObjectLiteral>
+        >,
+        aggregate,
+        limit,
+        authContext,
+        dataSource,
+      });
+    }
+  }
+
+  private getTargetObjectMetadata({
+    objectMetadataMaps,
+    parentObjectMetadataItem,
+    sourceFieldName,
+  }: {
+    objectMetadataMaps: ObjectMetadataMaps;
+    parentObjectMetadataItem: ObjectMetadataItemWithFieldMaps;
+    sourceFieldName: string;
+  }) {
+    const targetFieldMetadata =
+      parentObjectMetadataItem.fieldsByName[sourceFieldName];
+    const targetObjectMetadata = getTargetObjectMetadataOrThrow(
+      targetFieldMetadata,
+      objectMetadataMaps,
+    );
+
+    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,
+      );
+    }
+
+    const targetRelationName =
+      objectMetadataMaps.byId[
+        targetFieldMetadata.relationTargetObjectMetadataId
+      ]?.fieldsById[targetFieldMetadata.relationTargetFieldMetadataId]?.name;
+
+    return { targetRelationName, targetObjectMetadata };
+  }
+
+  private getUniqueIds({
+    records,
+    idField,
+  }: {
+    records: ObjectRecord[];
+    idField: string;
+  }): any[] {
+    return [...new Set(records.map((item) => item[idField]))];
+  }
+
+  private async findRelations({
+    referenceQueryBuilder,
+    column,
+    ids,
+    limit,
+    objectMetadataMaps,
+    targetObjectMetadata,
+    aggregate,
+    sourceFieldName,
+  }: {
+    referenceQueryBuilder: SelectQueryBuilder<any>;
+    column: string;
+    ids: any[];
+    limit: number;
+    objectMetadataMaps: ObjectMetadataMaps;
+    targetObjectMetadata: ObjectMetadataItemWithFieldMaps;
+    aggregate: Record<string, any>;
+    sourceFieldName: string;
+  }): Promise<{ relationResults: any[]; relationAggregatedFieldsResult: any }> {
+    if (ids.length === 0) {
+      return { relationResults: [], relationAggregatedFieldsResult: {} };
+    }
+
+    const aggregateForRelation = aggregate[sourceFieldName];
+    let relationAggregatedFieldsResult: Record<string, any> = {};
+
+    if (aggregateForRelation) {
+      const aggregateQueryBuilder = referenceQueryBuilder.clone();
+
+      this.processAggregateHelper.addSelectedAggregatedFieldsQueriesToQueryBuilder(
+        {
+          selectedAggregatedFields: aggregateForRelation,
+          queryBuilder: aggregateQueryBuilder,
+        },
+      );
+
+      const aggregatedFieldsValues = await aggregateQueryBuilder
+        .addSelect(column)
+        .where(`${column} IN (:...ids)`, {
+          ids,
+        })
+        .groupBy(column)
+        .getRawMany();
+
+      relationAggregatedFieldsResult = aggregatedFieldsValues.reduce(
+        (acc, item) => {
+          const columnWithoutQuotes = column.replace(/["']/g, '');
+          const key = item[columnWithoutQuotes];
+          const { [column]: _, ...itemWithoutColumn } = item;
+
+          acc[key] = itemWithoutColumn;
+
+          return acc;
+        },
+        {},
+      );
+    }
+
+    const result = await referenceQueryBuilder
+      .where(`${column} IN (:...ids)`, {
+        ids,
+      })
+      .take(limit)
+      .getMany();
+
+    const relationResults = formatResult<ObjectRecord[]>(
+      result,
+      targetObjectMetadata,
+      objectMetadataMaps,
+    );
+
+    return { relationResults, relationAggregatedFieldsResult };
+  }
+
+  private assignRelationResults({
+    parentRecords,
+    parentObjectRecordsAggregatedValues,
+    relationResults,
+    relationAggregatedFieldsResult,
+    sourceFieldName,
+    joinField,
+    relationType,
+  }: {
+    parentRecords: ObjectRecord[];
+    parentObjectRecordsAggregatedValues: Record<string, any>;
+    relationResults: any[];
+    relationAggregatedFieldsResult: Record<string, any>;
+    sourceFieldName: string;
+    joinField: string;
+    relationType: RelationType;
+  }): void {
+    parentRecords.forEach((item) => {
+      if (relationType === RelationType.ONE_TO_MANY) {
+        item[sourceFieldName] = relationResults.filter(
+          (rel) => rel[joinField] === item.id,
+        );
+      } else {
+        if (relationResults.length === 0) {
+          item[`${sourceFieldName}Id`] = null;
+        }
+        item[sourceFieldName] =
+          relationResults.find(
+            (rel) => rel.id === item[`${sourceFieldName}Id`],
+          ) ?? null;
+      }
+    });
+
+    parentObjectRecordsAggregatedValues[sourceFieldName] =
+      relationAggregatedFieldsResult;
+  }
+}

packages/twenty-server/src/engine/api/graphql/graphql-query-runner/helpers/process-nested-relations.helper.ts

@@ -1,3 +1,5 @@
+import { Injectable } from '@nestjs/common';
+
 import {
   DataSource,
   FindOptionsRelations,
@@ -12,23 +14,28 @@ import {
   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 { ProcessNestedRelationsV2Helper } from 'src/engine/api/graphql/graphql-query-runner/helpers/process-nested-relations-v2.helper';
 import {
   getRelationMetadata,
   getRelationObjectMetadata,
 } from 'src/engine/api/graphql/graphql-query-runner/utils/get-relation-object-metadata.util';
 import { AggregationField } from 'src/engine/api/graphql/workspace-schema-builder/utils/get-available-aggregations-from-object-fields.util';
+import { AuthContext } from 'src/engine/core-modules/auth/types/auth-context.type';
+import { FeatureFlagKey } from 'src/engine/core-modules/feature-flag/enums/feature-flag-key.enum';
+import { FeatureFlagService } from 'src/engine/core-modules/feature-flag/services/feature-flag.service';
 import { ObjectMetadataItemWithFieldMaps } from 'src/engine/metadata-modules/types/object-metadata-item-with-field-maps';
 import { ObjectMetadataMaps } from 'src/engine/metadata-modules/types/object-metadata-maps';
 import { getObjectMetadataMapItemByNameSingular } from 'src/engine/metadata-modules/utils/get-object-metadata-map-item-by-name-singular.util';
 import { formatResult } from 'src/engine/twenty-orm/utils/format-result.util';
 import { deduceRelationDirection } from 'src/engine/utils/deduce-relation-direction.util';
 
+@Injectable()
 export class ProcessNestedRelationsHelper {
-  private processAggregateHelper: ProcessAggregateHelper;
+  constructor(
-
+    private readonly processNestedRelationsV2Helper: ProcessNestedRelationsV2Helper,
-  constructor() {
+    private readonly processAggregateHelper: ProcessAggregateHelper,
-    this.processAggregateHelper = new ProcessAggregateHelper();
+    private readonly featureFlagService: FeatureFlagService,
-  }
+  ) {}
 
   public async processNestedRelations<T extends ObjectRecord = ObjectRecord>({
     objectMetadataMaps,
@@ -48,9 +55,28 @@ export class ProcessNestedRelationsHelper {
     relations: Record<string, FindOptionsRelations<ObjectLiteral>>;
     aggregate?: Record<string, AggregationField>;
     limit: number;
-    authContext: any;
+    authContext: AuthContext;
     dataSource: DataSource;
   }): Promise<void> {
+    const isNewRelationEnabled = await this.featureFlagService.isFeatureEnabled(
+      FeatureFlagKey.IsNewRelationEnabled,
+      authContext.workspace.id,
+    );
+
+    if (isNewRelationEnabled) {
+      return this.processNestedRelationsV2Helper.processNestedRelations({
+        objectMetadataMaps,
+        parentObjectMetadataItem,
+        parentObjectRecords,
+        parentObjectRecordsAggregatedValues,
+        relations,
+        aggregate,
+        limit,
+        authContext,
+        dataSource,
+      });
+    }
+
     const processRelationTasks = Object.entries(relations).map(
       ([relationName, nestedRelations]) =>
         this.processRelation({

packages/twenty-server/src/engine/api/graphql/graphql-query-runner/interfaces/base-resolver-service.ts

@@ -16,11 +16,13 @@ import {
 
 import { GraphqlQuerySelectedFieldsResult } from 'src/engine/api/graphql/graphql-query-runner/graphql-query-parsers/graphql-query-selected-fields/graphql-selected-fields.parser';
 import { GraphqlQueryParser } from 'src/engine/api/graphql/graphql-query-runner/graphql-query-parsers/graphql-query.parser';
+import { ProcessNestedRelationsHelper } from 'src/engine/api/graphql/graphql-query-runner/helpers/process-nested-relations.helper';
 import { ApiEventEmitterService } from 'src/engine/api/graphql/graphql-query-runner/services/api-event-emitter.service';
 import { QueryResultGettersFactory } from 'src/engine/api/graphql/workspace-query-runner/factories/query-result-getters/query-result-getters.factory';
 import { QueryRunnerArgsFactory } from 'src/engine/api/graphql/workspace-query-runner/factories/query-runner-args.factory';
 import { workspaceQueryRunnerGraphqlApiExceptionHandler } from 'src/engine/api/graphql/workspace-query-runner/utils/workspace-query-runner-graphql-api-exception-handler.util';
 import { WorkspaceQueryHookService } from 'src/engine/api/graphql/workspace-query-runner/workspace-query-hook/workspace-query-hook.service';
+import { FeatureFlagService } from 'src/engine/core-modules/feature-flag/services/feature-flag.service';
 import { WorkspaceRepository } from 'src/engine/twenty-orm/repository/workspace.repository';
 import { TwentyORMGlobalManager } from 'src/engine/twenty-orm/twenty-orm-global.manager';
 
@@ -52,6 +54,10 @@ export abstract class GraphqlQueryBaseResolverService<
   protected readonly apiEventEmitterService: ApiEventEmitterService;
   @Inject()
   protected readonly twentyORMGlobalManager: TwentyORMGlobalManager;
+  @Inject()
+  protected readonly processNestedRelationsHelper: ProcessNestedRelationsHelper;
+  @Inject()
+  protected readonly featureFlagService: FeatureFlagService;
 
   public async execute(
     args: Input,
@@ -86,9 +92,15 @@ export abstract class GraphqlQueryBaseResolverService<
         objectMetadataItemWithFieldMaps.nameSingular,
       );
 
+      const featureFlagsMap =
+        await this.featureFlagService.getWorkspaceFeatureFlagsMap(
+          authContext.workspace.id,
+        );
+
       const graphqlQueryParser = new GraphqlQueryParser(
         objectMetadataItemWithFieldMaps.fieldsByName,
         options.objectMetadataMaps,
+        featureFlagsMap,
       );
 
       const selectedFields = graphqlFields(options.info);

packages/twenty-server/src/engine/api/graphql/graphql-query-runner/resolvers/graphql-query-create-many-resolver.service.ts

@@ -12,7 +12,6 @@ import { CreateManyResolverArgs } from 'src/engine/api/graphql/workspace-resolve
 
 import { QUERY_MAX_RECORDS } from 'src/engine/api/graphql/graphql-query-runner/constants/query-max-records.constant';
 import { ObjectRecordsToGraphqlConnectionHelper } from 'src/engine/api/graphql/graphql-query-runner/helpers/object-records-to-graphql-connection.helper';
-import { ProcessNestedRelationsHelper } from 'src/engine/api/graphql/graphql-query-runner/helpers/process-nested-relations.helper';
 import { assertIsValidUuid } from 'src/engine/api/graphql/workspace-query-runner/utils/assert-is-valid-uuid.util';
 import { assertMutationNotOnRemoteObject } from 'src/engine/metadata-modules/object-metadata/utils/assert-mutation-not-on-remote-object.util';
 import { formatResult } from 'src/engine/twenty-orm/utils/format-result.util';
@@ -58,10 +57,8 @@ export class GraphqlQueryCreateManyResolverService extends GraphqlQueryBaseResol
       objectMetadataItemWithFieldMaps,
     );
 
-    const processNestedRelationsHelper = new ProcessNestedRelationsHelper();
-
     if (executionArgs.graphqlQuerySelectedFieldsResult.relations) {
-      await processNestedRelationsHelper.processNestedRelations({
+      await this.processNestedRelationsHelper.processNestedRelations({
         objectMetadataMaps,
         parentObjectMetadataItem: objectMetadataItemWithFieldMaps,
         parentObjectRecords: upsertedRecords,
@@ -72,8 +69,16 @@ export class GraphqlQueryCreateManyResolverService extends GraphqlQueryBaseResol
       });
     }
 
+    const featureFlagsMap =
+      await this.featureFlagService.getWorkspaceFeatureFlagsMap(
+        authContext.workspace.id,
+      );
+
     const typeORMObjectRecordsParser =
-      new ObjectRecordsToGraphqlConnectionHelper(objectMetadataMaps);
+      new ObjectRecordsToGraphqlConnectionHelper(
+        objectMetadataMaps,
+        featureFlagsMap,
+      );
 
     return upsertedRecords.map((record: ObjectRecord) =>
       typeORMObjectRecordsParser.processRecord({

packages/twenty-server/src/engine/api/graphql/graphql-query-runner/resolvers/graphql-query-create-one-resolver.service.ts

@@ -12,7 +12,6 @@ import { CreateOneResolverArgs } from 'src/engine/api/graphql/workspace-resolver
 
 import { QUERY_MAX_RECORDS } from 'src/engine/api/graphql/graphql-query-runner/constants/query-max-records.constant';
 import { ObjectRecordsToGraphqlConnectionHelper } from 'src/engine/api/graphql/graphql-query-runner/helpers/object-records-to-graphql-connection.helper';
-import { ProcessNestedRelationsHelper } from 'src/engine/api/graphql/graphql-query-runner/helpers/process-nested-relations.helper';
 import { assertIsValidUuid } from 'src/engine/api/graphql/workspace-query-runner/utils/assert-is-valid-uuid.util';
 import { assertMutationNotOnRemoteObject } from 'src/engine/metadata-modules/object-metadata/utils/assert-mutation-not-on-remote-object.util';
 import { formatResult } from 'src/engine/twenty-orm/utils/format-result.util';
@@ -58,10 +57,8 @@ export class GraphqlQueryCreateOneResolverService extends GraphqlQueryBaseResolv
       objectMetadataItemWithFieldMaps,
     );
 
-    const processNestedRelationsHelper = new ProcessNestedRelationsHelper();
-
     if (executionArgs.graphqlQuerySelectedFieldsResult.relations) {
-      await processNestedRelationsHelper.processNestedRelations({
+      await this.processNestedRelationsHelper.processNestedRelations({
         objectMetadataMaps,
         parentObjectMetadataItem: objectMetadataItemWithFieldMaps,
         parentObjectRecords: upsertedRecords,
@@ -72,8 +69,16 @@ export class GraphqlQueryCreateOneResolverService extends GraphqlQueryBaseResolv
       });
     }
 
+    const featureFlagsMap =
+      await this.featureFlagService.getWorkspaceFeatureFlagsMap(
+        authContext.workspace.id,
+      );
+
     const typeORMObjectRecordsParser =
-      new ObjectRecordsToGraphqlConnectionHelper(objectMetadataMaps);
+      new ObjectRecordsToGraphqlConnectionHelper(
+        objectMetadataMaps,
+        featureFlagsMap,
+      );
 
     return typeORMObjectRecordsParser.processRecord({
       objectRecord: upsertedRecords[0],

packages/twenty-server/src/engine/api/graphql/graphql-query-runner/resolvers/graphql-query-delete-many-resolver.service.ts

@@ -10,7 +10,6 @@ import { DeleteManyResolverArgs } from 'src/engine/api/graphql/workspace-resolve
 
 import { QUERY_MAX_RECORDS } from 'src/engine/api/graphql/graphql-query-runner/constants/query-max-records.constant';
 import { ObjectRecordsToGraphqlConnectionHelper } from 'src/engine/api/graphql/graphql-query-runner/helpers/object-records-to-graphql-connection.helper';
-import { ProcessNestedRelationsHelper } from 'src/engine/api/graphql/graphql-query-runner/helpers/process-nested-relations.helper';
 import { assertIsValidUuid } from 'src/engine/api/graphql/workspace-query-runner/utils/assert-is-valid-uuid.util';
 import { assertMutationNotOnRemoteObject } from 'src/engine/metadata-modules/object-metadata/utils/assert-mutation-not-on-remote-object.util';
 import { formatResult } from 'src/engine/twenty-orm/utils/format-result.util';
@@ -59,10 +58,8 @@ export class GraphqlQueryDeleteManyResolverService extends GraphqlQueryBaseResol
       objectMetadataItemWithFieldMaps,
     );
 
-    const processNestedRelationsHelper = new ProcessNestedRelationsHelper();
-
     if (executionArgs.graphqlQuerySelectedFieldsResult.relations) {
-      await processNestedRelationsHelper.processNestedRelations({
+      await this.processNestedRelationsHelper.processNestedRelations({
         objectMetadataMaps,
         parentObjectMetadataItem: objectMetadataItemWithFieldMaps,
         parentObjectRecords: formattedDeletedRecords,
@@ -73,8 +70,16 @@ export class GraphqlQueryDeleteManyResolverService extends GraphqlQueryBaseResol
       });
     }
 
+    const featureFlagsMap =
+      await this.featureFlagService.getWorkspaceFeatureFlagsMap(
+        authContext.workspace.id,
+      );
+
     const typeORMObjectRecordsParser =
-      new ObjectRecordsToGraphqlConnectionHelper(objectMetadataMaps);
+      new ObjectRecordsToGraphqlConnectionHelper(
+        objectMetadataMaps,
+        featureFlagsMap,
+      );
 
     return formattedDeletedRecords.map((record: ObjectRecord) =>
       typeORMObjectRecordsParser.processRecord({

packages/twenty-server/src/engine/api/graphql/graphql-query-runner/resolvers/graphql-query-delete-one-resolver.service.ts

@@ -14,7 +14,6 @@ import {
   GraphqlQueryRunnerExceptionCode,
 } from 'src/engine/api/graphql/graphql-query-runner/errors/graphql-query-runner.exception';
 import { ObjectRecordsToGraphqlConnectionHelper } from 'src/engine/api/graphql/graphql-query-runner/helpers/object-records-to-graphql-connection.helper';
-import { ProcessNestedRelationsHelper } from 'src/engine/api/graphql/graphql-query-runner/helpers/process-nested-relations.helper';
 import { assertIsValidUuid } from 'src/engine/api/graphql/workspace-query-runner/utils/assert-is-valid-uuid.util';
 import { assertMutationNotOnRemoteObject } from 'src/engine/metadata-modules/object-metadata/utils/assert-mutation-not-on-remote-object.util';
 import { formatResult } from 'src/engine/twenty-orm/utils/format-result.util';
@@ -61,10 +60,8 @@ export class GraphqlQueryDeleteOneResolverService extends GraphqlQueryBaseResolv
 
     const deletedRecord = formattedDeletedRecords[0];
 
-    const processNestedRelationsHelper = new ProcessNestedRelationsHelper();
-
     if (executionArgs.graphqlQuerySelectedFieldsResult.relations) {
-      await processNestedRelationsHelper.processNestedRelations({
+      await this.processNestedRelationsHelper.processNestedRelations({
         objectMetadataMaps,
         parentObjectMetadataItem: objectMetadataItemWithFieldMaps,
         parentObjectRecords: [deletedRecord],
@@ -75,8 +72,16 @@ export class GraphqlQueryDeleteOneResolverService extends GraphqlQueryBaseResolv
       });
     }
 
+    const featureFlagsMap =
+      await this.featureFlagService.getWorkspaceFeatureFlagsMap(
+        authContext.workspace.id,
+      );
+
     const typeORMObjectRecordsParser =
-      new ObjectRecordsToGraphqlConnectionHelper(objectMetadataMaps);
+      new ObjectRecordsToGraphqlConnectionHelper(
+        objectMetadataMaps,
+        featureFlagsMap,
+      );
 
     return typeORMObjectRecordsParser.processRecord({
       objectRecord: deletedRecord,

packages/twenty-server/src/engine/api/graphql/graphql-query-runner/resolvers/graphql-query-destroy-many-resolver.service.ts

@@ -10,7 +10,6 @@ import { DestroyManyResolverArgs } from 'src/engine/api/graphql/workspace-resolv
 
 import { QUERY_MAX_RECORDS } from 'src/engine/api/graphql/graphql-query-runner/constants/query-max-records.constant';
 import { ObjectRecordsToGraphqlConnectionHelper } from 'src/engine/api/graphql/graphql-query-runner/helpers/object-records-to-graphql-connection.helper';
-import { ProcessNestedRelationsHelper } from 'src/engine/api/graphql/graphql-query-runner/helpers/process-nested-relations.helper';
 import { formatResult } from 'src/engine/twenty-orm/utils/format-result.util';
 import { computeTableName } from 'src/engine/utils/compute-table-name.util';
 
@@ -57,10 +56,8 @@ export class GraphqlQueryDestroyManyResolverService extends GraphqlQueryBaseReso
       objectMetadataItemWithFieldMaps,
     );
 
-    const processNestedRelationsHelper = new ProcessNestedRelationsHelper();
-
     if (executionArgs.graphqlQuerySelectedFieldsResult.relations) {
-      await processNestedRelationsHelper.processNestedRelations({
+      await this.processNestedRelationsHelper.processNestedRelations({
         objectMetadataMaps,
         parentObjectMetadataItem: objectMetadataItemWithFieldMaps,
         parentObjectRecords: deletedRecords,
@@ -71,8 +68,16 @@ export class GraphqlQueryDestroyManyResolverService extends GraphqlQueryBaseReso
       });
     }
 
+    const featureFlagsMap =
+      await this.featureFlagService.getWorkspaceFeatureFlagsMap(
+        authContext.workspace.id,
+      );
+
     const typeORMObjectRecordsParser =
-      new ObjectRecordsToGraphqlConnectionHelper(objectMetadataMaps);
+      new ObjectRecordsToGraphqlConnectionHelper(
+        objectMetadataMaps,
+        featureFlagsMap,
+      );
 
     return deletedRecords.map((record: ObjectRecord) =>
       typeORMObjectRecordsParser.processRecord({

packages/twenty-server/src/engine/api/graphql/graphql-query-runner/resolvers/graphql-query-destroy-one-resolver.service.ts

@@ -14,7 +14,6 @@ import {
   GraphqlQueryRunnerExceptionCode,
 } from 'src/engine/api/graphql/graphql-query-runner/errors/graphql-query-runner.exception';
 import { ObjectRecordsToGraphqlConnectionHelper } from 'src/engine/api/graphql/graphql-query-runner/helpers/object-records-to-graphql-connection.helper';
-import { ProcessNestedRelationsHelper } from 'src/engine/api/graphql/graphql-query-runner/helpers/process-nested-relations.helper';
 import { formatResult } from 'src/engine/twenty-orm/utils/format-result.util';
 
 @Injectable()
@@ -57,10 +56,8 @@ export class GraphqlQueryDestroyOneResolverService extends GraphqlQueryBaseResol
       objectMetadataItemWithFieldMaps,
     );
 
-    const processNestedRelationsHelper = new ProcessNestedRelationsHelper();
-
     if (executionArgs.graphqlQuerySelectedFieldsResult.relations) {
-      await processNestedRelationsHelper.processNestedRelations({
+      await this.processNestedRelationsHelper.processNestedRelations({
         objectMetadataMaps,
         parentObjectMetadataItem: objectMetadataItemWithFieldMaps,
         parentObjectRecords: deletedRecords,
@@ -71,8 +68,16 @@ export class GraphqlQueryDestroyOneResolverService extends GraphqlQueryBaseResol
       });
     }
 
+    const featureFlagsMap =
+      await this.featureFlagService.getWorkspaceFeatureFlagsMap(
+        authContext.workspace.id,
+      );
+
     const typeORMObjectRecordsParser =
-      new ObjectRecordsToGraphqlConnectionHelper(objectMetadataMaps);
+      new ObjectRecordsToGraphqlConnectionHelper(
+        objectMetadataMaps,
+        featureFlagsMap,
+      );
 
     return typeORMObjectRecordsParser.processRecord({
       objectRecord: deletedRecords[0],

packages/twenty-server/src/engine/api/graphql/graphql-query-runner/resolvers/graphql-query-find-duplicates-resolver.service.ts

@@ -37,7 +37,7 @@ export class GraphqlQueryFindDuplicatesResolverService extends GraphqlQueryBaseR
   async resolve(
     executionArgs: GraphqlQueryResolverExecutionArgs<FindDuplicatesResolverArgs>,
   ): Promise<IConnection<ObjectRecord>[]> {
-    const { objectMetadataItemWithFieldMaps, objectMetadataMaps } =
+    const { objectMetadataItemWithFieldMaps, objectMetadataMaps, authContext } =
       executionArgs.options;
 
     const existingRecordsQueryBuilder =
@@ -58,13 +58,22 @@ export class GraphqlQueryFindDuplicatesResolverService extends GraphqlQueryBaseR
       );
     }
 
+    const featureFlagsMap =
+      await this.featureFlagService.getWorkspaceFeatureFlagsMap(
+        authContext.workspace.id,
+      );
+
     const graphqlQueryParser = new GraphqlQueryParser(
       objectMetadataItemWithFieldsMaps?.fieldsByName,
       objectMetadataMaps,
+      featureFlagsMap,
     );
 
     const typeORMObjectRecordsParser =
-      new ObjectRecordsToGraphqlConnectionHelper(objectMetadataMaps);
+      new ObjectRecordsToGraphqlConnectionHelper(
+        objectMetadataMaps,
+        featureFlagsMap,
+      );
 
     let objectRecords: Partial<ObjectRecord>[] = [];
 

packages/twenty-server/src/engine/api/graphql/graphql-query-runner/resolvers/graphql-query-find-many-resolver.service.ts

@@ -21,13 +21,11 @@ import {
 } from 'src/engine/api/graphql/graphql-query-runner/errors/graphql-query-runner.exception';
 import { ObjectRecordsToGraphqlConnectionHelper } from 'src/engine/api/graphql/graphql-query-runner/helpers/object-records-to-graphql-connection.helper';
 import { ProcessAggregateHelper } from 'src/engine/api/graphql/graphql-query-runner/helpers/process-aggregate.helper';
-import { ProcessNestedRelationsHelper } from 'src/engine/api/graphql/graphql-query-runner/helpers/process-nested-relations.helper';
 import { computeCursorArgFilter } from 'src/engine/api/graphql/graphql-query-runner/utils/compute-cursor-arg-filter';
 import {
   getCursor,
   getPaginationInfo,
 } from 'src/engine/api/graphql/graphql-query-runner/utils/cursors.util';
-import { FeatureFlagService } from 'src/engine/core-modules/feature-flag/services/feature-flag.service';
 import { formatResult } from 'src/engine/twenty-orm/utils/format-result.util';
 import { isDefined } from 'src/utils/is-defined';
 
@@ -36,7 +34,7 @@ export class GraphqlQueryFindManyResolverService extends GraphqlQueryBaseResolve
   FindManyResolverArgs,
   IConnection<ObjectRecord>
 > {
-  constructor(private readonly featureFlagService: FeatureFlagService) {
+  constructor(private readonly processAggregateHelper: ProcessAggregateHelper) {
     super();
   }
 
@@ -108,13 +106,13 @@ export class GraphqlQueryFindManyResolverService extends GraphqlQueryBaseResolve
       appliedFilters,
     );
 
-    const processAggregateHelper = new ProcessAggregateHelper();
+    this.processAggregateHelper.addSelectedAggregatedFieldsQueriesToQueryBuilder(
-
+      {
-    processAggregateHelper.addSelectedAggregatedFieldsQueriesToQueryBuilder({
+        selectedAggregatedFields:
-      selectedAggregatedFields:
+          executionArgs.graphqlQuerySelectedFieldsResult.aggregate,
-        executionArgs.graphqlQuerySelectedFieldsResult.aggregate,
+        queryBuilder: aggregateQueryBuilder,
-      queryBuilder: aggregateQueryBuilder,
+      },
-    });
+    );
 
     const limit =
       executionArgs.args.first ?? executionArgs.args.last ?? QUERY_MAX_RECORDS;
@@ -142,10 +140,8 @@ export class GraphqlQueryFindManyResolverService extends GraphqlQueryBaseResolve
     const parentObjectRecordsAggregatedValues =
       await aggregateQueryBuilder.getRawOne();
 
-    const processNestedRelationsHelper = new ProcessNestedRelationsHelper();
-
     if (executionArgs.graphqlQuerySelectedFieldsResult.relations) {
-      await processNestedRelationsHelper.processNestedRelations({
+      await this.processNestedRelationsHelper.processNestedRelations({
         objectMetadataMaps,
         parentObjectMetadataItem: objectMetadataItemWithFieldMaps,
         parentObjectRecords: objectRecords,
@@ -158,8 +154,16 @@ export class GraphqlQueryFindManyResolverService extends GraphqlQueryBaseResolve
       });
     }
 
+    const featureFlagsMap =
+      await this.featureFlagService.getWorkspaceFeatureFlagsMap(
+        authContext.workspace.id,
+      );
+
     const typeORMObjectRecordsParser =
-      new ObjectRecordsToGraphqlConnectionHelper(objectMetadataMaps);
+      new ObjectRecordsToGraphqlConnectionHelper(
+        objectMetadataMaps,
+        featureFlagsMap,
+      );
 
     return typeORMObjectRecordsParser.createConnection({
       objectRecords,

packages/twenty-server/src/engine/api/graphql/graphql-query-runner/resolvers/graphql-query-find-one-resolver.service.ts

@@ -17,7 +17,6 @@ import {
   GraphqlQueryRunnerExceptionCode,
 } from 'src/engine/api/graphql/graphql-query-runner/errors/graphql-query-runner.exception';
 import { ObjectRecordsToGraphqlConnectionHelper } from 'src/engine/api/graphql/graphql-query-runner/helpers/object-records-to-graphql-connection.helper';
-import { ProcessNestedRelationsHelper } from 'src/engine/api/graphql/graphql-query-runner/helpers/process-nested-relations.helper';
 import {
   WorkspaceQueryRunnerException,
   WorkspaceQueryRunnerExceptionCode,
@@ -65,12 +64,10 @@ export class GraphqlQueryFindOneResolverService extends GraphqlQueryBaseResolver
       );
     }
 
-    const processNestedRelationsHelper = new ProcessNestedRelationsHelper();
-
     const objectRecords = [objectRecord];
 
     if (executionArgs.graphqlQuerySelectedFieldsResult.relations) {
-      await processNestedRelationsHelper.processNestedRelations({
+      await this.processNestedRelationsHelper.processNestedRelations({
         objectMetadataMaps,
         parentObjectMetadataItem: objectMetadataItemWithFieldMaps,
         parentObjectRecords: objectRecords,
@@ -81,8 +78,16 @@ export class GraphqlQueryFindOneResolverService extends GraphqlQueryBaseResolver
       });
     }
 
+    const featureFlagsMap =
+      await this.featureFlagService.getWorkspaceFeatureFlagsMap(
+        authContext.workspace.id,
+      );
+
     const typeORMObjectRecordsParser =
-      new ObjectRecordsToGraphqlConnectionHelper(objectMetadataMaps);
+      new ObjectRecordsToGraphqlConnectionHelper(
+        objectMetadataMaps,
+        featureFlagsMap,
+      );
 
     return typeORMObjectRecordsParser.processRecord({
       objectRecord: objectRecords[0],

packages/twenty-server/src/engine/api/graphql/graphql-query-runner/resolvers/graphql-query-restore-many-resolver.service.ts

@@ -10,7 +10,6 @@ import { RestoreManyResolverArgs } from 'src/engine/api/graphql/workspace-resolv
 
 import { QUERY_MAX_RECORDS } from 'src/engine/api/graphql/graphql-query-runner/constants/query-max-records.constant';
 import { ObjectRecordsToGraphqlConnectionHelper } from 'src/engine/api/graphql/graphql-query-runner/helpers/object-records-to-graphql-connection.helper';
-import { ProcessNestedRelationsHelper } from 'src/engine/api/graphql/graphql-query-runner/helpers/process-nested-relations.helper';
 import { assertIsValidUuid } from 'src/engine/api/graphql/workspace-query-runner/utils/assert-is-valid-uuid.util';
 import { assertMutationNotOnRemoteObject } from 'src/engine/metadata-modules/object-metadata/utils/assert-mutation-not-on-remote-object.util';
 import { formatResult } from 'src/engine/twenty-orm/utils/format-result.util';
@@ -59,10 +58,8 @@ export class GraphqlQueryRestoreManyResolverService extends GraphqlQueryBaseReso
       objectMetadataItemWithFieldMaps,
     );
 
-    const processNestedRelationsHelper = new ProcessNestedRelationsHelper();
-
     if (executionArgs.graphqlQuerySelectedFieldsResult.relations) {
-      await processNestedRelationsHelper.processNestedRelations({
+      await this.processNestedRelationsHelper.processNestedRelations({
         objectMetadataMaps,
         parentObjectMetadataItem: objectMetadataItemWithFieldMaps,
         parentObjectRecords: formattedRestoredRecords,
@@ -73,8 +70,16 @@ export class GraphqlQueryRestoreManyResolverService extends GraphqlQueryBaseReso
       });
     }
 
+    const featureFlagsMap =
+      await this.featureFlagService.getWorkspaceFeatureFlagsMap(
+        authContext.workspace.id,
+      );
+
     const typeORMObjectRecordsParser =
-      new ObjectRecordsToGraphqlConnectionHelper(objectMetadataMaps);
+      new ObjectRecordsToGraphqlConnectionHelper(
+        objectMetadataMaps,
+        featureFlagsMap,
+      );
 
     return formattedRestoredRecords.map((record: ObjectRecord) =>
       typeORMObjectRecordsParser.processRecord({

packages/twenty-server/src/engine/api/graphql/graphql-query-runner/resolvers/graphql-query-restore-one-resolver.service.ts

@@ -14,7 +14,6 @@ import {
   GraphqlQueryRunnerExceptionCode,
 } from 'src/engine/api/graphql/graphql-query-runner/errors/graphql-query-runner.exception';
 import { ObjectRecordsToGraphqlConnectionHelper } from 'src/engine/api/graphql/graphql-query-runner/helpers/object-records-to-graphql-connection.helper';
-import { ProcessNestedRelationsHelper } from 'src/engine/api/graphql/graphql-query-runner/helpers/process-nested-relations.helper';
 import { assertIsValidUuid } from 'src/engine/api/graphql/workspace-query-runner/utils/assert-is-valid-uuid.util';
 import { assertMutationNotOnRemoteObject } from 'src/engine/metadata-modules/object-metadata/utils/assert-mutation-not-on-remote-object.util';
 import { formatResult } from 'src/engine/twenty-orm/utils/format-result.util';
@@ -61,10 +60,8 @@ export class GraphqlQueryRestoreOneResolverService extends GraphqlQueryBaseResol
 
     const restoredRecord = formattedRestoredRecords[0];
 
-    const processNestedRelationsHelper = new ProcessNestedRelationsHelper();
-
     if (executionArgs.graphqlQuerySelectedFieldsResult.relations) {
-      await processNestedRelationsHelper.processNestedRelations({
+      await this.processNestedRelationsHelper.processNestedRelations({
         objectMetadataMaps,
         parentObjectMetadataItem: objectMetadataItemWithFieldMaps,
         parentObjectRecords: [restoredRecord],
@@ -75,8 +72,16 @@ export class GraphqlQueryRestoreOneResolverService extends GraphqlQueryBaseResol
       });
     }
 
+    const featureFlagsMap =
+      await this.featureFlagService.getWorkspaceFeatureFlagsMap(
+        authContext.workspace.id,
+      );
+
     const typeORMObjectRecordsParser =
-      new ObjectRecordsToGraphqlConnectionHelper(objectMetadataMaps);
+      new ObjectRecordsToGraphqlConnectionHelper(
+        objectMetadataMaps,
+        featureFlagsMap,
+      );
 
     return typeORMObjectRecordsParser.processRecord({
       objectRecord: restoredRecord,

packages/twenty-server/src/engine/api/graphql/graphql-query-runner/resolvers/graphql-query-search-resolver.service.ts

@@ -17,7 +17,6 @@ import { SearchResolverArgs } from 'src/engine/api/graphql/workspace-resolver-bu
 
 import { QUERY_MAX_RECORDS } from 'src/engine/api/graphql/graphql-query-runner/constants/query-max-records.constant';
 import { ObjectRecordsToGraphqlConnectionHelper } from 'src/engine/api/graphql/graphql-query-runner/helpers/object-records-to-graphql-connection.helper';
-import { ProcessNestedRelationsHelper } from 'src/engine/api/graphql/graphql-query-runner/helpers/process-nested-relations.helper';
 import { SEARCH_VECTOR_FIELD } from 'src/engine/metadata-modules/constants/search-vector-field.constants';
 import { formatResult } from 'src/engine/twenty-orm/utils/format-result.util';
 import { isDefined } from 'src/utils/is-defined';
@@ -33,8 +32,16 @@ export class GraphqlQuerySearchResolverService extends GraphqlQueryBaseResolverS
     const { authContext, objectMetadataMaps, objectMetadataItemWithFieldMaps } =
       executionArgs.options;
 
+    const featureFlagsMap =
+      await this.featureFlagService.getWorkspaceFeatureFlagsMap(
+        authContext.workspace.id,
+      );
+
     const typeORMObjectRecordsParser =
-      new ObjectRecordsToGraphqlConnectionHelper(objectMetadataMaps);
+      new ObjectRecordsToGraphqlConnectionHelper(
+        objectMetadataMaps,
+        featureFlagsMap,
+      );
 
     if (!isDefined(executionArgs.args.searchInput)) {
       return typeORMObjectRecordsParser.createConnection({
@@ -113,10 +120,8 @@ export class GraphqlQuerySearchResolverService extends GraphqlQueryBaseResolverS
       : 0;
     const order = undefined;
 
-    const processNestedRelationsHelper = new ProcessNestedRelationsHelper();
-
     if (executionArgs.graphqlQuerySelectedFieldsResult.relations) {
-      await processNestedRelationsHelper.processNestedRelations({
+      await this.processNestedRelationsHelper.processNestedRelations({
         objectMetadataMaps,
         parentObjectMetadataItem: objectMetadataItemWithFieldMaps,
         parentObjectRecords: objectRecords,

packages/twenty-server/src/engine/api/graphql/graphql-query-runner/resolvers/graphql-query-update-many-resolver.service.ts

@@ -10,7 +10,6 @@ import { UpdateManyResolverArgs } from 'src/engine/api/graphql/workspace-resolve
 
 import { QUERY_MAX_RECORDS } from 'src/engine/api/graphql/graphql-query-runner/constants/query-max-records.constant';
 import { ObjectRecordsToGraphqlConnectionHelper } from 'src/engine/api/graphql/graphql-query-runner/helpers/object-records-to-graphql-connection.helper';
-import { ProcessNestedRelationsHelper } from 'src/engine/api/graphql/graphql-query-runner/helpers/process-nested-relations.helper';
 import { assertIsValidUuid } from 'src/engine/api/graphql/workspace-query-runner/utils/assert-is-valid-uuid.util';
 import { assertMutationNotOnRemoteObject } from 'src/engine/metadata-modules/object-metadata/utils/assert-mutation-not-on-remote-object.util';
 import { formatData } from 'src/engine/twenty-orm/utils/format-data.util';
@@ -83,10 +82,8 @@ export class GraphqlQueryUpdateManyResolverService extends GraphqlQueryBaseResol
       objectMetadataItemWithFieldMaps,
     );
 
-    const processNestedRelationsHelper = new ProcessNestedRelationsHelper();
-
     if (executionArgs.graphqlQuerySelectedFieldsResult.relations) {
-      await processNestedRelationsHelper.processNestedRelations({
+      await this.processNestedRelationsHelper.processNestedRelations({
         objectMetadataMaps,
         parentObjectMetadataItem: objectMetadataItemWithFieldMaps,
         parentObjectRecords: formattedUpdatedRecords,
@@ -97,8 +94,16 @@ export class GraphqlQueryUpdateManyResolverService extends GraphqlQueryBaseResol
       });
     }
 
+    const featureFlagsMap =
+      await this.featureFlagService.getWorkspaceFeatureFlagsMap(
+        authContext.workspace.id,
+      );
+
     const typeORMObjectRecordsParser =
-      new ObjectRecordsToGraphqlConnectionHelper(objectMetadataMaps);
+      new ObjectRecordsToGraphqlConnectionHelper(
+        objectMetadataMaps,
+        featureFlagsMap,
+      );
 
     return formattedUpdatedRecords.map((record: ObjectRecord) =>
       typeORMObjectRecordsParser.processRecord({

packages/twenty-server/src/engine/api/graphql/graphql-query-runner/resolvers/graphql-query-update-one-resolver.service.ts

@@ -14,7 +14,6 @@ import {
   GraphqlQueryRunnerExceptionCode,
 } from 'src/engine/api/graphql/graphql-query-runner/errors/graphql-query-runner.exception';
 import { ObjectRecordsToGraphqlConnectionHelper } from 'src/engine/api/graphql/graphql-query-runner/helpers/object-records-to-graphql-connection.helper';
-import { ProcessNestedRelationsHelper } from 'src/engine/api/graphql/graphql-query-runner/helpers/process-nested-relations.helper';
 import { assertIsValidUuid } from 'src/engine/api/graphql/workspace-query-runner/utils/assert-is-valid-uuid.util';
 import { assertMutationNotOnRemoteObject } from 'src/engine/metadata-modules/object-metadata/utils/assert-mutation-not-on-remote-object.util';
 import { formatData } from 'src/engine/twenty-orm/utils/format-data.util';
@@ -81,10 +80,8 @@ export class GraphqlQueryUpdateOneResolverService extends GraphqlQueryBaseResolv
 
     const updatedRecord = formattedUpdatedRecords[0];
 
-    const processNestedRelationsHelper = new ProcessNestedRelationsHelper();
-
     if (executionArgs.graphqlQuerySelectedFieldsResult.relations) {
-      await processNestedRelationsHelper.processNestedRelations({
+      await this.processNestedRelationsHelper.processNestedRelations({
         objectMetadataMaps,
         parentObjectMetadataItem: objectMetadataItemWithFieldMaps,
         parentObjectRecords: [updatedRecord],
@@ -95,8 +92,16 @@ export class GraphqlQueryUpdateOneResolverService extends GraphqlQueryBaseResolv
       });
     }
 
+    const featureFlagsMap =
+      await this.featureFlagService.getWorkspaceFeatureFlagsMap(
+        authContext.workspace.id,
+      );
+
     const typeORMObjectRecordsParser =
-      new ObjectRecordsToGraphqlConnectionHelper(objectMetadataMaps);
+      new ObjectRecordsToGraphqlConnectionHelper(
+        objectMetadataMaps,
+        featureFlagsMap,
+      );
 
     return typeORMObjectRecordsParser.processRecord({
       objectRecord: updatedRecord,

packages/twenty-server/src/engine/api/graphql/graphql-query-runner/utils/get-target-object-metadata.util.ts

@@ -0,0 +1,31 @@
+import { FieldMetadataInterface } from 'src/engine/metadata-modules/field-metadata/interfaces/field-metadata.interface';
+
+import {
+  GraphqlQueryRunnerException,
+  GraphqlQueryRunnerExceptionCode,
+} from 'src/engine/api/graphql/graphql-query-runner/errors/graphql-query-runner.exception';
+import { ObjectMetadataMaps } from 'src/engine/metadata-modules/types/object-metadata-maps';
+
+export const getTargetObjectMetadataOrThrow = (
+  fieldMetadata: FieldMetadataInterface,
+  objectMetadataMaps: ObjectMetadataMaps,
+) => {
+  if (!fieldMetadata.relationTargetObjectMetadataId) {
+    throw new GraphqlQueryRunnerException(
+      `Relation target object metadata id not found for field ${fieldMetadata.name}`,
+      GraphqlQueryRunnerExceptionCode.RELATION_TARGET_OBJECT_METADATA_NOT_FOUND,
+    );
+  }
+
+  const targetObjectMetadata =
+    objectMetadataMaps.byId[fieldMetadata.relationTargetObjectMetadataId];
+
+  if (!targetObjectMetadata) {
+    throw new GraphqlQueryRunnerException(
+      `Target object metadata not found for field ${fieldMetadata.name}`,
+      GraphqlQueryRunnerExceptionCode.RELATION_TARGET_OBJECT_METADATA_NOT_FOUND,
+    );
+  }
+
+  return targetObjectMetadata;
+};

packages/twenty-server/src/engine/api/graphql/workspace-query-runner/factories/query-result-getters/query-result-getters.factory.ts

@@ -16,10 +16,11 @@ import { AttachmentQueryResultGetterHandler } from 'src/engine/api/graphql/works
 import { PersonQueryResultGetterHandler } from 'src/engine/api/graphql/workspace-query-runner/factories/query-result-getters/handlers/person-query-result-getter.handler';
 import { WorkspaceMemberQueryResultGetterHandler } from 'src/engine/api/graphql/workspace-query-runner/factories/query-result-getters/handlers/workspace-member-query-result-getter.handler';
 import { CompositeInputTypeDefinitionFactory } from 'src/engine/api/graphql/workspace-schema-builder/factories/composite-input-type-definition.factory';
+import { FeatureFlagKey } from 'src/engine/core-modules/feature-flag/enums/feature-flag-key.enum';
 import { FeatureFlagService } from 'src/engine/core-modules/feature-flag/services/feature-flag.service';
 import { FileService } from 'src/engine/core-modules/file/services/file.service';
 import { ObjectMetadataMaps } from 'src/engine/metadata-modules/types/object-metadata-maps';
-import { isRelationFieldMetadataType } from 'src/engine/utils/is-relation-field-metadata-type.util';
+import { isRelationFieldMetadata } from 'src/engine/utils/is-relation-field-metadata.util';
 import { isDefined } from 'src/utils/is-defined';
 
 // TODO: find a way to prevent conflict between handlers executing logic on object relations
@@ -135,6 +136,11 @@ export class QueryResultGettersFactory {
   ): Promise<ObjectRecord> {
     const objectMetadataMapItem = objectMetadataMaps.byId[objectMetadataItemId];
 
+    const isNewRelationEnabled = await this.featureFlagService.isFeatureEnabled(
+      FeatureFlagKey.IsNewRelationEnabled,
+      workspaceId,
+    );
+
     const handler = this.getHandler(objectMetadataMapItem.nameSingular);
 
     const relationFields = Object.keys(record)
@@ -143,9 +149,7 @@ export class QueryResultGettersFactory {
           objectMetadataMapItem.fieldsByName[recordFieldName],
       )
       .filter(isDefined)
-      .filter((fieldMetadata) =>
+      .filter((fieldMetadata) => isRelationFieldMetadata(fieldMetadata));
-        isRelationFieldMetadataType(fieldMetadata.type),
-      );
 
     const relationFieldsProcessedMap = {} as Record<
       string,
@@ -153,38 +157,53 @@ export class QueryResultGettersFactory {
     >;
 
     for (const relationField of relationFields) {
-      const relationMetadata =
+      if (!isNewRelationEnabled) {
-        relationField.fromRelationMetadata ?? relationField.toRelationMetadata;
+        const relationMetadata =
+          relationField.fromRelationMetadata ??
+          relationField.toRelationMetadata;
 
-      if (!isDefined(relationMetadata)) {
+        if (!isDefined(relationMetadata)) {
-        throw new Error('Relation metadata is not defined');
+          throw new Error('Relation metadata is not defined');
+        }
+
+        // TODO: computing this by taking the opposite of the current object metadata id
+        // is really less than ideal. This should be computed based on the relation metadata
+        // But right now it is too complex with the current structure and / or lack of utils
+        // around the possible combinations with relation metadata from / to + MANY_TO_ONE / ONE_TO_MANY
+        const relationObjectMetadataItemId =
+          relationMetadata.fromObjectMetadataId === objectMetadataItemId
+            ? relationMetadata.toObjectMetadataId
+            : relationMetadata.fromObjectMetadataId;
+
+        const relationObjectMetadataItem =
+          objectMetadataMaps.byId[relationObjectMetadataItemId];
+
+        if (!isDefined(relationObjectMetadataItem)) {
+          throw new Error(
+            `Object metadata not found for id ${relationObjectMetadataItemId}`,
+          );
+        }
+
+        relationFieldsProcessedMap[relationField.name] =
+          await this.processQueryResultField(
+            record[relationField.name],
+            relationObjectMetadataItem.id,
+            objectMetadataMaps,
+            workspaceId,
+          );
+      } else {
+        if (!isDefined(relationField.relationTargetObjectMetadataId)) {
+          throw new Error('Relation target object metadata id is not defined');
+        }
+
+        relationFieldsProcessedMap[relationField.name] =
+          await this.processQueryResultField(
+            record[relationField.name],
+            relationField.relationTargetObjectMetadataId,
+            objectMetadataMaps,
+            workspaceId,
+          );
       }
-
-      // TODO: computing this by taking the opposite of the current object metadata id
-      // is really less than ideal. This should be computed based on the relation metadata
-      // But right now it is too complex with the current structure and / or lack of utils
-      // around the possible combinations with relation metadata from / to + MANY_TO_ONE / ONE_TO_MANY
-      const relationObjectMetadataItemId =
-        relationMetadata.fromObjectMetadataId === objectMetadataItemId
-          ? relationMetadata.toObjectMetadataId
-          : relationMetadata.fromObjectMetadataId;
-
-      const relationObjectMetadataItem =
-        objectMetadataMaps.byId[relationObjectMetadataItemId];
-
-      if (!isDefined(relationObjectMetadataItem)) {
-        throw new Error(
-          `Object metadata not found for id ${relationObjectMetadataItemId}`,
-        );
-      }
-
-      relationFieldsProcessedMap[relationField.name] =
-        await this.processQueryResultField(
-          record[relationField.name],
-          relationObjectMetadataItem.id,
-          objectMetadataMaps,
-          workspaceId,
-        );
     }
 
     const objectRecordProcessedWithoutRelationFields = await handler.handle(

packages/twenty-server/src/modules/workflow/workflow-executor/workflow-actions/record-crud/find-records.workflow-action.ts

@@ -12,6 +12,7 @@ import { WorkflowAction } from 'src/modules/workflow/workflow-executor/interface
 
 import { QUERY_MAX_RECORDS } from 'src/engine/api/graphql/graphql-query-runner/constants/query-max-records.constant';
 import { GraphqlQueryParser } from 'src/engine/api/graphql/graphql-query-runner/graphql-query-parsers/graphql-query.parser';
+import { FeatureFlagService } from 'src/engine/core-modules/feature-flag/services/feature-flag.service';
 import { ObjectMetadataItemWithFieldMaps } from 'src/engine/metadata-modules/types/object-metadata-item-with-field-maps';
 import { ObjectMetadataMaps } from 'src/engine/metadata-modules/types/object-metadata-maps';
 import { getObjectMetadataMapItemByNameSingular } from 'src/engine/metadata-modules/utils/get-object-metadata-map-item-by-name-singular.util';
@@ -33,6 +34,7 @@ export class FindRecordsWorflowAction implements WorkflowAction {
     private readonly twentyORMManager: TwentyORMManager,
     private readonly workspaceCacheStorageService: WorkspaceCacheStorageService,
     private readonly scopedWorkspaceContextFactory: ScopedWorkspaceContextFactory,
+    private readonly featureFlagService: FeatureFlagService,
   ) {}
 
   async execute(
@@ -86,9 +88,13 @@ export class FindRecordsWorflowAction implements WorkflowAction {
       );
     }
 
+    const featureFlagMaps =
+      await this.featureFlagService.getWorkspaceFeatureFlagsMap(workspaceId);
+
     const graphqlQueryParser = new GraphqlQueryParser(
       objectMetadataItemWithFieldsMaps.fieldsByName,
       objectMetadataMaps,
+      featureFlagMaps,
     );
 
     const objectRecords = await this.getObjectRecords(

packages/twenty-server/src/modules/workflow/workflow-executor/workflow-actions/record-crud/record-crud-action.module.ts

@@ -2,6 +2,7 @@ import { Module } from '@nestjs/common';
 
 import { NestjsQueryTypeOrmModule } from '@ptc-org/nestjs-query-typeorm';
 
+import { FeatureFlagModule } from 'src/engine/core-modules/feature-flag/feature-flag.module';
 import { ObjectMetadataEntity } from 'src/engine/metadata-modules/object-metadata/object-metadata.entity';
 import { ScopedWorkspaceContextFactory } from 'src/engine/twenty-orm/factories/scoped-workspace-context.factory';
 import { WorkspaceCacheStorageModule } from 'src/engine/workspace-cache-storage/workspace-cache-storage.module';
@@ -14,6 +15,7 @@ import { UpdateRecordWorkflowAction } from 'src/modules/workflow/workflow-execut
   imports: [
     WorkspaceCacheStorageModule,
     NestjsQueryTypeOrmModule.forFeature([ObjectMetadataEntity], 'metadata'),
+    FeatureFlagModule,
   ],
   providers: [
     ScopedWorkspaceContextFactory,