Remove old relations (#11993)

This is a first PR to remove old relation logic

Next steps:
- remove relationMetadata from cache
- remove relationMetadata table content and structure
- refactor relationDefinition to leverage field.settings instead

packages/twenty-front/src/generated-metadata/graphql.ts

@@ -656,7 +656,6 @@ export enum FeatureFlagKey {
   IsCopilotEnabled = 'IsCopilotEnabled',
   IsCustomDomainEnabled = 'IsCustomDomainEnabled',
   IsJsonFilterEnabled = 'IsJsonFilterEnabled',
-  IsNewRelationEnabled = 'IsNewRelationEnabled',
   IsPermissionsV2Enabled = 'IsPermissionsV2Enabled',
   IsPostgreSQLIntegrationEnabled = 'IsPostgreSQLIntegrationEnabled',
   IsStripeIntegrationEnabled = 'IsStripeIntegrationEnabled',

packages/twenty-front/src/generated/graphql.tsx

@@ -587,7 +587,6 @@ export enum FeatureFlagKey {
   IsCopilotEnabled = 'IsCopilotEnabled',
   IsCustomDomainEnabled = 'IsCustomDomainEnabled',
   IsJsonFilterEnabled = 'IsJsonFilterEnabled',
-  IsNewRelationEnabled = 'IsNewRelationEnabled',
   IsPermissionsV2Enabled = 'IsPermissionsV2Enabled',
   IsPostgreSQLIntegrationEnabled = 'IsPostgreSQLIntegrationEnabled',
   IsStripeIntegrationEnabled = 'IsStripeIntegrationEnabled',

packages/twenty-server/src/database/commands/upgrade-version-command/0-53/0-53-remove-relation-foreign-key-field-metadata.command.ts

@@ -9,11 +9,11 @@ import {
   ActiveOrSuspendedWorkspacesMigrationCommandRunner,
   RunOnWorkspaceArgs,
 } from 'src/database/commands/command-runners/active-or-suspended-workspaces-migration.command-runner';
-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 { Workspace } from 'src/engine/core-modules/workspace/workspace.entity';
 import { FieldMetadataEntity } from 'src/engine/metadata-modules/field-metadata/field-metadata.entity';
 import { TwentyORMGlobalManager } from 'src/engine/twenty-orm/twenty-orm-global.manager';
+import { FeatureFlagKey } from 'src/engine/core-modules/feature-flag/enums/feature-flag-key.enum';
 
 @Command({
   name: 'upgrade:0-53:remove-relation-foreign-key-field-metadata',
@@ -67,7 +67,7 @@ export class RemoveRelationForeignKeyFieldMetadataCommand extends ActiveOrSuspen
       );
     } else {
       await this.featureFlagService.enableFeatureFlags(
-        [FeatureFlagKey.IsNewRelationEnabled],
+        ['IS_NEW_RELATION_ENABLED' as FeatureFlagKey],
         workspaceId,
       );
       await this.fieldMetadataRepository.delete({

packages/twenty-server/src/database/typeorm-seeds/core/feature-flags.ts

@@ -45,11 +45,6 @@ export const seedFeatureFlags = async (
         workspaceId: workspaceId,
         value: false,
       },
-      {
-        key: FeatureFlagKey.IsNewRelationEnabled,
-        workspaceId: workspaceId,
-        value: true,
-      },
     ])
     .execute();
 };

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

@@ -6,7 +6,6 @@ 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';
 
@@ -20,14 +19,12 @@ export class GraphqlQueryFilterConditionParser {
   constructor(
     fieldMetadataMapByName: FieldMetadataMap,
     fieldMetadataMapByJoinColumnName: FieldMetadataMap,
-    featureFlagsMap: FeatureFlagMap,
   ) {
     this.fieldMetadataMapByName = fieldMetadataMapByName;
     this.fieldMetadataMapByJoinColumnName = fieldMetadataMapByJoinColumnName;
     this.queryFilterFieldParser = new GraphqlQueryFilterFieldParser(
       this.fieldMetadataMapByName,
       this.fieldMetadataMapByJoinColumnName,
-      featureFlagsMap,
     );
   }
 

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

@@ -2,7 +2,6 @@ import { capitalize } from 'twenty-shared/utils';
 import { WhereExpressionBuilder } from 'typeorm';
 
 import { FieldMetadataInterface } from 'src/engine/metadata-modules/field-metadata/interfaces/field-metadata.interface';
-import { FeatureFlagMap } from 'src/engine/core-modules/feature-flag/interfaces/feature-flag-map.interface';
 
 import {
   GraphqlQueryRunnerException,
@@ -19,16 +18,13 @@ const ARRAY_OPERATORS = ['in', 'contains', 'notContains'];
 export class GraphqlQueryFilterFieldParser {
   private fieldMetadataMapByName: FieldMetadataMap;
   private fieldMetadataMapByJoinColumnName: FieldMetadataMap;
-  private featureFlagsMap: FeatureFlagMap;
 
   constructor(
     fieldMetadataMapByName: FieldMetadataMap,
     fieldMetadataMapByJoinColumnName: FieldMetadataMap,
-    featureFlagsMap: FeatureFlagMap,
   ) {
     this.fieldMetadataMapByName = fieldMetadataMapByName;
     this.fieldMetadataMapByJoinColumnName = fieldMetadataMapByJoinColumnName;
-    this.featureFlagsMap = featureFlagsMap;
   }
 
   public 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,25 +1,17 @@
-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 {
   GraphqlQuerySelectedFieldsParser,
   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(
+  constructor(objectMetadataMaps: ObjectMetadataMaps) {
-    objectMetadataMaps: ObjectMetadataMaps,
-    featureFlagsMap: FeatureFlagMap,
-  ) {
     this.objectMetadataMaps = objectMetadataMaps;
-    this.featureFlagsMap = featureFlagsMap;
   }
 
   parseRelationField(
@@ -34,17 +26,14 @@ export class GraphqlQuerySelectedFieldsRelationParser {
 
     accumulator.relations[fieldKey] = true;
 
-    const isNewRelationEnabled =
+    const targetObjectMetadata = getTargetObjectMetadataOrThrow(
-      this.featureFlagsMap[FeatureFlagKey.IsNewRelationEnabled];
+      fieldMetadata,
-
+      this.objectMetadataMaps,
-    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, targetFields);
 

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

@@ -1,6 +1,5 @@
 import { capitalize } from 'twenty-shared/utils';
 
-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';
@@ -21,15 +20,9 @@ export class GraphqlQuerySelectedFieldsParser {
   private graphqlQuerySelectedFieldsRelationParser: GraphqlQuerySelectedFieldsRelationParser;
   private aggregateParser: GraphqlQuerySelectedFieldsAggregateParser;
 
-  constructor(
+  constructor(objectMetadataMaps: ObjectMetadataMaps) {
-    objectMetadataMaps: ObjectMetadataMaps,
-    featureFlagsMap: FeatureFlagMap,
-  ) {
     this.graphqlQuerySelectedFieldsRelationParser =
-      new GraphqlQuerySelectedFieldsRelationParser(
+      new GraphqlQuerySelectedFieldsRelationParser(objectMetadataMaps);
-        objectMetadataMaps,
-        featureFlagsMap,
-      );
     this.aggregateParser = new GraphqlQuerySelectedFieldsAggregateParser();
   }
 

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

@@ -9,8 +9,11 @@ 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 {
+  GraphqlQueryRunnerException,
+  GraphqlQueryRunnerExceptionCode,
+} from 'src/engine/api/graphql/graphql-query-runner/errors/graphql-query-runner.exception';
 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';
 import {
@@ -21,10 +24,6 @@ import { FieldMetadataMap } from 'src/engine/metadata-modules/types/field-metada
 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 {
-  GraphqlQueryRunnerException,
-  GraphqlQueryRunnerExceptionCode,
-} from 'src/engine/api/graphql/graphql-query-runner/errors/graphql-query-runner.exception';
 
 export class GraphqlQueryParser {
   private fieldMetadataMapByName: FieldMetadataMap;
@@ -32,22 +31,18 @@ export class GraphqlQueryParser {
   private objectMetadataMaps: ObjectMetadataMaps;
   private filterConditionParser: GraphqlQueryFilterConditionParser;
   private orderFieldParser: GraphqlQueryOrderFieldParser;
-  private featureFlagsMap: FeatureFlagMap;
 
   constructor(
     fieldMetadataMapByName: FieldMetadataMap,
     fieldMetadataMapByJoinColumnName: FieldMetadataMap,
     objectMetadataMaps: ObjectMetadataMaps,
-    featureFlagsMap: FeatureFlagMap,
   ) {
     this.objectMetadataMaps = objectMetadataMaps;
     this.fieldMetadataMapByName = fieldMetadataMapByName;
     this.fieldMetadataMapByJoinColumnName = fieldMetadataMapByJoinColumnName;
-    this.featureFlagsMap = featureFlagsMap;
     this.filterConditionParser = new GraphqlQueryFilterConditionParser(
       this.fieldMetadataMapByName,
       this.fieldMetadataMapByJoinColumnName,
-      featureFlagsMap,
     );
     this.orderFieldParser = new GraphqlQueryOrderFieldParser(
       this.fieldMetadataMapByName,
@@ -136,7 +131,6 @@ 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/helpers/object-records-to-graphql-connection.helper.ts

@@ -6,7 +6,6 @@ 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';
@@ -15,10 +14,8 @@ import {
   GraphqlQueryRunnerExceptionCode,
 } 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';
@@ -29,14 +26,9 @@ import { isPlainObject } from 'src/utils/is-plain-object';
 
 export class ObjectRecordsToGraphqlConnectionHelper {
   private objectMetadataMaps: ObjectMetadataMaps;
-  private featureFlagsMap: FeatureFlagMap;
 
-  constructor(
+  constructor(objectMetadataMaps: ObjectMetadataMaps) {
-    objectMetadataMaps: ObjectMetadataMaps,
-    featureFlagsMap: FeatureFlagMap,
-  ) {
     this.objectMetadataMaps = objectMetadataMaps;
-    this.featureFlagsMap = featureFlagsMap;
   }
 
   public createConnection<T extends ObjectRecord = ObjectRecord>({
@@ -154,9 +146,6 @@ export class ObjectRecordsToGraphqlConnectionHelper {
       );
     }
 
-    const isNewRelationEnabled =
-      this.featureFlagsMap[FeatureFlagKey.IsNewRelationEnabled];
-
     const objectMetadata = getObjectMetadataMapItemByNameSingular(
       this.objectMetadataMaps,
       objectName,
@@ -181,12 +170,10 @@ export class ObjectRecordsToGraphqlConnectionHelper {
 
       if (isRelationFieldMetadataType(fieldMetadata.type)) {
         if (Array.isArray(value)) {
-          const targetObjectMetadata = isNewRelationEnabled
+          const targetObjectMetadata = getTargetObjectMetadataOrThrow(
-            ? getTargetObjectMetadataOrThrow(
+            fieldMetadata,
-                fieldMetadata,
+            this.objectMetadataMaps,
-                this.objectMetadataMaps,
+          );
-              )
-            : getRelationObjectMetadata(fieldMetadata, this.objectMetadataMaps);
 
           processedObjectRecord[key] = this.createConnection({
             objectRecords: value,
@@ -206,12 +193,10 @@ export class ObjectRecordsToGraphqlConnectionHelper {
             depth: depth + 1,
           });
         } else if (isPlainObject(value)) {
-          const targetObjectMetadata = isNewRelationEnabled
+          const targetObjectMetadata = getTargetObjectMetadataOrThrow(
-            ? getTargetObjectMetadataOrThrow(
+            fieldMetadata,
-                fieldMetadata,
+            this.objectMetadataMaps,
-                this.objectMetadataMaps,
+          );
-              )
-            : getRelationObjectMetadata(fieldMetadata, this.objectMetadataMaps);
 
           processedObjectRecord[key] = this.processRecord({
             objectRecord: value,

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

@@ -324,7 +324,6 @@ export class ProcessNestedRelationsV2Helper {
       result,
       targetObjectMetadata,
       objectMetadataMaps,
-      true,
     );
 
     return { relationResults, relationAggregatedFieldsResult };

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

@@ -1,32 +1,16 @@
 import { Injectable } from '@nestjs/common';
 
-import {
+import { FindOptionsRelations, ObjectLiteral } from 'typeorm';
-  DataSource,
-  FindOptionsRelations,
-  ObjectLiteral,
-  SelectQueryBuilder,
-} from 'typeorm';
 
 import { ObjectRecord } from 'src/engine/api/graphql/workspace-query-builder/interfaces/object-record.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 { 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 { 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 { WorkspaceDataSource } from 'src/engine/twenty-orm/datasource/workspace.datasource';
-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 {
@@ -45,7 +29,6 @@ export class ProcessNestedRelationsHelper {
     limit,
     authContext,
     dataSource,
-    isNewRelationEnabled,
     shouldBypassPermissionChecks,
     roleId,
   }: {
@@ -58,472 +41,21 @@ export class ProcessNestedRelationsHelper {
     limit: number;
     authContext: AuthContext;
     dataSource: WorkspaceDataSource;
-    isNewRelationEnabled: boolean;
     shouldBypassPermissionChecks: boolean;
     roleId?: string;
   }): Promise<void> {
-    if (isNewRelationEnabled) {
+    return this.processNestedRelationsV2Helper.processNestedRelations({
-      return this.processNestedRelationsV2Helper.processNestedRelations({
-        objectMetadataMaps,
-        parentObjectMetadataItem,
-        parentObjectRecords,
-        parentObjectRecordsAggregatedValues,
-        relations,
-        aggregate,
-        limit,
-        authContext,
-        dataSource,
-        shouldBypassPermissionChecks,
-        roleId,
-      });
-    }
-
-    const processRelationTasks = Object.entries(relations).map(
-      ([relationName, nestedRelations]) =>
-        this.processRelation({
-          objectMetadataMaps,
-          parentObjectMetadataItem,
-          parentObjectRecords,
-          parentObjectRecordsAggregatedValues,
-          relationName,
-          nestedRelations,
-          aggregate,
-          limit,
-          authContext,
-          dataSource,
-          isNewRelationEnabled,
-          shouldBypassPermissionChecks,
-          roleId,
-        }),
-    );
-
-    await Promise.all(processRelationTasks);
-  }
-
-  private async processRelation<T extends ObjectRecord = ObjectRecord>({
-    objectMetadataMaps,
-    parentObjectMetadataItem,
-    parentObjectRecords,
-    parentObjectRecordsAggregatedValues,
-    relationName,
-    nestedRelations,
-    aggregate,
-    limit,
-    authContext,
-    dataSource,
-    isNewRelationEnabled,
-    shouldBypassPermissionChecks,
-    roleId,
-  }: {
-    objectMetadataMaps: ObjectMetadataMaps;
-    parentObjectMetadataItem: ObjectMetadataItemWithFieldMaps;
-    parentObjectRecords: T[];
-    parentObjectRecordsAggregatedValues: Record<string, any>;
-    relationName: string;
-    nestedRelations: any;
-    aggregate: Record<string, AggregationField>;
-    limit: number;
-    authContext: AuthContext;
-    dataSource: DataSource;
-    isNewRelationEnabled: boolean;
-    shouldBypassPermissionChecks: boolean;
-    roleId?: string;
-  }): Promise<void> {
-    const relationFieldMetadata =
-      parentObjectMetadataItem.fieldsByName[relationName];
-    const relationMetadata = getRelationMetadata(relationFieldMetadata);
-    const relationDirection = deduceRelationDirection(
-      relationFieldMetadata,
-      relationMetadata,
-    );
-
-    const processor =
-      relationDirection === 'to'
-        ? this.processToRelation
-        : this.processFromRelation;
-
-    await processor.call(this, {
       objectMetadataMaps,
       parentObjectMetadataItem,
       parentObjectRecords,
       parentObjectRecordsAggregatedValues,
-      relationName,
+      relations,
-      nestedRelations,
       aggregate,
       limit,
       authContext,
       dataSource,
-      isNewRelationEnabled,
       shouldBypassPermissionChecks,
       roleId,
     });
   }
-
-  private async processFromRelation<T extends ObjectRecord = ObjectRecord>({
-    objectMetadataMaps,
-    parentObjectMetadataItem,
-    parentObjectRecords,
-    parentObjectRecordsAggregatedValues,
-    relationName,
-    nestedRelations,
-    aggregate,
-    limit,
-    authContext,
-    dataSource,
-    isNewRelationEnabled,
-    shouldBypassPermissionChecks,
-    roleId,
-  }: {
-    objectMetadataMaps: ObjectMetadataMaps;
-    parentObjectMetadataItem: ObjectMetadataItemWithFieldMaps;
-    parentObjectRecords: T[];
-    parentObjectRecordsAggregatedValues: Record<string, any>;
-    relationName: string;
-    nestedRelations: any;
-    aggregate: Record<string, AggregationField>;
-    limit: number;
-    authContext: AuthContext;
-    dataSource: WorkspaceDataSource;
-    isNewRelationEnabled: boolean;
-    shouldBypassPermissionChecks: boolean;
-    roleId?: string;
-  }): Promise<void> {
-    const { inverseRelationName, referenceObjectMetadata } =
-      this.getRelationMetadata({
-        objectMetadataMaps,
-        parentObjectMetadataItem,
-        relationName,
-      });
-
-    const relationRepository = dataSource.getRepository(
-      referenceObjectMetadata.nameSingular,
-      shouldBypassPermissionChecks,
-      roleId,
-    );
-
-    const referenceQueryBuilder = relationRepository.createQueryBuilder(
-      referenceObjectMetadata.nameSingular,
-    );
-
-    const relationIds = this.getUniqueIds({
-      records: parentObjectRecords,
-      idField: 'id',
-    });
-    const { relationResults, relationAggregatedFieldsResult } =
-      await this.findRelations({
-        referenceQueryBuilder,
-        column: `"${inverseRelationName}Id"`,
-        ids: relationIds,
-        limit: limit * parentObjectRecords.length,
-        objectMetadataMaps,
-        referenceObjectMetadata,
-        aggregate,
-        relationName,
-      });
-
-    this.assignFromRelationResults({
-      parentRecords: parentObjectRecords,
-      parentObjectRecordsAggregatedValues,
-      relationResults,
-      relationAggregatedFieldsResult,
-      relationName,
-      joinField: `${inverseRelationName}Id`,
-    });
-
-    const referenceObjectMetadataItemWithFieldsMaps =
-      getObjectMetadataMapItemByNameSingular(
-        objectMetadataMaps,
-        referenceObjectMetadata.nameSingular,
-      );
-
-    if (!referenceObjectMetadataItemWithFieldsMaps) {
-      throw new GraphqlQueryRunnerException(
-        `Object ${referenceObjectMetadata.nameSingular} not found`,
-        GraphqlQueryRunnerExceptionCode.OBJECT_METADATA_NOT_FOUND,
-      );
-    }
-
-    if (Object.keys(nestedRelations).length > 0) {
-      await this.processNestedRelations({
-        objectMetadataMaps,
-        parentObjectMetadataItem: referenceObjectMetadataItemWithFieldsMaps,
-        parentObjectRecords: relationResults as ObjectRecord[],
-        parentObjectRecordsAggregatedValues: relationAggregatedFieldsResult,
-        relations: nestedRelations as Record<
-          string,
-          FindOptionsRelations<ObjectLiteral>
-        >,
-        aggregate,
-        limit,
-        authContext,
-        dataSource,
-        isNewRelationEnabled,
-        shouldBypassPermissionChecks,
-        roleId,
-      });
-    }
-  }
-
-  private async processToRelation<T extends ObjectRecord = ObjectRecord>({
-    objectMetadataMaps,
-    parentObjectMetadataItem,
-    parentObjectRecords,
-    parentObjectRecordsAggregatedValues,
-    relationName,
-    nestedRelations,
-    aggregate,
-    limit,
-    authContext,
-    dataSource,
-    isNewRelationEnabled,
-    shouldBypassPermissionChecks,
-    roleId,
-  }: {
-    objectMetadataMaps: ObjectMetadataMaps;
-    parentObjectMetadataItem: ObjectMetadataItemWithFieldMaps;
-    parentObjectRecords: T[];
-    parentObjectRecordsAggregatedValues: Record<string, any>;
-    relationName: string;
-    nestedRelations: any;
-    aggregate: Record<string, AggregationField>;
-    limit: number;
-    authContext: any;
-    dataSource: WorkspaceDataSource;
-    isNewRelationEnabled: boolean;
-    shouldBypassPermissionChecks: boolean;
-    roleId?: string;
-  }): Promise<void> {
-    const { referenceObjectMetadata } = this.getRelationMetadata({
-      objectMetadataMaps,
-      parentObjectMetadataItem,
-      relationName,
-    });
-
-    const relationRepository = dataSource.getRepository(
-      referenceObjectMetadata.nameSingular,
-      shouldBypassPermissionChecks,
-      roleId,
-    );
-
-    const referenceQueryBuilder = relationRepository.createQueryBuilder(
-      referenceObjectMetadata.nameSingular,
-    );
-
-    const relationIds = this.getUniqueIds({
-      records: parentObjectRecords,
-      idField: `${relationName}Id`,
-    });
-    const { relationResults, relationAggregatedFieldsResult } =
-      await this.findRelations({
-        referenceQueryBuilder,
-        column: 'id',
-        ids: relationIds,
-        limit,
-        objectMetadataMaps,
-        referenceObjectMetadata,
-        aggregate,
-        relationName,
-      });
-
-    this.assignToRelationResults({
-      parentRecords: parentObjectRecords,
-      parentObjectRecordsAggregatedValues: parentObjectRecordsAggregatedValues,
-      relationResults,
-      relationAggregatedFieldsResult,
-      relationName,
-    });
-
-    const referenceObjectMetadataItemWithFieldsMaps =
-      getObjectMetadataMapItemByNameSingular(
-        objectMetadataMaps,
-        referenceObjectMetadata.nameSingular,
-      );
-
-    if (!referenceObjectMetadataItemWithFieldsMaps) {
-      throw new GraphqlQueryRunnerException(
-        `Object ${referenceObjectMetadata.nameSingular} not found`,
-        GraphqlQueryRunnerExceptionCode.OBJECT_METADATA_NOT_FOUND,
-      );
-    }
-
-    if (Object.keys(nestedRelations).length > 0) {
-      await this.processNestedRelations({
-        objectMetadataMaps,
-        parentObjectMetadataItem: referenceObjectMetadataItemWithFieldsMaps,
-        parentObjectRecords: relationResults as ObjectRecord[],
-        parentObjectRecordsAggregatedValues: relationAggregatedFieldsResult,
-        relations: nestedRelations as Record<
-          string,
-          FindOptionsRelations<ObjectLiteral>
-        >,
-        aggregate,
-        limit,
-        authContext,
-        dataSource,
-        isNewRelationEnabled,
-        shouldBypassPermissionChecks,
-        roleId,
-      });
-    }
-  }
-
-  private getRelationMetadata({
-    objectMetadataMaps,
-    parentObjectMetadataItem,
-    relationName,
-  }: {
-    objectMetadataMaps: ObjectMetadataMaps;
-    parentObjectMetadataItem: ObjectMetadataItemWithFieldMaps;
-    relationName: string;
-  }) {
-    const relationFieldMetadata =
-      parentObjectMetadataItem.fieldsByName[relationName];
-    const relationMetadata = getRelationMetadata(relationFieldMetadata);
-    const referenceObjectMetadata = getRelationObjectMetadata(
-      relationFieldMetadata,
-      objectMetadataMaps,
-    );
-    const inverseRelationName =
-      objectMetadataMaps.byId[relationMetadata.toObjectMetadataId]?.fieldsById[
-        relationMetadata.toFieldMetadataId
-      ]?.name;
-
-    return { inverseRelationName, referenceObjectMetadata };
-  }
-
-  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,
-    referenceObjectMetadata,
-    aggregate,
-    relationName,
-  }: {
-    referenceQueryBuilder: SelectQueryBuilder<any>;
-    column: string;
-    ids: any[];
-    limit: number;
-    objectMetadataMaps: ObjectMetadataMaps;
-    referenceObjectMetadata: ObjectMetadataItemWithFieldMaps;
-    aggregate: Record<string, any>;
-    relationName: string;
-  }): Promise<{ relationResults: any[]; relationAggregatedFieldsResult: any }> {
-    if (ids.length === 0) {
-      return { relationResults: [], relationAggregatedFieldsResult: {} };
-    }
-
-    const aggregateForRelation = aggregate[relationName];
-    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,
-      referenceObjectMetadata,
-      objectMetadataMaps,
-      false,
-    );
-
-    return { relationResults, relationAggregatedFieldsResult };
-  }
-
-  private assignFromRelationResults({
-    parentRecords,
-    parentObjectRecordsAggregatedValues,
-    relationResults,
-    relationAggregatedFieldsResult,
-    relationName,
-    joinField,
-  }: {
-    parentRecords: ObjectRecord[];
-    parentObjectRecordsAggregatedValues: Record<string, any>;
-    relationResults: any[];
-    relationAggregatedFieldsResult: Record<string, any>;
-    relationName: string;
-    joinField: string;
-  }): void {
-    parentRecords.forEach((item) => {
-      item[relationName] = relationResults.filter(
-        (rel) => rel[joinField] === item.id,
-      );
-    });
-
-    parentObjectRecordsAggregatedValues[relationName] =
-      relationAggregatedFieldsResult;
-  }
-
-  private assignToRelationResults({
-    parentRecords,
-    parentObjectRecordsAggregatedValues,
-    relationResults,
-    relationAggregatedFieldsResult,
-    relationName,
-  }: {
-    parentRecords: ObjectRecord[];
-    parentObjectRecordsAggregatedValues: Record<string, any>;
-    relationResults: any[];
-    relationAggregatedFieldsResult: Record<string, any>;
-    relationName: string;
-  }): void {
-    parentRecords.forEach((item) => {
-      if (relationResults.length === 0) {
-        item[`${relationName}Id`] = null;
-      }
-      item[relationName] =
-        relationResults.find((rel) => rel.id === item[`${relationName}Id`]) ??
-        null;
-    });
-
-    parentObjectRecordsAggregatedValues[relationName] =
-      relationAggregatedFieldsResult;
-  }
 }

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

@@ -138,7 +138,6 @@ export abstract class GraphqlQueryBaseResolverService<
         objectMetadataItemWithFieldMaps.fieldsByName,
         objectMetadataItemWithFieldMaps.fieldsByJoinColumnName,
         options.objectMetadataMaps,
-        featureFlagsMap,
       );
 
       const selectedFields = graphqlFields(options.info);
@@ -170,7 +169,6 @@ export abstract class GraphqlQueryBaseResolverService<
         objectMetadataItemWithFieldMaps,
         authContext.workspace.id,
         options.objectMetadataMaps,
-        featureFlagsMap[FeatureFlagKey.IsNewRelationEnabled],
       );
 
       const resultWithGettersArray = Array.isArray(resultWithGetters)

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

@@ -14,7 +14,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 { assertIsValidUuid } from 'src/engine/api/graphql/workspace-query-runner/utils/assert-is-valid-uuid.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 { assertMutationNotOnRemoteObject } from 'src/engine/metadata-modules/object-metadata/utils/assert-mutation-not-on-remote-object.util';
 import { ObjectMetadataItemWithFieldMaps } from 'src/engine/metadata-modules/types/object-metadata-item-with-field-maps';
@@ -30,7 +29,6 @@ export class GraphqlQueryCreateManyResolverService extends GraphqlQueryBaseResol
 > {
   async resolve(
     executionArgs: GraphqlQueryResolverExecutionArgs<CreateManyResolverArgs>,
-    featureFlagsMap: Record<FeatureFlagKey, boolean>,
   ): Promise<ObjectRecord[]> {
     const { authContext, objectMetadataItemWithFieldMaps, objectMetadataMaps } =
       executionArgs.options;
@@ -44,7 +42,6 @@ export class GraphqlQueryCreateManyResolverService extends GraphqlQueryBaseResol
       objectRecords,
       objectMetadataItemWithFieldMaps,
       objectMetadataMaps,
-      featureFlagsMap,
     );
 
     this.apiEventEmitterService.emitCreateEvents(
@@ -60,7 +57,6 @@ export class GraphqlQueryCreateManyResolverService extends GraphqlQueryBaseResol
       upsertedRecords,
       objectMetadataItemWithFieldMaps,
       objectMetadataMaps,
-      featureFlagsMap,
       shouldBypassPermissionChecks,
       roleId,
     );
@@ -69,7 +65,6 @@ export class GraphqlQueryCreateManyResolverService extends GraphqlQueryBaseResol
       upsertedRecords,
       objectMetadataItemWithFieldMaps,
       objectMetadataMaps,
-      featureFlagsMap,
     );
   }
 
@@ -305,7 +300,6 @@ export class GraphqlQueryCreateManyResolverService extends GraphqlQueryBaseResol
     objectRecords: InsertResult,
     objectMetadataItemWithFieldMaps: ObjectMetadataItemWithFieldMaps,
     objectMetadataMaps: ObjectMetadataMaps,
-    featureFlagsMap: Record<FeatureFlagKey, boolean>,
   ): Promise<ObjectRecord[]> {
     const queryBuilder = executionArgs.repository.createQueryBuilder(
       objectMetadataItemWithFieldMaps.nameSingular,
@@ -322,7 +316,6 @@ export class GraphqlQueryCreateManyResolverService extends GraphqlQueryBaseResol
       nonFormattedUpsertedRecords,
       objectMetadataItemWithFieldMaps,
       objectMetadataMaps,
-      featureFlagsMap[FeatureFlagKey.IsNewRelationEnabled],
     );
   }
 
@@ -331,7 +324,6 @@ export class GraphqlQueryCreateManyResolverService extends GraphqlQueryBaseResol
     upsertedRecords: ObjectRecord[],
     objectMetadataItemWithFieldMaps: ObjectMetadataItemWithFieldMaps,
     objectMetadataMaps: ObjectMetadataMaps,
-    featureFlagsMap: Record<FeatureFlagKey, boolean>,
     shouldBypassPermissionChecks: boolean,
     roleId?: string,
   ): Promise<void> {
@@ -347,8 +339,6 @@ export class GraphqlQueryCreateManyResolverService extends GraphqlQueryBaseResol
       limit: QUERY_MAX_RECORDS,
       authContext: executionArgs.options.authContext,
       dataSource: executionArgs.dataSource,
-      isNewRelationEnabled:
-        featureFlagsMap[FeatureFlagKey.IsNewRelationEnabled],
       roleId,
       shouldBypassPermissionChecks,
     });
@@ -358,13 +348,9 @@ export class GraphqlQueryCreateManyResolverService extends GraphqlQueryBaseResol
     upsertedRecords: ObjectRecord[],
     objectMetadataItemWithFieldMaps: ObjectMetadataItemWithFieldMaps,
     objectMetadataMaps: ObjectMetadataMaps,
-    featureFlagsMap: Record<FeatureFlagKey, boolean>,
   ): ObjectRecord[] {
     const typeORMObjectRecordsParser =
-      new ObjectRecordsToGraphqlConnectionHelper(
+      new ObjectRecordsToGraphqlConnectionHelper(objectMetadataMaps);
-        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

@@ -13,7 +13,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 { assertIsValidUuid } from 'src/engine/api/graphql/workspace-query-runner/utils/assert-is-valid-uuid.util';
-import { FeatureFlagKey } from 'src/engine/core-modules/feature-flag/enums/feature-flag-key.enum';
 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';
 
@@ -24,7 +23,6 @@ export class GraphqlQueryCreateOneResolverService extends GraphqlQueryBaseResolv
 > {
   async resolve(
     executionArgs: GraphqlQueryResolverExecutionArgs<CreateOneResolverArgs>,
-    featureFlagsMap: Record<FeatureFlagKey, boolean>,
   ): Promise<ObjectRecord> {
     const { authContext, objectMetadataMaps, objectMetadataItemWithFieldMaps } =
       executionArgs.options;
@@ -53,7 +51,6 @@ export class GraphqlQueryCreateOneResolverService extends GraphqlQueryBaseResolv
       nonFormattedUpsertedRecords,
       objectMetadataItemWithFieldMaps,
       objectMetadataMaps,
-      featureFlagsMap[FeatureFlagKey.IsNewRelationEnabled],
     );
 
     this.apiEventEmitterService.emitCreateEvents(
@@ -71,18 +68,13 @@ export class GraphqlQueryCreateOneResolverService extends GraphqlQueryBaseResolv
         limit: QUERY_MAX_RECORDS,
         authContext,
         dataSource: executionArgs.dataSource,
-        isNewRelationEnabled:
-          featureFlagsMap[FeatureFlagKey.IsNewRelationEnabled],
         roleId,
         shouldBypassPermissionChecks: executionArgs.isExecutedByApiKey,
       });
     }
 
     const typeORMObjectRecordsParser =
-      new ObjectRecordsToGraphqlConnectionHelper(
+      new ObjectRecordsToGraphqlConnectionHelper(objectMetadataMaps);
-        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

@@ -11,7 +11,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 { assertIsValidUuid } from 'src/engine/api/graphql/workspace-query-runner/utils/assert-is-valid-uuid.util';
-import { FeatureFlagKey } from 'src/engine/core-modules/feature-flag/enums/feature-flag-key.enum';
 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';
 import { computeTableName } from 'src/engine/utils/compute-table-name.util';
@@ -23,7 +22,6 @@ export class GraphqlQueryDeleteManyResolverService extends GraphqlQueryBaseResol
 > {
   async resolve(
     executionArgs: GraphqlQueryResolverExecutionArgs<DeleteManyResolverArgs>,
-    featureFlagsMap: Record<FeatureFlagKey, boolean>,
   ): Promise<ObjectRecord[]> {
     const { authContext, objectMetadataItemWithFieldMaps, objectMetadataMaps } =
       executionArgs.options;
@@ -54,7 +52,6 @@ export class GraphqlQueryDeleteManyResolverService extends GraphqlQueryBaseResol
       nonFormattedDeletedObjectRecords.raw,
       objectMetadataItemWithFieldMaps,
       objectMetadataMaps,
-      featureFlagsMap[FeatureFlagKey.IsNewRelationEnabled],
     );
 
     this.apiEventEmitterService.emitDeletedEvents(
@@ -72,18 +69,13 @@ export class GraphqlQueryDeleteManyResolverService extends GraphqlQueryBaseResol
         limit: QUERY_MAX_RECORDS,
         authContext,
         dataSource: executionArgs.dataSource,
-        isNewRelationEnabled:
-          featureFlagsMap[FeatureFlagKey.IsNewRelationEnabled],
         roleId,
         shouldBypassPermissionChecks: executionArgs.isExecutedByApiKey,
       });
     }
 
     const typeORMObjectRecordsParser =
-      new ObjectRecordsToGraphqlConnectionHelper(
+      new ObjectRecordsToGraphqlConnectionHelper(objectMetadataMaps);
-        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

@@ -15,7 +15,6 @@ 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 { assertIsValidUuid } from 'src/engine/api/graphql/workspace-query-runner/utils/assert-is-valid-uuid.util';
-import { FeatureFlagKey } from 'src/engine/core-modules/feature-flag/enums/feature-flag-key.enum';
 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';
 
@@ -26,7 +25,6 @@ export class GraphqlQueryDeleteOneResolverService extends GraphqlQueryBaseResolv
 > {
   async resolve(
     executionArgs: GraphqlQueryResolverExecutionArgs<DeleteOneResolverArgs>,
-    featureFlagsMap: Record<FeatureFlagKey, boolean>,
   ): Promise<ObjectRecord> {
     const { authContext, objectMetadataItemWithFieldMaps, objectMetadataMaps } =
       executionArgs.options;
@@ -47,7 +45,6 @@ export class GraphqlQueryDeleteOneResolverService extends GraphqlQueryBaseResolv
       nonFormattedDeletedObjectRecords.raw,
       objectMetadataItemWithFieldMaps,
       objectMetadataMaps,
-      featureFlagsMap[FeatureFlagKey.IsNewRelationEnabled],
     );
 
     this.apiEventEmitterService.emitDeletedEvents(
@@ -74,18 +71,13 @@ export class GraphqlQueryDeleteOneResolverService extends GraphqlQueryBaseResolv
         limit: QUERY_MAX_RECORDS,
         authContext,
         dataSource: executionArgs.dataSource,
-        isNewRelationEnabled:
-          featureFlagsMap[FeatureFlagKey.IsNewRelationEnabled],
         roleId,
         shouldBypassPermissionChecks: executionArgs.isExecutedByApiKey,
       });
     }
 
     const typeORMObjectRecordsParser =
-      new ObjectRecordsToGraphqlConnectionHelper(
+      new ObjectRecordsToGraphqlConnectionHelper(objectMetadataMaps);
-        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 { FeatureFlagKey } from 'src/engine/core-modules/feature-flag/enums/feature-flag-key.enum';
 import { formatResult } from 'src/engine/twenty-orm/utils/format-result.util';
 import { computeTableName } from 'src/engine/utils/compute-table-name.util';
 
@@ -21,7 +20,6 @@ export class GraphqlQueryDestroyManyResolverService extends GraphqlQueryBaseReso
 > {
   async resolve(
     executionArgs: GraphqlQueryResolverExecutionArgs<DestroyManyResolverArgs>,
-    featureFlagsMap: Record<FeatureFlagKey, boolean>,
   ): Promise<ObjectRecord[]> {
     const { authContext, objectMetadataItemWithFieldMaps, objectMetadataMaps } =
       executionArgs.options;
@@ -52,7 +50,6 @@ export class GraphqlQueryDestroyManyResolverService extends GraphqlQueryBaseReso
       nonFormattedDeletedObjectRecords.raw,
       objectMetadataItemWithFieldMaps,
       objectMetadataMaps,
-      featureFlagsMap[FeatureFlagKey.IsNewRelationEnabled],
     );
 
     this.apiEventEmitterService.emitDestroyEvents(
@@ -70,18 +67,13 @@ export class GraphqlQueryDestroyManyResolverService extends GraphqlQueryBaseReso
         limit: QUERY_MAX_RECORDS,
         authContext,
         dataSource: executionArgs.dataSource,
-        isNewRelationEnabled:
-          featureFlagsMap[FeatureFlagKey.IsNewRelationEnabled],
         roleId,
         shouldBypassPermissionChecks: executionArgs.isExecutedByApiKey,
       });
     }
 
     const typeORMObjectRecordsParser =
-      new ObjectRecordsToGraphqlConnectionHelper(
+      new ObjectRecordsToGraphqlConnectionHelper(objectMetadataMaps);
-        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 { FeatureFlagKey } from 'src/engine/core-modules/feature-flag/enums/feature-flag-key.enum';
 import { formatResult } from 'src/engine/twenty-orm/utils/format-result.util';
 
 @Injectable()
@@ -24,7 +23,6 @@ export class GraphqlQueryDestroyOneResolverService extends GraphqlQueryBaseResol
 > {
   async resolve(
     executionArgs: GraphqlQueryResolverExecutionArgs<DestroyOneResolverArgs>,
-    featureFlagsMap: Record<FeatureFlagKey, boolean>,
   ): Promise<ObjectRecord> {
     const { authContext, objectMetadataItemWithFieldMaps, objectMetadataMaps } =
       executionArgs.options;
@@ -52,7 +50,6 @@ export class GraphqlQueryDestroyOneResolverService extends GraphqlQueryBaseResol
       nonFormattedDeletedObjectRecords.raw,
       objectMetadataItemWithFieldMaps,
       objectMetadataMaps,
-      featureFlagsMap[FeatureFlagKey.IsNewRelationEnabled],
     );
 
     this.apiEventEmitterService.emitDestroyEvents(
@@ -70,18 +67,13 @@ export class GraphqlQueryDestroyOneResolverService extends GraphqlQueryBaseResol
         limit: QUERY_MAX_RECORDS,
         authContext,
         dataSource: executionArgs.dataSource,
-        isNewRelationEnabled:
-          featureFlagsMap[FeatureFlagKey.IsNewRelationEnabled],
         roleId,
         shouldBypassPermissionChecks: executionArgs.isExecutedByApiKey,
       });
     }
 
     const typeORMObjectRecordsParser =
-      new ObjectRecordsToGraphqlConnectionHelper(
+      new ObjectRecordsToGraphqlConnectionHelper(objectMetadataMaps);
-        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

@@ -23,7 +23,6 @@ import {
 import { GraphqlQueryParser } from 'src/engine/api/graphql/graphql-query-runner/graphql-query-parsers/graphql-query.parser';
 import { ObjectRecordsToGraphqlConnectionHelper } from 'src/engine/api/graphql/graphql-query-runner/helpers/object-records-to-graphql-connection.helper';
 import { settings } from 'src/engine/constants/settings';
-import { FeatureFlagKey } from 'src/engine/core-modules/feature-flag/enums/feature-flag-key.enum';
 import { ObjectMetadataItemWithFieldMaps } from 'src/engine/metadata-modules/types/object-metadata-item-with-field-maps';
 import { getObjectMetadataMapItemByNameSingular } from 'src/engine/metadata-modules/utils/get-object-metadata-map-item-by-name-singular.util';
 import { formatData } from 'src/engine/twenty-orm/utils/format-data.util';
@@ -39,7 +38,6 @@ export class GraphqlQueryFindDuplicatesResolverService extends GraphqlQueryBaseR
 > {
   async resolve(
     executionArgs: GraphqlQueryResolverExecutionArgs<FindDuplicatesResolverArgs>,
-    featureFlagsMap: Record<FeatureFlagKey, boolean>,
   ): Promise<IConnection<ObjectRecord>[]> {
     const { objectMetadataItemWithFieldMaps, objectMetadataMaps } =
       executionArgs.options;
@@ -66,14 +64,10 @@ export class GraphqlQueryFindDuplicatesResolverService extends GraphqlQueryBaseR
       objectMetadataItemWithFieldsMaps?.fieldsByName,
       objectMetadataItemWithFieldsMaps?.fieldsByJoinColumnName,
       objectMetadataMaps,
-      featureFlagsMap,
     );
 
     const typeORMObjectRecordsParser =
-      new ObjectRecordsToGraphqlConnectionHelper(
+      new ObjectRecordsToGraphqlConnectionHelper(objectMetadataMaps);
-        objectMetadataMaps,
-        featureFlagsMap,
-      );
 
     let objectRecords: Partial<ObjectRecord>[] = [];
 
@@ -86,7 +80,6 @@ export class GraphqlQueryFindDuplicatesResolverService extends GraphqlQueryBaseR
         nonFormattedObjectRecords,
         objectMetadataItemWithFieldMaps,
         objectMetadataMaps,
-        featureFlagsMap[FeatureFlagKey.IsNewRelationEnabled],
       );
     } else if (executionArgs.args.data && !isEmpty(executionArgs.args.data)) {
       objectRecords = formatData(
@@ -133,7 +126,6 @@ export class GraphqlQueryFindDuplicatesResolverService extends GraphqlQueryBaseR
           nonFormattedDuplicates,
           objectMetadataItemWithFieldMaps,
           objectMetadataMaps,
-          featureFlagsMap[FeatureFlagKey.IsNewRelationEnabled],
         );
 
         return typeORMObjectRecordsParser.createConnection({

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

@@ -28,7 +28,6 @@ import {
   getCursor,
   getPaginationInfo,
 } from 'src/engine/api/graphql/graphql-query-runner/utils/cursors.util';
-import { FeatureFlagKey } from 'src/engine/core-modules/feature-flag/enums/feature-flag-key.enum';
 import { formatResult } from 'src/engine/twenty-orm/utils/format-result.util';
 
 @Injectable()
@@ -42,7 +41,6 @@ export class GraphqlQueryFindManyResolverService extends GraphqlQueryBaseResolve
 
   async resolve(
     executionArgs: GraphqlQueryResolverExecutionArgs<FindManyResolverArgs>,
-    featureFlagsMap: Record<FeatureFlagKey, boolean>,
   ): Promise<IConnection<ObjectRecord>> {
     const { authContext, objectMetadataItemWithFieldMaps, objectMetadataMaps } =
       executionArgs.options;
@@ -130,7 +128,6 @@ export class GraphqlQueryFindManyResolverService extends GraphqlQueryBaseResolve
       nonFormattedObjectRecords,
       objectMetadataItemWithFieldMaps,
       objectMetadataMaps,
-      featureFlagsMap[FeatureFlagKey.IsNewRelationEnabled],
     );
 
     const { hasNextPage, hasPreviousPage } = getPaginationInfo(
@@ -157,18 +154,13 @@ export class GraphqlQueryFindManyResolverService extends GraphqlQueryBaseResolve
         limit: QUERY_MAX_RECORDS,
         authContext,
         dataSource: executionArgs.dataSource,
-        isNewRelationEnabled:
-          featureFlagsMap[FeatureFlagKey.IsNewRelationEnabled],
         roleId,
         shouldBypassPermissionChecks: executionArgs.isExecutedByApiKey,
       });
     }
 
     const typeORMObjectRecordsParser =
-      new ObjectRecordsToGraphqlConnectionHelper(
+      new ObjectRecordsToGraphqlConnectionHelper(objectMetadataMaps);
-        objectMetadataMaps,
-        featureFlagsMap,
-      );
 
     return typeORMObjectRecordsParser.createConnection({
       objectRecords,

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

@@ -21,7 +21,6 @@ import {
   WorkspaceQueryRunnerException,
   WorkspaceQueryRunnerExceptionCode,
 } from 'src/engine/api/graphql/workspace-query-runner/workspace-query-runner.exception';
-import { FeatureFlagKey } from 'src/engine/core-modules/feature-flag/enums/feature-flag-key.enum';
 import { formatResult } from 'src/engine/twenty-orm/utils/format-result.util';
 
 @Injectable()
@@ -31,7 +30,6 @@ export class GraphqlQueryFindOneResolverService extends GraphqlQueryBaseResolver
 > {
   async resolve(
     executionArgs: GraphqlQueryResolverExecutionArgs<FindOneResolverArgs>,
-    featureFlagsMap: Record<FeatureFlagKey, boolean>,
   ): Promise<ObjectRecord> {
     const { authContext, objectMetadataItemWithFieldMaps, objectMetadataMaps } =
       executionArgs.options;
@@ -59,7 +57,6 @@ export class GraphqlQueryFindOneResolverService extends GraphqlQueryBaseResolver
       nonFormattedObjectRecord,
       objectMetadataItemWithFieldMaps,
       objectMetadataMaps,
-      featureFlagsMap[FeatureFlagKey.IsNewRelationEnabled],
     );
 
     if (!objectRecord) {
@@ -80,18 +77,13 @@ export class GraphqlQueryFindOneResolverService extends GraphqlQueryBaseResolver
         limit: QUERY_MAX_RECORDS,
         authContext,
         dataSource: executionArgs.dataSource,
-        isNewRelationEnabled:
-          featureFlagsMap[FeatureFlagKey.IsNewRelationEnabled],
         roleId,
         shouldBypassPermissionChecks: executionArgs.isExecutedByApiKey,
       });
     }
 
     const typeORMObjectRecordsParser =
-      new ObjectRecordsToGraphqlConnectionHelper(
+      new ObjectRecordsToGraphqlConnectionHelper(objectMetadataMaps);
-        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

@@ -11,7 +11,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 { assertIsValidUuid } from 'src/engine/api/graphql/workspace-query-runner/utils/assert-is-valid-uuid.util';
-import { FeatureFlagKey } from 'src/engine/core-modules/feature-flag/enums/feature-flag-key.enum';
 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';
 import { computeTableName } from 'src/engine/utils/compute-table-name.util';
@@ -23,7 +22,6 @@ export class GraphqlQueryRestoreManyResolverService extends GraphqlQueryBaseReso
 > {
   async resolve(
     executionArgs: GraphqlQueryResolverExecutionArgs<RestoreManyResolverArgs>,
-    featureFlagsMap: Record<FeatureFlagKey, boolean>,
   ): Promise<ObjectRecord[]> {
     const { authContext, objectMetadataItemWithFieldMaps, objectMetadataMaps } =
       executionArgs.options;
@@ -54,7 +52,6 @@ export class GraphqlQueryRestoreManyResolverService extends GraphqlQueryBaseReso
       nonFormattedRestoredObjectRecords.raw,
       objectMetadataItemWithFieldMaps,
       objectMetadataMaps,
-      featureFlagsMap[FeatureFlagKey.IsNewRelationEnabled],
     );
 
     this.apiEventEmitterService.emitRestoreEvents(
@@ -72,18 +69,13 @@ export class GraphqlQueryRestoreManyResolverService extends GraphqlQueryBaseReso
         limit: QUERY_MAX_RECORDS,
         authContext,
         dataSource: executionArgs.dataSource,
-        isNewRelationEnabled:
-          featureFlagsMap[FeatureFlagKey.IsNewRelationEnabled],
         roleId,
         shouldBypassPermissionChecks: executionArgs.isExecutedByApiKey,
       });
     }
 
     const typeORMObjectRecordsParser =
-      new ObjectRecordsToGraphqlConnectionHelper(
+      new ObjectRecordsToGraphqlConnectionHelper(objectMetadataMaps);
-        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

@@ -15,7 +15,6 @@ 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 { assertIsValidUuid } from 'src/engine/api/graphql/workspace-query-runner/utils/assert-is-valid-uuid.util';
-import { FeatureFlagKey } from 'src/engine/core-modules/feature-flag/enums/feature-flag-key.enum';
 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';
 
@@ -26,7 +25,6 @@ export class GraphqlQueryRestoreOneResolverService extends GraphqlQueryBaseResol
 > {
   async resolve(
     executionArgs: GraphqlQueryResolverExecutionArgs<RestoreOneResolverArgs>,
-    featureFlagsMap: Record<FeatureFlagKey, boolean>,
   ): Promise<ObjectRecord> {
     const { authContext, objectMetadataItemWithFieldMaps, objectMetadataMaps } =
       executionArgs.options;
@@ -47,7 +45,6 @@ export class GraphqlQueryRestoreOneResolverService extends GraphqlQueryBaseResol
       nonFormattedRestoredObjectRecords.raw,
       objectMetadataItemWithFieldMaps,
       objectMetadataMaps,
-      featureFlagsMap[FeatureFlagKey.IsNewRelationEnabled],
     );
 
     this.apiEventEmitterService.emitRestoreEvents(
@@ -74,18 +71,13 @@ export class GraphqlQueryRestoreOneResolverService extends GraphqlQueryBaseResol
         limit: QUERY_MAX_RECORDS,
         authContext,
         dataSource: executionArgs.dataSource,
-        isNewRelationEnabled:
-          featureFlagsMap[FeatureFlagKey.IsNewRelationEnabled],
         roleId,
         shouldBypassPermissionChecks: executionArgs.isExecutedByApiKey,
       });
     }
 
     const typeORMObjectRecordsParser =
-      new ObjectRecordsToGraphqlConnectionHelper(
+      new ObjectRecordsToGraphqlConnectionHelper(objectMetadataMaps);
-        objectMetadataMaps,
-        featureFlagsMap,
-      );
 
     return typeORMObjectRecordsParser.processRecord({
       objectRecord: restoredRecord,

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

@@ -17,7 +17,6 @@ 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 { assertIsValidUuid } from 'src/engine/api/graphql/workspace-query-runner/utils/assert-is-valid-uuid.util';
-import { FeatureFlagKey } from 'src/engine/core-modules/feature-flag/enums/feature-flag-key.enum';
 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';
 import { formatResult } from 'src/engine/twenty-orm/utils/format-result.util';
@@ -30,7 +29,6 @@ export class GraphqlQueryUpdateManyResolverService extends GraphqlQueryBaseResol
 > {
   async resolve(
     executionArgs: GraphqlQueryResolverExecutionArgs<UpdateManyResolverArgs>,
-    featureFlagsMap: Record<FeatureFlagKey, boolean>,
   ): Promise<ObjectRecord[]> {
     const { authContext, objectMetadataItemWithFieldMaps, objectMetadataMaps } =
       executionArgs.options;
@@ -55,7 +53,6 @@ export class GraphqlQueryUpdateManyResolverService extends GraphqlQueryBaseResol
       existingRecords,
       objectMetadataItemWithFieldMaps,
       objectMetadataMaps,
-      featureFlagsMap[FeatureFlagKey.IsNewRelationEnabled],
     );
 
     if (isEmpty(formattedExistingRecords)) {
@@ -90,7 +87,6 @@ export class GraphqlQueryUpdateManyResolverService extends GraphqlQueryBaseResol
       nonFormattedUpdatedObjectRecords.raw,
       objectMetadataItemWithFieldMaps,
       objectMetadataMaps,
-      featureFlagsMap[FeatureFlagKey.IsNewRelationEnabled],
     );
 
     this.apiEventEmitterService.emitUpdateEvents(
@@ -110,18 +106,13 @@ export class GraphqlQueryUpdateManyResolverService extends GraphqlQueryBaseResol
         limit: QUERY_MAX_RECORDS,
         authContext,
         dataSource: executionArgs.dataSource,
-        isNewRelationEnabled:
-          featureFlagsMap[FeatureFlagKey.IsNewRelationEnabled],
         roleId,
         shouldBypassPermissionChecks: executionArgs.isExecutedByApiKey,
       });
     }
 
     const typeORMObjectRecordsParser =
-      new ObjectRecordsToGraphqlConnectionHelper(
+      new ObjectRecordsToGraphqlConnectionHelper(objectMetadataMaps);
-        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

@@ -17,7 +17,6 @@ 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 { assertIsValidUuid } from 'src/engine/api/graphql/workspace-query-runner/utils/assert-is-valid-uuid.util';
-import { FeatureFlagKey } from 'src/engine/core-modules/feature-flag/enums/feature-flag-key.enum';
 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';
 import { formatResult } from 'src/engine/twenty-orm/utils/format-result.util';
@@ -29,7 +28,6 @@ export class GraphqlQueryUpdateOneResolverService extends GraphqlQueryBaseResolv
 > {
   async resolve(
     executionArgs: GraphqlQueryResolverExecutionArgs<UpdateOneResolverArgs>,
-    featureFlagsMap: Record<FeatureFlagKey, boolean>,
   ): Promise<ObjectRecord> {
     const { authContext, objectMetadataItemWithFieldMaps, objectMetadataMaps } =
       executionArgs.options;
@@ -55,7 +53,6 @@ export class GraphqlQueryUpdateOneResolverService extends GraphqlQueryBaseResolv
       existingRecords,
       objectMetadataItemWithFieldMaps,
       objectMetadataMaps,
-      featureFlagsMap[FeatureFlagKey.IsNewRelationEnabled],
     );
 
     if (isEmpty(formattedExistingRecords)) {
@@ -75,7 +72,6 @@ export class GraphqlQueryUpdateOneResolverService extends GraphqlQueryBaseResolv
       nonFormattedUpdatedObjectRecords.raw,
       objectMetadataItemWithFieldMaps,
       objectMetadataMaps,
-      featureFlagsMap[FeatureFlagKey.IsNewRelationEnabled],
     );
 
     this.apiEventEmitterService.emitUpdateEvents(
@@ -104,18 +100,13 @@ export class GraphqlQueryUpdateOneResolverService extends GraphqlQueryBaseResolv
         limit: QUERY_MAX_RECORDS,
         authContext,
         dataSource: executionArgs.dataSource,
-        isNewRelationEnabled:
-          featureFlagsMap[FeatureFlagKey.IsNewRelationEnabled],
         roleId,
         shouldBypassPermissionChecks: executionArgs.isExecutedByApiKey,
       });
     }
 
     const typeORMObjectRecordsParser =
-      new ObjectRecordsToGraphqlConnectionHelper(
+      new ObjectRecordsToGraphqlConnectionHelper(objectMetadataMaps);
-        objectMetadataMaps,
-        featureFlagsMap,
-      );
 
     return typeORMObjectRecordsParser.processRecord({
       objectRecord: updatedRecord,

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

@@ -1,48 +0,0 @@
-import { FieldMetadataInterface } from 'src/engine/metadata-modules/field-metadata/interfaces/field-metadata.interface';
-
-import { RelationMetadataEntity } from 'src/engine/metadata-modules/relation-metadata/relation-metadata.entity';
-import { ObjectMetadataMaps } from 'src/engine/metadata-modules/types/object-metadata-maps';
-import {
-  deduceRelationDirection,
-  RelationDirection,
-} from 'src/engine/utils/deduce-relation-direction.util';
-
-export const getRelationObjectMetadata = (
-  fieldMetadata: FieldMetadataInterface,
-  objectMetadataMaps: ObjectMetadataMaps,
-) => {
-  const relationMetadata = getRelationMetadata(fieldMetadata);
-
-  const relationDirection = deduceRelationDirection(
-    fieldMetadata,
-    relationMetadata,
-  );
-
-  const referencedObjectMetadata =
-    relationDirection === RelationDirection.TO
-      ? objectMetadataMaps.byId[relationMetadata.fromObjectMetadataId]
-      : objectMetadataMaps.byId[relationMetadata.toObjectMetadataId];
-
-  if (!referencedObjectMetadata) {
-    throw new Error(
-      `Referenced object metadata not found for relation ${relationMetadata.id}`,
-    );
-  }
-
-  return referencedObjectMetadata;
-};
-
-export const getRelationMetadata = (
-  fieldMetadata: FieldMetadataInterface,
-): RelationMetadataEntity => {
-  const relationMetadata =
-    fieldMetadata.fromRelationMetadata ?? fieldMetadata.toRelationMetadata;
-
-  if (!relationMetadata) {
-    throw new Error(
-      `Relation metadata not found for field ${fieldMetadata.name}`,
-    );
-  }
-
-  return relationMetadata;
-};

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

@@ -71,7 +71,6 @@ export class QueryResultGettersFactory {
     objectMetadataItemId: string,
     objectMetadataMaps: ObjectMetadataMaps,
     workspaceId: string,
-    isNewRelationEnabled: boolean,
   ): Promise<IConnection<ObjectRecord>> {
     return {
       ...connection,
@@ -83,7 +82,6 @@ export class QueryResultGettersFactory {
             objectMetadataItemId,
             objectMetadataMaps,
             workspaceId,
-            isNewRelationEnabled,
           ),
         })),
       ),
@@ -95,7 +93,6 @@ export class QueryResultGettersFactory {
     objectMetadataItemId: string,
     objectMetadataMaps: ObjectMetadataMaps,
     workspaceId: string,
-    isNewRelationEnabled: boolean,
   ) {
     return {
       ...result,
@@ -107,7 +104,6 @@ export class QueryResultGettersFactory {
               objectMetadataItemId,
               objectMetadataMaps,
               workspaceId,
-              isNewRelationEnabled,
             ),
         ),
       ),
@@ -119,7 +115,6 @@ export class QueryResultGettersFactory {
     objectMetadataItemId: string,
     objectMetadataMaps: ObjectMetadataMaps,
     workspaceId: string,
-    isNewRelationEnabled: boolean,
   ) {
     return await Promise.all(
       recordArray.map(
@@ -129,7 +124,6 @@ export class QueryResultGettersFactory {
             objectMetadataItemId,
             objectMetadataMaps,
             workspaceId,
-            isNewRelationEnabled,
           ),
       ),
     );
@@ -140,7 +134,6 @@ export class QueryResultGettersFactory {
     objectMetadataItemId: string,
     objectMetadataMaps: ObjectMetadataMaps,
     workspaceId: string,
-    isNewRelationEnabled: boolean,
   ): Promise<ObjectRecord> {
     const objectMetadataMapItem = objectMetadataMaps.byId[objectMetadataItemId];
 
@@ -165,55 +158,17 @@ export class QueryResultGettersFactory {
     >;
 
     for (const relationField of relationFields) {
-      if (!isNewRelationEnabled) {
+      if (!isDefined(relationField.relationTargetObjectMetadataId)) {
-        const relationMetadata =
+        throw new Error('Relation target object metadata id is not defined');
-          relationField.fromRelationMetadata ??
-          relationField.toRelationMetadata;
-
-        if (!isDefined(relationMetadata)) {
-          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,
-            isNewRelationEnabled,
-          );
-      } 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,
-            isNewRelationEnabled,
-          );
       }
+
+      relationFieldsProcessedMap[relationField.name] =
+        await this.processQueryResultField(
+          record[relationField.name],
+          relationField.relationTargetObjectMetadataId,
+          objectMetadataMaps,
+          workspaceId,
+        );
     }
 
     const objectRecordProcessedWithoutRelationFields = await handler.handle(
@@ -234,7 +189,6 @@ export class QueryResultGettersFactory {
     objectMetadataItemId: string,
     objectMetadataMaps: ObjectMetadataMaps,
     workspaceId: string,
-    isNewRelationEnabled: boolean,
   ) {
     if (isQueryResultFieldValueAConnection(queryResultField)) {
       return await this.processConnection(
@@ -242,7 +196,6 @@ export class QueryResultGettersFactory {
         objectMetadataItemId,
         objectMetadataMaps,
         workspaceId,
-        isNewRelationEnabled,
       );
     } else if (isQueryResultFieldValueANestedRecordArray(queryResultField)) {
       return await this.processNestedRecordArray(
@@ -250,7 +203,6 @@ export class QueryResultGettersFactory {
         objectMetadataItemId,
         objectMetadataMaps,
         workspaceId,
-        isNewRelationEnabled,
       );
     } else if (isQueryResultFieldValueARecordArray(queryResultField)) {
       return await this.processRecordArray(
@@ -258,7 +210,6 @@ export class QueryResultGettersFactory {
         objectMetadataItemId,
         objectMetadataMaps,
         workspaceId,
-        isNewRelationEnabled,
       );
     } else if (isQueryResultFieldValueARecord(queryResultField)) {
       return await this.processRecord(
@@ -266,7 +217,6 @@ export class QueryResultGettersFactory {
         objectMetadataItemId,
         objectMetadataMaps,
         workspaceId,
-        isNewRelationEnabled,
       );
     } else {
       this.logger.warn(
@@ -283,14 +233,12 @@ export class QueryResultGettersFactory {
     objectMetadataItem: ObjectMetadataInterface,
     workspaceId: string,
     objectMetadataMaps: ObjectMetadataMaps,
-    isNewRelationEnabled: boolean,
   ): Promise<any> {
     return await this.processQueryResultField(
       result,
       objectMetadataItem.id,
       objectMetadataMaps,
       workspaceId,
-      isNewRelationEnabled,
     );
   }
 

packages/twenty-server/src/engine/api/graphql/workspace-schema-builder/factories/input-type-definition.factory.ts

@@ -36,7 +36,6 @@ export class InputTypeDefinitionFactory {
     objectMetadata: ObjectMetadataInterface,
     kind: InputTypeDefinitionKind,
     options: WorkspaceBuildSchemaOptions,
-    isNewRelationEnabled = false,
   ): InputTypeDefinition {
     const inputType = new GraphQLInputObjectType({
       name: `${pascalCase(objectMetadata.nameSingular)}${kind.toString()}Input`,
@@ -59,7 +58,6 @@ export class InputTypeDefinitionFactory {
                 kind,
                 options,
                 this.inputTypeFactory,
-                isNewRelationEnabled,
               ),
               and: {
                 type: andOrType,
@@ -83,7 +81,6 @@ export class InputTypeDefinitionFactory {
               kind,
               options,
               this.inputTypeFactory,
-              isNewRelationEnabled,
             );
         }
       },

packages/twenty-server/src/engine/api/graphql/workspace-schema-builder/factories/object-type-definition.factory.ts

@@ -30,7 +30,6 @@ export class ObjectTypeDefinitionFactory {
     objectMetadata: ObjectMetadataInterface,
     kind: ObjectTypeDefinitionKind,
     options: WorkspaceBuildSchemaOptions,
-    isNewRelationEnabled = false,
   ): ObjectTypeDefinition {
     return {
       target: objectMetadata.id,
@@ -43,7 +42,6 @@ export class ObjectTypeDefinitionFactory {
           kind,
           options,
           this.outputTypeFactory,
-          isNewRelationEnabled,
         ),
       }),
     };

packages/twenty-server/src/engine/api/graphql/workspace-schema-builder/type-definitions.generator.ts

@@ -1,7 +1,5 @@
 import { Injectable, Logger } from '@nestjs/common';
 
-import chalk from 'chalk';
-
 import { CompositeType } from 'src/engine/metadata-modules/field-metadata/interfaces/composite-type.interface';
 import { ObjectMetadataInterface } from 'src/engine/metadata-modules/field-metadata/interfaces/object-metadata.interface';
 
@@ -10,13 +8,10 @@ import { CompositeInputTypeDefinitionFactory } from 'src/engine/api/graphql/work
 import { CompositeObjectTypeDefinitionFactory } from 'src/engine/api/graphql/workspace-schema-builder/factories/composite-object-type-definition.factory';
 import { EnumTypeDefinitionFactory } from 'src/engine/api/graphql/workspace-schema-builder/factories/enum-type-definition.factory';
 import { ExtendObjectTypeDefinitionV2Factory } from 'src/engine/api/graphql/workspace-schema-builder/factories/extend-object-type-definition-v2.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 { compositeTypeDefinitions } from 'src/engine/metadata-modules/field-metadata/composite-types';
 
 import { ConnectionTypeDefinitionFactory } from './factories/connection-type-definition.factory';
 import { EdgeTypeDefinitionFactory } from './factories/edge-type-definition.factory';
-import { ExtendObjectTypeDefinitionFactory } from './factories/extend-object-type-definition.factory';
 import {
   InputTypeDefinitionFactory,
   InputTypeDefinitionKind,
@@ -43,24 +38,17 @@ export class TypeDefinitionsGenerator {
     private readonly compositeInputTypeDefinitionFactory: CompositeInputTypeDefinitionFactory,
     private readonly edgeTypeDefinitionFactory: EdgeTypeDefinitionFactory,
     private readonly connectionTypeDefinitionFactory: ConnectionTypeDefinitionFactory,
-    private readonly extendObjectTypeDefinitionFactory: ExtendObjectTypeDefinitionFactory,
     private readonly extendObjectTypeDefinitionV2Factory: ExtendObjectTypeDefinitionV2Factory,
-    private readonly featureFlagService: FeatureFlagService,
   ) {}
 
   async generate(
     objectMetadataCollection: ObjectMetadataInterface[],
     options: WorkspaceBuildSchemaOptions,
-    isNewRelationEnabled: boolean,
   ) {
     // Generate composite type objects first because they can be used in dynamic objects
     await this.generateCompositeTypeDefs(options);
     // Generate metadata objects
-    await this.generateMetadataTypeDefs(
+    await this.generateMetadataTypeDefs(objectMetadataCollection, options);
-      objectMetadataCollection,
-      options,
-      isNewRelationEnabled,
-    );
   }
 
   /**
@@ -160,7 +148,6 @@ export class TypeDefinitionsGenerator {
   private async generateMetadataTypeDefs(
     dynamicObjectMetadataCollection: ObjectMetadataInterface[],
     options: WorkspaceBuildSchemaOptions,
-    isNewRelationEnabled: boolean,
   ) {
     this.logger.log(
       `Generating metadata objects: [${dynamicObjectMetadataCollection
@@ -170,17 +157,9 @@ export class TypeDefinitionsGenerator {
 
     // Generate dynamic objects
     this.generateEnumTypeDefs(dynamicObjectMetadataCollection, options);
-    this.generateObjectTypeDefs(
+    this.generateObjectTypeDefs(dynamicObjectMetadataCollection, options);
-      dynamicObjectMetadataCollection,
-      options,
-      isNewRelationEnabled,
-    );
     this.generatePaginationTypeDefs(dynamicObjectMetadataCollection, options);
-    this.generateInputTypeDefs(
+    this.generateInputTypeDefs(dynamicObjectMetadataCollection, options);
-      dynamicObjectMetadataCollection,
-      options,
-      isNewRelationEnabled,
-    );
     await this.generateExtendedObjectTypeDefs(
       dynamicObjectMetadataCollection,
       options,
@@ -190,14 +169,12 @@ export class TypeDefinitionsGenerator {
   private generateObjectTypeDefs(
     objectMetadataCollection: ObjectMetadataInterface[] | CompositeType[],
     options: WorkspaceBuildSchemaOptions,
-    isNewRelationEnabled: boolean,
   ) {
     const objectTypeDefs = objectMetadataCollection.map((objectMetadata) =>
       this.objectTypeDefinitionFactory.create(
         objectMetadata,
         ObjectTypeDefinitionKind.Plain,
         options,
-        isNewRelationEnabled,
       ),
     );
 
@@ -225,7 +202,6 @@ export class TypeDefinitionsGenerator {
   private generateInputTypeDefs(
     objectMetadataCollection: ObjectMetadataInterface[],
     options: WorkspaceBuildSchemaOptions,
-    isNewRelationEnabled: boolean,
   ) {
     const inputTypeDefs = objectMetadataCollection
       .map((objectMetadata) => {
@@ -243,28 +219,24 @@ export class TypeDefinitionsGenerator {
             objectMetadata,
             InputTypeDefinitionKind.Create,
             options,
-            isNewRelationEnabled,
           ),
           // Input type for update
           this.inputTypeDefinitionFactory.create(
             optionalExtendedObjectMetadata,
             InputTypeDefinitionKind.Update,
             options,
-            isNewRelationEnabled,
           ),
           // Filter input type
           this.inputTypeDefinitionFactory.create(
             optionalExtendedObjectMetadata,
             InputTypeDefinitionKind.Filter,
             options,
-            isNewRelationEnabled,
           ),
           // OrderBy input type
           this.inputTypeDefinitionFactory.create(
             optionalExtendedObjectMetadata,
             InputTypeDefinitionKind.OrderBy,
             options,
-            isNewRelationEnabled,
           ),
         ];
       })
@@ -300,34 +272,14 @@ export class TypeDefinitionsGenerator {
       throw new Error('Workspace ID not found');
     }
 
-    const isNewRelationEnabled = await this.featureFlagService.isFeatureEnabled(
+    const objectTypeDefs = objectMetadataCollectionWithCompositeFields.map(
-      FeatureFlagKey.IsNewRelationEnabled,
+      (objectMetadata) =>
-      workspaceId,
+        this.extendObjectTypeDefinitionV2Factory.create(
+          objectMetadata,
+          options,
+        ),
     );
 
-    if (!isNewRelationEnabled) {
+    this.typeDefinitionsStorage.addObjectTypes(objectTypeDefs);
-      const objectTypeDefs = objectMetadataCollectionWithCompositeFields.map(
-        (objectMetadata) =>
-          this.extendObjectTypeDefinitionFactory.create(
-            objectMetadata,
-            options,
-          ),
-      );
-
-      this.typeDefinitionsStorage.addObjectTypes(objectTypeDefs);
-    } else {
-      this.logger.log(
-        chalk.green('Extend object type definition with new relation fields'),
-      );
-      const objectTypeDefsV2 = objectMetadataCollectionWithCompositeFields.map(
-        (objectMetadata) =>
-          this.extendObjectTypeDefinitionV2Factory.create(
-            objectMetadata,
-            options,
-          ),
-      );
-
-      this.typeDefinitionsStorage.addObjectTypes(objectTypeDefsV2);
-    }
   }
 }

packages/twenty-server/src/engine/api/graphql/workspace-schema-builder/utils/generate-fields.utils.ts

@@ -41,7 +41,6 @@ export const generateFields = <
   kind: T,
   options: WorkspaceBuildSchemaOptions,
   typeFactory: TypeFactory<T>,
-  isNewRelationEnabled = false,
 ): T extends InputTypeDefinitionKind
   ? GraphQLInputFieldConfigMap
   : GraphQLFieldConfigMap<any, any> => {
@@ -53,8 +52,7 @@ export const generateFields = <
         fieldMetadata,
         FieldMetadataType.RELATION,
       ) &&
-      (fieldMetadata.settings?.relationType !== RelationType.MANY_TO_ONE ||
+      fieldMetadata.settings?.relationType !== RelationType.MANY_TO_ONE
-        !isNewRelationEnabled)
     ) {
       continue;
     }

packages/twenty-server/src/engine/api/graphql/workspace-schema-builder/workspace-graphql-schema.factory.ts

@@ -25,13 +25,11 @@ export class WorkspaceGraphQLSchemaFactory {
     objectMetadataCollection: ObjectMetadataInterface[],
     workspaceResolverBuilderMethods: WorkspaceResolverBuilderMethods,
     options: WorkspaceBuildSchemaOptions = {},
-    isNewRelationEnabled = false,
   ): Promise<GraphQLSchema> {
     // Generate type definitions
     await this.typeDefinitionsGenerator.generate(
       objectMetadataCollection,
       options,
-      isNewRelationEnabled,
     );
 
     // Generate schema

packages/twenty-server/src/engine/api/graphql/workspace-schema-builder/workspace-schema-builder.module.ts

@@ -1,7 +1,6 @@
 import { Module } from '@nestjs/common';
 
 import { WorkspaceResolverBuilderModule } from 'src/engine/api/graphql/workspace-resolver-builder/workspace-resolver-builder.module';
-import { FeatureFlagModule } from 'src/engine/core-modules/feature-flag/feature-flag.module';
 import { ObjectMetadataModule } from 'src/engine/metadata-modules/object-metadata/object-metadata.module';
 
 import { TypeDefinitionsGenerator } from './type-definitions.generator';
@@ -12,11 +11,7 @@ import { TypeMapperService } from './services/type-mapper.service';
 import { TypeDefinitionsStorage } from './storages/type-definitions.storage';
 
 @Module({
-  imports: [
+  imports: [ObjectMetadataModule, WorkspaceResolverBuilderModule],
-    ObjectMetadataModule,
-    FeatureFlagModule,
-    WorkspaceResolverBuilderModule,
-  ],
   providers: [
     TypeDefinitionsStorage,
     TypeMapperService,

packages/twenty-server/src/engine/api/graphql/workspace-schema.factory.ts

@@ -1,13 +1,10 @@
 import { Injectable } from '@nestjs/common';
 
 import { makeExecutableSchema } from '@graphql-tools/schema';
-import chalk from 'chalk';
 import { GraphQLSchema, printSchema } from 'graphql';
 import { gql } from 'graphql-tag';
 import { isDefined } from 'twenty-shared/utils';
 
-import { NodeEnvironment } from 'src/engine/core-modules/twenty-config/interfaces/node-environment.interface';
-
 import {
   GraphqlQueryRunnerException,
   GraphqlQueryRunnerExceptionCode,
@@ -17,13 +14,12 @@ import { workspaceResolverBuilderMethodNames } from 'src/engine/api/graphql/work
 import { WorkspaceResolverFactory } from 'src/engine/api/graphql/workspace-resolver-builder/workspace-resolver.factory';
 import { WorkspaceGraphQLSchemaFactory } from 'src/engine/api/graphql/workspace-schema-builder/workspace-graphql-schema.factory';
 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 { TwentyConfigService } from 'src/engine/core-modules/twenty-config/twenty-config.service';
 import { DataSourceService } from 'src/engine/metadata-modules/data-source/data-source.service';
 import { ObjectMetadataMaps } from 'src/engine/metadata-modules/types/object-metadata-maps';
 import { WorkspaceMetadataCacheService } from 'src/engine/metadata-modules/workspace-metadata-cache/services/workspace-metadata-cache.service';
 import { WorkspaceCacheStorageService } from 'src/engine/workspace-cache-storage/workspace-cache-storage.service';
-import { TwentyConfigService } from 'src/engine/core-modules/twenty-config/twenty-config.service';
 
 @Injectable()
 export class WorkspaceSchemaFactory {
@@ -43,21 +39,6 @@ export class WorkspaceSchemaFactory {
       return new GraphQLSchema({});
     }
 
-    const isNewRelationEnabled = await this.featureFlagService.isFeatureEnabled(
-      FeatureFlagKey.IsNewRelationEnabled,
-      authContext.workspace.id,
-    );
-
-    if (
-      isNewRelationEnabled &&
-      this.twentyConfigService.get('NODE_ENV') !== NodeEnvironment.test
-    ) {
-      // eslint-disable-next-line no-console
-      console.log(
-        chalk.yellow('🚧 New relation schema generation is enabled 🚧'),
-      );
-    }
-
     const dataSourcesMetadata =
       await this.dataSourceService.getDataSourcesMetadataFromWorkspaceId(
         authContext.workspace.id,
@@ -140,7 +121,6 @@ export class WorkspaceSchemaFactory {
           objectMetadataCollection,
           workspaceResolverBuilderMethodNames,
           {},
-          isNewRelationEnabled,
         );
 
       usedScalarNames =

packages/twenty-server/src/engine/api/rest/core/handlers/rest-api-get-many.handler.ts

@@ -11,7 +11,6 @@ export class RestApiGetManyHandler extends RestApiBaseHandler {
       objectMetadataNameSingular,
       objectMetadataNamePlural,
       repository,
-      dataSource,
       objectMetadata,
       objectMetadataItemWithFieldsMaps,
     } = await this.getRepositoryAndMetadataOrFail(request);
@@ -20,7 +19,6 @@ export class RestApiGetManyHandler extends RestApiBaseHandler {
       await this.findRecords({
         request,
         repository,
-        dataSource,
         objectMetadata,
         objectMetadataNameSingular,
         objectMetadataItemWithFieldsMaps,

packages/twenty-server/src/engine/api/rest/core/handlers/rest-api-get-one.handler.ts

@@ -21,7 +21,6 @@ export class RestApiGetOneHandler extends RestApiBaseHandler {
     const {
       objectMetadataNameSingular,
       repository,
-      dataSource,
       objectMetadata,
       objectMetadataItemWithFieldsMaps,
     } = await this.getRepositoryAndMetadataOrFail(request);
@@ -30,7 +29,6 @@ export class RestApiGetOneHandler extends RestApiBaseHandler {
       request,
       recordId,
       repository,
-      dataSource,
       objectMetadata,
       objectMetadataNameSingular,
       objectMetadataItemWithFieldsMaps,

packages/twenty-server/src/engine/api/rest/core/interfaces/rest-api-base.handler.ts

@@ -1,37 +1,35 @@
 import { BadRequestException, Inject } from '@nestjs/common';
 
 import { Request } from 'express';
+import { FieldMetadataType } from 'twenty-shared/types';
 import { capitalize, isDefined } from 'twenty-shared/utils';
 import { In, ObjectLiteral, SelectQueryBuilder } from 'typeorm';
-import { FieldMetadataType } from 'twenty-shared/types';
 
 import {
   ObjectRecord,
   OrderByDirection,
 } from 'src/engine/api/graphql/workspace-query-builder/interfaces/object-record.interface';
 
+import { GraphqlQueryParser } from 'src/engine/api/graphql/graphql-query-runner/graphql-query-parsers/graphql-query.parser';
+import { ApiEventEmitterService } from 'src/engine/api/graphql/graphql-query-runner/services/api-event-emitter.service';
 import { CoreQueryBuilderFactory } from 'src/engine/api/rest/core/query-builder/core-query-builder.factory';
-import { TwentyORMGlobalManager } from 'src/engine/twenty-orm/twenty-orm-global.manager';
 import { GetVariablesFactory } from 'src/engine/api/rest/core/query-builder/factories/get-variables.factory';
+import { parseCorePath } from 'src/engine/api/rest/core/query-builder/utils/path-parsers/parse-core-path.utils';
+import { QueryVariables } from 'src/engine/api/rest/core/types/query-variables.type';
 import {
   Depth,
   DepthInputFactory,
   MAX_DEPTH,
 } from 'src/engine/api/rest/input-factories/depth-input.factory';
-import { ApiEventEmitterService } from 'src/engine/api/graphql/graphql-query-runner/services/api-event-emitter.service';
-import { WorkspacePermissionsCacheService } from 'src/engine/metadata-modules/workspace-permissions-cache/workspace-permissions-cache.service';
 import { AuthContext } from 'src/engine/core-modules/auth/types/auth-context.type';
-import { parseCorePath } from 'src/engine/api/rest/core/query-builder/utils/path-parsers/parse-core-path.utils';
-import { getObjectMetadataMapItemByNameSingular } from 'src/engine/metadata-modules/utils/get-object-metadata-map-item-by-name-singular.util';
 import { RecordInputTransformerService } from 'src/engine/core-modules/record-transformer/services/record-input-transformer.service';
-import { WorkspaceRepository } from 'src/engine/twenty-orm/repository/workspace.repository';
-import { ObjectMetadataMaps } from 'src/engine/metadata-modules/types/object-metadata-maps';
 import { ObjectMetadataItemWithFieldMaps } from 'src/engine/metadata-modules/types/object-metadata-item-with-field-maps';
-import { WorkspaceDataSource } from 'src/engine/twenty-orm/datasource/workspace.datasource';
+import { ObjectMetadataMaps } from 'src/engine/metadata-modules/types/object-metadata-maps';
-import { GraphqlQueryParser } from 'src/engine/api/graphql/graphql-query-runner/graphql-query-parsers/graphql-query.parser';
+import { getObjectMetadataMapItemByNameSingular } from 'src/engine/metadata-modules/utils/get-object-metadata-map-item-by-name-singular.util';
+import { WorkspacePermissionsCacheService } from 'src/engine/metadata-modules/workspace-permissions-cache/workspace-permissions-cache.service';
+import { WorkspaceRepository } from 'src/engine/twenty-orm/repository/workspace.repository';
+import { TwentyORMGlobalManager } from 'src/engine/twenty-orm/twenty-orm-global.manager';
 import { formatResult as formatGetManyData } from 'src/engine/twenty-orm/utils/format-result.util';
-import { FeatureFlagKey } from 'src/engine/core-modules/feature-flag/enums/feature-flag-key.enum';
-import { QueryVariables } from 'src/engine/api/rest/core/types/query-variables.type';
 
 export interface PageInfo {
   hasNextPage?: boolean;
@@ -284,7 +282,6 @@ export abstract class RestApiBaseHandler {
     request,
     recordId,
     repository,
-    dataSource,
     objectMetadata,
     objectMetadataNameSingular,
     objectMetadataItemWithFieldsMaps,
@@ -292,7 +289,6 @@ export abstract class RestApiBaseHandler {
     request: Request;
     recordId?: string;
     repository: WorkspaceRepository<ObjectLiteral>;
-    dataSource: WorkspaceDataSource;
     objectMetadata: any;
     objectMetadataNameSingular: string;
     objectMetadataItemWithFieldsMaps:
@@ -316,7 +312,6 @@ export abstract class RestApiBaseHandler {
       fieldMetadataMapByName,
       fieldMetadataMapByJoinColumnName,
       objectMetadata.objectMetadataMaps,
-      dataSource.featureFlagMap,
     );
 
     const filters = this.computeFilters(inputs);
@@ -366,7 +361,6 @@ export abstract class RestApiBaseHandler {
         records,
         objectMetadataItemWithFieldsMaps as any,
         objectMetadata.objectMetadataMaps,
-        dataSource.featureFlagMap[FeatureFlagKey.IsNewRelationEnabled],
       ),
       totalCount,
       hasMoreRecords,

packages/twenty-server/src/engine/core-modules/feature-flag/enums/feature-flag-key.enum.ts

@@ -7,6 +7,5 @@ export enum FeatureFlagKey {
   IsUniqueIndexesEnabled = 'IS_UNIQUE_INDEXES_ENABLED',
   IsJsonFilterEnabled = 'IS_JSON_FILTER_ENABLED',
   IsCustomDomainEnabled = 'IS_CUSTOM_DOMAIN_ENABLED',
-  IsNewRelationEnabled = 'IS_NEW_RELATION_ENABLED',
   IsPermissionsV2Enabled = 'IS_PERMISSIONS_V2_ENABLED',
 }

packages/twenty-server/src/engine/core-modules/search/search.module.ts

@@ -1,13 +1,12 @@
 import { Module } from '@nestjs/common';
 
-import { FeatureFlagModule } from 'src/engine/core-modules/feature-flag/feature-flag.module';
 import { FileModule } from 'src/engine/core-modules/file/file.module';
 import { SearchResolver } from 'src/engine/core-modules/search/search.resolver';
 import { SearchService } from 'src/engine/core-modules/search/services/search.service';
 import { WorkspaceCacheStorageModule } from 'src/engine/workspace-cache-storage/workspace-cache-storage.module';
 
 @Module({
-  imports: [WorkspaceCacheStorageModule, FeatureFlagModule, FileModule],
+  imports: [WorkspaceCacheStorageModule, FileModule],
   providers: [SearchResolver, SearchService],
 })
 export class SearchModule {}

packages/twenty-server/src/engine/core-modules/search/search.resolver.ts

@@ -5,7 +5,6 @@ import chunk from 'lodash.chunk';
 
 import { ObjectRecordFilter } from 'src/engine/api/graphql/workspace-query-builder/interfaces/object-record.interface';
 
-import { FeatureFlagService } from 'src/engine/core-modules/feature-flag/services/feature-flag.service';
 import { SearchArgs } from 'src/engine/core-modules/search/dtos/search-args';
 import { SearchRecordDTO } from 'src/engine/core-modules/search/dtos/search-record-dto';
 import {
@@ -30,7 +29,6 @@ export class SearchResolver {
     private readonly workspaceCacheStorageService: WorkspaceCacheStorageService,
     private readonly twentyORMManager: TwentyORMManager,
     private readonly searchService: SearchService,
-    private readonly featureFlagService: FeatureFlagService,
   ) {}
 
   @Query(() => [SearchRecordDTO])
@@ -68,9 +66,6 @@ export class SearchResolver {
       );
     }
 
-    const featureFlagMap =
-      await this.featureFlagService.getWorkspaceFeatureFlagsMap(workspace.id);
-
     const objectMetadataItemWithFieldMaps = Object.values(
       objectMetadataMaps.byId,
     );
@@ -102,7 +97,6 @@ export class SearchResolver {
             records: await this.searchService.buildSearchQueryAndGetRecords({
               entityManager: repository,
               objectMetadataItem,
-              featureFlagMap,
               searchTerms: formatSearchTerms(searchInput, 'and'),
               searchTermsOr: formatSearchTerms(searchInput, 'or'),
               limit,

packages/twenty-server/src/engine/core-modules/search/services/search.service.ts

@@ -6,7 +6,6 @@ import { getLogoUrlFromDomainName } from 'twenty-shared/utils';
 import { Brackets, ObjectLiteral } from 'typeorm';
 
 import { ObjectRecord } 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 { GraphqlQueryParser } from 'src/engine/api/graphql/graphql-query-runner/graphql-query-parsers/graphql-query.parser';
 import { FileService } from 'src/engine/core-modules/file/services/file.service';
@@ -57,7 +56,6 @@ export class SearchService {
   async buildSearchQueryAndGetRecords<Entity extends ObjectLiteral>({
     entityManager,
     objectMetadataItem,
-    featureFlagMap,
     searchTerms,
     searchTermsOr,
     limit,
@@ -65,7 +63,6 @@ export class SearchService {
   }: {
     entityManager: WorkspaceRepository<Entity>;
     objectMetadataItem: ObjectMetadataItemWithFieldMaps;
-    featureFlagMap: FeatureFlagMap;
     searchTerms: string;
     searchTermsOr: string;
     limit: number;
@@ -77,7 +74,6 @@ export class SearchService {
       objectMetadataItem.fieldsByName,
       objectMetadataItem.fieldsByJoinColumnName,
       generateObjectMetadataMaps([objectMetadataItem]),
-      featureFlagMap,
     );
 
     queryParser.applyFilterToBuilder(

packages/twenty-server/src/engine/metadata-modules/field-metadata/field-metadata.module.ts

@@ -9,7 +9,6 @@ import { NestjsQueryTypeOrmModule } from '@ptc-org/nestjs-query-typeorm';
 
 import { TypeORMModule } from 'src/database/typeorm/typeorm.module';
 import { ActorModule } from 'src/engine/core-modules/actor/actor.module';
-import { FeatureFlagModule } from 'src/engine/core-modules/feature-flag/feature-flag.module';
 import { WorkspaceAuthGuard } from 'src/engine/guards/workspace-auth.guard';
 import { DataSourceModule } from 'src/engine/metadata-modules/data-source/data-source.module';
 import { FieldMetadataDTO } from 'src/engine/metadata-modules/field-metadata/dtos/field-metadata.dto';
@@ -49,7 +48,6 @@ import { UpdateFieldInput } from './dtos/update-field.input';
         WorkspaceMigrationRunnerModule,
         WorkspaceMetadataVersionModule,
         WorkspaceCacheStorageModule,
-        FeatureFlagModule,
         ObjectMetadataModule,
         DataSourceModule,
         TypeORMModule,

packages/twenty-server/src/engine/metadata-modules/field-metadata/field-metadata.resolver.ts

@@ -10,8 +10,6 @@ import {
 
 import { FieldMetadataType } from 'twenty-shared/types';
 
-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 {
   ForbiddenError,
   ValidationError,
@@ -53,7 +51,6 @@ import { createDeterministicUuid } from 'src/engine/workspace-manager/workspace-
 export class FieldMetadataResolver {
   constructor(
     private readonly fieldMetadataService: FieldMetadataService,
-    private readonly featureFlagService: FeatureFlagService,
     private readonly beforeUpdateOneField: BeforeUpdateOneField<UpdateFieldInput>,
   ) {}
 
@@ -178,51 +175,28 @@ export class FieldMetadataResolver {
       return null;
     }
 
-    const isNewRelationEnabled = await this.featureFlagService.isFeatureEnabled(
+    const relation = await this.relation(
-      FeatureFlagKey.IsNewRelationEnabled,
+      workspace,
-      workspace.id,
+      fieldMetadata as FieldMetadataEntity<FieldMetadataType.RELATION>,
+      context,
     );
 
-    // TODO: Remove this once we drop old relations or update the front-end to use the new relation
+    if (!relation) {
-    if (isNewRelationEnabled) {
+      return null;
-      const relation = await this.relation(
-        workspace,
-        fieldMetadata as FieldMetadataEntity<FieldMetadataType.RELATION>,
-        context,
-      );
-
-      if (!relation) {
-        return null;
-      }
-
-      return {
-        // Temporary fix as we don't have relationId in the new relation
-        relationId: createDeterministicUuid([
-          relation.sourceFieldMetadata.id,
-          relation.targetFieldMetadata.id,
-        ]),
-        direction: relation.type as unknown as RelationDefinitionType,
-        sourceObjectMetadata: relation.sourceObjectMetadata,
-        targetObjectMetadata: relation.targetObjectMetadata,
-        sourceFieldMetadata: relation.sourceFieldMetadata,
-        targetFieldMetadata: relation.targetFieldMetadata,
-      };
     }
 
-    try {
+    return {
-      const relationMetadataItem =
+      // Temporary fix as we don't have relationId in the new relation
-        await context.loaders.relationMetadataLoader.load({
+      relationId: createDeterministicUuid([
-          fieldMetadata,
+        relation.sourceFieldMetadata.id,
-          workspaceId: workspace.id,
+        relation.targetFieldMetadata.id,
-        });
+      ]),
-
+      direction: relation.type as unknown as RelationDefinitionType,
-      return await this.fieldMetadataService.getRelationDefinitionFromRelationMetadata(
+      sourceObjectMetadata: relation.sourceObjectMetadata,
-        fieldMetadata,
+      targetObjectMetadata: relation.targetObjectMetadata,
-        relationMetadataItem,
+      sourceFieldMetadata: relation.sourceFieldMetadata,
-      );
+      targetFieldMetadata: relation.targetFieldMetadata,
-    } catch (error) {
+    };
-      fieldMetadataGraphqlApiExceptionHandler(error);
-    }
   }
 
   @ResolveField(() => RelationDTO, { nullable: true })
@@ -236,18 +210,6 @@ export class FieldMetadataResolver {
     }
 
     try {
-      const isNewRelationEnabled =
-        await this.featureFlagService.isFeatureEnabled(
-          FeatureFlagKey.IsNewRelationEnabled,
-          workspace.id,
-        );
-
-      if (!isNewRelationEnabled) {
-        throw new FieldMetadataException(
-          'New relation feature is not enabled for this workspace',
-          FieldMetadataExceptionCode.FIELD_METADATA_RELATION_NOT_ENABLED,
-        );
-      }
       const {
         sourceObjectMetadata,
         targetObjectMetadata,

packages/twenty-server/src/engine/metadata-modules/object-metadata/object-metadata.module.ts

@@ -10,7 +10,6 @@ import { NestjsQueryTypeOrmModule } from '@ptc-org/nestjs-query-typeorm';
 
 import { TypeORMModule } from 'src/database/typeorm/typeorm.module';
 import { FeatureFlag } from 'src/engine/core-modules/feature-flag/feature-flag.entity';
-import { FeatureFlagModule } from 'src/engine/core-modules/feature-flag/feature-flag.module';
 import { SettingsPermissionsGuard } from 'src/engine/guards/settings-permissions.guard';
 import { WorkspaceAuthGuard } from 'src/engine/guards/workspace-auth.guard';
 import { DataSourceModule } from 'src/engine/metadata-modules/data-source/data-source.module';
@@ -22,7 +21,6 @@ import { ObjectMetadataResolver } from 'src/engine/metadata-modules/object-metad
 import { ObjectMetadataFieldRelationService } from 'src/engine/metadata-modules/object-metadata/services/object-metadata-field-relation.service';
 import { ObjectMetadataMigrationService } from 'src/engine/metadata-modules/object-metadata/services/object-metadata-migration.service';
 import { ObjectMetadataRelatedRecordsService } from 'src/engine/metadata-modules/object-metadata/services/object-metadata-related-records.service';
-import { ObjectMetadataRelationService } from 'src/engine/metadata-modules/object-metadata/services/object-metadata-relation.service';
 import { SettingPermissionType } from 'src/engine/metadata-modules/permissions/constants/setting-permission-type.constants';
 import { PermissionsModule } from 'src/engine/metadata-modules/permissions/permissions.module';
 import { PermissionsGraphqlApiExceptionFilter } from 'src/engine/metadata-modules/permissions/utils/permissions-graphql-api-exception.filter';
@@ -58,14 +56,12 @@ import { UpdateObjectPayload } from './dtos/update-object.input';
         RemoteTableRelationsModule,
         SearchVectorModule,
         IndexMetadataModule,
-        FeatureFlagModule,
         PermissionsModule,
         WorkspacePermissionsCacheModule,
       ],
       services: [
         ObjectMetadataService,
         ObjectMetadataMigrationService,
-        ObjectMetadataRelationService,
         ObjectMetadataFieldRelationService,
         ObjectMetadataRelatedRecordsService,
       ],

packages/twenty-server/src/engine/metadata-modules/object-metadata/object-metadata.service.ts

@@ -10,8 +10,6 @@ import { FindManyOptions, FindOneOptions, In, Not, Repository } from 'typeorm';
 
 import { ObjectMetadataStandardIdToIdMap } from 'src/engine/metadata-modules/object-metadata/interfaces/object-metadata-standard-id-to-id-map';
 
-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 { generateMessageId } from 'src/engine/core-modules/i18n/utils/generateMessageId';
 import { DataSourceService } from 'src/engine/metadata-modules/data-source/data-source.service';
 import { FieldMetadataEntity } from 'src/engine/metadata-modules/field-metadata/field-metadata.entity';
@@ -29,7 +27,6 @@ import {
 import { ObjectMetadataFieldRelationService } from 'src/engine/metadata-modules/object-metadata/services/object-metadata-field-relation.service';
 import { ObjectMetadataMigrationService } from 'src/engine/metadata-modules/object-metadata/services/object-metadata-migration.service';
 import { ObjectMetadataRelatedRecordsService } from 'src/engine/metadata-modules/object-metadata/services/object-metadata-related-records.service';
-import { ObjectMetadataRelationService } from 'src/engine/metadata-modules/object-metadata/services/object-metadata-relation.service';
 import { buildDefaultFieldsForCustomObject } from 'src/engine/metadata-modules/object-metadata/utils/build-default-fields-for-custom-object.util';
 import {
   validateLowerCasedAndTrimmedStringsAreDifferentOrThrow,
@@ -64,13 +61,11 @@ export class ObjectMetadataService extends TypeOrmQueryService<ObjectMetadataEnt
     private readonly workspaceMigrationRunnerService: WorkspaceMigrationRunnerService,
     private readonly workspaceMetadataVersionService: WorkspaceMetadataVersionService,
     private readonly searchVectorService: SearchVectorService,
-    private readonly objectMetadataRelationService: ObjectMetadataRelationService,
     private readonly objectMetadataFieldRelationService: ObjectMetadataFieldRelationService,
     private readonly objectMetadataMigrationService: ObjectMetadataMigrationService,
     private readonly objectMetadataRelatedRecordsService: ObjectMetadataRelatedRecordsService,
     private readonly indexMetadataService: IndexMetadataService,
     private readonly workspacePermissionsCacheService: WorkspacePermissionsCacheService,
-    private readonly featureFlagService: FeatureFlagService,
   ) {
     super(objectMetadataRepository);
   }
@@ -188,33 +183,12 @@ export class ObjectMetadataService extends TypeOrmQueryService<ObjectMetadataEnt
         createdObjectMetadata.fields,
       );
 
-      const isNewRelationEnabled =
+      const createdRelatedObjectMetadataCollection =
-        await this.featureFlagService.isFeatureEnabled(
+        await this.objectMetadataFieldRelationService.createRelationsAndForeignKeysMetadata(
-          FeatureFlagKey.IsNewRelationEnabled,
           objectMetadataInput.workspaceId,
+          createdObjectMetadata,
         );
 
-      let createdRelatedObjectMetadataCollection: ObjectMetadataEntity[];
-
-      if (isNewRelationEnabled) {
-        createdRelatedObjectMetadataCollection =
-          await this.objectMetadataFieldRelationService.createRelationsAndForeignKeysMetadata(
-            objectMetadataInput.workspaceId,
-            createdObjectMetadata,
-          );
-      } else {
-        createdRelatedObjectMetadataCollection =
-          await this.objectMetadataRelationService.createRelationsAndForeignKeysMetadata(
-            objectMetadataInput.workspaceId,
-            createdObjectMetadata,
-            {
-              primaryKeyFieldMetadataSettings:
-                objectMetadataInput.primaryKeyFieldMetadataSettings,
-              primaryKeyColumnType: objectMetadataInput.primaryKeyColumnType,
-            },
-          );
-      }
-
       await this.objectMetadataMigrationService.createRelationMigrations(
         createdObjectMetadata,
         createdRelatedObjectMetadataCollection,
@@ -316,27 +290,12 @@ export class ObjectMetadataService extends TypeOrmQueryService<ObjectMetadataEnt
 
     const updatedObject = await super.updateOne(inputId, inputPayload);
 
-    const isNewRelationEnabled = await this.featureFlagService.isFeatureEnabled(
-      FeatureFlagKey.IsNewRelationEnabled,
-      workspaceId,
-    );
-
     await this.handleObjectNameAndLabelUpdates(
       existingObjectMetadata,
       existingObjectMetadataCombinedWithUpdateInput,
       inputPayload,
     );
 
-    if (inputPayload.isActive !== undefined) {
-      // For new relation system, the active status is stitched to the field metadata
-      if (!isNewRelationEnabled) {
-        await this.objectMetadataRelationService.updateObjectRelationshipsActivationStatus(
-          inputId,
-          inputPayload.isActive,
-        );
-      }
-    }
-
     await this.workspaceMigrationRunnerService.executeMigrationFromPendingMigrations(
       workspaceId,
     );
@@ -377,11 +336,6 @@ export class ObjectMetadataService extends TypeOrmQueryService<ObjectMetadataEnt
     input: DeleteOneObjectInput,
     workspaceId: string,
   ): Promise<ObjectMetadataEntity> {
-    const isNewRelationEnabled = await this.featureFlagService.isFeatureEnabled(
-      FeatureFlagKey.IsNewRelationEnabled,
-      workspaceId,
-    );
-
     const objectMetadata = await this.objectMetadataRepository.findOne({
       relations: [
         'fields',
@@ -419,7 +373,6 @@ export class ObjectMetadataService extends TypeOrmQueryService<ObjectMetadataEnt
       await this.objectMetadataMigrationService.deleteAllRelationsAndDropTable(
         objectMetadata,
         workspaceId,
-        isNewRelationEnabled,
       );
     }
 
@@ -536,11 +489,6 @@ export class ObjectMetadataService extends TypeOrmQueryService<ObjectMetadataEnt
     objectMetadataForUpdate: ObjectMetadataEntity,
     inputPayload: UpdateObjectPayload,
   ) {
-    const isNewRelationEnabled = await this.featureFlagService.isFeatureEnabled(
-      FeatureFlagKey.IsNewRelationEnabled,
-      objectMetadataForUpdate.workspaceId,
-    );
-
     const newTargetTableName = computeObjectTargetTable(
       objectMetadataForUpdate,
     );
@@ -555,33 +503,18 @@ export class ObjectMetadataService extends TypeOrmQueryService<ObjectMetadataEnt
         objectMetadataForUpdate.workspaceId,
       );
 
-      if (isNewRelationEnabled) {
+      const relationMetadataCollection =
-        const relationMetadataCollection =
+        await this.objectMetadataFieldRelationService.updateRelationsAndForeignKeysMetadata(
-          await this.objectMetadataFieldRelationService.updateRelationsAndForeignKeysMetadata(
-            objectMetadataForUpdate.workspaceId,
-            objectMetadataForUpdate,
-          );
-
-        await this.objectMetadataMigrationService.updateRelationMigrations(
-          existingObjectMetadata,
-          objectMetadataForUpdate,
-          relationMetadataCollection,
           objectMetadataForUpdate.workspaceId,
-        );
-      } else {
-        const relationsAndForeignKeysMetadata =
-          await this.objectMetadataRelationService.updateRelationsAndForeignKeysMetadata(
-            objectMetadataForUpdate.workspaceId,
-            objectMetadataForUpdate,
-          );
-
-        await this.objectMetadataMigrationService.createUpdateForeignKeysMigrations(
-          existingObjectMetadata,
           objectMetadataForUpdate,
-          relationsAndForeignKeysMetadata,
-          objectMetadataForUpdate.workspaceId,
         );
-      }
+
+      await this.objectMetadataMigrationService.updateRelationMigrations(
+        existingObjectMetadata,
+        objectMetadataForUpdate,
+        relationMetadataCollection,
+        objectMetadataForUpdate.workspaceId,
+      );
 
       await this.objectMetadataMigrationService.recomputeEnumNames(
         objectMetadataForUpdate,

packages/twenty-server/src/engine/metadata-modules/object-metadata/services/object-metadata-migration.service.ts

@@ -7,7 +7,6 @@ import { In, Repository } from 'typeorm';
 import { RelationType } from 'src/engine/metadata-modules/field-metadata/interfaces/relation-type.interface';
 
 import { FieldMetadataEntity } from 'src/engine/metadata-modules/field-metadata/field-metadata.entity';
-import { computeColumnName } from 'src/engine/metadata-modules/field-metadata/utils/compute-column-name.util';
 import { ObjectMetadataEntity } from 'src/engine/metadata-modules/object-metadata/object-metadata.entity';
 import { buildMigrationsForCustomObjectRelations } from 'src/engine/metadata-modules/object-metadata/utils/build-migrations-for-custom-object-relations.util';
 import { RelationMetadataEntity } from 'src/engine/metadata-modules/relation-metadata/relation-metadata.entity';
@@ -30,8 +29,6 @@ import { RELATION_MIGRATION_PRIORITY_PREFIX } from 'src/engine/workspace-manager
 @Injectable()
 export class ObjectMetadataMigrationService {
   constructor(
-    @InjectRepository(ObjectMetadataEntity, 'metadata')
-    private readonly objectMetadataRepository: Repository<ObjectMetadataEntity>,
     @InjectRepository(FieldMetadataEntity, 'metadata')
     private readonly fieldMetadataRepository: Repository<FieldMetadataEntity>,
     @InjectRepository(RelationMetadataEntity, 'metadata')
@@ -222,7 +219,6 @@ export class ObjectMetadataMigrationService {
   public async deleteAllRelationsAndDropTable(
     objectMetadata: ObjectMetadataEntity,
     workspaceId: string,
-    isNewRelationEnabled: boolean,
   ) {
     const relationsMetadataToDelete: RelationToDelete[] = [];
 
@@ -275,88 +271,59 @@ export class ObjectMetadataMigrationService {
         relationToDelete.fromFieldMetadataId,
         relationToDelete.toFieldMetadataId,
       ]);
-
-      if (relationToDelete.direction === 'from' && !isNewRelationEnabled) {
-        await this.workspaceMigrationService.createCustomMigration(
-          generateMigrationName(
-            `delete-${RELATION_MIGRATION_PRIORITY_PREFIX}-${relationToDelete.fromObjectName}-${relationToDelete.toObjectName}`,
-          ),
-          workspaceId,
-          [
-            {
-              name: computeTableName(
-                relationToDelete.toObjectName,
-                relationToDelete.toObjectMetadataIsCustom,
-              ),
-              action: WorkspaceMigrationTableActionType.ALTER,
-              columns: [
-                {
-                  action: WorkspaceMigrationColumnActionType.DROP,
-                  columnName: computeColumnName(
-                    relationToDelete.toFieldMetadataName,
-                    { isForeignKey: true },
-                  ),
-                } satisfies WorkspaceMigrationColumnDrop,
-              ],
-            },
-          ],
-        );
-      }
     }
 
-    if (isNewRelationEnabled) {
+    const manyToOneRelationFieldsToDelete = objectMetadata.fields.filter(
-      const manyToOneRelationFieldsToDelete = objectMetadata.fields.filter(
+      (field) =>
-        (field) =>
+        isFieldMetadataInterfaceOfType(field, FieldMetadataType.RELATION) &&
-          isFieldMetadataInterfaceOfType(field, FieldMetadataType.RELATION) &&
+        (field as FieldMetadataEntity<FieldMetadataType.RELATION>).settings
-          (field as FieldMetadataEntity<FieldMetadataType.RELATION>).settings
+          ?.relationType === RelationType.MANY_TO_ONE,
-            ?.relationType === RelationType.MANY_TO_ONE,
+    ) as FieldMetadataEntity<FieldMetadataType.RELATION>[];
-      ) as FieldMetadataEntity<FieldMetadataType.RELATION>[];
 
-      const oneToManyRelationFieldsToDelete = objectMetadata.fields.filter(
+    const oneToManyRelationFieldsToDelete = objectMetadata.fields.filter(
-        (field) =>
+      (field) =>
-          isFieldMetadataInterfaceOfType(field, FieldMetadataType.RELATION) &&
+        isFieldMetadataInterfaceOfType(field, FieldMetadataType.RELATION) &&
-          (field as FieldMetadataEntity<FieldMetadataType.RELATION>).settings
+        (field as FieldMetadataEntity<FieldMetadataType.RELATION>).settings
-            ?.relationType === RelationType.ONE_TO_MANY,
+          ?.relationType === RelationType.ONE_TO_MANY,
-      );
+    );
 
-      const relationFieldsToDelete = [
+    const relationFieldsToDelete = [
-        ...manyToOneRelationFieldsToDelete,
+      ...manyToOneRelationFieldsToDelete,
-        ...(oneToManyRelationFieldsToDelete.map(
+      ...(oneToManyRelationFieldsToDelete.map(
-          (field) => field.relationTargetFieldMetadata,
+        (field) => field.relationTargetFieldMetadata,
-        ) as FieldMetadataEntity<FieldMetadataType.RELATION>[]),
+      ) as FieldMetadataEntity<FieldMetadataType.RELATION>[]),
-      ];
+    ];
 
-      for (const relationFieldToDelete of relationFieldsToDelete) {
+    for (const relationFieldToDelete of relationFieldsToDelete) {
-        const joinColumnName = relationFieldToDelete.settings?.joinColumnName;
+      const joinColumnName = relationFieldToDelete.settings?.joinColumnName;
 
-        if (!joinColumnName) {
+      if (!joinColumnName) {
-          throw new Error(
+        throw new Error(
-            `Join column name is not set for relation field ${relationFieldToDelete.name}`,
+          `Join column name is not set for relation field ${relationFieldToDelete.name}`,
-          );
-        }
-
-        await this.workspaceMigrationService.createCustomMigration(
-          generateMigrationName(
-            `delete-${RELATION_MIGRATION_PRIORITY_PREFIX}-${relationFieldToDelete.name}`,
-          ),
-          workspaceId,
-          [
-            {
-              name: computeTableName(
-                relationFieldToDelete.object.nameSingular,
-                relationFieldToDelete.object.isCustom,
-              ),
-              action: WorkspaceMigrationTableActionType.ALTER,
-              columns: [
-                {
-                  action: WorkspaceMigrationColumnActionType.DROP,
-                  columnName: joinColumnName,
-                } satisfies WorkspaceMigrationColumnDrop,
-              ],
-            },
-          ],
         );
       }
+
+      await this.workspaceMigrationService.createCustomMigration(
+        generateMigrationName(
+          `delete-${RELATION_MIGRATION_PRIORITY_PREFIX}-${relationFieldToDelete.name}`,
+        ),
+        workspaceId,
+        [
+          {
+            name: computeTableName(
+              relationFieldToDelete.object.nameSingular,
+              relationFieldToDelete.object.isCustom,
+            ),
+            action: WorkspaceMigrationTableActionType.ALTER,
+            columns: [
+              {
+                action: WorkspaceMigrationColumnActionType.DROP,
+                columnName: joinColumnName,
+              } satisfies WorkspaceMigrationColumnDrop,
+            ],
+          },
+        ],
+      );
     }
 
     // DROP TABLE

packages/twenty-server/src/engine/metadata-modules/object-metadata/services/object-metadata-relation.service.ts

@@ -1,451 +0,0 @@
-import { Injectable } from '@nestjs/common';
-import { InjectRepository } from '@nestjs/typeorm';
-
-import { In, Repository } from 'typeorm';
-import { capitalize } from 'twenty-shared/utils';
-import { FieldMetadataType } from 'twenty-shared/types';
-
-import { FieldMetadataSettings } from 'src/engine/metadata-modules/field-metadata/interfaces/field-metadata-settings.interface';
-
-import { FieldMetadataEntity } from 'src/engine/metadata-modules/field-metadata/field-metadata.entity';
-import { ObjectMetadataEntity } from 'src/engine/metadata-modules/object-metadata/object-metadata.entity';
-import { buildDescriptionForRelationFieldMetadataOnFromField } from 'src/engine/metadata-modules/object-metadata/utils/build-description-for-relation-field-on-from-field.util';
-import { buildDescriptionForRelationFieldMetadataOnToField } from 'src/engine/metadata-modules/object-metadata/utils/build-description-for-relation-field-on-to-field.util';
-import { buildNameLabelAndDescriptionForForeignKeyFieldMetadata } from 'src/engine/metadata-modules/object-metadata/utils/build-name-label-and-description-for-foreign-key-field-metadata.util';
-import {
-  RelationMetadataEntity,
-  RelationMetadataType,
-  RelationOnDeleteAction,
-} from 'src/engine/metadata-modules/relation-metadata/relation-metadata.entity';
-import { mapUdtNameToFieldType } from 'src/engine/metadata-modules/remote-server/remote-table/utils/udt-name-mapper.util';
-import {
-  CUSTOM_OBJECT_STANDARD_FIELD_IDS,
-  STANDARD_OBJECT_FIELD_IDS,
-} from 'src/engine/workspace-manager/workspace-sync-metadata/constants/standard-field-ids';
-import { STANDARD_OBJECT_ICONS } from 'src/engine/workspace-manager/workspace-sync-metadata/constants/standard-object-icons';
-import { STANDARD_OBJECT_IDS } from 'src/engine/workspace-manager/workspace-sync-metadata/constants/standard-object-ids';
-import {
-  createForeignKeyDeterministicUuid,
-  createRelationDeterministicUuid,
-} from 'src/engine/workspace-manager/workspace-sync-metadata/utils/create-deterministic-uuid.util';
-
-const DEFAULT_RELATIONS_OBJECTS_STANDARD_IDS = [
-  STANDARD_OBJECT_IDS.timelineActivity,
-  STANDARD_OBJECT_IDS.favorite,
-  STANDARD_OBJECT_IDS.attachment,
-  STANDARD_OBJECT_IDS.noteTarget,
-  STANDARD_OBJECT_IDS.taskTarget,
-];
-
-@Injectable()
-export class ObjectMetadataRelationService {
-  constructor(
-    @InjectRepository(ObjectMetadataEntity, 'metadata')
-    private readonly objectMetadataRepository: Repository<ObjectMetadataEntity>,
-    @InjectRepository(FieldMetadataEntity, 'metadata')
-    private readonly fieldMetadataRepository: Repository<FieldMetadataEntity>,
-    @InjectRepository(RelationMetadataEntity, 'metadata')
-    private readonly relationMetadataRepository: Repository<RelationMetadataEntity>,
-  ) {}
-
-  public async createRelationsAndForeignKeysMetadata(
-    workspaceId: string,
-    createdObjectMetadata: ObjectMetadataEntity,
-    { primaryKeyFieldMetadataSettings, primaryKeyColumnType },
-  ) {
-    const relatedObjectMetadataCollection = await Promise.all(
-      DEFAULT_RELATIONS_OBJECTS_STANDARD_IDS.map(
-        async (relationObjectMetadataStandardId) =>
-          this.createRelationAndForeignKeyMetadata(
-            workspaceId,
-            createdObjectMetadata,
-            mapUdtNameToFieldType(primaryKeyColumnType ?? 'uuid'),
-            primaryKeyFieldMetadataSettings,
-            relationObjectMetadataStandardId,
-          ),
-      ),
-    );
-
-    return relatedObjectMetadataCollection;
-  }
-
-  private async createRelationAndForeignKeyMetadata(
-    workspaceId: string,
-    createdObjectMetadata: ObjectMetadataEntity,
-    objectPrimaryKeyType: FieldMetadataType,
-    objectPrimaryKeyFieldSettings:
-      | FieldMetadataSettings<FieldMetadataType>
-      | undefined,
-    relationObjectMetadataStandardId: string,
-  ) {
-    const relatedObjectMetadata =
-      await this.objectMetadataRepository.findOneByOrFail({
-        standardId: relationObjectMetadataStandardId,
-        workspaceId: workspaceId,
-        isCustom: false,
-      });
-
-    const relationFieldMetadataCollection =
-      await this.createRelationFieldMetadas(
-        workspaceId,
-        createdObjectMetadata,
-        relatedObjectMetadata,
-        objectPrimaryKeyType,
-        objectPrimaryKeyFieldSettings,
-      );
-
-    await this.createRelationMetadataFromFieldMetadatas(
-      workspaceId,
-      createdObjectMetadata,
-      relatedObjectMetadata,
-      relationFieldMetadataCollection,
-    );
-
-    return relatedObjectMetadata;
-  }
-
-  private async createRelationFieldMetadas(
-    workspaceId: string,
-    createdObjectMetadata: ObjectMetadataEntity,
-    relatedObjectMetadata: ObjectMetadataEntity,
-    objectPrimaryKeyType: FieldMetadataType,
-    objectPrimaryKeyFieldSettings:
-      | FieldMetadataSettings<FieldMetadataType>
-      | undefined,
-  ) {
-    return this.fieldMetadataRepository.save([
-      this.buildFromFieldMetadata(
-        workspaceId,
-        createdObjectMetadata,
-        relatedObjectMetadata,
-      ),
-      this.buildToFieldMetadata(
-        workspaceId,
-        createdObjectMetadata,
-        relatedObjectMetadata,
-      ),
-      this.buildForeignKeyFieldMetadata(
-        workspaceId,
-        createdObjectMetadata,
-        relatedObjectMetadata,
-        objectPrimaryKeyType,
-        objectPrimaryKeyFieldSettings,
-      ),
-    ]);
-  }
-
-  public async updateRelationsAndForeignKeysMetadata(
-    workspaceId: string,
-    updatedObjectMetadata: ObjectMetadataEntity,
-  ): Promise<
-    {
-      relatedObjectMetadata: ObjectMetadataEntity;
-      foreignKeyFieldMetadata: FieldMetadataEntity;
-      toFieldMetadata: FieldMetadataEntity;
-      fromFieldMetadata: FieldMetadataEntity;
-    }[]
-  > {
-    return await Promise.all(
-      DEFAULT_RELATIONS_OBJECTS_STANDARD_IDS.map(
-        async (relationObjectMetadataStandardId) =>
-          this.updateRelationAndForeignKeyMetadata(
-            workspaceId,
-            updatedObjectMetadata,
-            relationObjectMetadataStandardId,
-          ),
-      ),
-    );
-  }
-
-  private async updateRelationAndForeignKeyMetadata(
-    workspaceId: string,
-    updatedObjectMetadata: ObjectMetadataEntity,
-    relationObjectMetadataStandardId: string,
-  ) {
-    const relatedObjectMetadata =
-      await this.objectMetadataRepository.findOneByOrFail({
-        standardId: relationObjectMetadataStandardId,
-        workspaceId: workspaceId,
-        isCustom: false,
-      });
-
-    const toFieldMetadataUpdateCriteria = {
-      standardId: createRelationDeterministicUuid({
-        objectId: updatedObjectMetadata.id,
-        standardId:
-          STANDARD_OBJECT_FIELD_IDS[relatedObjectMetadata.nameSingular].custom,
-      }),
-      objectMetadataId: relatedObjectMetadata.id,
-      workspaceId: workspaceId,
-    };
-    const toFieldMetadataUpdateData = this.buildToFieldMetadata(
-      workspaceId,
-      updatedObjectMetadata,
-      relatedObjectMetadata,
-      true,
-    );
-    const toFieldMetadataToUpdate =
-      await this.fieldMetadataRepository.findOneBy(
-        toFieldMetadataUpdateCriteria,
-      );
-    const toFieldMetadata = await this.fieldMetadataRepository.save({
-      ...toFieldMetadataToUpdate,
-      ...toFieldMetadataUpdateData,
-    });
-
-    const fromFieldMetadataUpdateCriteria = {
-      standardId:
-        CUSTOM_OBJECT_STANDARD_FIELD_IDS[relatedObjectMetadata.namePlural],
-      objectMetadataId: updatedObjectMetadata.id,
-      workspaceId: workspaceId,
-    };
-    const fromFieldMetadataUpdateData = this.buildFromFieldMetadata(
-      workspaceId,
-      updatedObjectMetadata,
-      relatedObjectMetadata,
-      true,
-    );
-    const fromFieldMetadataToUpdate =
-      await this.fieldMetadataRepository.findOneBy(
-        fromFieldMetadataUpdateCriteria,
-      );
-    const fromFieldMetadata = await this.fieldMetadataRepository.save({
-      ...fromFieldMetadataToUpdate,
-      ...fromFieldMetadataUpdateData,
-    });
-
-    const foreignKeyFieldMetadataUpdateCriteria = {
-      standardId: createForeignKeyDeterministicUuid({
-        objectId: updatedObjectMetadata.id,
-        standardId:
-          STANDARD_OBJECT_FIELD_IDS[relatedObjectMetadata.nameSingular].custom,
-      }),
-      objectMetadataId: relatedObjectMetadata.id,
-      workspaceId: workspaceId,
-    };
-    const foreignKeyFieldMetadataUpdateData = this.buildForeignKeyFieldMetadata(
-      workspaceId,
-      updatedObjectMetadata,
-      relatedObjectMetadata,
-      FieldMetadataType.UUID,
-      undefined,
-      true,
-    );
-    const foreignKeyFieldMetadataToUpdate =
-      await this.fieldMetadataRepository.findOneBy(
-        foreignKeyFieldMetadataUpdateCriteria,
-      );
-    const foreignKeyFieldMetadata = await this.fieldMetadataRepository.save({
-      ...foreignKeyFieldMetadataToUpdate,
-      ...foreignKeyFieldMetadataUpdateData,
-    });
-
-    return {
-      relatedObjectMetadata,
-      foreignKeyFieldMetadata,
-      toFieldMetadata,
-      fromFieldMetadata,
-    };
-  }
-
-  private buildFromFieldMetadata(
-    workspaceId: string,
-    objectMetadata: ObjectMetadataEntity,
-    relatedObjectMetadata: ObjectMetadataEntity,
-    isUpdate = false,
-  ) {
-    const relationObjectMetadataNamePlural = relatedObjectMetadata.namePlural;
-
-    const { description } = buildDescriptionForRelationFieldMetadataOnFromField(
-      {
-        relationObjectMetadataNamePlural,
-        targetObjectLabelSingular: objectMetadata.labelSingular,
-      },
-    );
-
-    return {
-      description,
-      ...(!isUpdate
-        ? {
-            standardId:
-              CUSTOM_OBJECT_STANDARD_FIELD_IDS[
-                relationObjectMetadataNamePlural
-              ],
-            objectMetadataId: objectMetadata.id,
-            workspaceId: workspaceId,
-            isCustom: false,
-            isActive: true,
-            isSystem: true,
-            type: FieldMetadataType.RELATION,
-            name: relatedObjectMetadata.namePlural,
-            label: capitalize(relationObjectMetadataNamePlural),
-            description,
-            icon:
-              STANDARD_OBJECT_ICONS[relatedObjectMetadata.nameSingular] ||
-              'IconBuildingSkyscraper',
-            isNullable: true,
-          }
-        : {}),
-    };
-  }
-
-  private buildToFieldMetadata(
-    workspaceId: string,
-    objectMetadata: ObjectMetadataEntity,
-    relatedObjectMetadata: ObjectMetadataEntity,
-    isUpdate = false,
-  ) {
-    const customStandardFieldId =
-      STANDARD_OBJECT_FIELD_IDS[relatedObjectMetadata.nameSingular].custom;
-
-    if (!customStandardFieldId) {
-      throw new Error(
-        `Custom standard field ID not found for ${relatedObjectMetadata.nameSingular}`,
-      );
-    }
-
-    const { description } = buildDescriptionForRelationFieldMetadataOnToField({
-      relationObjectMetadataNamePlural: relatedObjectMetadata.namePlural,
-      targetObjectLabelSingular: objectMetadata.labelSingular,
-    });
-
-    return {
-      name: objectMetadata.nameSingular,
-      label: objectMetadata.labelSingular,
-      description,
-      ...(!isUpdate
-        ? {
-            standardId: createRelationDeterministicUuid({
-              objectId: objectMetadata.id,
-              standardId: customStandardFieldId,
-            }),
-            objectMetadataId: relatedObjectMetadata.id,
-            workspaceId: workspaceId,
-            isCustom: false,
-            isActive: true,
-            isSystem: true,
-            type: FieldMetadataType.RELATION,
-            name: objectMetadata.nameSingular,
-            label: objectMetadata.labelSingular,
-            description,
-            icon: 'IconBuildingSkyscraper',
-            isNullable: true,
-          }
-        : {}),
-    };
-  }
-
-  private buildForeignKeyFieldMetadata(
-    workspaceId: string,
-    objectMetadata: ObjectMetadataEntity,
-    relatedObjectMetadata: ObjectMetadataEntity,
-    objectPrimaryKeyType: FieldMetadataType,
-    objectPrimaryKeyFieldSettings:
-      | FieldMetadataSettings<FieldMetadataType>
-      | undefined,
-    isUpdate = false,
-  ) {
-    const customStandardFieldId =
-      STANDARD_OBJECT_FIELD_IDS[relatedObjectMetadata.nameSingular].custom;
-
-    if (!customStandardFieldId) {
-      throw new Error(
-        `Custom standard field ID not found for ${relatedObjectMetadata.nameSingular}`,
-      );
-    }
-
-    const { name, label, description } =
-      buildNameLabelAndDescriptionForForeignKeyFieldMetadata({
-        targetObjectNameSingular: objectMetadata.nameSingular,
-        targetObjectLabelSingular: objectMetadata.labelSingular,
-        relatedObjectLabelSingular: relatedObjectMetadata.labelSingular,
-      });
-
-    return {
-      name,
-      label,
-      description,
-      ...(!isUpdate
-        ? {
-            standardId: createForeignKeyDeterministicUuid({
-              objectId: objectMetadata.id,
-              standardId: customStandardFieldId,
-            }),
-            objectMetadataId: relatedObjectMetadata.id,
-            workspaceId: workspaceId,
-            isCustom: false,
-            isActive: true,
-            type: objectPrimaryKeyType,
-            name,
-            label,
-            description,
-            icon: undefined,
-            isNullable: true,
-            isSystem: true,
-            defaultValue: undefined,
-            settings: { ...objectPrimaryKeyFieldSettings, isForeignKey: true },
-          }
-        : {}),
-    };
-  }
-
-  private async createRelationMetadataFromFieldMetadatas(
-    workspaceId: string,
-    createdObjectMetadata: ObjectMetadataEntity,
-    relatedObjectMetadata: ObjectMetadataEntity,
-    relationFieldMetadataCollection: FieldMetadataEntity[],
-  ) {
-    const relationFieldMetadataMap = relationFieldMetadataCollection.reduce(
-      (acc, fieldMetadata: FieldMetadataEntity) => {
-        if (fieldMetadata.type === FieldMetadataType.RELATION) {
-          acc[fieldMetadata.objectMetadataId] = fieldMetadata;
-        }
-
-        return acc;
-      },
-      {},
-    );
-
-    await this.relationMetadataRepository.save([
-      {
-        workspaceId: workspaceId,
-        relationType: RelationMetadataType.ONE_TO_MANY,
-        fromObjectMetadataId: createdObjectMetadata.id,
-        toObjectMetadataId: relatedObjectMetadata.id,
-        fromFieldMetadataId:
-          relationFieldMetadataMap[createdObjectMetadata.id].id,
-        toFieldMetadataId:
-          relationFieldMetadataMap[relatedObjectMetadata.id].id,
-        onDeleteAction: RelationOnDeleteAction.CASCADE,
-      },
-    ]);
-  }
-
-  async updateObjectRelationshipsActivationStatus(
-    objectMetadataId: string,
-    isActive: boolean,
-  ) {
-    const affectedRelations = await this.relationMetadataRepository.find({
-      where: [
-        { fromObjectMetadataId: objectMetadataId },
-        { toObjectMetadataId: objectMetadataId },
-      ],
-    });
-
-    const affectedFieldIds = affectedRelations.reduce(
-      (acc, { fromFieldMetadataId, toFieldMetadataId }) => {
-        acc.push(fromFieldMetadataId, toFieldMetadataId);
-
-        return acc;
-      },
-      [] as string[],
-    );
-
-    if (affectedFieldIds.length > 0) {
-      await this.fieldMetadataRepository.update(
-        { id: In(affectedFieldIds) },
-        { isActive: isActive },
-      );
-    }
-  }
-}

packages/twenty-server/src/engine/metadata-modules/relation-metadata/relation-metadata.service.ts

@@ -12,8 +12,6 @@ import { FieldMetadataDefaultSettings } from 'src/engine/metadata-modules/field-
 import { FieldMetadataInterface } from 'src/engine/metadata-modules/field-metadata/interfaces/field-metadata.interface';
 import { RelationType } from 'src/engine/metadata-modules/field-metadata/interfaces/relation-type.interface';
 
-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 { FieldMetadataEntity } from 'src/engine/metadata-modules/field-metadata/field-metadata.entity';
 import { FieldMetadataService } from 'src/engine/metadata-modules/field-metadata/field-metadata.service';
 import { IndexMetadataService } from 'src/engine/metadata-modules/index-metadata/index-metadata.service';
@@ -60,7 +58,6 @@ export class RelationMetadataService extends TypeOrmQueryService<RelationMetadat
     private readonly workspaceMetadataVersionService: WorkspaceMetadataVersionService,
     private readonly indexMetadataService: IndexMetadataService,
     private readonly workspaceCacheStorageService: WorkspaceCacheStorageService,
-    private readonly featureFlagService: FeatureFlagService,
   ) {
     super(relationMetadataRepository);
   }
@@ -72,11 +69,6 @@ export class RelationMetadataService extends TypeOrmQueryService<RelationMetadat
       relationMetadataInput,
     );
 
-    const isNewRelationEnabled = await this.featureFlagService.isFeatureEnabled(
-      FeatureFlagKey.IsNewRelationEnabled,
-      relationMetadataInput.workspaceId,
-    );
-
     try {
       validateMetadataNameOrThrow(relationMetadataInput.fromName);
       validateMetadataNameOrThrow(relationMetadataInput.toName);
@@ -116,15 +108,6 @@ export class RelationMetadataService extends TypeOrmQueryService<RelationMetadat
             isCustom,
             toId,
           ),
-          // We don't want to create the join column field metadata for new relation
-          ...(isNewRelationEnabled
-            ? []
-            : [
-                this.createForeignKeyFieldMetadata(
-                  relationMetadataInput,
-                  columnName,
-                ),
-              ]),
         ].flat(),
       );
 
@@ -190,30 +173,6 @@ export class RelationMetadataService extends TypeOrmQueryService<RelationMetadat
 
     this.throwIfDeletedAtFieldMetadataNotFound(deletedAtFieldMetadata);
 
-    if (!isNewRelationEnabled) {
-      const foreignKeyFieldMetadata = createdRelationFieldsMetadata.find(
-        (fieldMetadata) => fieldMetadata.type === FieldMetadataType.UUID,
-      );
-
-      if (!foreignKeyFieldMetadata) {
-        throw new RelationMetadataException(
-          `ForeignKey field metadata not found`,
-          RelationMetadataExceptionCode.RELATION_METADATA_NOT_FOUND,
-        );
-      }
-
-      await this.indexMetadataService.createIndexMetadata(
-        relationMetadataInput.workspaceId,
-        toObjectMetadata,
-        [
-          foreignKeyFieldMetadata,
-          deletedAtFieldMetadata as FieldMetadataEntity<FieldMetadataType>,
-        ],
-        false,
-        false,
-      );
-    }
-
     await this.workspaceMigrationRunnerService.executeMigrationFromPendingMigrations(
       relationMetadataInput.workspaceId,
     );

packages/twenty-server/src/engine/twenty-orm/factories/entity-schema-column.factory.ts

@@ -26,10 +26,7 @@ type EntitySchemaColumnMap = {
 
 @Injectable()
 export class EntitySchemaColumnFactory {
-  create(
+  create(fieldMetadataMapByName: FieldMetadataMap): EntitySchemaColumnMap {
-    fieldMetadataMapByName: FieldMetadataMap,
-    isNewRelationEnabled: boolean,
-  ): EntitySchemaColumnMap {
     let entitySchemaColumnMap: EntitySchemaColumnMap = {};
 
     const fieldMetadataCollection = Object.values(fieldMetadataMapByName);
@@ -43,57 +40,28 @@ export class EntitySchemaColumnFactory {
           FieldMetadataType.RELATION,
         )
       ) {
-        if (!isNewRelationEnabled) {
+        const isManyToOneRelation =
-          const relationMetadata =
+          fieldMetadata.settings?.relationType === RelationType.MANY_TO_ONE;
-            fieldMetadata.fromRelationMetadata ??
+        const joinColumnName = fieldMetadata.settings?.joinColumnName;
-            fieldMetadata.toRelationMetadata;
-
-          if (!relationMetadata) {
-            throw new Error(
-              `Relation metadata is missing for field ${fieldMetadata.name}`,
-            );
-          }
-
-          const joinColumnKey = fieldMetadata.name + 'Id';
-          const joinColumn = fieldMetadataCollection.find(
-            (field) => field.name === joinColumnKey,
-          )
-            ? joinColumnKey
-            : null;
-
-          if (joinColumn) {
-            entitySchemaColumnMap[joinColumn] = {
-              name: joinColumn,
-              type: 'uuid',
-              nullable: fieldMetadata.isNullable,
-            };
-          }
-
-          continue;
-        } else {
-          const isManyToOneRelation =
-            fieldMetadata.settings?.relationType === RelationType.MANY_TO_ONE;
-          const joinColumnName = fieldMetadata.settings?.joinColumnName;
-
-          if (!isManyToOneRelation) {
-            continue;
-          }
-
-          if (!isDefined(joinColumnName)) {
-            throw new TwentyORMException(
-              `Field ${fieldMetadata.id} of type ${fieldMetadata.type}  is a many to one relation but does not have a join column name`,
-              TwentyORMExceptionCode.MALFORMED_METADATA,
-            );
-          }
-
-          entitySchemaColumnMap[joinColumnName] = {
-            name: joinColumnName,
-            type: 'uuid',
-            nullable: fieldMetadata.isNullable,
-          };
 
+        if (!isManyToOneRelation) {
           continue;
         }
+
+        if (!isDefined(joinColumnName)) {
+          throw new TwentyORMException(
+            `Field ${fieldMetadata.id} of type ${fieldMetadata.type}  is a many to one relation but does not have a join column name`,
+            TwentyORMExceptionCode.MALFORMED_METADATA,
+          );
+        }
+
+        entitySchemaColumnMap[joinColumnName] = {
+          name: joinColumnName,
+          type: 'uuid',
+          nullable: fieldMetadata.isNullable,
+        };
+
+        continue;
       }
 
       if (isCompositeFieldMetadataType(fieldMetadata.type)) {

packages/twenty-server/src/engine/twenty-orm/factories/entity-schema-relation.factory.ts

@@ -5,7 +5,6 @@ import { EntitySchemaRelationOptions } from 'typeorm';
 
 import { FieldMetadataMap } from 'src/engine/metadata-modules/types/field-metadata-map';
 import { ObjectMetadataMaps } from 'src/engine/metadata-modules/types/object-metadata-maps';
-import { determineRelationDetails } from 'src/engine/twenty-orm/utils/determine-relation-details.util';
 import { determineSchemaRelationDetails } from 'src/engine/twenty-orm/utils/determine-schema-relation-details.util';
 import { isFieldMetadataInterfaceOfType } from 'src/engine/utils/is-field-metadata-of-type.util';
 
@@ -20,7 +19,6 @@ export class EntitySchemaRelationFactory {
   async create(
     fieldMetadataMapByName: FieldMetadataMap,
     objectMetadataMaps: ObjectMetadataMaps,
-    isNewRelationEnabled: boolean,
   ): Promise<EntitySchemaRelationMap> {
     const entitySchemaRelationMap: EntitySchemaRelationMap = {};
 
@@ -36,48 +34,23 @@ export class EntitySchemaRelationFactory {
         continue;
       }
 
-      if (!isNewRelationEnabled) {
+      if (!fieldMetadata.settings) {
-        const relationMetadata =
+        throw new Error(
-          fieldMetadata.fromRelationMetadata ??
+          `Field metadata settings are missing for field ${fieldMetadata.name}`,
-          fieldMetadata.toRelationMetadata;
-
-        if (!relationMetadata) {
-          throw new Error(
-            `Relation metadata is missing for field ${fieldMetadata.name}`,
-          );
-        }
-
-        const relationDetails = await determineRelationDetails(
-          fieldMetadata,
-          relationMetadata,
-          objectMetadataMaps,
         );
-
-        entitySchemaRelationMap[fieldMetadata.name] = {
-          type: relationDetails.relationType,
-          target: relationDetails.target,
-          inverseSide: relationDetails.inverseSide,
-          joinColumn: relationDetails.joinColumn,
-        } satisfies EntitySchemaRelationOptions;
-      } else {
-        if (!fieldMetadata.settings) {
-          throw new Error(
-            `Field metadata settings are missing for field ${fieldMetadata.name}`,
-          );
-        }
-
-        const schemaRelationDetails = await determineSchemaRelationDetails(
-          fieldMetadata,
-          objectMetadataMaps,
-        );
-
-        entitySchemaRelationMap[fieldMetadata.name] = {
-          type: schemaRelationDetails.relationType,
-          target: schemaRelationDetails.target,
-          inverseSide: schemaRelationDetails.inverseSide,
-          joinColumn: schemaRelationDetails.joinColumn,
-        } satisfies EntitySchemaRelationOptions;
       }
+
+      const schemaRelationDetails = await determineSchemaRelationDetails(
+        fieldMetadata,
+        objectMetadataMaps,
+      );
+
+      entitySchemaRelationMap[fieldMetadata.name] = {
+        type: schemaRelationDetails.relationType,
+        target: schemaRelationDetails.target,
+        inverseSide: schemaRelationDetails.inverseSide,
+        joinColumn: schemaRelationDetails.joinColumn,
+      } satisfies EntitySchemaRelationOptions;
     }
 
     return entitySchemaRelationMap;

packages/twenty-server/src/engine/twenty-orm/factories/entity-schema.factory.ts

@@ -2,7 +2,6 @@ import { Injectable } from '@nestjs/common';
 
 import { EntitySchema } from 'typeorm';
 
-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';
@@ -25,20 +24,13 @@ export class EntitySchemaFactory {
     objectMetadata: ObjectMetadataItemWithFieldMaps,
     objectMetadataMaps: ObjectMetadataMaps,
   ): Promise<EntitySchema> {
-    const isNewRelationEnabled = await this.featureFlagService.isFeatureEnabled(
-      FeatureFlagKey.IsNewRelationEnabled,
-      workspaceId,
-    );
-
     const columns = this.entitySchemaColumnFactory.create(
       objectMetadata.fieldsByName,
-      isNewRelationEnabled,
     );
 
     const relations = await this.entitySchemaRelationFactory.create(
       objectMetadata.fieldsByName,
       objectMetadataMaps,
-      isNewRelationEnabled,
     );
 
     const entitySchema = new EntitySchema({

packages/twenty-server/src/engine/twenty-orm/repository/workspace.repository.ts

@@ -729,14 +729,7 @@ export class WorkspaceRepository<
     objectMetadata ??= await this.getObjectMetadataFromTarget();
 
     const objectMetadataMaps = this.internalContext.objectMetadataMaps;
-    const isNewRelationEnabled =
-      this.internalContext.featureFlagsMap[FeatureFlagKey.IsNewRelationEnabled];
 
-    return formatResult(
+    return formatResult(data, objectMetadata, objectMetadataMaps) as T;
-      data,
-      objectMetadata,
-      objectMetadataMaps,
-      isNewRelationEnabled,
-    ) as T;
   }
 }

packages/twenty-server/src/engine/twenty-orm/utils/format-result.util.ts

@@ -8,10 +8,8 @@ import { FieldMetadataInterface } from 'src/engine/metadata-modules/field-metada
 
 import { compositeTypeDefinitions } from 'src/engine/metadata-modules/field-metadata/composite-types';
 import { computeCompositeColumnName } from 'src/engine/metadata-modules/field-metadata/utils/compute-column-name.util';
-import { RelationMetadataEntity } from 'src/engine/metadata-modules/relation-metadata/relation-metadata.entity';
 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 { computeRelationType } from 'src/engine/twenty-orm/utils/compute-relation-type.util';
 import { getCompositeFieldMetadataCollection } from 'src/engine/twenty-orm/utils/get-composite-field-metadata-collection';
 import { isFieldMetadataInterfaceOfType } from 'src/engine/utils/is-field-metadata-of-type.util';
 import { isDate } from 'src/utils/date/isDate';
@@ -21,7 +19,6 @@ export function formatResult<T>(
   data: any,
   objectMetadataItemWithFieldMaps: ObjectMetadataItemWithFieldMaps,
   objectMetadataMaps: ObjectMetadataMaps,
-  isNewRelationEnabled: boolean,
 ): T {
   if (!data) {
     return data;
@@ -29,12 +26,7 @@ export function formatResult<T>(
 
   if (Array.isArray(data)) {
     return data.map((item) =>
-      formatResult(
+      formatResult(item, objectMetadataItemWithFieldMaps, objectMetadataMaps),
-        item,
-        objectMetadataItemWithFieldMaps,
-        objectMetadataMaps,
-        isNewRelationEnabled,
-      ),
     ) as T;
   }
 
@@ -50,36 +42,6 @@ export function formatResult<T>(
     objectMetadataItemWithFieldMaps,
   );
 
-  const relationMetadataMap: Map<
-    string,
-    {
-      relationMetadata: RelationMetadataEntity | undefined;
-      relationType: string;
-    }
-  > = isNewRelationEnabled
-    ? new Map()
-    : new Map(
-        Object.values(objectMetadataItemWithFieldMaps.fieldsById)
-          .filter((fieldMetadata) =>
-            isFieldMetadataInterfaceOfType(
-              fieldMetadata,
-              FieldMetadataType.RELATION,
-            ),
-          )
-          .map((fieldMetadata) => [
-            fieldMetadata.name,
-            {
-              relationMetadata:
-                fieldMetadata.fromRelationMetadata ??
-                fieldMetadata.toRelationMetadata,
-              relationType: computeRelationType(
-                fieldMetadata,
-                fieldMetadata.fromRelationMetadata ??
-                  (fieldMetadata.toRelationMetadata as RelationMetadataEntity),
-              ),
-            },
-          ]),
-      );
   const newData: object = {};
   const objectMetadaItemFieldsByName =
     objectMetadataMaps.byId[objectMetadataItemWithFieldMaps.id]?.fieldsByName;
@@ -104,7 +66,6 @@ export function formatResult<T>(
           value,
           objectMetadataItemWithFieldMaps,
           objectMetadataMaps,
-          isNewRelationEnabled,
         );
       } else if (objectMetadaItemFieldsByName[key]) {
         newData[key] = formatFieldMetadataValue(
@@ -118,63 +79,27 @@ export function formatResult<T>(
       continue;
     }
 
-    if (!isNewRelationEnabled) {
+    if (isRelation) {
-      const { relationMetadata, relationType } =
+      if (!isDefined(fieldMetadata?.relationTargetObjectMetadataId)) {
-        relationMetadataMap.get(key) ?? {};
+        throw new Error(
-
+          `Relation target object metadata ID is missing for field "${key}"`,
-      if (relationMetadata) {
-        const toObjectMetadata =
-          objectMetadataMaps.byId[relationMetadata.toObjectMetadataId];
-
-        const fromObjectMetadata =
-          objectMetadataMaps.byId[relationMetadata.fromObjectMetadataId];
-
-        if (!toObjectMetadata) {
-          throw new Error(
-            `Object metadata for object metadataId "${relationMetadata.toObjectMetadataId}" is missing`,
-          );
-        }
-
-        if (!fromObjectMetadata) {
-          throw new Error(
-            `Object metadata for object metadataId "${relationMetadata.fromObjectMetadataId}" is missing`,
-          );
-        }
-
-        newData[key] = formatResult(
-          value,
-          relationType === 'one-to-many'
-            ? toObjectMetadata
-            : fromObjectMetadata,
-          objectMetadataMaps,
-          isNewRelationEnabled,
-        );
-        continue;
-      }
-    } else {
-      if (isRelation) {
-        if (!isDefined(fieldMetadata?.relationTargetObjectMetadataId)) {
-          throw new Error(
-            `Relation target object metadata ID is missing for field "${key}"`,
-          );
-        }
-
-        const targetObjectMetadata =
-          objectMetadataMaps.byId[fieldMetadata.relationTargetObjectMetadataId];
-
-        if (!targetObjectMetadata) {
-          throw new Error(
-            `Object metadata for object metadataId "${fieldMetadata.relationTargetObjectMetadataId}" is missing`,
-          );
-        }
-
-        newData[key] = formatResult(
-          value,
-          targetObjectMetadata,
-          objectMetadataMaps,
-          isNewRelationEnabled,
         );
       }
+
+      const targetObjectMetadata =
+        objectMetadataMaps.byId[fieldMetadata.relationTargetObjectMetadataId];
+
+      if (!targetObjectMetadata) {
+        throw new Error(
+          `Object metadata for object metadataId "${fieldMetadata.relationTargetObjectMetadataId}" is missing`,
+        );
+      }
+
+      newData[key] = formatResult(
+        value,
+        targetObjectMetadata,
+        objectMetadataMaps,
+      );
     }
 
     if (!compositePropertyArgs) {

packages/twenty-server/src/engine/workspace-cache-storage/workspace-cache-storage.service.ts

@@ -10,7 +10,6 @@ import { FeatureFlagMap } from 'src/engine/core-modules/feature-flag/interfaces/
 import { InjectCacheStorage } from 'src/engine/core-modules/cache-storage/decorators/cache-storage.decorator';
 import { CacheStorageService } from 'src/engine/core-modules/cache-storage/services/cache-storage.service';
 import { CacheStorageNamespace } from 'src/engine/core-modules/cache-storage/types/cache-storage-namespace.enum';
-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 enum WorkspaceCacheKeys {
@@ -172,22 +171,6 @@ export class WorkspaceCacheStorageService {
     );
   }
 
-  // TODO: remove this after the feature flag is droped
-  setIsNewRelationEnabled(workspaceId: string, isNewRelationEnabled: boolean) {
-    return this.cacheStorageService.set<boolean>(
-      `${WorkspaceCacheKeys.GraphQLFeatureFlag}:${workspaceId}:${FeatureFlagKey.IsNewRelationEnabled}`,
-      isNewRelationEnabled,
-      TTL_INFINITE,
-    );
-  }
-
-  // TODO: remove this after the feature flag is droped
-  getIsNewRelationEnabled(workspaceId: string): Promise<boolean | undefined> {
-    return this.cacheStorageService.get<boolean>(
-      `${WorkspaceCacheKeys.GraphQLFeatureFlag}:${workspaceId}:${FeatureFlagKey.IsNewRelationEnabled}`,
-    );
-  }
-
   getFeatureFlagsMapVersionFromCache(
     workspaceId: string,
   ): Promise<string | undefined> {
@@ -321,10 +304,5 @@ export class WorkspaceCacheStorageService {
     await this.cacheStorageService.del(
       `${WorkspaceCacheKeys.FeatureFlagMapOngoingCachingLock}:${workspaceId}`,
     );
-
-    // TODO: remove this after the feature flag is droped
-    await this.cacheStorageService.del(
-      `${FeatureFlagKey.IsNewRelationEnabled}:${workspaceId}`,
-    );
   }
 }

packages/twenty-server/src/engine/workspace-manager/workspace-migration-builder/factories/workspace-migration-field.factory.ts

@@ -5,7 +5,6 @@ import { FieldMetadataType } from 'twenty-shared/types';
 
 import { WorkspaceMigrationBuilderAction } from 'src/engine/workspace-manager/workspace-migration-builder/interfaces/workspace-migration-builder-action.interface';
 
-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 { FieldMetadataEntity } from 'src/engine/metadata-modules/field-metadata/field-metadata.entity';
 import { ObjectMetadataEntity } from 'src/engine/metadata-modules/object-metadata/object-metadata.entity';
@@ -95,13 +94,6 @@ export class WorkspaceMigrationFieldFactory {
       return [];
     }
 
-    const workspaceId = fieldMetadataCollection[0]?.workspaceId;
-
-    const isNewRelationEnabled = await this.featureFlagService.isFeatureEnabled(
-      FeatureFlagKey.IsNewRelationEnabled,
-      workspaceId,
-    );
-
     const fieldMetadataCollectionGroupByObjectMetadataId =
       fieldMetadataCollection.reduce(
         (result, currentFieldMetadata) => {
@@ -125,14 +117,6 @@ export class WorkspaceMigrationFieldFactory {
         originalObjectMetadataMap[fieldMetadataCollection[0]?.objectMetadataId];
 
       for (const fieldMetadata of fieldMetadataCollection) {
-        // Relations are handled in workspace-migration-relation.factory.ts
-        if (
-          !isNewRelationEnabled &&
-          fieldMetadata.type === FieldMetadataType.RELATION
-        ) {
-          continue;
-        }
-
         columns.push(
           ...this.workspaceMigrationFactory.createColumnActions(
             WorkspaceMigrationColumnActionType.CREATE,
@@ -172,22 +156,7 @@ export class WorkspaceMigrationFieldFactory {
       return [];
     }
 
-    const workspaceId = fieldMetadataUpdateCollection[0]?.current.workspaceId;
-
-    const isNewRelationEnabled = await this.featureFlagService.isFeatureEnabled(
-      FeatureFlagKey.IsNewRelationEnabled,
-      workspaceId,
-    );
-
     for (const fieldMetadataUpdate of fieldMetadataUpdateCollection) {
-      // Skip relations, because they're just representation and not real columns
-      if (
-        !isNewRelationEnabled &&
-        fieldMetadataUpdate.altered.type === FieldMetadataType.RELATION
-      ) {
-        continue;
-      }
-
       const columnActions = this.workspaceMigrationFactory.createColumnActions(
         WorkspaceMigrationColumnActionType.ALTER,
         fieldMetadataUpdate.current,

packages/twenty-server/src/engine/workspace-manager/workspace-sync-metadata/constants/default-feature-flags.ts

@@ -1,3 +1 @@
-import { FeatureFlagKey } from 'src/engine/core-modules/feature-flag/enums/feature-flag-key.enum';
+export const DEFAULT_FEATURE_FLAGS = [];
-
-export const DEFAULT_FEATURE_FLAGS = [FeatureFlagKey.IsNewRelationEnabled];

packages/twenty-server/src/engine/workspace-manager/workspace-sync-metadata/factories/standard-field.factory.ts

@@ -13,11 +13,8 @@ import {
 } from 'src/engine/workspace-manager/workspace-sync-metadata/interfaces/partial-field-metadata.interface';
 import { WorkspaceSyncContext } from 'src/engine/workspace-manager/workspace-sync-metadata/interfaces/workspace-sync-context.interface';
 
-import { FeatureFlagKey } from 'src/engine/core-modules/feature-flag/enums/feature-flag-key.enum';
 import { BaseWorkspaceEntity } from 'src/engine/twenty-orm/base.workspace-entity';
 import { metadataArgsStorage } from 'src/engine/twenty-orm/storage/metadata-args.storage';
-import { getJoinColumn } from 'src/engine/twenty-orm/utils/get-join-column.util';
-import { createDeterministicUuid } from 'src/engine/workspace-manager/workspace-sync-metadata/utils/create-deterministic-uuid.util';
 import { isGatedAndNotEnabled } from 'src/engine/workspace-manager/workspace-sync-metadata/utils/is-gate-and-not-enabled.util';
 
 @Injectable()
@@ -169,21 +166,7 @@ export class StandardFieldFactory {
     workspaceRelationMetadataArgs: WorkspaceRelationMetadataArgs,
     context: WorkspaceSyncContext,
   ): PartialFieldMetadata[] {
-    const isNewRelationEnabled =
-      context.featureFlags[FeatureFlagKey.IsNewRelationEnabled];
-
     const fieldMetadataCollection: PartialFieldMetadata[] = [];
-    const foreignKeyStandardId = createDeterministicUuid(
-      workspaceRelationMetadataArgs.standardId,
-    );
-    const joinColumnMetadataArgsCollection =
-      metadataArgsStorage.filterJoinColumns(
-        workspaceRelationMetadataArgs.target,
-      );
-    const joinColumn = getJoinColumn(
-      joinColumnMetadataArgsCollection,
-      workspaceRelationMetadataArgs,
-    );
 
     if (
       isGatedAndNotEnabled(
@@ -194,28 +177,6 @@ export class StandardFieldFactory {
       return [];
     }
 
-    // We don't want to create the join column field metadata for new relation
-    if (!isNewRelationEnabled && joinColumn) {
-      fieldMetadataCollection.push({
-        type: FieldMetadataType.UUID,
-        standardId: foreignKeyStandardId,
-        name: joinColumn,
-        label: `${workspaceRelationMetadataArgs.label} id (foreign key)`,
-        description: `${workspaceRelationMetadataArgs.description} id foreign key`,
-        icon: workspaceRelationMetadataArgs.icon,
-        defaultValue: null,
-        options: undefined,
-        settings: undefined,
-        workspaceId: context.workspaceId,
-        isCustom: false,
-        isSystem: true,
-        isNullable: workspaceRelationMetadataArgs.isNullable,
-        isUnique:
-          workspaceRelationMetadataArgs.type === RelationType.ONE_TO_ONE,
-        isActive: workspaceRelationMetadataArgs.isActive ?? true,
-      });
-    }
-
     fieldMetadataCollection.push({
       type: FieldMetadataType.RELATION,
       standardId: workspaceRelationMetadataArgs.standardId,

packages/twenty-server/src/engine/workspace-manager/workspace-sync-metadata/services/workspace-metadata-updater.service.ts

@@ -17,7 +17,6 @@ import { PartialFieldMetadata } from 'src/engine/workspace-manager/workspace-syn
 import { PartialIndexMetadata } from 'src/engine/workspace-manager/workspace-sync-metadata/interfaces/partial-index-metadata.interface';
 import { UpdaterOptions } from 'src/engine/workspace-manager/workspace-sync-metadata/interfaces/updater-options.interface';
 
-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 { compositeTypeDefinitions } from 'src/engine/metadata-modules/field-metadata/composite-types';
 import { FieldMetadataComplexOption } from 'src/engine/metadata-modules/field-metadata/dtos/options.input';
@@ -369,15 +368,6 @@ export class WorkspaceMetadataUpdaterService {
     createdIndexMetadataCollection: IndexMetadataEntity[];
   }> {
     const indexMetadataRepository = manager.getRepository(IndexMetadataEntity);
-    const workspaceId = originalObjectMetadataCollection?.[0]?.workspaceId;
-    let isNewRelationEnabled = false;
-
-    if (workspaceId) {
-      isNewRelationEnabled = await this.featureFlagService.isFeatureEnabled(
-        FeatureFlagKey.IsNewRelationEnabled,
-        workspaceId,
-      );
-    }
 
     const convertIndexMetadataForSaving = (
       indexMetadata: PartialIndexMetadata,
@@ -391,7 +381,6 @@ export class WorkspaceMetadataUpdaterService {
           .find((object) => object.id === indexMetadata.objectMetadataId)
           ?.fields.find((field) => {
             if (
-              isNewRelationEnabled &&
               isFieldMetadataEntityOfType(field, FieldMetadataType.RELATION)
             ) {
               if (field.settings?.joinColumnName === column) {

packages/twenty-server/src/engine/workspace-manager/workspace-sync-metadata/utils/compute-standard-fields.util.ts

@@ -1,5 +1,3 @@
-import { FieldMetadataType } from 'twenty-shared/types';
-
 import {
   ComputedPartialFieldMetadata,
   PartialComputedFieldMetadata,
@@ -7,12 +5,8 @@ import {
 } from 'src/engine/workspace-manager/workspace-sync-metadata/interfaces/partial-field-metadata.interface';
 import { WorkspaceSyncContext } from 'src/engine/workspace-manager/workspace-sync-metadata/interfaces/workspace-sync-context.interface';
 
-import { FeatureFlagKey } from 'src/engine/core-modules/feature-flag/enums/feature-flag-key.enum';
 import { ObjectMetadataEntity } from 'src/engine/metadata-modules/object-metadata/object-metadata.entity';
-import {
+import { createRelationDeterministicUuid } from 'src/engine/workspace-manager/workspace-sync-metadata/utils/create-deterministic-uuid.util';
-  createForeignKeyDeterministicUuid,
-  createRelationDeterministicUuid,
-} from 'src/engine/workspace-manager/workspace-sync-metadata/utils/create-deterministic-uuid.util';
 
 export const computeStandardFields = (
   context: WorkspaceSyncContext,
@@ -25,9 +19,6 @@ export const computeStandardFields = (
 ): ComputedPartialFieldMetadata[] => {
   const fields: ComputedPartialFieldMetadata[] = [];
 
-  const isNewRelationEnabled =
-    context.featureFlags[FeatureFlagKey.IsNewRelationEnabled];
-
   for (const partialFieldMetadata of standardFieldMetadataCollection) {
     // Relation from standard object to custom object
     if ('argsFactory' in partialFieldMetadata) {
@@ -39,10 +30,6 @@ export const computeStandardFields = (
           objectId: customObjectMetadata.id,
           standardId: data.standardId,
         });
-        const foreignKeyStandardId = createForeignKeyDeterministicUuid({
-          objectId: customObjectMetadata.id,
-          standardId: data.standardId,
-        });
 
         if (!joinColumn) {
           throw new Error(
@@ -57,23 +44,6 @@ export const computeStandardFields = (
           standardId: relationStandardId,
           defaultValue: null,
         });
-
-        // Only add foreign key if new relation is disabled
-        // As new relation will no longer create the field metadata related to foreign key
-        if (!isNewRelationEnabled) {
-          // Foreign key
-          fields.push({
-            ...rest,
-            standardId: foreignKeyStandardId,
-            name: joinColumn,
-            type: FieldMetadataType.UUID,
-            label: `${data.label} ID (foreign key)`,
-            description: `${data.description} id foreign key`,
-            defaultValue: null,
-            icon: undefined,
-            isSystem: true,
-          });
-        }
       }
     } else {
       // Relation from standard object to standard object

packages/twenty-server/src/engine/workspace-manager/workspace-sync-metadata/workspace-sync-metadata.service.ts

@@ -5,7 +5,6 @@ import { DataSource, QueryFailedError } from 'typeorm';
 
 import { WorkspaceSyncContext } from 'src/engine/workspace-manager/workspace-sync-metadata/interfaces/workspace-sync-context.interface';
 
-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 { WorkspaceMetadataVersionService } from 'src/engine/metadata-modules/workspace-metadata-version/services/workspace-metadata-version.service';
 import {
@@ -70,12 +69,6 @@ export class WorkspaceSyncMetadataService {
     const manager = queryRunner.manager;
 
     try {
-      const isNewRelationEnabled =
-        await this.featureFlagService.isFeatureEnabled(
-          FeatureFlagKey.IsNewRelationEnabled,
-          context.workspaceId,
-        );
-
       const workspaceMigrationRepository = manager.getRepository(
         WorkspaceMigrationEntity,
       );
@@ -127,21 +120,12 @@ export class WorkspaceSyncMetadataService {
 
       let workspaceRelationMigrations: Partial<WorkspaceMigrationEntity>[] = [];
 
-      if (isNewRelationEnabled) {
+      workspaceRelationMigrations =
-        workspaceRelationMigrations =
+        await this.workspaceSyncFieldMetadataRelationService.synchronize(
-          await this.workspaceSyncFieldMetadataRelationService.synchronize(
+          context,
-            context,
+          manager,
-            manager,
+          storage,
-            storage,
+        );
-          );
-      } else {
-        workspaceRelationMigrations =
-          await this.workspaceSyncRelationMetadataService.synchronize(
-            context,
-            manager,
-            storage,
-          );
-      }
 
       const workspaceRelationMigrationsEnd = performance.now();
 
@@ -149,24 +133,22 @@ export class WorkspaceSyncMetadataService {
         `Workspace relation migrations took ${workspaceRelationMigrationsEnd - workspaceRelationMigrationsStart}ms`,
       );
 
-      let workspaceIndexMigrations: Partial<WorkspaceMigrationEntity>[] = [];
+      const workspaceIndexMigrations: Partial<WorkspaceMigrationEntity>[] = [];
 
       // 4 - Sync standard indexes on standard objects
-      if (!isNewRelationEnabled) {
+      const workspaceIndexMigrationsStart = performance.now();
-        const workspaceIndexMigrationsStart = performance.now();
 
-        workspaceIndexMigrations =
+      // workspaceIndexMigrations =
-          await this.workspaceSyncIndexMetadataService.synchronize(
+      //   await this.workspaceSyncIndexMetadataService.synchronize(
-            context,
+      //     context,
-            manager,
+      //     manager,
-            storage,
+      //     storage,
-          );
+      //   );
-        const workspaceIndexMigrationsEnd = performance.now();
+      const workspaceIndexMigrationsEnd = performance.now();
 
-        this.logger.log(
+      this.logger.log(
-          `Workspace index migrations took ${workspaceIndexMigrationsEnd - workspaceIndexMigrationsStart}ms`,
+        `Workspace index migrations took ${workspaceIndexMigrationsEnd - workspaceIndexMigrationsStart}ms`,
-        );
+      );
-      }
 
       // 5 - Sync standard object metadata identifiers, does not need to return nor apply migrations
       const workspaceObjectMetadataIdentifiersStart = performance.now();

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

@@ -12,8 +12,6 @@ import { WorkflowExecutor } from 'src/modules/workflow/workflow-executor/interfa
 
 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 { 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 { ScopedWorkspaceContextFactory } from 'src/engine/twenty-orm/factories/scoped-workspace-context.factory';
@@ -40,7 +38,6 @@ export class FindRecordsWorkflowAction implements WorkflowExecutor {
   constructor(
     private readonly twentyORMManager: TwentyORMManager,
     private readonly scopedWorkspaceContextFactory: ScopedWorkspaceContextFactory,
-    private readonly featureFlagService: FeatureFlagService,
     private readonly workflowCommonWorkspaceService: WorkflowCommonWorkspaceService,
   ) {}
 
@@ -89,14 +86,10 @@ export class FindRecordsWorkflowAction implements WorkflowExecutor {
         workspaceId,
       );
 
-    const featureFlagMaps =
-      await this.featureFlagService.getWorkspaceFeatureFlagsMap(workspaceId);
-
     const graphqlQueryParser = new GraphqlQueryParser(
       objectMetadataItemWithFieldsMaps.fieldsByName,
       objectMetadataItemWithFieldsMaps.fieldsByJoinColumnName,
       objectMetadataMaps,
-      featureFlagMaps,
     );
 
     const objectRecords = await this.getObjectRecords(
@@ -129,11 +122,6 @@ export class FindRecordsWorkflowAction implements WorkflowExecutor {
     repository: WorkspaceRepository<T>,
     graphqlQueryParser: GraphqlQueryParser,
   ) {
-    const isNewRelationEnabled = await this.featureFlagService.isFeatureEnabled(
-      FeatureFlagKey.IsNewRelationEnabled,
-      objectMetadataItemWithFieldsMaps.workspaceId,
-    );
-
     const queryBuilder = repository.createQueryBuilder(
       workflowActionInput.objectName,
     );
@@ -164,7 +152,6 @@ export class FindRecordsWorkflowAction implements WorkflowExecutor {
       nonFormattedObjectRecords,
       objectMetadataItemWithFieldsMaps,
       objectMetadataMaps,
-      isNewRelationEnabled,
     );
   }
 

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

@@ -2,7 +2,6 @@ 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 { RecordPositionModule } from 'src/engine/core-modules/record-position/record-position.module';
 import { RecordTransformerModule } from 'src/engine/core-modules/record-transformer/record-transformer.module';
 import { ObjectMetadataEntity } from 'src/engine/metadata-modules/object-metadata/object-metadata.entity';
@@ -18,7 +17,6 @@ import { UpdateRecordWorkflowAction } from 'src/modules/workflow/workflow-execut
   imports: [
     WorkspaceCacheStorageModule,
     NestjsQueryTypeOrmModule.forFeature([ObjectMetadataEntity], 'metadata'),
-    FeatureFlagModule,
     RecordPositionModule,
     RecordTransformerModule,
     WorkflowCommonModule,