feat: new relation sync-metadata, twenty-orm, create/update (#10217)

Fix
https://github.com/twentyhq/core-team-issues/issues/330#issue-2827026606
and
https://github.com/twentyhq/core-team-issues/issues/327#issue-2827001814

What this PR does when `isNewRelationEnabled` is set to `true`:
- [x] Drop the creation of the  foreign key as a `FieldMetadata`
- [x] Stop creating `RelationMetadata`
- [x] Properly fill `FieldMetadata` of type `RELATION` during the sync
command
- [x] Use new relation settings in TwentyORM
- [x] Properly create `FieldMetadata` relations when we create a new
object
- [x] Handle `database:reset` with new relations

---------

Co-authored-by: Charles Bochet <charles@twenty.com>
Co-authored-by: Charles Bochet <charlesBochet@users.noreply.github.com>

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

@@ -29,6 +29,7 @@ export const mockPersonObjectMetadata = (
   fields: [],
   indexMetadatas: [],
   fieldsById: {},
+  fieldsByJoinColumnName: {},
   fieldsByName: {
     name: {
       id: '',

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

@@ -14,15 +14,19 @@ import { GraphqlQueryFilterFieldParser } from './graphql-query-filter-field.pars
 
 export class GraphqlQueryFilterConditionParser {
   private fieldMetadataMapByName: FieldMetadataMap;
+  private fieldMetadataMapByJoinColumnName: FieldMetadataMap;
   private queryFilterFieldParser: GraphqlQueryFilterFieldParser;
 
   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

@@ -1,5 +1,5 @@
-import { WhereExpressionBuilder } from 'typeorm';
 import { capitalize } from 'twenty-shared/utils';
+import { WhereExpressionBuilder } from 'typeorm';
 
 import { FeatureFlagMap } from 'src/engine/core-modules/feature-flag/interfaces/feature-flag-map.interface';
 import { FieldMetadataInterface } from 'src/engine/metadata-modules/field-metadata/interfaces/field-metadata.interface';
@@ -18,13 +18,16 @@ 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;
   }
 
@@ -35,7 +38,9 @@ export class GraphqlQueryFilterFieldParser {
     filterValue: any,
     isFirst = false,
   ): void {
-    const fieldMetadata = this.fieldMetadataMapByName[`${key}`];
+    const fieldMetadata =
+      this.fieldMetadataMapByName[`${key}`] ||
+      this.fieldMetadataMapByJoinColumnName[`${key}`];
 
     if (!fieldMetadata) {
       throw new Error(`Field metadata not found for field: ${key}`);

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

@@ -24,6 +24,7 @@ import { getObjectMetadataMapItemByNameSingular } from 'src/engine/metadata-modu
 
 export class GraphqlQueryParser {
   private fieldMetadataMapByName: FieldMetadataMap;
+  private fieldMetadataMapByJoinColumnName: FieldMetadataMap;
   private objectMetadataMaps: ObjectMetadataMaps;
   private filterConditionParser: GraphqlQueryFilterConditionParser;
   private orderFieldParser: GraphqlQueryOrderFieldParser;
@@ -31,14 +32,17 @@ export class GraphqlQueryParser {
 
   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(

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

@@ -23,7 +23,7 @@ import { ObjectMetadataMaps } from 'src/engine/metadata-modules/types/object-met
 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 { isFieldMetadataOfType } from 'src/engine/utils/is-field-metadata-of-type.util';
+import { isFieldMetadataInterfaceOfType } from 'src/engine/utils/is-field-metadata-of-type.util';
 
 @Injectable()
 export class ProcessNestedRelationsV2Helper {
@@ -103,7 +103,10 @@ export class ProcessNestedRelationsV2Helper {
       parentObjectMetadataItem.fieldsByName[sourceFieldName];
 
     if (
-      !isFieldMetadataOfType(sourceFieldMetadata, FieldMetadataType.RELATION)
+      !isFieldMetadataInterfaceOfType(
+        sourceFieldMetadata,
+        FieldMetadataType.RELATION,
+      )
     ) {
       // TODO: Maybe we should throw an error here ?
       return;
@@ -149,7 +152,7 @@ export class ProcessNestedRelationsV2Helper {
             ? `"${targetRelationName}Id"`
             : 'id',
         ids: relationIds,
-        limit,
+        limit: limit * parentObjectRecords.length,
         objectMetadataMaps,
         targetObjectMetadata,
         aggregate,
@@ -313,6 +316,7 @@ 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

@@ -453,6 +453,7 @@ export class ProcessNestedRelationsHelper {
       result,
       referenceObjectMetadata,
       objectMetadataMaps,
+      false,
     );
 
     return { relationResults, relationAggregatedFieldsResult };

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

@@ -130,6 +130,7 @@ export abstract class GraphqlQueryBaseResolverService<
 
       const graphqlQueryParser = new GraphqlQueryParser(
         objectMetadataItemWithFieldMaps.fieldsByName,
+        objectMetadataItemWithFieldMaps.fieldsByJoinColumnName,
         options.objectMetadataMaps,
         featureFlagsMap,
       );

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

@@ -44,6 +44,7 @@ export class GraphqlQueryCreateManyResolverService extends GraphqlQueryBaseResol
       objectRecords,
       objectMetadataItemWithFieldMaps,
       objectMetadataMaps,
+      featureFlagsMap,
     );
 
     this.apiEventEmitterService.emitCreateEvents(
@@ -301,6 +302,7 @@ export class GraphqlQueryCreateManyResolverService extends GraphqlQueryBaseResol
     objectRecords: InsertResult,
     objectMetadataItemWithFieldMaps: ObjectMetadataItemWithFieldMaps,
     objectMetadataMaps: ObjectMetadataMaps,
+    featureFlagsMap: Record<FeatureFlagKey, boolean>,
   ): Promise<ObjectRecord[]> {
     const queryBuilder = executionArgs.repository.createQueryBuilder(
       objectMetadataItemWithFieldMaps.nameSingular,
@@ -317,6 +319,7 @@ export class GraphqlQueryCreateManyResolverService extends GraphqlQueryBaseResol
       nonFormattedUpsertedRecords,
       objectMetadataItemWithFieldMaps,
       objectMetadataMaps,
+      featureFlagsMap[FeatureFlagKey.IsNewRelationEnabled],
     );
   }
 

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

@@ -53,6 +53,7 @@ export class GraphqlQueryCreateOneResolverService extends GraphqlQueryBaseResolv
       nonFormattedUpsertedRecords,
       objectMetadataItemWithFieldMaps,
       objectMetadataMaps,
+      featureFlagsMap[FeatureFlagKey.IsNewRelationEnabled],
     );
 
     this.apiEventEmitterService.emitCreateEvents(

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

@@ -54,6 +54,7 @@ export class GraphqlQueryDeleteManyResolverService extends GraphqlQueryBaseResol
       nonFormattedDeletedObjectRecords.raw,
       objectMetadataItemWithFieldMaps,
       objectMetadataMaps,
+      featureFlagsMap[FeatureFlagKey.IsNewRelationEnabled],
     );
 
     this.apiEventEmitterService.emitDeletedEvents(

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

@@ -47,6 +47,7 @@ export class GraphqlQueryDeleteOneResolverService extends GraphqlQueryBaseResolv
       nonFormattedDeletedObjectRecords.raw,
       objectMetadataItemWithFieldMaps,
       objectMetadataMaps,
+      featureFlagsMap[FeatureFlagKey.IsNewRelationEnabled],
     );
 
     this.apiEventEmitterService.emitDeletedEvents(

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

@@ -52,6 +52,7 @@ export class GraphqlQueryDestroyManyResolverService extends GraphqlQueryBaseReso
       nonFormattedDeletedObjectRecords.raw,
       objectMetadataItemWithFieldMaps,
       objectMetadataMaps,
+      featureFlagsMap[FeatureFlagKey.IsNewRelationEnabled],
     );
 
     this.apiEventEmitterService.emitDestroyEvents(

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

@@ -52,6 +52,7 @@ export class GraphqlQueryDestroyOneResolverService extends GraphqlQueryBaseResol
       nonFormattedDeletedObjectRecords.raw,
       objectMetadataItemWithFieldMaps,
       objectMetadataMaps,
+      featureFlagsMap[FeatureFlagKey.IsNewRelationEnabled],
     );
 
     this.apiEventEmitterService.emitDestroyEvents(

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

@@ -64,6 +64,7 @@ export class GraphqlQueryFindDuplicatesResolverService extends GraphqlQueryBaseR
 
     const graphqlQueryParser = new GraphqlQueryParser(
       objectMetadataItemWithFieldsMaps?.fieldsByName,
+      objectMetadataItemWithFieldsMaps?.fieldsByJoinColumnName,
       objectMetadataMaps,
       featureFlagsMap,
     );
@@ -85,6 +86,7 @@ export class GraphqlQueryFindDuplicatesResolverService extends GraphqlQueryBaseR
         nonFormattedObjectRecords,
         objectMetadataItemWithFieldMaps,
         objectMetadataMaps,
+        featureFlagsMap[FeatureFlagKey.IsNewRelationEnabled],
       );
     } else if (executionArgs.args.data && !isEmpty(executionArgs.args.data)) {
       objectRecords = formatData(
@@ -131,6 +133,7 @@ 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

@@ -130,6 +130,7 @@ export class GraphqlQueryFindManyResolverService extends GraphqlQueryBaseResolve
       nonFormattedObjectRecords,
       objectMetadataItemWithFieldMaps,
       objectMetadataMaps,
+      featureFlagsMap[FeatureFlagKey.IsNewRelationEnabled],
     );
 
     const { hasNextPage, hasPreviousPage } = getPaginationInfo(

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

@@ -59,6 +59,7 @@ export class GraphqlQueryFindOneResolverService extends GraphqlQueryBaseResolver
       nonFormattedObjectRecord,
       objectMetadataItemWithFieldMaps,
       objectMetadataMaps,
+      featureFlagsMap[FeatureFlagKey.IsNewRelationEnabled],
     );
 
     if (!objectRecord) {

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

@@ -54,6 +54,7 @@ export class GraphqlQueryRestoreManyResolverService extends GraphqlQueryBaseReso
       nonFormattedRestoredObjectRecords.raw,
       objectMetadataItemWithFieldMaps,
       objectMetadataMaps,
+      featureFlagsMap[FeatureFlagKey.IsNewRelationEnabled],
     );
 
     this.apiEventEmitterService.emitRestoreEvents(

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

@@ -47,6 +47,7 @@ export class GraphqlQueryRestoreOneResolverService extends GraphqlQueryBaseResol
       nonFormattedRestoredObjectRecords.raw,
       objectMetadataItemWithFieldMaps,
       objectMetadataMaps,
+      featureFlagsMap[FeatureFlagKey.IsNewRelationEnabled],
     );
 
     this.apiEventEmitterService.emitRestoreEvents(

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

@@ -55,6 +55,7 @@ export class GraphqlQueryUpdateManyResolverService extends GraphqlQueryBaseResol
       existingRecords,
       objectMetadataItemWithFieldMaps,
       objectMetadataMaps,
+      featureFlagsMap[FeatureFlagKey.IsNewRelationEnabled],
     );
 
     if (isEmpty(formattedExistingRecords)) {
@@ -89,6 +90,7 @@ export class GraphqlQueryUpdateManyResolverService extends GraphqlQueryBaseResol
       nonFormattedUpdatedObjectRecords.raw,
       objectMetadataItemWithFieldMaps,
       objectMetadataMaps,
+      featureFlagsMap[FeatureFlagKey.IsNewRelationEnabled],
     );
 
     this.apiEventEmitterService.emitUpdateEvents(

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

@@ -55,6 +55,7 @@ export class GraphqlQueryUpdateOneResolverService extends GraphqlQueryBaseResolv
       existingRecords,
       objectMetadataItemWithFieldMaps,
       objectMetadataMaps,
+      featureFlagsMap[FeatureFlagKey.IsNewRelationEnabled],
     );
 
     if (isEmpty(formattedExistingRecords)) {
@@ -74,6 +75,7 @@ export class GraphqlQueryUpdateOneResolverService extends GraphqlQueryBaseResolv
       nonFormattedUpdatedObjectRecords.raw,
       objectMetadataItemWithFieldMaps,
       objectMetadataMaps,
+      featureFlagsMap[FeatureFlagKey.IsNewRelationEnabled],
     );
 
     this.apiEventEmitterService.emitUpdateEvents(

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

@@ -22,7 +22,7 @@ import { CompositeInputTypeDefinitionFactory } from 'src/engine/api/graphql/work
 import { FeatureFlagService } from 'src/engine/core-modules/feature-flag/services/feature-flag.service';
 import { FileService } from 'src/engine/core-modules/file/services/file.service';
 import { ObjectMetadataMaps } from 'src/engine/metadata-modules/types/object-metadata-maps';
-import { isFieldMetadataOfType } from 'src/engine/utils/is-field-metadata-of-type.util';
+import { isFieldMetadataInterfaceOfType } from 'src/engine/utils/is-field-metadata-of-type.util';
 
 // TODO: find a way to prevent conflict between handlers executing logic on object relations
 // And this factory that is also executing logic on object relations
@@ -153,7 +153,10 @@ export class QueryResultGettersFactory {
       )
       .filter(isDefined)
       .filter((fieldMetadata) =>
-        isFieldMetadataOfType(fieldMetadata, FieldMetadataType.RELATION),
+        isFieldMetadataInterfaceOfType(
+          fieldMetadata,
+          FieldMetadataType.RELATION,
+        ),
       );
 
     const relationFieldsProcessedMap = {} as Record<

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

@@ -15,7 +15,7 @@ import { RelationTypeV2Factory } from 'src/engine/api/graphql/workspace-schema-b
 import { TypeDefinitionsStorage } from 'src/engine/api/graphql/workspace-schema-builder/storages/type-definitions.storage';
 import { getResolverArgs } from 'src/engine/api/graphql/workspace-schema-builder/utils/get-resolver-args.util';
 import { objectContainsRelationField } from 'src/engine/api/graphql/workspace-schema-builder/utils/object-contains-relation-field';
-import { isFieldMetadataOfType } from 'src/engine/utils/is-field-metadata-of-type.util';
+import { isFieldMetadataInterfaceOfType } from 'src/engine/utils/is-field-metadata-of-type.util';
 
 import { ArgsFactory } from './args.factory';
 
@@ -108,7 +108,12 @@ export class ExtendObjectTypeDefinitionV2Factory {
 
     for (const fieldMetadata of objectMetadata.fields) {
       // Ignore non-relation fields as they are already defined
-      if (!isFieldMetadataOfType(fieldMetadata, FieldMetadataType.RELATION)) {
+      if (
+        !isFieldMetadataInterfaceOfType(
+          fieldMetadata,
+          FieldMetadataType.RELATION,
+        )
+      ) {
         continue;
       }
 

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

@@ -36,6 +36,7 @@ export class InputTypeDefinitionFactory {
     objectMetadata: ObjectMetadataInterface,
     kind: InputTypeDefinitionKind,
     options: WorkspaceBuildSchemaOptions,
+    isNewRelationEnabled = false,
   ): InputTypeDefinition {
     const inputType = new GraphQLInputObjectType({
       name: `${pascalCase(objectMetadata.nameSingular)}${kind.toString()}Input`,
@@ -58,6 +59,7 @@ export class InputTypeDefinitionFactory {
                 kind,
                 options,
                 this.inputTypeFactory,
+                isNewRelationEnabled,
               ),
               and: {
                 type: andOrType,
@@ -81,6 +83,7 @@ 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,6 +30,7 @@ export class ObjectTypeDefinitionFactory {
     objectMetadata: ObjectMetadataInterface,
     kind: ObjectTypeDefinitionKind,
     options: WorkspaceBuildSchemaOptions,
+    isNewRelationEnabled = false,
   ): ObjectTypeDefinition {
     return {
       target: objectMetadata.id,
@@ -42,6 +43,7 @@ export class ObjectTypeDefinitionFactory {
           kind,
           options,
           this.outputTypeFactory,
+          isNewRelationEnabled,
         ),
       }),
     };

packages/twenty-server/src/engine/api/graphql/workspace-schema-builder/services/type-mapper.service.ts

@@ -58,7 +58,7 @@ export class TypeMapperService {
     settings?: FieldMetadataSettings<FieldMetadataType>,
     isIdField?: boolean,
   ): GraphQLScalarType | undefined {
-    if (isIdField || settings?.isForeignKey) {
+    if (isIdField || fieldMetadataType === FieldMetadataType.RELATION) {
       return GraphQLID;
     }
     const typeScalarMapping = new Map<FieldMetadataType, GraphQLScalarType>([
@@ -93,7 +93,7 @@ export class TypeMapperService {
     settings?: FieldMetadataSettings<FieldMetadataType>,
     isIdField?: boolean,
   ): GraphQLInputObjectType | GraphQLScalarType | undefined {
-    if (isIdField || settings?.isForeignKey) {
+    if (isIdField || fieldMetadataType === FieldMetadataType.RELATION) {
       return IDFilterType;
     }
 
@@ -132,6 +132,7 @@ export class TypeMapperService {
   ): GraphQLInputType | undefined {
     const typeOrderByMapping = new Map<FieldMetadataType, GraphQLEnumType>([
       [FieldMetadataType.UUID, OrderByDirectionType],
+      [FieldMetadataType.RELATION, OrderByDirectionType],
       [FieldMetadataType.TEXT, OrderByDirectionType],
       [FieldMetadataType.DATE_TIME, OrderByDirectionType],
       [FieldMetadataType.DATE, OrderByDirectionType],

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

@@ -51,11 +51,16 @@ export class TypeDefinitionsGenerator {
   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(objectMetadataCollection, options);
+    await this.generateMetadataTypeDefs(
+      objectMetadataCollection,
+      options,
+      isNewRelationEnabled,
+    );
   }
 
   /**
@@ -155,6 +160,7 @@ export class TypeDefinitionsGenerator {
   private async generateMetadataTypeDefs(
     dynamicObjectMetadataCollection: ObjectMetadataInterface[],
     options: WorkspaceBuildSchemaOptions,
+    isNewRelationEnabled: boolean,
   ) {
     this.logger.log(
       `Generating metadata objects: [${dynamicObjectMetadataCollection
@@ -164,9 +170,17 @@ export class TypeDefinitionsGenerator {
 
     // Generate dynamic objects
     this.generateEnumTypeDefs(dynamicObjectMetadataCollection, options);
-    this.generateObjectTypeDefs(dynamicObjectMetadataCollection, options);
+    this.generateObjectTypeDefs(
+      dynamicObjectMetadataCollection,
+      options,
+      isNewRelationEnabled,
+    );
     this.generatePaginationTypeDefs(dynamicObjectMetadataCollection, options);
-    this.generateInputTypeDefs(dynamicObjectMetadataCollection, options);
+    this.generateInputTypeDefs(
+      dynamicObjectMetadataCollection,
+      options,
+      isNewRelationEnabled,
+    );
     await this.generateExtendedObjectTypeDefs(
       dynamicObjectMetadataCollection,
       options,
@@ -176,12 +190,14 @@ 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,
       ),
     );
 
@@ -209,6 +225,7 @@ export class TypeDefinitionsGenerator {
   private generateInputTypeDefs(
     objectMetadataCollection: ObjectMetadataInterface[],
     options: WorkspaceBuildSchemaOptions,
+    isNewRelationEnabled: boolean,
   ) {
     const inputTypeDefs = objectMetadataCollection
       .map((objectMetadata) => {
@@ -226,24 +243,28 @@ 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,
           ),
         ];
       })

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

@@ -8,11 +8,12 @@ import { FieldMetadataType } from 'twenty-shared/types';
 
 import { WorkspaceBuildSchemaOptions } from 'src/engine/api/graphql/workspace-schema-builder/interfaces/workspace-build-schema-optionts.interface';
 import { ObjectMetadataInterface } from 'src/engine/metadata-modules/field-metadata/interfaces/object-metadata.interface';
+import { RelationType } from 'src/engine/metadata-modules/field-metadata/interfaces/relation-type.interface';
 
 import { InputTypeDefinitionKind } from 'src/engine/api/graphql/workspace-schema-builder/factories/input-type-definition.factory';
 import { ObjectTypeDefinitionKind } from 'src/engine/api/graphql/workspace-schema-builder/factories/object-type-definition.factory';
 import { isCompositeFieldMetadataType } from 'src/engine/metadata-modules/field-metadata/utils/is-composite-field-metadata-type.util';
-import { isRelationFieldMetadataType } from 'src/engine/utils/is-relation-field-metadata-type.util';
+import { isFieldMetadataInterfaceOfType } from 'src/engine/utils/is-field-metadata-of-type.util';
 
 type TypeFactory<T extends InputTypeDefinitionKind | ObjectTypeDefinitionKind> =
   {
@@ -40,13 +41,21 @@ export const generateFields = <
   kind: T,
   options: WorkspaceBuildSchemaOptions,
   typeFactory: TypeFactory<T>,
+  isNewRelationEnabled = false,
 ): T extends InputTypeDefinitionKind
   ? GraphQLInputFieldConfigMap
   : GraphQLFieldConfigMap<any, any> => {
   const fields = {};
 
   for (const fieldMetadata of objectMetadata.fields) {
-    if (isRelationFieldMetadataType(fieldMetadata.type)) {
+    if (
+      isFieldMetadataInterfaceOfType(
+        fieldMetadata,
+        FieldMetadataType.RELATION,
+      ) &&
+      (fieldMetadata.settings?.relationType !== RelationType.MANY_TO_ONE ||
+        !isNewRelationEnabled)
+    ) {
       continue;
     }
 
@@ -80,6 +89,25 @@ export const generateFields = <
       typeFactoryOptions,
     );
 
+    if (
+      isFieldMetadataInterfaceOfType(
+        fieldMetadata,
+        FieldMetadataType.RELATION,
+      ) &&
+      fieldMetadata.settings?.relationType === RelationType.MANY_TO_ONE
+    ) {
+      const joinColumnName = fieldMetadata.settings?.joinColumnName;
+
+      if (!joinColumnName) {
+        throw new Error('Join column name is not defined');
+      }
+
+      fields[joinColumnName] = {
+        type,
+        description: fieldMetadata.description,
+      };
+    }
+
     fields[fieldMetadata.name] = {
       type,
       description: fieldMetadata.description,

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

@@ -25,11 +25,13 @@ 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.factory.ts

@@ -149,6 +149,8 @@ export class WorkspaceSchemaFactory {
         await this.workspaceGraphQLSchemaFactory.create(
           objectMetadataCollection,
           workspaceResolverBuilderMethodNames,
+          {},
+          isNewRelationEnabled,
         );
 
       usedScalarNames =

packages/twenty-server/src/engine/api/rest/core/query-builder/utils/__tests__/check-fields.utils.spec.ts

@@ -31,6 +31,7 @@ describe('checkFields', () => {
     ...objectMetadataItemMock,
     fieldsById,
     fieldsByName,
+    fieldsByJoinColumnName: {},
   };
 
   it('should check field types', () => {

packages/twenty-server/src/engine/api/rest/core/query-builder/utils/__tests__/get-field-type.utils.spec.ts

@@ -32,6 +32,7 @@ describe('getFieldType', () => {
     ...objectMetadataItemMock,
     fieldsById,
     fieldsByName,
+    fieldsByJoinColumnName: {},
   };
 
   it('should get field type', () => {

packages/twenty-server/src/engine/api/rest/core/query-builder/utils/__tests__/map-field-metadata-to-graphql-query.utils.spec.ts

@@ -61,6 +61,7 @@ describe('mapFieldMetadataToGraphqlQuery', () => {
     ...objectMetadataItemMock,
     fieldsById,
     fieldsByName,
+    fieldsByJoinColumnName: {},
   };
 
   const objectMetadataMapsMock: ObjectMetadataMaps = {

packages/twenty-server/src/engine/api/rest/core/query-builder/utils/filter-utils/__tests__/check-filter-enum-values.spec.ts

@@ -33,6 +33,7 @@ describe('checkFilterEnumValues', () => {
     ...objectMetadataItemMock,
     fieldsById,
     fieldsByName,
+    fieldsByJoinColumnName: {},
   };
 
   it('should check properly', () => {

packages/twenty-server/src/engine/api/rest/core/query-builder/utils/filter-utils/__tests__/parse-filter.utils.spec.ts

@@ -43,6 +43,7 @@ describe('parseFilter', () => {
     ...objectMetadataItemMock,
     fieldsById,
     fieldsByName,
+    fieldsByJoinColumnName: {},
   };
 
   it('should parse string filter test 1', () => {

packages/twenty-server/src/engine/core-modules/auth/token/services/access-token.service.ts

@@ -72,6 +72,7 @@ export class AccessTokenService {
         await this.twentyORMGlobalManager.getRepositoryForWorkspace<WorkspaceMemberWorkspaceEntity>(
           workspaceId,
           'workspaceMember',
+          false,
         );
 
       const workspaceMember = await workspaceMemberRepository.findOne({

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

@@ -62,6 +62,7 @@ export const mockObjectMetadataItemsWithFieldMaps: ObjectMetadataItemWithFieldMa
           workspaceId: '',
         },
       },
+      fieldsByJoinColumnName: {},
     },
     {
       id: '',
@@ -140,6 +141,7 @@ export const mockObjectMetadataItemsWithFieldMaps: ObjectMetadataItemWithFieldMa
           workspaceId: '',
         },
       },
+      fieldsByJoinColumnName: {},
     },
     {
       id: '',
@@ -218,6 +220,7 @@ export const mockObjectMetadataItemsWithFieldMaps: ObjectMetadataItemWithFieldMa
           workspaceId: '',
         },
       },
+      fieldsByJoinColumnName: {},
     },
     {
       id: '',
@@ -243,5 +246,6 @@ export const mockObjectMetadataItemsWithFieldMaps: ObjectMetadataItemWithFieldMa
       indexMetadatas: [],
       fieldsById: {},
       fieldsByName: {},
+      fieldsByJoinColumnName: {},
     },
   ];

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

@@ -74,6 +74,7 @@ export class SearchService {
 
     const queryParser = new GraphqlQueryParser(
       objectMetadataItem.fieldsByName,
+      objectMetadataItem.fieldsByJoinColumnName,
       generateObjectMetadataMaps([objectMetadataItem]),
       featureFlagMap,
     );

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

@@ -25,7 +25,10 @@ import { WorkspaceAuthGuard } from 'src/engine/guards/workspace-auth.guard';
 import { CreateOneFieldMetadataInput } from 'src/engine/metadata-modules/field-metadata/dtos/create-field.input';
 import { DeleteOneFieldInput } from 'src/engine/metadata-modules/field-metadata/dtos/delete-field.input';
 import { FieldMetadataDTO } from 'src/engine/metadata-modules/field-metadata/dtos/field-metadata.dto';
-import { RelationDefinitionDTO } from 'src/engine/metadata-modules/field-metadata/dtos/relation-definition.dto';
+import {
+  RelationDefinitionDTO,
+  RelationDefinitionType,
+} from 'src/engine/metadata-modules/field-metadata/dtos/relation-definition.dto';
 import { RelationDTO } from 'src/engine/metadata-modules/field-metadata/dtos/relation.dto';
 import {
   UpdateFieldInput,
@@ -42,6 +45,7 @@ import { fieldMetadataGraphqlApiExceptionHandler } from 'src/engine/metadata-mod
 import { SettingPermissionType } from 'src/engine/metadata-modules/permissions/constants/setting-permission-type.constants';
 import { PermissionsGraphqlApiExceptionFilter } from 'src/engine/metadata-modules/permissions/utils/permissions-graphql-api-exception.filter';
 import { isRelationFieldMetadataType } from 'src/engine/utils/is-relation-field-metadata-type.util';
+import { createDeterministicUuid } from 'src/engine/workspace-manager/workspace-sync-metadata/utils/create-deterministic-uuid.util';
 
 @UseGuards(WorkspaceAuthGuard)
 @Resolver(() => FieldMetadataDTO)
@@ -180,6 +184,37 @@ export class FieldMetadataResolver {
       return null;
     }
 
+    const isNewRelationEnabled = await this.featureFlagService.isFeatureEnabled(
+      FeatureFlagKey.IsNewRelationEnabled,
+      workspace.id,
+    );
+
+    // TODO: Remove this once we drop old relations or update the front-end to use the new relation
+    if (isNewRelationEnabled) {
+      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 {
       const relationMetadataItem =
         await context.loaders.relationMetadataLoader.load({

packages/twenty-server/src/engine/metadata-modules/field-metadata/interfaces/field-metadata-settings.interface.ts

@@ -42,7 +42,7 @@ export type FieldMetadataDateTimeSettings = {
 export type FieldMetadataRelationSettings = {
   relationType: RelationType;
   onDelete?: RelationOnDeleteAction;
-  joinColumnName?: string;
+  joinColumnName?: string | null;
 };
 
 type FieldMetadataSettingsMapping = {

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

@@ -19,6 +19,7 @@ import { IndexMetadataModule } from 'src/engine/metadata-modules/index-metadata/
 import { BeforeUpdateOneObject } from 'src/engine/metadata-modules/object-metadata/hooks/before-update-one-object.hook';
 import { ObjectMetadataGraphqlApiExceptionInterceptor } from 'src/engine/metadata-modules/object-metadata/interceptors/object-metadata-graphql-api-exception.interceptor';
 import { ObjectMetadataResolver } from 'src/engine/metadata-modules/object-metadata/object-metadata.resolver';
+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';
@@ -63,6 +64,7 @@ import { UpdateObjectPayload } from './dtos/update-object.input';
         ObjectMetadataService,
         ObjectMetadataMigrationService,
         ObjectMetadataRelationService,
+        ObjectMetadataFieldRelationService,
         ObjectMetadataRelatedRecordsService,
       ],
       resolvers: [

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

@@ -10,6 +10,8 @@ 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';
@@ -24,6 +26,7 @@ import {
   ObjectMetadataException,
   ObjectMetadataExceptionCode,
 } from 'src/engine/metadata-modules/object-metadata/object-metadata.exception';
+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';
@@ -61,9 +64,11 @@ export class ObjectMetadataService extends TypeOrmQueryService<ObjectMetadataEnt
     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 featureFlagService: FeatureFlagService,
   ) {
     super(objectMetadataRepository);
   }
@@ -181,17 +186,33 @@ export class ObjectMetadataService extends TypeOrmQueryService<ObjectMetadataEnt
         createdObjectMetadata.fields,
       );
 
-      const createdRelatedObjectMetadataCollection =
-        await this.objectMetadataRelationService.createRelationsAndForeignKeysMetadata(
+      const isNewRelationEnabled =
+        await this.featureFlagService.isFeatureEnabled(
+          FeatureFlagKey.IsNewRelationEnabled,
           objectMetadataInput.workspaceId,
-          createdObjectMetadata,
-          {
-            primaryKeyFieldMetadataSettings:
-              objectMetadataInput.primaryKeyFieldMetadataSettings,
-            primaryKeyColumnType: objectMetadataInput.primaryKeyColumnType,
-          },
         );
 
+      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,
@@ -295,11 +316,19 @@ export class ObjectMetadataService extends TypeOrmQueryService<ObjectMetadataEnt
       inputPayload,
     );
 
+    const isNewRelationEnabled = await this.featureFlagService.isFeatureEnabled(
+      FeatureFlagKey.IsNewRelationEnabled,
+      workspaceId,
+    );
+
     if (inputPayload.isActive !== undefined) {
-      await this.objectMetadataRelationService.updateObjectRelationshipsActivationStatus(
-        inputId,
-        inputPayload.isActive,
-      );
+      // 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(
@@ -342,8 +371,17 @@ 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',
+        'fields.object',
+        'fields.relationTargetFieldMetadata',
+        'fields.relationTargetFieldMetadata.object',
         'fromRelations.fromFieldMetadata',
         'fromRelations.toFieldMetadata',
         'toRelations.fromFieldMetadata',
@@ -375,6 +413,7 @@ export class ObjectMetadataService extends TypeOrmQueryService<ObjectMetadataEnt
       await this.objectMetadataMigrationService.deleteAllRelationsAndDropTable(
         objectMetadata,
         workspaceId,
+        isNewRelationEnabled,
       );
     }
 
@@ -387,6 +426,15 @@ export class ObjectMetadataService extends TypeOrmQueryService<ObjectMetadataEnt
       workspaceId,
     );
 
+    const fieldMetadataIds = objectMetadata.fields.map((field) => field.id);
+    const relationMetadataIds = objectMetadata.fields
+      .map((field) => field.relationTargetFieldMetadata?.id)
+      .filter(isDefined);
+
+    await this.fieldMetadataRepository.delete({
+      id: In(fieldMetadataIds.concat(relationMetadataIds)),
+    });
+
     await this.objectMetadataRepository.delete(objectMetadata.id);
 
     await this.workspaceMetadataVersionService.incrementMetadataVersion(
@@ -478,6 +526,11 @@ export class ObjectMetadataService extends TypeOrmQueryService<ObjectMetadataEnt
     objectMetadataForUpdate: ObjectMetadataEntity,
     inputPayload: UpdateObjectPayload,
   ) {
+    const isNewRelationEnabled = await this.featureFlagService.isFeatureEnabled(
+      FeatureFlagKey.IsNewRelationEnabled,
+      objectMetadataForUpdate.workspaceId,
+    );
+
     const newTargetTableName = computeObjectTargetTable(
       objectMetadataForUpdate,
     );
@@ -492,18 +545,33 @@ export class ObjectMetadataService extends TypeOrmQueryService<ObjectMetadataEnt
         objectMetadataForUpdate.workspaceId,
       );
 
-      const relationsAndForeignKeysMetadata =
-        await this.objectMetadataRelationService.updateRelationsAndForeignKeysMetadata(
-          objectMetadataForUpdate.workspaceId,
-          objectMetadataForUpdate,
-        );
+      if (isNewRelationEnabled) {
+        const relationMetadataCollection =
+          await this.objectMetadataFieldRelationService.updateRelationsAndForeignKeysMetadata(
+            objectMetadataForUpdate.workspaceId,
+            objectMetadataForUpdate,
+          );
 
-      await this.objectMetadataMigrationService.createUpdateForeignKeysMigrations(
-        existingObjectMetadata,
-        objectMetadataForUpdate,
-        relationsAndForeignKeysMetadata,
-        objectMetadataForUpdate.workspaceId,
-      );
+        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.recomputeEnumNames(
         objectMetadataForUpdate,

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

@@ -0,0 +1,311 @@
+import { Injectable } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+
+import { FieldMetadataType } from 'twenty-shared/types';
+import { capitalize } from 'twenty-shared/utils';
+import { Repository } from 'typeorm';
+import { v4 as uuidV4 } from 'uuid';
+
+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 { 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 { RelationOnDeleteAction } from 'src/engine/metadata-modules/relation-metadata/relation-metadata.entity';
+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 { 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 ObjectMetadataFieldRelationService {
+  constructor(
+    @InjectRepository(ObjectMetadataEntity, 'metadata')
+    private readonly objectMetadataRepository: Repository<ObjectMetadataEntity>,
+    @InjectRepository(FieldMetadataEntity, 'metadata')
+    private readonly fieldMetadataRepository: Repository<FieldMetadataEntity>,
+  ) {}
+
+  public async createRelationsAndForeignKeysMetadata(
+    workspaceId: string,
+    sourceObjectMetadata: ObjectMetadataEntity,
+  ) {
+    const relatedObjectMetadataCollection = await Promise.all(
+      DEFAULT_RELATIONS_OBJECTS_STANDARD_IDS.map(
+        async (relationObjectMetadataStandardId) =>
+          this.createRelationAndForeignKeyMetadata(
+            workspaceId,
+            sourceObjectMetadata,
+            relationObjectMetadataStandardId,
+          ),
+      ),
+    );
+
+    return relatedObjectMetadataCollection;
+  }
+
+  private async createRelationAndForeignKeyMetadata(
+    workspaceId: string,
+    sourceObjectMetadata: ObjectMetadataEntity,
+    relationObjectMetadataStandardId: string,
+  ) {
+    const targetObjectMetadata =
+      await this.objectMetadataRepository.findOneByOrFail({
+        standardId: relationObjectMetadataStandardId,
+        workspaceId: workspaceId,
+        isCustom: false,
+      });
+
+    await this.createFieldMetadataRelation(
+      workspaceId,
+      sourceObjectMetadata,
+      targetObjectMetadata,
+    );
+
+    return targetObjectMetadata;
+  }
+
+  private async createFieldMetadataRelation(
+    workspaceId: string,
+    sourceObjectMetadata: ObjectMetadataEntity,
+    targetObjectMetadata: ObjectMetadataEntity,
+  ): Promise<FieldMetadataEntity<FieldMetadataType.RELATION>[]> {
+    const sourceFieldMetadata = this.createSourceFieldMetadata(
+      workspaceId,
+      sourceObjectMetadata,
+      targetObjectMetadata,
+    );
+
+    const targetFieldMetadata = this.createTargetFieldMetadata(
+      workspaceId,
+      sourceObjectMetadata,
+      targetObjectMetadata,
+    );
+
+    return this.fieldMetadataRepository.save([
+      {
+        ...sourceFieldMetadata,
+        settings: {
+          relationType: RelationType.ONE_TO_MANY,
+          onDelete: RelationOnDeleteAction.CASCADE,
+        },
+        relationTargetObjectMetadataId: targetObjectMetadata.id,
+        relationTargetFieldMetadataId: targetFieldMetadata.id,
+      } as Partial<FieldMetadataEntity<FieldMetadataType.RELATION>>,
+      {
+        ...targetFieldMetadata,
+        settings: {
+          relationType: RelationType.MANY_TO_ONE,
+          onDelete: RelationOnDeleteAction.CASCADE,
+          joinColumnName: `${sourceObjectMetadata.nameSingular}Id`,
+        },
+        relationTargetObjectMetadataId: sourceObjectMetadata.id,
+        relationTargetFieldMetadataId: sourceFieldMetadata.id,
+      } as Partial<FieldMetadataEntity<FieldMetadataType.RELATION>>,
+    ]);
+  }
+
+  public async updateRelationsAndForeignKeysMetadata(
+    workspaceId: string,
+    updatedObjectMetadata: ObjectMetadataEntity,
+  ): Promise<
+    {
+      targetObjectMetadata: ObjectMetadataEntity;
+      targetFieldMetadata: FieldMetadataEntity;
+      sourceFieldMetadata: FieldMetadataEntity;
+    }[]
+  > {
+    return await Promise.all(
+      DEFAULT_RELATIONS_OBJECTS_STANDARD_IDS.map(
+        async (relationObjectMetadataStandardId) =>
+          this.updateRelationAndForeignKeyMetadata(
+            workspaceId,
+            updatedObjectMetadata,
+            relationObjectMetadataStandardId,
+          ),
+      ),
+    );
+  }
+
+  private async updateRelationAndForeignKeyMetadata(
+    workspaceId: string,
+    sourceObjectMetadata: ObjectMetadataEntity,
+    targetObjectMetadataStandardId: string,
+  ) {
+    const targetObjectMetadata =
+      await this.objectMetadataRepository.findOneByOrFail({
+        standardId: targetObjectMetadataStandardId,
+        workspaceId: workspaceId,
+        isCustom: false,
+      });
+
+    const targetFieldMetadataUpdateData = this.updateTargetFieldMetadata(
+      sourceObjectMetadata,
+      targetObjectMetadata,
+    );
+    const targetFieldMetadataToUpdate =
+      await this.fieldMetadataRepository.findOneByOrFail({
+        standardId: createRelationDeterministicUuid({
+          objectId: sourceObjectMetadata.id,
+          standardId:
+            STANDARD_OBJECT_FIELD_IDS[targetObjectMetadata.nameSingular].custom,
+        }),
+        objectMetadataId: targetObjectMetadata.id,
+        workspaceId: workspaceId,
+      });
+    const targetFieldMetadata = await this.fieldMetadataRepository.save({
+      id: targetFieldMetadataToUpdate.id,
+      ...targetFieldMetadataUpdateData,
+    });
+
+    const sourceFieldMetadataUpdateData = this.updateSourceFieldMetadata(
+      sourceObjectMetadata,
+      targetObjectMetadata,
+    );
+    const sourceFieldMetadataToUpdate =
+      await this.fieldMetadataRepository.findOneByOrFail({
+        standardId:
+          CUSTOM_OBJECT_STANDARD_FIELD_IDS[targetObjectMetadata.namePlural],
+        objectMetadataId: sourceObjectMetadata.id,
+        workspaceId: workspaceId,
+      });
+    const sourceFieldMetadata = await this.fieldMetadataRepository.save({
+      id: sourceFieldMetadataToUpdate.id,
+      ...sourceFieldMetadataUpdateData,
+    });
+
+    return {
+      targetObjectMetadata,
+      targetFieldMetadata,
+      sourceFieldMetadata,
+    };
+  }
+
+  private createSourceFieldMetadata(
+    workspaceId: string,
+    sourceObjectMetadata: ObjectMetadataEntity,
+    targetObjectMetadata: ObjectMetadataEntity,
+  ): Partial<FieldMetadataEntity<FieldMetadataType.RELATION>> {
+    const relationObjectMetadataNamePlural = targetObjectMetadata.namePlural;
+
+    const { description } = buildDescriptionForRelationFieldMetadataOnFromField(
+      {
+        relationObjectMetadataNamePlural,
+        targetObjectLabelSingular: sourceObjectMetadata.labelSingular,
+      },
+    );
+
+    return {
+      id: uuidV4(),
+      standardId:
+        CUSTOM_OBJECT_STANDARD_FIELD_IDS[relationObjectMetadataNamePlural],
+      objectMetadataId: sourceObjectMetadata.id,
+      workspaceId: workspaceId,
+      isCustom: false,
+      isActive: true,
+      isSystem: true,
+      type: FieldMetadataType.RELATION,
+      name: targetObjectMetadata.namePlural,
+      label: capitalize(relationObjectMetadataNamePlural),
+      description,
+      icon:
+        STANDARD_OBJECT_ICONS[targetObjectMetadata.nameSingular] ||
+        'IconBuildingSkyscraper',
+      isNullable: true,
+    };
+  }
+
+  private updateSourceFieldMetadata(
+    sourceObjectMetadata: ObjectMetadataEntity,
+    targetObjectMetadata: ObjectMetadataEntity,
+  ) {
+    const relationObjectMetadataNamePlural = targetObjectMetadata.namePlural;
+
+    const { description } = buildDescriptionForRelationFieldMetadataOnFromField(
+      {
+        relationObjectMetadataNamePlural,
+        targetObjectLabelSingular: sourceObjectMetadata.labelSingular,
+      },
+    );
+
+    return {
+      description,
+    };
+  }
+
+  private createTargetFieldMetadata(
+    workspaceId: string,
+    sourceObjectMetadata: ObjectMetadataEntity,
+    targetObjectMetadata: ObjectMetadataEntity,
+  ): Partial<FieldMetadataEntity<FieldMetadataType.RELATION>> {
+    const customStandardFieldId =
+      STANDARD_OBJECT_FIELD_IDS[targetObjectMetadata.nameSingular].custom;
+
+    if (!customStandardFieldId) {
+      throw new Error(
+        `Custom standard field ID not found for ${targetObjectMetadata.nameSingular}`,
+      );
+    }
+
+    const { description } = buildDescriptionForRelationFieldMetadataOnToField({
+      relationObjectMetadataNamePlural: targetObjectMetadata.namePlural,
+      targetObjectLabelSingular: sourceObjectMetadata.labelSingular,
+    });
+
+    return {
+      id: uuidV4(),
+      name: sourceObjectMetadata.nameSingular,
+      label: sourceObjectMetadata.labelSingular,
+      description,
+      standardId: createRelationDeterministicUuid({
+        objectId: sourceObjectMetadata.id,
+        standardId: customStandardFieldId,
+      }),
+      objectMetadataId: targetObjectMetadata.id,
+      workspaceId: workspaceId,
+      isCustom: false,
+      isActive: true,
+      isSystem: true,
+      type: FieldMetadataType.RELATION,
+      icon: 'IconBuildingSkyscraper',
+      isNullable: true,
+    };
+  }
+
+  private updateTargetFieldMetadata(
+    sourceObjectMetadata: ObjectMetadataEntity,
+    targetObjectMetadata: ObjectMetadataEntity,
+  ) {
+    const customStandardFieldId =
+      STANDARD_OBJECT_FIELD_IDS[targetObjectMetadata.nameSingular].custom;
+
+    if (!customStandardFieldId) {
+      throw new Error(
+        `Custom standard field ID not found for ${targetObjectMetadata.nameSingular}`,
+      );
+    }
+
+    const { description } = buildDescriptionForRelationFieldMetadataOnToField({
+      relationObjectMetadataNamePlural: targetObjectMetadata.namePlural,
+      targetObjectLabelSingular: sourceObjectMetadata.labelSingular,
+    });
+
+    return {
+      name: sourceObjectMetadata.nameSingular,
+      label: sourceObjectMetadata.labelSingular,
+      description,
+    };
+  }
+}

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

@@ -1,8 +1,10 @@
 import { Injectable } from '@nestjs/common';
 import { InjectRepository } from '@nestjs/typeorm';
 
-import { In, Repository } from 'typeorm';
 import { FieldMetadataType } from 'twenty-shared/types';
+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';
@@ -22,6 +24,7 @@ import { WorkspaceMigrationFactory } from 'src/engine/metadata-modules/workspace
 import { WorkspaceMigrationService } from 'src/engine/metadata-modules/workspace-migration/workspace-migration.service';
 import { computeObjectTargetTable } from 'src/engine/utils/compute-object-target-table.util';
 import { computeTableName } from 'src/engine/utils/compute-table-name.util';
+import { isFieldMetadataInterfaceOfType } from 'src/engine/utils/is-field-metadata-of-type.util';
 import { RELATION_MIGRATION_PRIORITY_PREFIX } from 'src/engine/workspace-manager/workspace-migration-runner/workspace-migration-runner.service';
 
 @Injectable()
@@ -117,6 +120,52 @@ export class ObjectMetadataMigrationService {
     );
   }
 
+  public async updateRelationMigrations(
+    currentObjectMetadata: ObjectMetadataEntity,
+    alteredObjectMetadata: ObjectMetadataEntity,
+    relationMetadataCollection: {
+      targetObjectMetadata: ObjectMetadataEntity;
+      targetFieldMetadata: FieldMetadataEntity;
+      sourceFieldMetadata: FieldMetadataEntity;
+    }[],
+    workspaceId: string,
+  ) {
+    for (const { targetObjectMetadata } of relationMetadataCollection) {
+      const targetTableName = computeObjectTargetTable(targetObjectMetadata);
+      const columnName = `${currentObjectMetadata.nameSingular}Id`;
+
+      await this.workspaceMigrationService.createCustomMigration(
+        generateMigrationName(
+          `rename-${currentObjectMetadata.nameSingular}-to-${alteredObjectMetadata.nameSingular}-in-${targetObjectMetadata.nameSingular}`,
+        ),
+        workspaceId,
+        [
+          {
+            name: targetTableName,
+            action: WorkspaceMigrationTableActionType.ALTER,
+            columns: [
+              {
+                action: WorkspaceMigrationColumnActionType.ALTER,
+                currentColumnDefinition: {
+                  columnName,
+                  columnType: 'uuid',
+                  isNullable: true,
+                  defaultValue: null,
+                },
+                alteredColumnDefinition: {
+                  columnName: `${alteredObjectMetadata.nameSingular}Id`,
+                  columnType: 'uuid',
+                  isNullable: true,
+                  defaultValue: null,
+                },
+              },
+            ],
+          },
+        ],
+      );
+    }
+  }
+
   public async createUpdateForeignKeysMigrations(
     existingObjectMetadata: ObjectMetadataEntity,
     updatedObjectMetadata: ObjectMetadataEntity,
@@ -173,15 +222,16 @@ export class ObjectMetadataMigrationService {
   public async deleteAllRelationsAndDropTable(
     objectMetadata: ObjectMetadataEntity,
     workspaceId: string,
+    isNewRelationEnabled: boolean,
   ) {
-    const relationsToDelete: RelationToDelete[] = [];
+    const relationsMetadataToDelete: RelationToDelete[] = [];
 
     // TODO: Most of this logic should be moved to relation-metadata.service.ts
     for (const relation of [
       ...objectMetadata.fromRelations,
       ...objectMetadata.toRelations,
     ]) {
-      relationsToDelete.push({
+      relationsMetadataToDelete.push({
         id: relation.id,
         fromFieldMetadataId: relation.fromFieldMetadata.id,
         toFieldMetadataId: relation.toFieldMetadata.id,
@@ -201,13 +251,13 @@ export class ObjectMetadataMigrationService {
       });
     }
 
-    if (relationsToDelete.length > 0) {
+    if (relationsMetadataToDelete.length > 0) {
       await this.relationMetadataRepository.delete(
-        relationsToDelete.map((relation) => relation.id),
+        relationsMetadataToDelete.map((relation) => relation.id),
       );
     }
 
-    for (const relationToDelete of relationsToDelete) {
+    for (const relationToDelete of relationsMetadataToDelete) {
       const foreignKeyFieldsToDelete = await this.fieldMetadataRepository.find({
         where: {
           name: `${relationToDelete.toFieldMetadataName}Id`,
@@ -254,6 +304,61 @@ export class ObjectMetadataMigrationService {
       }
     }
 
+    if (isNewRelationEnabled) {
+      const manyToOneRelationFieldsToDelete = objectMetadata.fields.filter(
+        (field) =>
+          isFieldMetadataInterfaceOfType(field, FieldMetadataType.RELATION) &&
+          (field as FieldMetadataEntity<FieldMetadataType.RELATION>).settings
+            ?.relationType === RelationType.MANY_TO_ONE,
+      ) as FieldMetadataEntity<FieldMetadataType.RELATION>[];
+
+      const oneToManyRelationFieldsToDelete = objectMetadata.fields.filter(
+        (field) =>
+          isFieldMetadataInterfaceOfType(field, FieldMetadataType.RELATION) &&
+          (field as FieldMetadataEntity<FieldMetadataType.RELATION>).settings
+            ?.relationType === RelationType.ONE_TO_MANY,
+      );
+
+      const relationFieldsToDelete = [
+        ...manyToOneRelationFieldsToDelete,
+        ...(oneToManyRelationFieldsToDelete.map(
+          (field) => field.relationTargetFieldMetadata,
+        ) as FieldMetadataEntity<FieldMetadataType.RELATION>[]),
+      ];
+
+      for (const relationFieldToDelete of relationFieldsToDelete) {
+        const joinColumnName = relationFieldToDelete.settings?.joinColumnName;
+
+        if (!joinColumnName) {
+          throw new Error(
+            `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,
+              ],
+            },
+          ],
+        );
+      }
+    }
+
     // DROP TABLE
     await this.workspaceMigrationService.createCustomMigration(
       generateMigrationName(`delete-${objectMetadata.nameSingular}`),

packages/twenty-server/src/engine/metadata-modules/object-metadata/utils/build-migrations-for-custom-object-relations.util.ts

@@ -23,6 +23,7 @@ export const buildMigrationsForCustomObjectRelations = (
         columns: [
           {
             action: WorkspaceMigrationColumnActionType.CREATE,
+            // TODO: When we get rid of this and use the sync metadata, columnName must be based on the joinColumnName from the field metadata settings
             columnName: computeColumnName(createdObjectMetadata.nameSingular, {
               isForeignKey: true,
             }),
@@ -38,6 +39,7 @@ export const buildMigrationsForCustomObjectRelations = (
         columns: [
           {
             action: WorkspaceMigrationColumnActionType.CREATE_FOREIGN_KEY,
+            // TODO: When we get rid of this and use the sync metadata, columnName must be based on the joinColumnName from the field metadata settings
             columnName: computeColumnName(createdObjectMetadata.nameSingular, {
               isForeignKey: true,
             }),

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

@@ -3,13 +3,17 @@ import { InjectRepository } from '@nestjs/typeorm';
 
 import { TypeOrmQueryService } from '@ptc-org/nestjs-query-typeorm';
 import camelCase from 'lodash.camelcase';
-import { FindOneOptions, In, Repository } from 'typeorm';
-import { v4 as uuidV4 } from 'uuid';
 import { FieldMetadataType } from 'twenty-shared/types';
 import { isDefined } from 'twenty-shared/utils';
+import { FindOneOptions, In, Repository } from 'typeorm';
+import { v4 as uuidV4 } from 'uuid';
 
+import { FieldMetadataDefaultSettings } from 'src/engine/metadata-modules/field-metadata/interfaces/field-metadata-settings.interface';
 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';
@@ -20,6 +24,7 @@ import {
   RelationMetadataException,
   RelationMetadataExceptionCode,
 } from 'src/engine/metadata-modules/relation-metadata/relation-metadata.exception';
+import { InvalidMetadataNameException } from 'src/engine/metadata-modules/utils/exceptions/invalid-metadata-name.exception';
 import { validateFieldNameAvailabilityOrThrow } from 'src/engine/metadata-modules/utils/validate-field-name-availability.utils';
 import { validateMetadataNameOrThrow } from 'src/engine/metadata-modules/utils/validate-metadata-name.utils';
 import { WorkspaceMetadataVersionService } from 'src/engine/metadata-modules/workspace-metadata-version/services/workspace-metadata-version.service';
@@ -34,7 +39,6 @@ import { computeObjectTargetTable } from 'src/engine/utils/compute-object-target
 import { WorkspaceCacheStorageService } from 'src/engine/workspace-cache-storage/workspace-cache-storage.service';
 import { WorkspaceMigrationRunnerService } from 'src/engine/workspace-manager/workspace-migration-runner/workspace-migration-runner.service';
 import { BASE_OBJECT_STANDARD_FIELD_IDS } from 'src/engine/workspace-manager/workspace-sync-metadata/constants/standard-field-ids';
-import { InvalidMetadataNameException } from 'src/engine/metadata-modules/utils/exceptions/invalid-metadata-name.exception';
 
 import {
   RelationMetadataEntity,
@@ -56,6 +60,7 @@ export class RelationMetadataService extends TypeOrmQueryService<RelationMetadat
     private readonly workspaceMetadataVersionService: WorkspaceMetadataVersionService,
     private readonly indexMetadataService: IndexMetadataService,
     private readonly workspaceCacheStorageService: WorkspaceCacheStorageService,
+    private readonly featureFlagService: FeatureFlagService,
   ) {
     super(relationMetadataRepository);
   }
@@ -67,6 +72,11 @@ export class RelationMetadataService extends TypeOrmQueryService<RelationMetadat
       relationMetadataInput,
     );
 
+    const isNewRelationEnabled = await this.featureFlagService.isFeatureEnabled(
+      FeatureFlagKey.IsNewRelationEnabled,
+      relationMetadataInput.workspaceId,
+    );
+
     try {
       validateMetadataNameOrThrow(relationMetadataInput.fromName);
       validateMetadataNameOrThrow(relationMetadataInput.toName);
@@ -92,21 +102,31 @@ export class RelationMetadataService extends TypeOrmQueryService<RelationMetadat
     const toId = uuidV4();
 
     const createdRelationFieldsMetadata =
-      await this.fieldMetadataRepository.save([
-        this.createFieldMetadataForRelationMetadata(
-          relationMetadataInput,
-          'from',
-          isCustom,
-          fromId,
-        ),
-        this.createFieldMetadataForRelationMetadata(
-          relationMetadataInput,
-          'to',
-          isCustom,
-          toId,
-        ),
-        this.createForeignKeyFieldMetadata(relationMetadataInput, columnName),
-      ]);
+      await this.fieldMetadataRepository.save(
+        [
+          this.createFieldMetadataForRelationMetadata(
+            relationMetadataInput,
+            'from',
+            isCustom,
+            fromId,
+          ),
+          this.createFieldMetadataForRelationMetadata(
+            relationMetadataInput,
+            'to',
+            isCustom,
+            toId,
+          ),
+          // We don't want to create the join column field metadata for new relation
+          ...(isNewRelationEnabled
+            ? []
+            : [
+                this.createForeignKeyFieldMetadata(
+                  relationMetadataInput,
+                  columnName,
+                ),
+              ]),
+        ].flat(),
+      );
 
     const createdRelationMetadata = await super.createOne({
       ...relationMetadataInput,
@@ -114,6 +134,46 @@ export class RelationMetadataService extends TypeOrmQueryService<RelationMetadat
       toFieldMetadataId: toId,
     });
 
+    const fromFieldMetadata = createdRelationFieldsMetadata.find(
+      (fieldMetadata) => fieldMetadata.id === fromId,
+    );
+
+    if (!fromFieldMetadata) {
+      throw new RelationMetadataException(
+        `From field metadata not found`,
+        RelationMetadataExceptionCode.RELATION_METADATA_NOT_FOUND,
+      );
+    }
+
+    const toFieldMetadata = createdRelationFieldsMetadata.find(
+      (fieldMetadata) => fieldMetadata.id === toId,
+    );
+
+    if (!toFieldMetadata) {
+      throw new RelationMetadataException(
+        `To field metadata not found`,
+        RelationMetadataExceptionCode.RELATION_METADATA_NOT_FOUND,
+      );
+    }
+
+    await this.fieldMetadataRepository.update(fromId, {
+      settings: {
+        relationType: RelationType.ONE_TO_MANY,
+      } as Partial<FieldMetadataDefaultSettings>,
+      relationTargetFieldMetadataId: toId,
+      relationTargetObjectMetadataId: relationMetadataInput.toObjectMetadataId,
+    });
+
+    await this.fieldMetadataRepository.update(toId, {
+      settings: {
+        relationType: RelationType.MANY_TO_ONE,
+        joinColumnName: `${relationMetadataInput.toName}Id`,
+      } as Partial<FieldMetadataDefaultSettings>,
+      relationTargetFieldMetadataId: fromId,
+      relationTargetObjectMetadataId:
+        relationMetadataInput.fromObjectMetadataId,
+    });
+
     await this.createWorkspaceCustomMigration(
       relationMetadataInput,
       objectMetadataMap,
@@ -123,17 +183,6 @@ export class RelationMetadataService extends TypeOrmQueryService<RelationMetadat
     const toObjectMetadata =
       objectMetadataMap[relationMetadataInput.toObjectMetadataId];
 
-    const foreignKeyFieldMetadata = createdRelationFieldsMetadata.find(
-      (fieldMetadata) => fieldMetadata.type === FieldMetadataType.UUID,
-    );
-
-    if (!foreignKeyFieldMetadata) {
-      throw new RelationMetadataException(
-        `ForeignKey field metadata not found`,
-        RelationMetadataExceptionCode.RELATION_METADATA_NOT_FOUND,
-      );
-    }
-
     const deletedAtFieldMetadata = toObjectMetadata.fields.find(
       (fieldMetadata) =>
         fieldMetadata.standardId === BASE_OBJECT_STANDARD_FIELD_IDS.deletedAt,
@@ -141,16 +190,29 @@ export class RelationMetadataService extends TypeOrmQueryService<RelationMetadat
 
     this.throwIfDeletedAtFieldMetadataNotFound(deletedAtFieldMetadata);
 
-    await this.indexMetadataService.createIndexMetadata(
-      relationMetadataInput.workspaceId,
-      toObjectMetadata,
-      [
-        foreignKeyFieldMetadata,
-        deletedAtFieldMetadata as FieldMetadataEntity<FieldMetadataType>,
-      ],
-      false,
-      false,
-    );
+    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/metadata-modules/types/object-metadata-item-with-field-maps.ts

@@ -5,4 +5,5 @@ import { FieldMetadataMap } from 'src/engine/metadata-modules/types/field-metada
 export type ObjectMetadataItemWithFieldMaps = ObjectMetadataInterface & {
   fieldsById: FieldMetadataMap;
   fieldsByName: FieldMetadataMap;
+  fieldsByJoinColumnName: FieldMetadataMap;
 };

packages/twenty-server/src/engine/metadata-modules/utils/generate-object-metadata-maps.util.ts

@@ -1,8 +1,11 @@
+import { FieldMetadataType } from 'twenty-shared/types';
+
 import { ObjectMetadataInterface } from 'src/engine/metadata-modules/field-metadata/interfaces/object-metadata.interface';
 
 import { FieldMetadataMap } from 'src/engine/metadata-modules/types/field-metadata-map';
 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 { isFieldMetadataInterfaceOfType } from 'src/engine/utils/is-field-metadata-of-type.util';
 
 export const generateObjectMetadataMaps = (
   objectMetadataCollection: ObjectMetadataInterface[],
@@ -15,8 +18,21 @@ export const generateObjectMetadataMaps = (
   for (const objectMetadata of objectMetadataCollection) {
     const fieldsByIdMap: FieldMetadataMap = {};
     const fieldsByNameMap: FieldMetadataMap = {};
+    const fieldsByJoinColumnNameMap: FieldMetadataMap = {};
 
     for (const fieldMetadata of objectMetadata.fields) {
+      if (
+        isFieldMetadataInterfaceOfType(
+          fieldMetadata,
+          FieldMetadataType.RELATION,
+        )
+      ) {
+        if (fieldMetadata.settings?.joinColumnName) {
+          fieldsByJoinColumnNameMap[fieldMetadata.settings.joinColumnName] =
+            fieldMetadata;
+        }
+      }
+
       fieldsByNameMap[fieldMetadata.name] = fieldMetadata;
       fieldsByIdMap[fieldMetadata.id] = fieldMetadata;
     }
@@ -25,6 +41,7 @@ export const generateObjectMetadataMaps = (
       ...objectMetadata,
       fieldsById: fieldsByIdMap,
       fieldsByName: fieldsByNameMap,
+      fieldsByJoinColumnName: fieldsByJoinColumnNameMap,
     };
 
     objectMetadataMaps.byId[objectMetadata.id] = processedObjectMetadata;

packages/twenty-server/src/engine/metadata-modules/workspace-migration/factories/factories.ts

@@ -1,6 +1,7 @@
 import { BasicColumnActionFactory } from 'src/engine/metadata-modules/workspace-migration/factories/basic-column-action.factory';
 import { CompositeColumnActionFactory } from 'src/engine/metadata-modules/workspace-migration/factories/composite-column-action.factory';
 import { EnumColumnActionFactory } from 'src/engine/metadata-modules/workspace-migration/factories/enum-column-action.factory';
+import { RelationColumnActionFactory } from 'src/engine/metadata-modules/workspace-migration/factories/relation-column-action.factory';
 import { TsVectorColumnActionFactory } from 'src/engine/metadata-modules/workspace-migration/factories/ts-vector-column-action.factory';
 
 export const workspaceColumnActionFactories = [
@@ -8,4 +9,5 @@ export const workspaceColumnActionFactories = [
   BasicColumnActionFactory,
   EnumColumnActionFactory,
   CompositeColumnActionFactory,
+  RelationColumnActionFactory,
 ];

packages/twenty-server/src/engine/metadata-modules/workspace-migration/factories/relation-column-action.factory.ts

@@ -0,0 +1,97 @@
+import { Injectable, Logger } from '@nestjs/common';
+
+import { FieldMetadataType } from 'twenty-shared/types';
+
+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 { WorkspaceColumnActionOptions } from 'src/engine/metadata-modules/workspace-migration/interfaces/workspace-column-action-options.interface';
+
+import { ColumnActionAbstractFactory } from 'src/engine/metadata-modules/workspace-migration/factories/column-action-abstract.factory';
+import { fieldMetadataTypeToColumnType } from 'src/engine/metadata-modules/workspace-migration/utils/field-metadata-type-to-column-type.util';
+import {
+  WorkspaceMigrationColumnActionType,
+  WorkspaceMigrationColumnAlter,
+  WorkspaceMigrationColumnCreate,
+} from 'src/engine/metadata-modules/workspace-migration/workspace-migration.entity';
+import {
+  WorkspaceMigrationException,
+  WorkspaceMigrationExceptionCode,
+} from 'src/engine/metadata-modules/workspace-migration/workspace-migration.exception';
+
+@Injectable()
+export class RelationColumnActionFactory extends ColumnActionAbstractFactory<FieldMetadataType.RELATION> {
+  protected readonly logger = new Logger(RelationColumnActionFactory.name);
+
+  protected handleCreateAction(
+    fieldMetadata: FieldMetadataInterface<FieldMetadataType.RELATION>,
+    _options?: WorkspaceColumnActionOptions,
+  ): WorkspaceMigrationColumnCreate[] {
+    if (!fieldMetadata.settings || !fieldMetadata.settings.joinColumnName) {
+      return [];
+    }
+
+    const joinColumnName = fieldMetadata.settings.joinColumnName;
+
+    return [
+      {
+        action: WorkspaceMigrationColumnActionType.CREATE,
+        columnName: joinColumnName,
+        columnType: fieldMetadataTypeToColumnType(FieldMetadataType.UUID),
+        isArray: false,
+        isNullable: fieldMetadata.isNullable ?? true,
+        isUnique:
+          fieldMetadata.settings.relationType === RelationType.ONE_TO_ONE,
+        defaultValue: null,
+      },
+    ];
+  }
+
+  protected handleAlterAction(
+    currentFieldMetadata: FieldMetadataInterface<FieldMetadataType.RELATION>,
+    alteredFieldMetadata: FieldMetadataInterface<FieldMetadataType.RELATION>,
+    _options?: WorkspaceColumnActionOptions,
+  ): WorkspaceMigrationColumnAlter[] {
+    if (!currentFieldMetadata.settings || !alteredFieldMetadata.settings) {
+      return [];
+    }
+
+    const currentJoinColumnName = currentFieldMetadata.settings.joinColumnName;
+    const alteredJoinColumnName = alteredFieldMetadata.settings.joinColumnName;
+
+    if (!currentJoinColumnName || !alteredJoinColumnName) {
+      this.logger.error(
+        `Column name not found for current or altered field metadata, can be due to a missing or an invalid target column map. Current column name: ${currentJoinColumnName}, Altered column name: ${alteredJoinColumnName}.`,
+      );
+      throw new WorkspaceMigrationException(
+        `Column name not found for current or altered field metadata`,
+        WorkspaceMigrationExceptionCode.INVALID_FIELD_METADATA,
+      );
+    }
+
+    return [
+      {
+        action: WorkspaceMigrationColumnActionType.ALTER,
+        currentColumnDefinition: {
+          columnName: currentJoinColumnName,
+          columnType: fieldMetadataTypeToColumnType(FieldMetadataType.UUID),
+          isArray: false,
+          isNullable: currentFieldMetadata.isNullable ?? true,
+          isUnique:
+            currentFieldMetadata.settings.relationType ===
+            RelationType.ONE_TO_ONE,
+          defaultValue: null,
+        },
+        alteredColumnDefinition: {
+          columnName: alteredJoinColumnName,
+          columnType: fieldMetadataTypeToColumnType(FieldMetadataType.UUID),
+          isArray: false,
+          isNullable: alteredFieldMetadata.isNullable ?? true,
+          isUnique:
+            alteredFieldMetadata.settings.relationType ===
+            RelationType.ONE_TO_ONE,
+          defaultValue: null,
+        },
+      },
+    ];
+  }
+}

packages/twenty-server/src/engine/metadata-modules/workspace-migration/workspace-migration.factory.ts

@@ -9,6 +9,7 @@ import { WorkspaceColumnActionOptions } from 'src/engine/metadata-modules/worksp
 import { BasicColumnActionFactory } from 'src/engine/metadata-modules/workspace-migration/factories/basic-column-action.factory';
 import { CompositeColumnActionFactory } from 'src/engine/metadata-modules/workspace-migration/factories/composite-column-action.factory';
 import { EnumColumnActionFactory } from 'src/engine/metadata-modules/workspace-migration/factories/enum-column-action.factory';
+import { RelationColumnActionFactory } from 'src/engine/metadata-modules/workspace-migration/factories/relation-column-action.factory';
 import { TsVectorColumnActionFactory } from 'src/engine/metadata-modules/workspace-migration/factories/ts-vector-column-action.factory';
 import {
   WorkspaceMigrationColumnAction,
@@ -35,6 +36,7 @@ export class WorkspaceMigrationFactory {
     private readonly tsVectorColumnActionFactory: TsVectorColumnActionFactory,
     private readonly enumColumnActionFactory: EnumColumnActionFactory,
     private readonly compositeColumnActionFactory: CompositeColumnActionFactory,
+    private readonly relationColumnActionFactory: RelationColumnActionFactory,
   ) {
     this.factoriesMap = new Map<
       FieldMetadataType,
@@ -98,6 +100,10 @@ export class WorkspaceMigrationFactory {
         FieldMetadataType.RICH_TEXT_V2,
         { factory: this.compositeColumnActionFactory },
       ],
+      [
+        FieldMetadataType.RELATION,
+        { factory: this.relationColumnActionFactory },
+      ],
     ]);
   }
 

packages/twenty-server/src/engine/twenty-orm/custom.workspace-entity.ts

@@ -1,14 +1,13 @@
 import { msg } from '@lingui/core/macro';
 import { FieldMetadataType } from 'twenty-shared/types';
 
+import { RelationOnDeleteAction } from 'src/engine/metadata-modules/field-metadata/interfaces/relation-on-delete-action.interface';
+import { RelationType } from 'src/engine/metadata-modules/field-metadata/interfaces/relation-type.interface';
+
 import { SEARCH_VECTOR_FIELD } from 'src/engine/metadata-modules/constants/search-vector-field.constants';
 import { ActorMetadata } from 'src/engine/metadata-modules/field-metadata/composite-types/actor.composite-type';
 import { IndexType } from 'src/engine/metadata-modules/index-metadata/index-metadata.entity';
 import { DEFAULT_LABEL_IDENTIFIER_FIELD_NAME } from 'src/engine/metadata-modules/object-metadata/object-metadata.constants';
-import {
-  RelationMetadataType,
-  RelationOnDeleteAction,
-} from 'src/engine/metadata-modules/relation-metadata/relation-metadata.entity';
 import { BaseWorkspaceEntity } from 'src/engine/twenty-orm/base.workspace-entity';
 import { WorkspaceCustomEntity } from 'src/engine/twenty-orm/decorators/workspace-custom-entity.decorator';
 import { WorkspaceFieldIndex } from 'src/engine/twenty-orm/decorators/workspace-field-index.decorator';
@@ -67,7 +66,7 @@ export class CustomWorkspaceEntity extends BaseWorkspaceEntity {
   @WorkspaceRelation({
     standardId: CUSTOM_OBJECT_STANDARD_FIELD_IDS.noteTargets,
     label: msg`Notes`,
-    type: RelationMetadataType.ONE_TO_MANY,
+    type: RelationType.ONE_TO_MANY,
     description: (objectMetadata) => {
       const label = objectMetadata.labelSingular;
 
@@ -83,7 +82,7 @@ export class CustomWorkspaceEntity extends BaseWorkspaceEntity {
   @WorkspaceRelation({
     standardId: CUSTOM_OBJECT_STANDARD_FIELD_IDS.taskTargets,
     label: msg`Tasks`,
-    type: RelationMetadataType.ONE_TO_MANY,
+    type: RelationType.ONE_TO_MANY,
     description: (objectMetadata) => {
       const label = objectMetadata.labelSingular;
 
@@ -99,7 +98,7 @@ export class CustomWorkspaceEntity extends BaseWorkspaceEntity {
   @WorkspaceRelation({
     standardId: CUSTOM_OBJECT_STANDARD_FIELD_IDS.favorites,
     label: msg`Favorites`,
-    type: RelationMetadataType.ONE_TO_MANY,
+    type: RelationType.ONE_TO_MANY,
     description: (objectMetadata) => {
       const label = objectMetadata.labelSingular;
 
@@ -116,7 +115,7 @@ export class CustomWorkspaceEntity extends BaseWorkspaceEntity {
   @WorkspaceRelation({
     standardId: CUSTOM_OBJECT_STANDARD_FIELD_IDS.attachments,
     label: msg`Attachments`,
-    type: RelationMetadataType.ONE_TO_MANY,
+    type: RelationType.ONE_TO_MANY,
     description: (objectMetadata) => {
       const label = objectMetadata.labelSingular;
 
@@ -132,7 +131,7 @@ export class CustomWorkspaceEntity extends BaseWorkspaceEntity {
   @WorkspaceRelation({
     standardId: CUSTOM_OBJECT_STANDARD_FIELD_IDS.timelineActivities,
     label: msg`Timeline Activities`,
-    type: RelationMetadataType.ONE_TO_MANY,
+    type: RelationType.ONE_TO_MANY,
     description: (objectMetadata) => {
       const label = objectMetadata.labelSingular;
 

packages/twenty-server/src/engine/twenty-orm/decorators/workspace-dynamic-relation.decorator.ts

@@ -1,16 +1,14 @@
 import { ObjectType } from 'typeorm';
 
+import { RelationOnDeleteAction } from 'src/engine/metadata-modules/field-metadata/interfaces/relation-on-delete-action.interface';
+import { RelationType } from 'src/engine/metadata-modules/field-metadata/interfaces/relation-type.interface';
 import { WorkspaceDynamicRelationMetadataArgsFactory } from 'src/engine/twenty-orm/interfaces/workspace-dynamic-relation-metadata-args.interface';
 
-import {
-  RelationMetadataType,
-  RelationOnDeleteAction,
-} from 'src/engine/metadata-modules/relation-metadata/relation-metadata.entity';
 import { metadataArgsStorage } from 'src/engine/twenty-orm/storage/metadata-args.storage';
 import { TypedReflect } from 'src/utils/typed-reflect';
 
 interface WorkspaceBaseDynamicRelationOptions<TClass> {
-  type: RelationMetadataType;
+  type: RelationType;
   argsFactory: WorkspaceDynamicRelationMetadataArgsFactory;
   inverseSideTarget: () => ObjectType<TClass>;
   inverseSideFieldKey?: keyof TClass;

packages/twenty-server/src/engine/twenty-orm/decorators/workspace-field-index.decorator.ts

@@ -28,6 +28,15 @@ export function WorkspaceFieldIndex(
       ...additionalDefaultColumnsForIndex,
     ];
 
+    // TODO: Remove this when we are handling properly indexes for new relation metadata
+    if (
+      process.env.SYNC_METADATA_INDEX_ENABLED === 'false' ||
+      process.env.SYNC_METADATA_INDEX_ENABLED === '' ||
+      process.env.SYNC_METADATA_INDEX_ENABLED === undefined
+    ) {
+      return;
+    }
+
     metadataArgsStorage.addIndexes({
       name: `IDX_${generateDeterministicIndexName([
         convertClassNameToObjectMetadataName(target.constructor.name),

packages/twenty-server/src/engine/twenty-orm/decorators/workspace-field.decorator.ts

@@ -11,7 +11,11 @@ import { metadataArgsStorage } from 'src/engine/twenty-orm/storage/metadata-args
 import { TypedReflect } from 'src/utils/typed-reflect';
 
 export interface WorkspaceFieldOptions<
-  T extends FieldMetadataType = FieldMetadataType,
+  T extends FieldMetadataType = Exclude<
+    FieldMetadataType,
+    // Use @WorkspaceRelation or @WorkspaceDynamicRelation for relation fields
+    FieldMetadataType.RELATION
+  >,
 > {
   standardId: string;
   type: T;

packages/twenty-server/src/engine/twenty-orm/decorators/workspace-index.decorator.ts

@@ -18,6 +18,15 @@ export function WorkspaceIndex(
     throw new Error('Class level WorkspaceIndex should be used with columns');
   }
 
+  // TODO: Remove this when we are handling properly indexes for new relation metadata
+  if (
+    process.env.SYNC_METADATA_INDEX_ENABLED === 'false' ||
+    process.env.SYNC_METADATA_INDEX_ENABLED === '' ||
+    process.env.SYNC_METADATA_INDEX_ENABLED === undefined
+  ) {
+    return (_target: any) => {};
+  }
+
   return (target: any) => {
     const gate = TypedReflect.getMetadata(
       'workspace:gate-metadata-args',

packages/twenty-server/src/engine/twenty-orm/decorators/workspace-is-unique.decorator.ts

@@ -17,17 +17,20 @@ export function WorkspaceIsUnique(): PropertyDecorator {
 
     const columns = [propertyKey.toString()];
 
-    metadataArgsStorage.addIndexes({
-      name: `IDX_UNIQUE_${generateDeterministicIndexName([
-        convertClassNameToObjectMetadataName(target.constructor.name),
-        ...columns,
-      ])}`,
-      columns,
-      target: target.constructor,
-      gate,
-      isUnique: true,
-      whereClause: null,
-    });
+    // TODO: Remove this when we are handling properly indexes for new relation metadata
+    if (process.env.SYNC_METADATA_INDEX_ENABLED === 'true') {
+      metadataArgsStorage.addIndexes({
+        name: `IDX_UNIQUE_${generateDeterministicIndexName([
+          convertClassNameToObjectMetadataName(target.constructor.name),
+          ...columns,
+        ])}`,
+        columns,
+        target: target.constructor,
+        gate,
+        isUnique: true,
+        whereClause: null,
+      });
+    }
 
     return TypedReflect.defineMetadata(
       'workspace:is-unique-metadata-args',

packages/twenty-server/src/engine/twenty-orm/decorators/workspace-relation.decorator.ts

@@ -1,15 +1,14 @@
 import { MessageDescriptor } from '@lingui/core';
 import { ObjectType } from 'typeorm';
 
+import { RelationOnDeleteAction } from 'src/engine/metadata-modules/field-metadata/interfaces/relation-on-delete-action.interface';
+import { RelationType } from 'src/engine/metadata-modules/field-metadata/interfaces/relation-type.interface';
+
 import { ObjectMetadataEntity } from 'src/engine/metadata-modules/object-metadata/object-metadata.entity';
-import {
-  RelationMetadataType,
-  RelationOnDeleteAction,
-} from 'src/engine/metadata-modules/relation-metadata/relation-metadata.entity';
 import { metadataArgsStorage } from 'src/engine/twenty-orm/storage/metadata-args.storage';
 import { TypedReflect } from 'src/utils/typed-reflect';
 
-interface WorkspaceRelationOptions<TClass> {
+interface WorkspaceRelationBaseOptions<TClass> {
   standardId: string;
   label:
     | MessageDescriptor
@@ -18,12 +17,26 @@ interface WorkspaceRelationOptions<TClass> {
     | MessageDescriptor
     | ((objectMetadata: ObjectMetadataEntity) => MessageDescriptor);
   icon?: string;
-  type: RelationMetadataType;
   inverseSideTarget: () => ObjectType<TClass>;
   inverseSideFieldKey?: keyof TClass;
   onDelete?: RelationOnDeleteAction;
 }
 
+interface WorkspaceOtherRelationOptions<TClass>
+  extends WorkspaceRelationBaseOptions<TClass> {
+  type: RelationType.ONE_TO_MANY | RelationType.ONE_TO_ONE;
+}
+
+interface WorkspaceManyToOneRelationOptions<TClass extends object>
+  extends WorkspaceRelationBaseOptions<TClass> {
+  type: RelationType.MANY_TO_ONE;
+  inverseSideFieldKey: keyof TClass;
+}
+
+type WorkspaceRelationOptions<TClass extends object> =
+  | WorkspaceOtherRelationOptions<TClass>
+  | WorkspaceManyToOneRelationOptions<TClass>;
+
 export function WorkspaceRelation<TClass extends object>(
   options: WorkspaceRelationOptions<TClass>,
 ): PropertyDecorator {

packages/twenty-server/src/engine/twenty-orm/exceptions/twenty-orm.exception.ts

@@ -14,4 +14,5 @@ export enum TwentyORMExceptionCode {
   ROLES_PERMISSIONS_VERSION_NOT_FOUND = 'ROLES_PERMISSIONS_VERSION_NOT_FOUND',
   FEATURE_FLAG_MAP_VERSION_NOT_FOUND = 'FEATURE_FLAG_MAP_VERSION_NOT_FOUND',
   USER_WORKSPACE_ROLE_MAP_VERSION_NOT_FOUND = 'USER_WORKSPACE_ROLE_MAP_VERSION_NOT_FOUND',
+  MALFORMED_METADATA = 'MALFORMED_METADATA',
 }

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

@@ -1,9 +1,11 @@
 import { Injectable } from '@nestjs/common';
 
-import { ColumnType, EntitySchemaColumnOptions } from 'typeorm';
 import { FieldMetadataType } from 'twenty-shared/types';
+import { isDefined } from 'twenty-shared/utils';
+import { ColumnType, EntitySchemaColumnOptions } from 'typeorm';
 
 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 { compositeTypeDefinitions } from 'src/engine/metadata-modules/field-metadata/composite-types';
 import { computeCompositeColumnName } from 'src/engine/metadata-modules/field-metadata/utils/compute-column-name.util';
@@ -12,7 +14,11 @@ import { isEnumFieldMetadataType } from 'src/engine/metadata-modules/field-metad
 import { serializeDefaultValue } from 'src/engine/metadata-modules/field-metadata/utils/serialize-default-value';
 import { FieldMetadataMap } from 'src/engine/metadata-modules/types/field-metadata-map';
 import { fieldMetadataTypeToColumnType } from 'src/engine/metadata-modules/workspace-migration/utils/field-metadata-type-to-column-type.util';
-import { isRelationFieldMetadataType } from 'src/engine/utils/is-relation-field-metadata-type.util';
+import {
+  TwentyORMException,
+  TwentyORMExceptionCode,
+} from 'src/engine/twenty-orm/exceptions/twenty-orm.exception';
+import { isFieldMetadataInterfaceOfType } from 'src/engine/utils/is-field-metadata-of-type.util';
 
 type EntitySchemaColumnMap = {
   [key: string]: EntitySchemaColumnOptions;
@@ -20,7 +26,10 @@ type EntitySchemaColumnMap = {
 
 @Injectable()
 export class EntitySchemaColumnFactory {
-  create(fieldMetadataMapByName: FieldMetadataMap): EntitySchemaColumnMap {
+  create(
+    fieldMetadataMapByName: FieldMetadataMap,
+    isNewRelationEnabled: boolean,
+  ): EntitySchemaColumnMap {
     let entitySchemaColumnMap: EntitySchemaColumnMap = {};
 
     const fieldMetadataCollection = Object.values(fieldMetadataMapByName);
@@ -28,33 +37,63 @@ export class EntitySchemaColumnFactory {
     for (const fieldMetadata of fieldMetadataCollection) {
       const key = fieldMetadata.name;
 
-      if (isRelationFieldMetadataType(fieldMetadata.type)) {
-        const relationMetadata =
-          fieldMetadata.fromRelationMetadata ??
-          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,
+      if (
+        isFieldMetadataInterfaceOfType(
+          fieldMetadata,
+          FieldMetadataType.RELATION,
         )
-          ? joinColumnKey
-          : null;
+      ) {
+        if (!isNewRelationEnabled) {
+          const relationMetadata =
+            fieldMetadata.fromRelationMetadata ??
+            fieldMetadata.toRelationMetadata;
 
-        if (joinColumn) {
-          entitySchemaColumnMap[joinColumn] = {
-            name: joinColumn,
+          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,
           };
-        }
 
-        continue;
+          continue;
+        }
       }
 
       if (isCompositeFieldMetadataType(fieldMetadata.type)) {

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

@@ -1,11 +1,13 @@
 import { Injectable } from '@nestjs/common';
 
+import { FieldMetadataType } from 'twenty-shared/types';
 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 { isRelationFieldMetadataType } from 'src/engine/utils/is-relation-field-metadata-type.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';
 
 type EntitySchemaRelationMap = {
   [key: string]: EntitySchemaRelationOptions;
@@ -18,37 +20,64 @@ export class EntitySchemaRelationFactory {
   async create(
     fieldMetadataMapByName: FieldMetadataMap,
     objectMetadataMaps: ObjectMetadataMaps,
+    isNewRelationEnabled: boolean,
   ): Promise<EntitySchemaRelationMap> {
     const entitySchemaRelationMap: EntitySchemaRelationMap = {};
 
     const fieldMetadataCollection = Object.values(fieldMetadataMapByName);
 
     for (const fieldMetadata of fieldMetadataCollection) {
-      if (!isRelationFieldMetadataType(fieldMetadata.type)) {
+      if (
+        !isFieldMetadataInterfaceOfType(
+          fieldMetadata,
+          FieldMetadataType.RELATION,
+        )
+      ) {
         continue;
       }
 
-      const relationMetadata =
-        fieldMetadata.fromRelationMetadata ?? fieldMetadata.toRelationMetadata;
+      if (!isNewRelationEnabled) {
+        const relationMetadata =
+          fieldMetadata.fromRelationMetadata ??
+          fieldMetadata.toRelationMetadata;
 
-      if (!relationMetadata) {
-        throw new Error(
-          `Relation metadata is missing for field ${fieldMetadata.name}`,
+        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 relationDetails = await determineRelationDetails(
-        fieldMetadata,
-        relationMetadata,
-        objectMetadataMaps,
-      );
-
-      entitySchemaRelationMap[fieldMetadata.name] = {
-        type: relationDetails.relationType,
-        target: relationDetails.target,
-        inverseSide: relationDetails.inverseSide,
-        joinColumn: relationDetails.joinColumn,
-      } satisfies EntitySchemaRelationOptions;
     }
 
     return entitySchemaRelationMap;

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

@@ -2,6 +2,8 @@ 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';
 import { EntitySchemaColumnFactory } from 'src/engine/twenty-orm/factories/entity-schema-column.factory';
@@ -14,6 +16,7 @@ export class EntitySchemaFactory {
   constructor(
     private readonly entitySchemaColumnFactory: EntitySchemaColumnFactory,
     private readonly entitySchemaRelationFactory: EntitySchemaRelationFactory,
+    private readonly featureFlagService: FeatureFlagService,
   ) {}
 
   async create(
@@ -22,13 +25,20 @@ 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/factories/workspace-datasource.factory.ts

@@ -147,6 +147,7 @@ export class WorkspaceDatasourceFactory {
             {
               workspaceId,
               objectMetadataMaps: cachedObjectMetadataMaps,
+              featureFlagsMap: cachedFeatureFlagMap,
             },
             {
               url:

packages/twenty-server/src/engine/twenty-orm/interfaces/workspace-dynamic-relation-metadata-args.interface.ts

@@ -1,12 +1,10 @@
 import { ObjectType } from 'typeorm';
 
+import { RelationOnDeleteAction } from 'src/engine/metadata-modules/field-metadata/interfaces/relation-on-delete-action.interface';
+import { RelationType } from 'src/engine/metadata-modules/field-metadata/interfaces/relation-type.interface';
 import { Gate } from 'src/engine/twenty-orm/interfaces/gate.interface';
 
 import { ObjectMetadataEntity } from 'src/engine/metadata-modules/object-metadata/object-metadata.entity';
-import {
-  RelationMetadataType,
-  RelationOnDeleteAction,
-} from 'src/engine/metadata-modules/relation-metadata/relation-metadata.entity';
 
 export type WorkspaceDynamicRelationMetadataArgsFactory = (
   oppositeObjectMetadata: ObjectMetadataEntity,
@@ -57,7 +55,7 @@ export interface WorkspaceDynamicRelationMetadataArgs {
   /**
    * Relation type.
    */
-  readonly type: RelationMetadataType;
+  readonly type: RelationType;
 
   /**
    * Relation inverse side target.

packages/twenty-server/src/engine/twenty-orm/interfaces/workspace-internal-context.interface.ts

@@ -1,6 +1,8 @@
+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 interface WorkspaceInternalContext {
   workspaceId: string;
   objectMetadataMaps: ObjectMetadataMaps;
+  featureFlagsMap: Record<FeatureFlagKey, boolean>;
 }

packages/twenty-server/src/engine/twenty-orm/interfaces/workspace-relation-metadata-args.interface.ts

@@ -1,12 +1,10 @@
 import { ObjectType } from 'typeorm';
 
+import { RelationOnDeleteAction } from 'src/engine/metadata-modules/field-metadata/interfaces/relation-on-delete-action.interface';
+import { RelationType } from 'src/engine/metadata-modules/field-metadata/interfaces/relation-type.interface';
 import { Gate } from 'src/engine/twenty-orm/interfaces/gate.interface';
 
 import { ObjectMetadataEntity } from 'src/engine/metadata-modules/object-metadata/object-metadata.entity';
-import {
-  RelationMetadataType,
-  RelationOnDeleteAction,
-} from 'src/engine/metadata-modules/relation-metadata/relation-metadata.entity';
 
 export interface WorkspaceRelationMetadataArgs {
   /**
@@ -33,7 +31,7 @@ export interface WorkspaceRelationMetadataArgs {
   /**
    * Relation type.
    */
-  readonly type: RelationMetadataType;
+  readonly type: RelationType;
 
   /**
    * Relation description.

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

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

packages/twenty-server/src/engine/twenty-orm/utils/convert-relation-type-to-typeorm-relation-type.util.ts

@@ -0,0 +1,14 @@
+import { RelationType } from 'src/engine/metadata-modules/field-metadata/interfaces/relation-type.interface';
+
+export const converRelationTypeToTypeORMRelationType = (type: RelationType) => {
+  switch (type) {
+    case RelationType.ONE_TO_MANY:
+      return 'one-to-many';
+    case RelationType.MANY_TO_ONE:
+      return 'many-to-one';
+    case RelationType.ONE_TO_ONE:
+      return 'one-to-one';
+    default:
+      throw new Error(`Invalid relation type: ${type}`);
+  }
+};

packages/twenty-server/src/engine/twenty-orm/utils/determine-schema-relation-details.util.ts

@@ -0,0 +1,62 @@
+import { FieldMetadataType } from 'twenty-shared/types';
+import { RelationType } from 'typeorm/metadata/types/RelationTypes';
+
+import { FieldMetadataInterface } from 'src/engine/metadata-modules/field-metadata/interfaces/field-metadata.interface';
+
+import { ObjectMetadataMaps } from 'src/engine/metadata-modules/types/object-metadata-maps';
+import { converRelationTypeToTypeORMRelationType } from 'src/engine/twenty-orm/utils/convert-relation-type-to-typeorm-relation-type.util';
+
+interface RelationDetails {
+  relationType: RelationType;
+  target: string;
+  inverseSide: string;
+  joinColumn: { name: string } | undefined;
+}
+
+export async function determineSchemaRelationDetails(
+  fieldMetadata: FieldMetadataInterface<FieldMetadataType.RELATION>,
+  objectMetadataMaps: ObjectMetadataMaps,
+): Promise<RelationDetails> {
+  if (!fieldMetadata.settings) {
+    throw new Error('Field metadata settings are missing');
+  }
+
+  const relationType = converRelationTypeToTypeORMRelationType(
+    fieldMetadata.settings.relationType,
+  );
+
+  if (!fieldMetadata.relationTargetObjectMetadataId) {
+    throw new Error('Relation target object metadata ID is missing');
+  }
+
+  const sourceObjectMetadata =
+    objectMetadataMaps.byId[fieldMetadata.objectMetadataId];
+  const targetObjectMetadata =
+    objectMetadataMaps.byId[fieldMetadata.relationTargetObjectMetadataId];
+
+  if (!sourceObjectMetadata || !targetObjectMetadata) {
+    throw new Error('Object metadata not found');
+  }
+
+  if (!fieldMetadata.relationTargetFieldMetadataId) {
+    throw new Error('Relation target field metadata ID is missing');
+  }
+
+  const targetFieldMetadata =
+    targetObjectMetadata.fieldsById[
+      fieldMetadata.relationTargetFieldMetadataId
+    ];
+
+  if (!targetFieldMetadata) {
+    throw new Error('Target field metadata not found');
+  }
+
+  return {
+    relationType,
+    target: targetObjectMetadata.nameSingular,
+    inverseSide: targetFieldMetadata.name,
+    joinColumn: fieldMetadata.settings.joinColumnName
+      ? { name: fieldMetadata.settings.joinColumnName }
+      : undefined,
+  };
+}

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

@@ -7,6 +7,7 @@ import { compositeTypeDefinitions } from 'src/engine/metadata-modules/field-meta
 import { isCompositeFieldMetadataType } from 'src/engine/metadata-modules/field-metadata/utils/is-composite-field-metadata-type.util';
 import { ObjectMetadataItemWithFieldMaps } from 'src/engine/metadata-modules/types/object-metadata-item-with-field-maps';
 import { CompositeFieldMetadataType } from 'src/engine/metadata-modules/workspace-migration/factories/composite-column-action.factory';
+import { isFieldMetadataInterfaceOfType } from 'src/engine/utils/is-field-metadata-of-type.util';
 
 export function formatData<T>(
   data: T,
@@ -23,9 +24,28 @@ export function formatData<T>(
   }
 
   const newData: Record<string, any> = {};
+  const fieldMetadataByJoinColumnName =
+    objectMetadataItemWithFieldMaps.fields.reduce((acc, fieldMetadata) => {
+      if (
+        isFieldMetadataInterfaceOfType(
+          fieldMetadata,
+          FieldMetadataType.RELATION,
+        )
+      ) {
+        const joinColumnName = fieldMetadata.settings?.joinColumnName;
+
+        if (joinColumnName) {
+          acc.set(joinColumnName, fieldMetadata);
+        }
+      }
+
+      return acc;
+    }, new Map<string, FieldMetadataInterface>());
 
   for (const [key, value] of Object.entries(data)) {
-    const fieldMetadata = objectMetadataItemWithFieldMaps.fieldsByName[key];
+    const fieldMetadata =
+      objectMetadataItemWithFieldMaps.fieldsByName[key] ||
+      fieldMetadataByJoinColumnName.get(key);
 
     if (!fieldMetadata) {
       throw new Error(

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

@@ -13,7 +13,7 @@ import { ObjectMetadataItemWithFieldMaps } from 'src/engine/metadata-modules/typ
 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 { isRelationFieldMetadataType } from 'src/engine/utils/is-relation-field-metadata-type.util';
+import { isFieldMetadataInterfaceOfType } from 'src/engine/utils/is-field-metadata-of-type.util';
 import { isDate } from 'src/utils/date/isDate';
 import { isValidDate } from 'src/utils/date/isValidDate';
 
@@ -21,6 +21,7 @@ export function formatResult<T>(
   data: any,
   objectMetadataItemWithFieldMaps: ObjectMetadataItemWithFieldMaps,
   objectMetadataMaps: ObjectMetadataMaps,
+  isNewRelationEnabled: boolean,
 ): T {
   if (!data) {
     return data;
@@ -28,7 +29,12 @@ export function formatResult<T>(
 
   if (Array.isArray(data)) {
     return data.map((item) =>
-      formatResult(item, objectMetadataItemWithFieldMaps, objectMetadataMaps),
+      formatResult(
+        item,
+        objectMetadataItemWithFieldMaps,
+        objectMetadataMaps,
+        isNewRelationEnabled,
+      ),
     ) as T;
   }
 
@@ -44,38 +50,57 @@ export function formatResult<T>(
     objectMetadataItemWithFieldMaps,
   );
 
-  const relationMetadataMap = new Map(
-    Object.values(objectMetadataItemWithFieldMaps.fieldsById)
-      .filter(({ type }) => isRelationFieldMetadataType(type))
-      .map((fieldMetadata) => [
-        fieldMetadata.name,
-        {
-          relationMetadata:
-            fieldMetadata.fromRelationMetadata ??
-            fieldMetadata.toRelationMetadata,
-          relationType: computeRelationType(
-            fieldMetadata,
-            fieldMetadata.fromRelationMetadata ??
-              (fieldMetadata.toRelationMetadata as RelationMetadataEntity),
-          ),
-        },
-      ]),
-  );
+  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;
 
   for (const [key, value] of Object.entries(data)) {
     const compositePropertyArgs = compositeFieldMetadataMap.get(key);
-    const { relationMetadata, relationType } =
-      relationMetadataMap.get(key) ?? {};
+    const fieldMetadata = objectMetadataItemWithFieldMaps.fieldsById[key];
+    const isRelation = fieldMetadata
+      ? isFieldMetadataInterfaceOfType(
+          fieldMetadata,
+          FieldMetadataType.RELATION,
+        )
+      : false;
 
-    if (!compositePropertyArgs && !relationMetadata) {
+    if (!compositePropertyArgs && !isRelation) {
       if (isPlainObject(value)) {
         newData[key] = formatResult(
           value,
           objectMetadataItemWithFieldMaps,
           objectMetadataMaps,
+          isNewRelationEnabled,
         );
       } else if (objectMetadaItemFieldsByName[key]) {
         newData[key] = formatFieldMetadataValue(
@@ -89,31 +114,63 @@ export function formatResult<T>(
       continue;
     }
 
-    if (relationMetadata) {
-      const toObjectMetadata =
-        objectMetadataMaps.byId[relationMetadata.toObjectMetadataId];
+    if (!isNewRelationEnabled) {
+      const { relationMetadata, relationType } =
+        relationMetadataMap.get(key) ?? {};
 
-      const fromObjectMetadata =
-        objectMetadataMaps.byId[relationMetadata.fromObjectMetadataId];
+      if (relationMetadata) {
+        const toObjectMetadata =
+          objectMetadataMaps.byId[relationMetadata.toObjectMetadataId];
 
-      if (!toObjectMetadata) {
-        throw new Error(
-          `Object metadata for object metadataId "${relationMetadata.toObjectMetadataId}" is missing`,
+        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 (!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,
         );
       }
-
-      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,
-      );
-      continue;
     }
 
     if (!compositePropertyArgs) {

packages/twenty-server/src/engine/twenty-orm/utils/get-join-column.util.ts

@@ -1,7 +1,7 @@
+import { RelationType } from 'src/engine/metadata-modules/field-metadata/interfaces/relation-type.interface';
 import { WorkspaceJoinColumnsMetadataArgs } from 'src/engine/twenty-orm/interfaces/workspace-join-columns-metadata-args.interface';
 import { WorkspaceRelationMetadataArgs } from 'src/engine/twenty-orm/interfaces/workspace-relation-metadata-args.interface';
 
-import { RelationMetadataType } from 'src/engine/metadata-modules/relation-metadata/relation-metadata.entity';
 import { metadataArgsStorage } from 'src/engine/twenty-orm/storage/metadata-args.storage';
 
 export const getJoinColumn = (
@@ -9,10 +9,7 @@ export const getJoinColumn = (
   relationMetadataArgs: WorkspaceRelationMetadataArgs,
   opposite = false,
 ): string | null => {
-  if (
-    relationMetadataArgs.type === RelationMetadataType.ONE_TO_MANY ||
-    relationMetadataArgs.type === RelationMetadataType.MANY_TO_MANY
-  ) {
+  if (relationMetadataArgs.type === RelationType.ONE_TO_MANY) {
     return null;
   }
 
@@ -41,7 +38,7 @@ export const getJoinColumn = (
 
   // If we're in a ONE_TO_ONE relation and there are no join columns, we need to find the join column on the inverse side
   if (
-    relationMetadataArgs.type === RelationMetadataType.ONE_TO_ONE &&
+    relationMetadataArgs.type === RelationType.ONE_TO_ONE &&
     filteredJoinColumnsMetadataArgsCollection.length === 0 &&
     !opposite
   ) {

packages/twenty-server/src/engine/utils/is-field-metadata-of-type.util.ts

@@ -4,25 +4,22 @@ import { FieldMetadataInterface } from 'src/engine/metadata-modules/field-metada
 
 import { FieldMetadataEntity } from 'src/engine/metadata-modules/field-metadata/field-metadata.entity';
 
-export function isFieldMetadataOfType<
+export function isFieldMetadataInterfaceOfType<
   Field extends FieldMetadataInterface<FieldMetadataType>,
   Type extends FieldMetadataType,
 >(
   fieldMetadata: Field,
   type: Type,
-): fieldMetadata is Field & FieldMetadataInterface<Type>;
-export function isFieldMetadataOfType<
+): fieldMetadata is Field & FieldMetadataInterface<Type> {
+  return fieldMetadata.type === type;
+}
+
+export function isFieldMetadataEntityOfType<
   Field extends FieldMetadataEntity<FieldMetadataType>,
   Type extends FieldMetadataType,
 >(
   fieldMetadata: Field,
   type: Type,
-): fieldMetadata is Field & FieldMetadataEntity<Type>;
-export function isFieldMetadataOfType<
-  Field extends
-    | FieldMetadataInterface<FieldMetadataType>
-    | FieldMetadataEntity<FieldMetadataType>,
-  Type extends FieldMetadataType,
->(fieldMetadata: Field, type: Type): boolean {
+): fieldMetadata is Field & FieldMetadataEntity<Type> {
   return fieldMetadata.type === type;
 }

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

@@ -93,9 +93,13 @@ export class WorkspaceManagerService {
         schemaName,
       );
 
+    const featureFlags =
+      await this.featureFlagService.getWorkspaceFeatureFlagsMap(workspaceId);
+
     await this.workspaceSyncMetadataService.synchronize({
       workspaceId,
       dataSourceId: dataSourceMetadata.id,
+      featureFlags,
     });
 
     const dataSourceMetadataCreationEnd = performance.now();
@@ -145,9 +149,13 @@ export class WorkspaceManagerService {
         schemaName,
       );
 
+    const featureFlags =
+      await this.featureFlagService.getWorkspaceFeatureFlagsMap(workspaceId);
+
     await this.workspaceSyncMetadataService.synchronize({
       workspaceId,
       dataSourceId: dataSourceMetadata.id,
+      featureFlags,
     });
 
     await this.prefillWorkspaceWithDemoObjects(dataSourceMetadata, workspaceId);
@@ -165,9 +173,13 @@ export class WorkspaceManagerService {
         schemaName,
       );
 
+    const featureFlags =
+      await this.featureFlagService.getWorkspaceFeatureFlagsMap(workspaceId);
+
     await this.workspaceSyncMetadataService.synchronize({
       workspaceId: workspaceId,
       dataSourceId: dataSourceMetadata.id,
+      featureFlags,
     });
 
     await this.initPermissionsDev(workspaceId);

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

@@ -1,12 +1,14 @@
 import { WorkspaceMigrationIndexFactory } from 'src/engine/workspace-manager/workspace-migration-builder/factories/workspace-migration-index.factory';
 
-import { WorkspaceMigrationObjectFactory } from './workspace-migration-object.factory';
+import { WorkspaceMigrationFieldRelationFactory } from './workspace-migration-field-relation.factory';
 import { WorkspaceMigrationFieldFactory } from './workspace-migration-field.factory';
+import { WorkspaceMigrationObjectFactory } from './workspace-migration-object.factory';
 import { WorkspaceMigrationRelationFactory } from './workspace-migration-relation.factory';
 
 export const workspaceMigrationBuilderFactories = [
   WorkspaceMigrationObjectFactory,
   WorkspaceMigrationFieldFactory,
+  WorkspaceMigrationFieldRelationFactory,
   WorkspaceMigrationRelationFactory,
   WorkspaceMigrationIndexFactory,
 ];

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

@@ -0,0 +1,388 @@
+import { Injectable } from '@nestjs/common';
+
+import { FieldMetadataType } from 'twenty-shared/types';
+
+import { RelationType } from 'src/engine/metadata-modules/field-metadata/interfaces/relation-type.interface';
+import { WorkspaceMigrationBuilderAction } from 'src/engine/workspace-manager/workspace-migration-builder/interfaces/workspace-migration-builder-action.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 { generateMigrationName } from 'src/engine/metadata-modules/workspace-migration/utils/generate-migration-name.util';
+import {
+  WorkspaceMigrationColumnActionType,
+  WorkspaceMigrationEntity,
+  WorkspaceMigrationTableAction,
+  WorkspaceMigrationTableActionType,
+} from 'src/engine/metadata-modules/workspace-migration/workspace-migration.entity';
+import { WorkspaceMigrationFactory } from 'src/engine/metadata-modules/workspace-migration/workspace-migration.factory';
+import { computeObjectTargetTable } from 'src/engine/utils/compute-object-target-table.util';
+import { isFieldMetadataEntityOfType } from 'src/engine/utils/is-field-metadata-of-type.util';
+import { FieldMetadataUpdate } from 'src/engine/workspace-manager/workspace-migration-builder/factories/workspace-migration-field.factory';
+import { camelCase } from 'src/utils/camel-case';
+@Injectable()
+export class WorkspaceMigrationFieldRelationFactory {
+  constructor(
+    private readonly workspaceMigrationFactory: WorkspaceMigrationFactory,
+  ) {}
+
+  async create(
+    originalObjectMetadataCollection: ObjectMetadataEntity[],
+    fieldMetadataCollection: FieldMetadataEntity<FieldMetadataType.RELATION>[],
+    action:
+      | WorkspaceMigrationBuilderAction.CREATE
+      | WorkspaceMigrationBuilderAction.DELETE,
+  ): Promise<Partial<WorkspaceMigrationEntity>[]>;
+
+  async create(
+    originalObjectMetadataCollection: ObjectMetadataEntity[],
+    fieldMetadataUpdateCollection: FieldMetadataUpdate<FieldMetadataType.RELATION>[],
+    action: WorkspaceMigrationBuilderAction.UPDATE,
+  ): Promise<Partial<WorkspaceMigrationEntity>[]>;
+
+  /**
+   * Deletion of the relation is handled by field deletion
+   */
+  async create(
+    originalObjectMetadataCollection: ObjectMetadataEntity[],
+    fieldMetadataCollectionOrFieldMetadataUpdateCollection:
+      | FieldMetadataEntity<FieldMetadataType.RELATION>[]
+      | FieldMetadataUpdate<FieldMetadataType.RELATION>[],
+    action: WorkspaceMigrationBuilderAction,
+  ): Promise<Partial<WorkspaceMigrationEntity>[]> {
+    const originalObjectMetadataMap = originalObjectMetadataCollection.reduce(
+      (result, currentObject) => {
+        result[currentObject.id] = currentObject;
+
+        return result;
+      },
+      {} as Record<string, ObjectMetadataEntity>,
+    );
+
+    switch (action) {
+      case WorkspaceMigrationBuilderAction.CREATE:
+        return this.createFieldRelationMigration(
+          originalObjectMetadataMap,
+          fieldMetadataCollectionOrFieldMetadataUpdateCollection as FieldMetadataEntity<FieldMetadataType.RELATION>[],
+        );
+      case WorkspaceMigrationBuilderAction.UPDATE:
+        return this.updateFieldRelationMigration(
+          originalObjectMetadataMap,
+          fieldMetadataCollectionOrFieldMetadataUpdateCollection as FieldMetadataUpdate<FieldMetadataType.RELATION>[],
+        );
+      case WorkspaceMigrationBuilderAction.DELETE:
+        return this.deleteFieldRelationMigration(
+          originalObjectMetadataMap,
+          fieldMetadataCollectionOrFieldMetadataUpdateCollection as FieldMetadataEntity<FieldMetadataType.RELATION>[],
+        );
+      default:
+        return [];
+    }
+  }
+
+  private async updateFieldRelationMigration(
+    originalObjectMetadataMap: Record<string, ObjectMetadataEntity>,
+    fieldMetadataUpdateCollection: FieldMetadataUpdate<FieldMetadataType.RELATION>[],
+  ): Promise<Partial<WorkspaceMigrationEntity>[]> {
+    const workspaceMigrations: Partial<WorkspaceMigrationEntity>[] = [];
+
+    for (const {
+      altered: sourceFieldMetadata,
+    } of fieldMetadataUpdateCollection) {
+      const sourceObjectMetadata =
+        originalObjectMetadataMap[sourceFieldMetadata.objectMetadataId];
+      const targetObjectMetadata =
+        originalObjectMetadataMap[
+          sourceFieldMetadata.relationTargetObjectMetadataId
+        ];
+
+      if (!sourceObjectMetadata) {
+        throw new Error(
+          `ObjectMetadata with id ${sourceFieldMetadata.objectMetadataId} not found`,
+        );
+      }
+
+      if (!targetObjectMetadata) {
+        throw new Error(
+          `ObjectMetadata with id ${sourceFieldMetadata.relationTargetObjectMetadataId} not found`,
+        );
+      }
+
+      const targetFieldMetadata = targetObjectMetadata.fields.find(
+        (field) =>
+          field.id === sourceFieldMetadata.relationTargetFieldMetadataId,
+      );
+
+      if (!targetFieldMetadata) {
+        throw new Error(
+          `FieldMetadata with id ${sourceFieldMetadata.relationTargetFieldMetadataId} not found`,
+        );
+      }
+
+      if (
+        !isFieldMetadataEntityOfType(
+          targetFieldMetadata,
+          FieldMetadataType.RELATION,
+        )
+      ) {
+        throw new Error(
+          `FieldMetadata with id ${sourceFieldMetadata.relationTargetFieldMetadataId} is not a relation`,
+        );
+      }
+
+      if (!targetFieldMetadata.settings) {
+        throw new Error(
+          `FieldMetadata for relation with id ${sourceFieldMetadata.id} has no settings`,
+        );
+      }
+
+      const migrations: WorkspaceMigrationTableAction[] = [
+        {
+          name: computeObjectTargetTable(targetObjectMetadata),
+          action: WorkspaceMigrationTableActionType.ALTER,
+          columns: [
+            {
+              action: WorkspaceMigrationColumnActionType.DROP_FOREIGN_KEY,
+              columnName: `${camelCase(targetFieldMetadata.name)}Id`,
+            },
+          ],
+        },
+        {
+          name: computeObjectTargetTable(targetObjectMetadata),
+          action: WorkspaceMigrationTableActionType.ALTER,
+          columns: [
+            {
+              action: WorkspaceMigrationColumnActionType.CREATE_FOREIGN_KEY,
+              columnName: `${camelCase(targetFieldMetadata.name)}Id`,
+              referencedTableName:
+                computeObjectTargetTable(sourceObjectMetadata),
+              referencedTableColumnName: 'id',
+              isUnique:
+                targetFieldMetadata.settings.relationType ===
+                RelationType.ONE_TO_ONE,
+              onDelete: targetFieldMetadata.settings.onDelete,
+            },
+          ],
+        },
+      ];
+
+      workspaceMigrations.push({
+        workspaceId: sourceFieldMetadata.workspaceId,
+        name: generateMigrationName(
+          `update-relation-from-${sourceObjectMetadata.nameSingular}-to-${targetObjectMetadata.nameSingular}`,
+        ),
+        isCustom: false,
+        migrations,
+      });
+    }
+
+    return workspaceMigrations;
+  }
+
+  private async createFieldRelationMigration(
+    originalObjectMetadataMap: Record<string, ObjectMetadataEntity>,
+    fieldRelationMetadataCollection: FieldMetadataEntity<FieldMetadataType.RELATION>[],
+  ): Promise<Partial<WorkspaceMigrationEntity>[]> {
+    const workspaceMigrations: Partial<WorkspaceMigrationEntity>[] = [];
+
+    for (const sourceFieldMetadata of fieldRelationMetadataCollection) {
+      const sourceObjectMetadata =
+        originalObjectMetadataMap[sourceFieldMetadata.objectMetadataId];
+      const targetObjectMetadata =
+        originalObjectMetadataMap[
+          sourceFieldMetadata.relationTargetObjectMetadataId
+        ];
+
+      if (!sourceFieldMetadata.settings) {
+        throw new Error(
+          `FieldMetadata for relation with id ${sourceFieldMetadata.id} has no settings`,
+        );
+      }
+
+      // We're creating it from `ONE_TO_MANY` with the join column so we don't need to create a migration for `MANY_TO_ONE`
+      if (
+        sourceFieldMetadata.settings.relationType === RelationType.MANY_TO_ONE
+      ) {
+        continue;
+      }
+
+      if (!sourceObjectMetadata) {
+        throw new Error(
+          `ObjectMetadata with id ${sourceFieldMetadata.objectMetadataId} not found`,
+        );
+      }
+
+      if (!targetObjectMetadata) {
+        throw new Error(
+          `ObjectMetadata with id ${sourceFieldMetadata.relationTargetObjectMetadataId} not found`,
+        );
+      }
+
+      const targetFieldMetadata = targetObjectMetadata.fields.find(
+        (field) =>
+          field.id === sourceFieldMetadata.relationTargetFieldMetadataId,
+      );
+
+      if (!targetFieldMetadata) {
+        throw new Error(
+          `FieldMetadata with id ${sourceFieldMetadata.relationTargetFieldMetadataId} not found`,
+        );
+      }
+
+      if (
+        !isFieldMetadataEntityOfType(
+          targetFieldMetadata,
+          FieldMetadataType.RELATION,
+        )
+      ) {
+        throw new Error(
+          `FieldMetadata with id ${sourceFieldMetadata.relationTargetFieldMetadataId} is not a relation`,
+        );
+      }
+
+      if (!targetFieldMetadata.settings) {
+        throw new Error(
+          `FieldMetadata for relation with id ${sourceFieldMetadata.id} has no settings`,
+        );
+      }
+
+      if (!targetFieldMetadata.settings.joinColumnName) {
+        continue;
+      }
+
+      const migrations: WorkspaceMigrationTableAction[] = [
+        {
+          name: computeObjectTargetTable(targetObjectMetadata),
+          action: WorkspaceMigrationTableActionType.ALTER,
+          columns: [
+            ...this.workspaceMigrationFactory.createColumnActions(
+              WorkspaceMigrationColumnActionType.CREATE,
+              targetFieldMetadata,
+            ),
+          ],
+        },
+        {
+          name: computeObjectTargetTable(targetObjectMetadata),
+          action: WorkspaceMigrationTableActionType.ALTER,
+          columns: [
+            {
+              action: WorkspaceMigrationColumnActionType.CREATE_FOREIGN_KEY,
+              columnName:
+                targetFieldMetadata.settings.joinColumnName ??
+                `${camelCase(targetFieldMetadata.name)}Id`,
+              referencedTableName:
+                computeObjectTargetTable(sourceObjectMetadata),
+              referencedTableColumnName: 'id',
+              isUnique:
+                targetFieldMetadata.settings.relationType ===
+                RelationType.ONE_TO_ONE,
+              onDelete: targetFieldMetadata.settings.onDelete,
+            },
+          ],
+        },
+      ];
+
+      workspaceMigrations.push({
+        workspaceId: sourceFieldMetadata.workspaceId,
+        name: generateMigrationName(
+          `create-relation-from-${sourceObjectMetadata.nameSingular}-to-${targetObjectMetadata.nameSingular}`,
+        ),
+        isCustom: false,
+        migrations,
+      });
+    }
+
+    return workspaceMigrations;
+  }
+
+  private async deleteFieldRelationMigration(
+    originalObjectMetadataMap: Record<string, ObjectMetadataEntity>,
+    fieldRelationMetadataCollection: FieldMetadataEntity<FieldMetadataType.RELATION>[],
+  ): Promise<Partial<WorkspaceMigrationEntity>[]> {
+    const workspaceMigrations: Partial<WorkspaceMigrationEntity>[] = [];
+
+    for (const sourceFieldMetadata of fieldRelationMetadataCollection) {
+      const sourceObjectMetadata =
+        originalObjectMetadataMap[sourceFieldMetadata.objectMetadataId];
+      const targetObjectMetadata =
+        originalObjectMetadataMap[
+          sourceFieldMetadata.relationTargetObjectMetadataId
+        ];
+
+      if (!sourceObjectMetadata) {
+        throw new Error(
+          `ObjectMetadata with id ${sourceFieldMetadata.objectMetadataId} not found`,
+        );
+      }
+
+      if (!targetObjectMetadata) {
+        throw new Error(
+          `ObjectMetadata with id ${sourceFieldMetadata.relationTargetObjectMetadataId} not found`,
+        );
+      }
+
+      const targetFieldMetadata = targetObjectMetadata.fields.find(
+        (field) =>
+          field.id === sourceFieldMetadata.relationTargetFieldMetadataId,
+      );
+
+      if (!targetFieldMetadata) {
+        throw new Error(
+          `FieldMetadata with id ${sourceFieldMetadata.relationTargetFieldMetadataId} not found`,
+        );
+      }
+
+      if (
+        !isFieldMetadataEntityOfType(
+          targetFieldMetadata,
+          FieldMetadataType.RELATION,
+        )
+      ) {
+        throw new Error(
+          `FieldMetadata with id ${sourceFieldMetadata.relationTargetFieldMetadataId} is not a relation`,
+        );
+      }
+
+      if (!targetFieldMetadata.settings) {
+        throw new Error(
+          `FieldMetadata for relation with id ${sourceFieldMetadata.id} has no settings`,
+        );
+      }
+
+      const migrations: WorkspaceMigrationTableAction[] = [
+        {
+          name: computeObjectTargetTable(targetObjectMetadata),
+          action: WorkspaceMigrationTableActionType.ALTER,
+          columns: [
+            {
+              action: WorkspaceMigrationColumnActionType.DROP_FOREIGN_KEY,
+              columnName: `${camelCase(targetFieldMetadata.name)}Id`,
+            },
+          ],
+        },
+        {
+          name: computeObjectTargetTable(targetObjectMetadata),
+          action: WorkspaceMigrationTableActionType.ALTER,
+          columns: [
+            {
+              action: WorkspaceMigrationColumnActionType.DROP,
+              columnName:
+                targetFieldMetadata.settings.joinColumnName ??
+                `${camelCase(targetFieldMetadata.name)}Id`,
+            },
+          ],
+        },
+      ];
+
+      workspaceMigrations.push({
+        workspaceId: sourceFieldMetadata.workspaceId,
+        name: generateMigrationName(
+          `update-relation-from-${sourceObjectMetadata.nameSingular}-to-${targetObjectMetadata.nameSingular}`,
+        ),
+        isCustom: false,
+        migrations,
+      });
+    }
+
+    return workspaceMigrations;
+  }
+}

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

@@ -5,6 +5,8 @@ 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';
 import { generateMigrationName } from 'src/engine/metadata-modules/workspace-migration/utils/generate-migration-name.util';
@@ -18,15 +20,18 @@ import {
 import { WorkspaceMigrationFactory } from 'src/engine/metadata-modules/workspace-migration/workspace-migration.factory';
 import { computeObjectTargetTable } from 'src/engine/utils/compute-object-target-table.util';
 
-export interface FieldMetadataUpdate {
-  current: FieldMetadataEntity;
-  altered: FieldMetadataEntity;
+export interface FieldMetadataUpdate<
+  Type extends FieldMetadataType = FieldMetadataType,
+> {
+  current: FieldMetadataEntity<Type>;
+  altered: FieldMetadataEntity<Type>;
 }
 
 @Injectable()
 export class WorkspaceMigrationFieldFactory {
   constructor(
     private readonly workspaceMigrationFactory: WorkspaceMigrationFactory,
+    private readonly featureFlagService: FeatureFlagService,
   ) {}
 
   async create(
@@ -86,6 +91,17 @@ export class WorkspaceMigrationFieldFactory {
   ): Promise<Partial<WorkspaceMigrationEntity>[]> {
     const workspaceMigrations: Partial<WorkspaceMigrationEntity>[] = [];
 
+    if (fieldMetadataCollection.length === 0) {
+      return [];
+    }
+
+    const workspaceId = fieldMetadataCollection[0]?.workspaceId;
+
+    const isNewRelationEnabled = await this.featureFlagService.isFeatureEnabled(
+      FeatureFlagKey.IsNewRelationEnabled,
+      workspaceId,
+    );
+
     const fieldMetadataCollectionGroupByObjectMetadataId =
       fieldMetadataCollection.reduce(
         (result, currentFieldMetadata) => {
@@ -110,7 +126,10 @@ export class WorkspaceMigrationFieldFactory {
 
       for (const fieldMetadata of fieldMetadataCollection) {
         // Relations are handled in workspace-migration-relation.factory.ts
-        if (fieldMetadata.type === FieldMetadataType.RELATION) {
+        if (
+          !isNewRelationEnabled &&
+          fieldMetadata.type === FieldMetadataType.RELATION
+        ) {
           continue;
         }
 
@@ -127,7 +146,7 @@ export class WorkspaceMigrationFieldFactory {
         name: generateMigrationName(
           `create-${objectMetadata.nameSingular}-fields`,
         ),
-        isCustom: false,
+        isCustom: objectMetadata.isCustom,
         migrations: [
           {
             name: computeObjectTargetTable(
@@ -149,9 +168,23 @@ export class WorkspaceMigrationFieldFactory {
   ): Promise<Partial<WorkspaceMigrationEntity>[]> {
     const workspaceMigrations: Partial<WorkspaceMigrationEntity>[] = [];
 
+    if (fieldMetadataUpdateCollection.length === 0) {
+      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 (fieldMetadataUpdate.altered.type === FieldMetadataType.RELATION) {
+      if (
+        !isNewRelationEnabled &&
+        fieldMetadataUpdate.altered.type === FieldMetadataType.RELATION
+      ) {
         continue;
       }
 
@@ -211,7 +244,7 @@ export class WorkspaceMigrationFieldFactory {
           name: generateMigrationName(
             `update-${fieldMetadataUpdate.altered.name}`,
           ),
-          isCustom: false,
+          isCustom: fieldMetadataUpdate.altered.isCustom,
           migrations,
         });
       }
@@ -250,7 +283,7 @@ export class WorkspaceMigrationFieldFactory {
       workspaceMigrations.push({
         workspaceId: fieldMetadata.workspaceId,
         name: generateMigrationName(`delete-${fieldMetadata.name}`),
-        isCustom: false,
+        isCustom: fieldMetadata.isCustom,
         migrations,
       });
     }

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

@@ -109,7 +109,7 @@ export class WorkspaceMigrationObjectFactory {
       workspaceMigrations.push({
         workspaceId: objectMetadata.workspaceId,
         name: generateMigrationName(`create-${objectMetadata.nameSingular}`),
-        isCustom: false,
+        isCustom: objectMetadata.isCustom,
         migrations,
       });
     }
@@ -136,7 +136,7 @@ export class WorkspaceMigrationObjectFactory {
           name: generateMigrationName(
             `rename-${objectMetadataUpdate.current.nameSingular}`,
           ),
-          isCustom: false,
+          isCustom: objectMetadataUpdate.altered.isCustom,
           migrations: [
             {
               name: oldTableName,
@@ -167,7 +167,7 @@ export class WorkspaceMigrationObjectFactory {
       workspaceMigrations.push({
         workspaceId: objectMetadata.workspaceId,
         name: generateMigrationName(`delete-${objectMetadata.nameSingular}`),
-        isCustom: false,
+        isCustom: objectMetadata.isCustom,
         migrations: [
           ...(relationMetadataCollection ?? []).map(
             (relationMetadata) =>

packages/twenty-server/src/engine/workspace-manager/workspace-migration-builder/workspace-migration-builder.module.ts

@@ -1,11 +1,12 @@
 import { Module } from '@nestjs/common';
 
+import { FeatureFlagModule } from 'src/engine/core-modules/feature-flag/feature-flag.module';
 import { WorkspaceMigrationModule } from 'src/engine/metadata-modules/workspace-migration/workspace-migration.module';
 
 import { workspaceMigrationBuilderFactories } from './factories';
 
 @Module({
-  imports: [WorkspaceMigrationModule],
+  imports: [WorkspaceMigrationModule, FeatureFlagModule],
   providers: [...workspaceMigrationBuilderFactories],
   exports: [...workspaceMigrationBuilderFactories],
 })

packages/twenty-server/src/engine/workspace-manager/workspace-migration-runner/utils/convert-on-delete-action-to-on-delete.util.ts

@@ -3,6 +3,10 @@ import { RelationOnDeleteAction } from 'src/engine/metadata-modules/relation-met
 export const convertOnDeleteActionToOnDelete = (
   onDeleteAction: RelationOnDeleteAction | undefined,
 ): 'CASCADE' | 'SET NULL' | 'RESTRICT' | 'NO ACTION' | undefined => {
+  if (!onDeleteAction) {
+    return undefined;
+  }
+
   switch (onDeleteAction) {
     case 'CASCADE':
       return 'CASCADE';

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

@@ -7,6 +7,7 @@ import {
   ActiveOrSuspendedWorkspacesMigrationCommandRunner,
   RunOnWorkspaceArgs,
 } from 'src/database/commands/command-runners/active-or-suspended-workspaces-migration.command-runner';
+import { FeatureFlagService } from 'src/engine/core-modules/feature-flag/services/feature-flag.service';
 import { Workspace } from 'src/engine/core-modules/workspace/workspace.entity';
 import { DataSourceService } from 'src/engine/metadata-modules/data-source/data-source.service';
 import { TwentyORMGlobalManager } from 'src/engine/twenty-orm/twenty-orm-global.manager';
@@ -25,6 +26,7 @@ export class SyncWorkspaceMetadataCommand extends ActiveOrSuspendedWorkspacesMig
     private readonly workspaceSyncMetadataService: WorkspaceSyncMetadataService,
     private readonly dataSourceService: DataSourceService,
     private readonly syncWorkspaceLoggerService: SyncWorkspaceLoggerService,
+    private readonly featureFlagService: FeatureFlagService,
     protected readonly twentyORMGlobalManager: TwentyORMGlobalManager,
   ) {
     super(workspaceRepository, twentyORMGlobalManager);
@@ -45,11 +47,15 @@ export class SyncWorkspaceMetadataCommand extends ActiveOrSuspendedWorkspacesMig
         workspaceId,
       );
 
+    const featureFlags =
+      await this.featureFlagService.getWorkspaceFeatureFlagsMap(workspaceId);
+
     const { storage, workspaceMigrations } =
       await this.workspaceSyncMetadataService.synchronize(
         {
           workspaceId,
           dataSourceId: dataSourceMetadata.id,
+          featureFlags,
         },
         { applyChanges: !options.dryRun },
       );

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

@@ -1,6 +1,7 @@
 import { Module } from '@nestjs/common';
 import { TypeOrmModule } from '@nestjs/typeorm';
 
+import { FeatureFlagModule } from 'src/engine/core-modules/feature-flag/feature-flag.module';
 import { Workspace } from 'src/engine/core-modules/workspace/workspace.entity';
 import { WorkspaceModule } from 'src/engine/core-modules/workspace/workspace.module';
 import { DataSourceModule } from 'src/engine/metadata-modules/data-source/data-source.module';
@@ -19,6 +20,7 @@ import { SyncWorkspaceMetadataCommand } from './sync-workspace-metadata.command'
     WorkspaceModule,
     DataSourceModule,
     WorkspaceDataSourceModule,
+    FeatureFlagModule,
     TypeOrmModule.forFeature([Workspace], 'core'),
     SyncWorkspaceLoggerModule,
   ],

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

@@ -1,3 +1,4 @@
+import { WorkspaceFieldRelationComparator } from 'src/engine/workspace-manager/workspace-sync-metadata/comparators/workspace-field-relation.comparator';
 import { WorkspaceIndexComparator } from 'src/engine/workspace-manager/workspace-sync-metadata/comparators/workspace-index.comparator';
 
 import { WorkspaceFieldComparator } from './workspace-field.comparator';
@@ -6,6 +7,7 @@ import { WorkspaceRelationComparator } from './workspace-relation.comparator';
 
 export const workspaceSyncMetadataComparators = [
   WorkspaceFieldComparator,
+  WorkspaceFieldRelationComparator,
   WorkspaceObjectComparator,
   WorkspaceRelationComparator,
   WorkspaceIndexComparator,

packages/twenty-server/src/engine/workspace-manager/workspace-sync-metadata/comparators/workspace-field-relation.comparator.ts

@@ -0,0 +1,250 @@
+import { Injectable } from '@nestjs/common';
+
+import diff, { DifferenceChange, DifferenceRemove } from 'microdiff';
+import { FieldMetadataType } from 'twenty-shared/types';
+
+import { FieldMetadataRelationSettings } from 'src/engine/metadata-modules/field-metadata/interfaces/field-metadata-settings.interface';
+import {
+  ComparatorAction,
+  FieldRelationComparatorResult,
+} from 'src/engine/workspace-manager/workspace-sync-metadata/interfaces/comparator.interface';
+
+import { FieldMetadataEntity } from 'src/engine/metadata-modules/field-metadata/field-metadata.entity';
+import { transformMetadataForComparison } from 'src/engine/workspace-manager/workspace-sync-metadata/comparators/utils/transform-metadata-for-comparison.util';
+
+const fieldPropertiesToCompare = [
+  'settings',
+  'relationTargetObjectMetadataId',
+  'relationTargetFieldMetadataId',
+];
+
+const fieldPropertiesToStringify = ['settings'] as const;
+
+@Injectable()
+export class WorkspaceFieldRelationComparator {
+  constructor() {}
+
+  public compare(
+    originalFieldMetadataCollection: FieldMetadataEntity<FieldMetadataType.RELATION>[],
+    standardFieldMetadataCollection: FieldMetadataEntity<FieldMetadataType.RELATION>[],
+  ): FieldRelationComparatorResult[] {
+    const result: FieldRelationComparatorResult[] = [];
+    const propertiesMap: Record<
+      string,
+      Partial<FieldMetadataEntity<FieldMetadataType.RELATION>>
+    > = {};
+
+    // Double security to only compare non-custom fields
+    const filteredOriginalFieldCollection =
+      originalFieldMetadataCollection.filter((field) => !field.isCustom);
+    const originalFieldMetadataMap = transformMetadataForComparison(
+      filteredOriginalFieldCollection,
+      {
+        shouldIgnoreProperty: (property) => {
+          if (fieldPropertiesToCompare.includes(property)) {
+            return false;
+          }
+
+          return true;
+        },
+        propertiesToStringify: fieldPropertiesToStringify,
+        keyFactory(datum) {
+          // Happen when the field is custom
+          return datum.standardId || datum.name;
+        },
+      },
+    );
+    const standardFieldMetadataMap = transformMetadataForComparison(
+      standardFieldMetadataCollection,
+      {
+        shouldIgnoreProperty: (property) => {
+          if (fieldPropertiesToCompare.includes(property)) {
+            return false;
+          }
+
+          return true;
+        },
+        propertiesToStringify: fieldPropertiesToStringify,
+        keyFactory(datum) {
+          // Happen when the field is custom
+          return datum.standardId || datum.name;
+        },
+      },
+    );
+
+    // Compare fields
+    const fieldMetadataDifference = diff(
+      originalFieldMetadataMap,
+      standardFieldMetadataMap,
+    );
+
+    const fieldMetadataDifferenceMap = fieldMetadataDifference.reduce(
+      (acc, difference) => {
+        const fieldId = difference.path[0];
+
+        if (difference.type === 'CREATE') {
+          throw new Error(
+            `CREATE should never happen when comparing relations as they are created previously`,
+          );
+        }
+
+        if (!acc[fieldId]) {
+          acc[fieldId] = [];
+        }
+
+        acc[fieldId].push(difference);
+
+        return acc;
+      },
+      {} as Record<string, (DifferenceChange | DifferenceRemove)[]>,
+    );
+
+    differenceLoop: for (const [fieldId, differences] of Object.entries(
+      fieldMetadataDifferenceMap,
+    )) {
+      const findField = (
+        field: FieldMetadataEntity<FieldMetadataType.RELATION>,
+      ) => {
+        return field.standardId === fieldId;
+      };
+      // Object shouldn't have thousands of fields, so we can use find here
+      const standardFieldMetadata =
+        standardFieldMetadataCollection.find(findField);
+      const originalFieldMetadata =
+        originalFieldMetadataCollection.find(findField);
+      const allNewPropertiesAreNull = Object.values(differences).every(
+        (difference) => {
+          if (difference.type === 'REMOVE') {
+            return true;
+          }
+
+          return difference.value === null;
+        },
+      );
+      const allOldPropertiesAreNull = Object.values(differences).every(
+        (difference) => difference.oldValue === null,
+      );
+      let relationTypeChange = false;
+
+      if (!originalFieldMetadata) {
+        throw new Error(`Field ${fieldId} not found in originalObjectMetadata`);
+      }
+
+      if (!standardFieldMetadata) {
+        throw new Error(`Field ${fieldId} not found in standardObjectMetadata`);
+      }
+
+      for (const difference of differences) {
+        const property = difference.path[difference.path.length - 1];
+
+        if (difference.type === 'REMOVE') {
+          // Whole relation is removed
+          if (property === fieldId) {
+            result.push({
+              action: ComparatorAction.DELETE,
+              object: originalFieldMetadata,
+            });
+
+            continue differenceLoop;
+          }
+
+          throw new Error(
+            `REMOVE partial part of relation should never happen, it should ben an update`,
+          );
+        }
+
+        // If the old value and the new value are both null, skip
+        // Database is storing null, and we can get undefined here
+        if (
+          difference.oldValue === null &&
+          (difference.value === null || difference.value === undefined)
+        ) {
+          break;
+        }
+
+        if (typeof property !== 'string') {
+          break;
+        }
+
+        if (!propertiesMap[fieldId]) {
+          propertiesMap[fieldId] = {};
+        }
+
+        // If the property is a stringified JSON, parse it
+        if (
+          (fieldPropertiesToStringify as readonly string[]).includes(property)
+        ) {
+          const newValue = this.parseJSONOrString(difference.value);
+
+          if (property === 'settings' && difference.oldValue) {
+            const newSettings = newValue as FieldMetadataRelationSettings;
+            const oldSettings =
+              difference.oldValue as FieldMetadataRelationSettings;
+
+            // Check if the relation type has changed
+            if (oldSettings.relationType !== newSettings.relationType) {
+              relationTypeChange = true;
+            }
+          }
+
+          propertiesMap[fieldId][property] = newValue;
+        } else {
+          propertiesMap[fieldId][property] = difference.value;
+        }
+      }
+
+      if (relationTypeChange) {
+        result.push({
+          action: ComparatorAction.DELETE,
+          object: originalFieldMetadata,
+        });
+
+        result.push({
+          action: ComparatorAction.CREATE,
+          object: {
+            ...propertiesMap[fieldId],
+            id: originalFieldMetadata.id,
+            standardId: standardFieldMetadata.standardId ?? undefined,
+          },
+        });
+      } else if (allOldPropertiesAreNull) {
+        result.push({
+          action: ComparatorAction.CREATE,
+          object: {
+            ...propertiesMap[fieldId],
+            id: originalFieldMetadata.id,
+            standardId: standardFieldMetadata.standardId ?? undefined,
+          },
+        });
+      } else if (allNewPropertiesAreNull) {
+        result.push({
+          action: ComparatorAction.DELETE,
+          object: originalFieldMetadata,
+        });
+      } else {
+        result.push({
+          action: ComparatorAction.UPDATE,
+          object: {
+            ...propertiesMap[fieldId],
+            id: originalFieldMetadata.id,
+            standardId: standardFieldMetadata.standardId ?? undefined,
+          },
+        });
+      }
+    }
+
+    return result;
+  }
+
+  private parseJSONOrString(value: string | null): string | object | null {
+    if (value === null) {
+      return null;
+    }
+
+    try {
+      return JSON.parse(value);
+    } catch {
+      return value;
+    }
+  }
+}

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

@@ -1,5 +1,6 @@
 import { StandardIndexFactory } from 'src/engine/workspace-manager/workspace-sync-metadata/factories/standard-index.factory';
 
+import { StandardFieldRelationFactory } from './standard-field-relation.factory';
 import { StandardFieldFactory } from './standard-field.factory';
 import { StandardObjectFactory } from './standard-object.factory';
 import { StandardRelationFactory } from './standard-relation.factory';
@@ -8,5 +9,6 @@ export const workspaceSyncMetadataFactories = [
   StandardFieldFactory,
   StandardObjectFactory,
   StandardRelationFactory,
+  StandardFieldRelationFactory,
   StandardIndexFactory,
 ];

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

@@ -0,0 +1,186 @@
+import { Injectable } from '@nestjs/common';
+
+import { FieldMetadataType } from 'twenty-shared/types';
+
+import { WorkspaceSyncContext } from 'src/engine/workspace-manager/workspace-sync-metadata/interfaces/workspace-sync-context.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 { 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 { convertClassNameToObjectMetadataName } from 'src/engine/workspace-manager/workspace-sync-metadata/utils/convert-class-to-object-metadata-name.util';
+import { isGatedAndNotEnabled } from 'src/engine/workspace-manager/workspace-sync-metadata/utils/is-gate-and-not-enabled.util';
+import { assert } from 'src/utils/assert';
+
+interface CustomRelationFactory {
+  object: ObjectMetadataEntity;
+  metadata: typeof BaseWorkspaceEntity;
+}
+
+@Injectable()
+export class StandardFieldRelationFactory {
+  createFieldRelationForCustomObject(
+    customObjectFactories: CustomRelationFactory[],
+    context: WorkspaceSyncContext,
+    originalObjectMetadataMap: Record<string, ObjectMetadataEntity>,
+  ): FieldMetadataEntity<FieldMetadataType.RELATION>[] {
+    return customObjectFactories.flatMap((customObjectFactory) =>
+      this.updateFieldRelationMetadata(
+        customObjectFactory,
+        context,
+        originalObjectMetadataMap,
+      ),
+    );
+  }
+
+  createFieldRelationForStandardObject(
+    standardObjectMetadataDefinitions: (typeof BaseWorkspaceEntity)[],
+    context: WorkspaceSyncContext,
+    originalObjectMetadataMap: Record<string, ObjectMetadataEntity>,
+  ): Map<string, FieldMetadataEntity<FieldMetadataType.RELATION>[]> {
+    return standardObjectMetadataDefinitions.reduce(
+      (acc, standardObjectMetadata) => {
+        const workspaceEntityMetadataArgs = metadataArgsStorage.filterEntities(
+          standardObjectMetadata,
+        );
+
+        if (!workspaceEntityMetadataArgs) {
+          return acc;
+        }
+
+        if (
+          isGatedAndNotEnabled(
+            workspaceEntityMetadataArgs.gate,
+            context.featureFlags,
+          )
+        ) {
+          return acc;
+        }
+
+        acc.set(
+          workspaceEntityMetadataArgs.standardId,
+          this.updateFieldRelationMetadata(
+            standardObjectMetadata,
+            context,
+            originalObjectMetadataMap,
+          ),
+        );
+
+        return acc;
+      },
+      new Map<string, FieldMetadataEntity<FieldMetadataType.RELATION>[]>(),
+    );
+  }
+
+  private updateFieldRelationMetadata(
+    workspaceEntityOrCustomRelationFactory:
+      | typeof BaseWorkspaceEntity
+      | CustomRelationFactory,
+    context: WorkspaceSyncContext,
+    originalObjectMetadataMap: Record<string, ObjectMetadataEntity>,
+  ): FieldMetadataEntity<FieldMetadataType.RELATION>[] {
+    const target =
+      'metadata' in workspaceEntityOrCustomRelationFactory
+        ? workspaceEntityOrCustomRelationFactory.metadata
+        : workspaceEntityOrCustomRelationFactory;
+    const workspaceEntity =
+      'metadata' in workspaceEntityOrCustomRelationFactory
+        ? metadataArgsStorage.filterExtendedEntities(target)
+        : metadataArgsStorage.filterEntities(target);
+    const workspaceRelationMetadataArgsCollection =
+      metadataArgsStorage.filterRelations(target);
+
+    if (!workspaceEntity) {
+      throw new Error(
+        `Object metadata decorator not found, can't parse ${target.name}`,
+      );
+    }
+
+    if (
+      !workspaceRelationMetadataArgsCollection ||
+      isGatedAndNotEnabled(workspaceEntity?.gate, context.featureFlags)
+    ) {
+      return [];
+    }
+
+    return workspaceRelationMetadataArgsCollection
+      .filter(
+        (workspaceRelationMetadataArgs) =>
+          !isGatedAndNotEnabled(
+            workspaceRelationMetadataArgs.gate,
+            context.featureFlags,
+          ),
+      )
+      .map((workspaceRelationMetadataArgs) => {
+        // Compute reflect relation metadata
+        const sourceObjectNameSingular =
+          'object' in workspaceEntityOrCustomRelationFactory
+            ? workspaceEntityOrCustomRelationFactory.object.nameSingular
+            : convertClassNameToObjectMetadataName(
+                workspaceRelationMetadataArgs.target.name,
+              );
+        const inverseSideTarget =
+          workspaceRelationMetadataArgs.inverseSideTarget();
+        const targetObjectNameSingular = convertClassNameToObjectMetadataName(
+          inverseSideTarget.name,
+        );
+        const sourceFieldMetadataName = workspaceRelationMetadataArgs.name;
+        const targetFieldMetadataName =
+          (workspaceRelationMetadataArgs.inverseSideFieldKey as
+            | string
+            | undefined) ?? sourceObjectNameSingular;
+        const sourceObjectMetadata =
+          originalObjectMetadataMap[sourceObjectNameSingular];
+        const joinColumnsMetadataArgsCollection =
+          metadataArgsStorage.filterJoinColumns(target);
+        const joinColumnName = getJoinColumn(
+          joinColumnsMetadataArgsCollection,
+          workspaceRelationMetadataArgs,
+        );
+
+        assert(
+          sourceObjectMetadata,
+          `Source object ${sourceObjectNameSingular} not found in databse for relation ${workspaceRelationMetadataArgs.name} of type ${workspaceRelationMetadataArgs.type}`,
+        );
+
+        const targetObjectMetadata =
+          originalObjectMetadataMap[targetObjectNameSingular];
+
+        assert(
+          targetObjectMetadata,
+          `Target object ${targetObjectNameSingular} not found in databse for relation ${workspaceRelationMetadataArgs.name} of type ${workspaceRelationMetadataArgs.type}`,
+        );
+
+        const sourceFieldMetadata = sourceObjectMetadata?.fields.find(
+          (field) => field.name === sourceFieldMetadataName,
+        ) as FieldMetadataEntity<FieldMetadataType.RELATION>;
+
+        assert(
+          sourceFieldMetadata,
+          `Source field ${sourceFieldMetadataName} not found in object ${sourceObjectNameSingular} for relation ${workspaceRelationMetadataArgs.name} of type ${workspaceRelationMetadataArgs.type}`,
+        );
+
+        const targetFieldMetadata = targetObjectMetadata?.fields.find(
+          (field) => field.name === targetFieldMetadataName,
+        ) as FieldMetadataEntity<FieldMetadataType.RELATION>;
+
+        assert(
+          targetFieldMetadata,
+          `Target field ${targetFieldMetadataName} not found in object ${targetObjectNameSingular} for relation ${workspaceRelationMetadataArgs.name} of type ${workspaceRelationMetadataArgs.type}`,
+        );
+
+        return {
+          ...sourceFieldMetadata,
+          type: FieldMetadataType.RELATION,
+          settings: {
+            relationType: workspaceRelationMetadataArgs.type,
+            onDelete: workspaceRelationMetadataArgs.onDelete,
+            joinColumnName,
+          },
+          relationTargetObjectMetadataId: targetObjectMetadata.id,
+          relationTargetFieldMetadataId: targetFieldMetadata.id,
+        } satisfies FieldMetadataEntity<FieldMetadataType.RELATION>;
+      });
+  }
+}

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

@@ -2,7 +2,7 @@ import { Injectable } from '@nestjs/common';
 
 import { FieldMetadataType } from 'twenty-shared/types';
 
-import { FeatureFlagMap } from 'src/engine/core-modules/feature-flag/interfaces/feature-flag-map.interface';
+import { RelationType } from 'src/engine/metadata-modules/field-metadata/interfaces/relation-type.interface';
 import { WorkspaceDynamicRelationMetadataArgs } from 'src/engine/twenty-orm/interfaces/workspace-dynamic-relation-metadata-args.interface';
 import { WorkspaceEntityMetadataArgs } from 'src/engine/twenty-orm/interfaces/workspace-entity-metadata-args.interface';
 import { WorkspaceFieldMetadataArgs } from 'src/engine/twenty-orm/interfaces/workspace-field-metadata-args.interface';
@@ -13,7 +13,7 @@ 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 { RelationMetadataType } from 'src/engine/metadata-modules/relation-metadata/relation-metadata.entity';
+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';
@@ -25,13 +25,11 @@ export class StandardFieldFactory {
   create(
     target: typeof BaseWorkspaceEntity,
     context: WorkspaceSyncContext,
-    workspaceFeatureFlagsMap: FeatureFlagMap,
   ): (PartialFieldMetadata | PartialComputedFieldMetadata)[];
 
   create(
     targets: (typeof BaseWorkspaceEntity)[],
     context: WorkspaceSyncContext,
-    workspaceFeatureFlagsMap: FeatureFlagMap, // Map of standardId to field metadata
   ): Map<string, (PartialFieldMetadata | PartialComputedFieldMetadata)[]>;
 
   create(
@@ -39,7 +37,6 @@ export class StandardFieldFactory {
       | typeof BaseWorkspaceEntity
       | (typeof BaseWorkspaceEntity)[],
     context: WorkspaceSyncContext,
-    workspaceFeatureFlagsMap: FeatureFlagMap,
   ):
     | (PartialFieldMetadata | PartialComputedFieldMetadata)[]
     | Map<string, (PartialFieldMetadata | PartialComputedFieldMetadata)[]> {
@@ -55,7 +52,7 @@ export class StandardFieldFactory {
         if (
           isGatedAndNotEnabled(
             workspaceEntityMetadataArgs.gate,
-            workspaceFeatureFlagsMap,
+            context.featureFlags,
           )
         ) {
           return acc;
@@ -63,7 +60,7 @@ export class StandardFieldFactory {
 
         acc.set(
           workspaceEntityMetadataArgs.standardId,
-          this.create(target, context, workspaceFeatureFlagsMap),
+          this.create(target, context),
         );
 
         return acc;
@@ -79,21 +76,18 @@ export class StandardFieldFactory {
         workspaceEntityMetadataArgs,
         metadataCollections.fields,
         context,
-        workspaceFeatureFlagsMap,
         this.createFieldMetadata,
       ),
       ...this.processMetadata(
         workspaceEntityMetadataArgs,
         metadataCollections.relations,
         context,
-        workspaceFeatureFlagsMap,
         this.createFieldRelationMetadata,
       ),
       ...this.processMetadata(
         workspaceEntityMetadataArgs,
         metadataCollections.dynamicRelations,
         context,
-        workspaceFeatureFlagsMap,
         this.createComputedFieldRelationMetadata,
       ),
     ];
@@ -114,22 +108,15 @@ export class StandardFieldFactory {
     workspaceEntityMetadataArgs: WorkspaceEntityMetadataArgs | undefined,
     metadataArgs: T[],
     context: WorkspaceSyncContext,
-    featureFlagsMap: FeatureFlagMap,
     createMetadata: (
       workspaceEntityMetadataArgs: WorkspaceEntityMetadataArgs | undefined,
       args: T,
       context: WorkspaceSyncContext,
-      featureFlagsMap: FeatureFlagMap,
     ) => U[],
   ): U[] {
     return metadataArgs
       .flatMap((args) =>
-        createMetadata(
-          workspaceEntityMetadataArgs,
-          args,
-          context,
-          featureFlagsMap,
-        ),
+        createMetadata(workspaceEntityMetadataArgs, args, context),
       )
       .filter(Boolean) as U[];
   }
@@ -141,12 +128,11 @@ export class StandardFieldFactory {
     workspaceEntityMetadataArgs: WorkspaceEntityMetadataArgs | undefined,
     workspaceFieldMetadataArgs: WorkspaceFieldMetadataArgs,
     context: WorkspaceSyncContext,
-    workspaceFeatureFlagsMap: FeatureFlagMap,
   ): PartialFieldMetadata[] {
     if (
       isGatedAndNotEnabled(
         workspaceFieldMetadataArgs.gate,
-        workspaceFeatureFlagsMap,
+        context.featureFlags,
       )
     ) {
       return [];
@@ -182,8 +168,10 @@ export class StandardFieldFactory {
     workspaceEntityMetadataArgs: WorkspaceEntityMetadataArgs | undefined,
     workspaceRelationMetadataArgs: WorkspaceRelationMetadataArgs,
     context: WorkspaceSyncContext,
-    workspaceFeatureFlagsMap: FeatureFlagMap,
   ): PartialFieldMetadata[] {
+    const isNewRelationEnabled =
+      context.featureFlags[FeatureFlagKey.IsNewRelationEnabled];
+
     const fieldMetadataCollection: PartialFieldMetadata[] = [];
     const foreignKeyStandardId = createDeterministicUuid(
       workspaceRelationMetadataArgs.standardId,
@@ -200,13 +188,14 @@ export class StandardFieldFactory {
     if (
       isGatedAndNotEnabled(
         workspaceRelationMetadataArgs.gate,
-        workspaceFeatureFlagsMap,
+        context.featureFlags,
       )
     ) {
       return [];
     }
 
-    if (joinColumn) {
+    // We don't want to create the join column field metadata for new relation
+    if (!isNewRelationEnabled && joinColumn) {
       fieldMetadataCollection.push({
         type: FieldMetadataType.UUID,
         standardId: foreignKeyStandardId,
@@ -222,8 +211,7 @@ export class StandardFieldFactory {
         isSystem: true,
         isNullable: workspaceRelationMetadataArgs.isNullable,
         isUnique:
-          workspaceRelationMetadataArgs.type ===
-          RelationMetadataType.ONE_TO_ONE,
+          workspaceRelationMetadataArgs.type === RelationType.ONE_TO_ONE,
         isActive: workspaceRelationMetadataArgs.isActive ?? true,
       });
     }
@@ -235,15 +223,13 @@ export class StandardFieldFactory {
       label: workspaceRelationMetadataArgs.label,
       description: workspaceRelationMetadataArgs.description,
       icon: workspaceRelationMetadataArgs.icon,
-      defaultValue: null,
       workspaceId: context.workspaceId,
       isCustom: false,
       isSystem:
         workspaceEntityMetadataArgs?.isSystem ||
         workspaceRelationMetadataArgs.isSystem,
       isNullable: true,
-      isUnique:
-        workspaceRelationMetadataArgs.type === RelationMetadataType.ONE_TO_ONE,
+      isUnique: workspaceRelationMetadataArgs.type === RelationType.ONE_TO_ONE,
       isActive: workspaceRelationMetadataArgs.isActive ?? true,
     });
 
@@ -259,13 +245,12 @@ export class StandardFieldFactory {
       | WorkspaceDynamicRelationMetadataArgs
       | undefined,
     context: WorkspaceSyncContext,
-    workspaceFeatureFlagsMap: FeatureFlagMap,
   ): PartialComputedFieldMetadata[] {
     if (
       !workspaceDynamicRelationMetadataArgs ||
       isGatedAndNotEnabled(
         workspaceDynamicRelationMetadataArgs.gate,
-        workspaceFeatureFlagsMap,
+        context.featureFlags,
       )
     ) {
       return [];

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

@@ -1,6 +1,5 @@
 import { Injectable } from '@nestjs/common';
 
-import { FeatureFlagMap } from 'src/engine/core-modules/feature-flag/interfaces/feature-flag-map.interface';
 import { PartialIndexMetadata } from 'src/engine/workspace-manager/workspace-sync-metadata/interfaces/partial-index-metadata.interface';
 import { WorkspaceSyncContext } from 'src/engine/workspace-manager/workspace-sync-metadata/interfaces/workspace-sync-context.interface';
 
@@ -20,7 +19,6 @@ export class StandardIndexFactory {
     context: WorkspaceSyncContext,
     originalStandardObjectMetadataMap: Record<string, ObjectMetadataEntity>,
     originalCustomObjectMetadataMap: Record<string, ObjectMetadataEntity>,
-    workspaceFeatureFlagsMap: FeatureFlagMap,
   ): Partial<IndexMetadataEntity>[] {
     const standardIndexOnStandardObjects =
       standardObjectMetadataDefinitions.flatMap((standardObjectMetadata) =>
@@ -28,7 +26,6 @@ export class StandardIndexFactory {
           standardObjectMetadata,
           context,
           originalStandardObjectMetadataMap,
-          workspaceFeatureFlagsMap,
         ),
       );
 
@@ -36,7 +33,6 @@ export class StandardIndexFactory {
       this.createStandardIndexMetadataForCustomObject(
         context,
         originalCustomObjectMetadataMap,
-        workspaceFeatureFlagsMap,
       );
 
     return [
@@ -49,7 +45,6 @@ export class StandardIndexFactory {
     target: typeof BaseWorkspaceEntity,
     context: WorkspaceSyncContext,
     originalStandardObjectMetadataMap: Record<string, ObjectMetadataEntity>,
-    workspaceFeatureFlagsMap: FeatureFlagMap,
   ): Partial<IndexMetadataEntity>[] {
     const workspaceEntity = metadataArgsStorage.filterEntities(target);
 
@@ -59,7 +54,7 @@ export class StandardIndexFactory {
       );
     }
 
-    if (isGatedAndNotEnabled(workspaceEntity?.gate, workspaceFeatureFlagsMap)) {
+    if (isGatedAndNotEnabled(workspaceEntity?.gate, context.featureFlags)) {
       return [];
     }
 
@@ -68,7 +63,7 @@ export class StandardIndexFactory {
       .filter((workspaceIndexMetadataArgs) => {
         return !isGatedAndNotEnabled(
           workspaceIndexMetadataArgs.gate,
-          workspaceFeatureFlagsMap,
+          context.featureFlags,
         );
       });
 
@@ -102,7 +97,6 @@ export class StandardIndexFactory {
   private createStandardIndexMetadataForCustomObject(
     context: WorkspaceSyncContext,
     originalCustomObjectMetadataMap: Record<string, ObjectMetadataEntity>,
-    workspaceFeatureFlagsMap: FeatureFlagMap,
   ): Partial<IndexMetadataEntity>[] {
     const target = CustomWorkspaceEntity;
     const workspaceEntity = metadataArgsStorage.filterExtendedEntities(target);
@@ -118,7 +112,7 @@ export class StandardIndexFactory {
       .filter((workspaceIndexMetadataArgs) => {
         return !isGatedAndNotEnabled(
           workspaceIndexMetadataArgs.gate,
-          workspaceFeatureFlagsMap,
+          context.featureFlags,
         );
       });
 

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

@@ -1,6 +1,5 @@
 import { Injectable } from '@nestjs/common';
 
-import { FeatureFlagMap } from 'src/engine/core-modules/feature-flag/interfaces/feature-flag-map.interface';
 import { PartialWorkspaceEntity } from 'src/engine/workspace-manager/workspace-sync-metadata/interfaces/partial-object-metadata.interface';
 import { WorkspaceSyncContext } from 'src/engine/workspace-manager/workspace-sync-metadata/interfaces/workspace-sync-context.interface';
 
@@ -13,19 +12,15 @@ export class StandardObjectFactory {
   create(
     standardObjectMetadataDefinitions: (typeof BaseWorkspaceEntity)[],
     context: WorkspaceSyncContext,
-    workspaceFeatureFlagsMap: FeatureFlagMap,
   ): Omit<PartialWorkspaceEntity, 'fields' | 'indexMetadatas'>[] {
     return standardObjectMetadataDefinitions
-      .map((metadata) =>
-        this.createObjectMetadata(metadata, context, workspaceFeatureFlagsMap),
-      )
+      .map((metadata) => this.createObjectMetadata(metadata, context))
       .filter((metadata): metadata is PartialWorkspaceEntity => !!metadata);
   }
 
   private createObjectMetadata(
     target: typeof BaseWorkspaceEntity,
     context: WorkspaceSyncContext,
-    workspaceFeatureFlagsMap: FeatureFlagMap,
   ): Omit<PartialWorkspaceEntity, 'fields' | 'indexMetadatas'> | undefined {
     const workspaceEntityMetadataArgs =
       metadataArgsStorage.filterEntities(target);
@@ -39,7 +34,7 @@ export class StandardObjectFactory {
     if (
       isGatedAndNotEnabled(
         workspaceEntityMetadataArgs.gate,
-        workspaceFeatureFlagsMap,
+        context.featureFlags,
       )
     ) {
       return undefined;

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

@@ -1,18 +1,18 @@
 import { Injectable } from '@nestjs/common';
 
+import { RelationType } from 'src/engine/metadata-modules/field-metadata/interfaces/relation-type.interface';
 import { WorkspaceSyncContext } from 'src/engine/workspace-manager/workspace-sync-metadata/interfaces/workspace-sync-context.interface';
-import { FeatureFlagMap } from 'src/engine/core-modules/feature-flag/interfaces/feature-flag-map.interface';
 
-import { isGatedAndNotEnabled } from 'src/engine/workspace-manager/workspace-sync-metadata/utils/is-gate-and-not-enabled.util';
-import { assert } from 'src/utils/assert';
+import { ObjectMetadataEntity } from 'src/engine/metadata-modules/object-metadata/object-metadata.entity';
 import {
   RelationMetadataEntity,
   RelationMetadataType,
 } from 'src/engine/metadata-modules/relation-metadata/relation-metadata.entity';
-import { ObjectMetadataEntity } from 'src/engine/metadata-modules/object-metadata/object-metadata.entity';
-import { convertClassNameToObjectMetadataName } from 'src/engine/workspace-manager/workspace-sync-metadata/utils/convert-class-to-object-metadata-name.util';
 import { BaseWorkspaceEntity } from 'src/engine/twenty-orm/base.workspace-entity';
 import { metadataArgsStorage } from 'src/engine/twenty-orm/storage/metadata-args.storage';
+import { convertClassNameToObjectMetadataName } from 'src/engine/workspace-manager/workspace-sync-metadata/utils/convert-class-to-object-metadata-name.util';
+import { isGatedAndNotEnabled } from 'src/engine/workspace-manager/workspace-sync-metadata/utils/is-gate-and-not-enabled.util';
+import { assert } from 'src/utils/assert';
 
 interface CustomRelationFactory {
   object: ObjectMetadataEntity;
@@ -25,14 +25,12 @@ export class StandardRelationFactory {
     customObjectFactories: CustomRelationFactory[],
     context: WorkspaceSyncContext,
     originalObjectMetadataMap: Record<string, ObjectMetadataEntity>,
-    workspaceFeatureFlagsMap: FeatureFlagMap,
   ): Partial<RelationMetadataEntity>[];
 
   create(
     standardObjectMetadataDefinitions: (typeof BaseWorkspaceEntity)[],
     context: WorkspaceSyncContext,
     originalObjectMetadataMap: Record<string, ObjectMetadataEntity>,
-    workspaceFeatureFlagsMap: FeatureFlagMap,
   ): Partial<RelationMetadataEntity>[];
 
   create(
@@ -44,7 +42,6 @@ export class StandardRelationFactory {
         }[],
     context: WorkspaceSyncContext,
     originalObjectMetadataMap: Record<string, ObjectMetadataEntity>,
-    workspaceFeatureFlagsMap: FeatureFlagMap,
   ): Partial<RelationMetadataEntity>[] {
     return standardObjectMetadataDefinitionsOrCustomObjectFactories.flatMap(
       (
@@ -56,7 +53,6 @@ export class StandardRelationFactory {
           standardObjectMetadata,
           context,
           originalObjectMetadataMap,
-          workspaceFeatureFlagsMap,
         ),
     );
   }
@@ -67,7 +63,6 @@ export class StandardRelationFactory {
       | CustomRelationFactory,
     context: WorkspaceSyncContext,
     originalObjectMetadataMap: Record<string, ObjectMetadataEntity>,
-    workspaceFeatureFlagsMap: FeatureFlagMap,
   ): Partial<RelationMetadataEntity>[] {
     const target =
       'metadata' in workspaceEntityOrCustomRelationFactory
@@ -88,7 +83,7 @@ export class StandardRelationFactory {
 
     if (
       !workspaceRelationMetadataArgsCollection ||
-      isGatedAndNotEnabled(workspaceEntity?.gate, workspaceFeatureFlagsMap)
+      isGatedAndNotEnabled(workspaceEntity?.gate, context.featureFlags)
     ) {
       return [];
     }
@@ -96,16 +91,13 @@ export class StandardRelationFactory {
     return workspaceRelationMetadataArgsCollection
       .filter((workspaceRelationMetadataArgs) => {
         // We're not storing many-to-one relations in the DB for the moment
-        if (
-          workspaceRelationMetadataArgs.type ===
-          RelationMetadataType.MANY_TO_ONE
-        ) {
+        if (workspaceRelationMetadataArgs.type === RelationType.MANY_TO_ONE) {
           return false;
         }
 
         return !isGatedAndNotEnabled(
           workspaceRelationMetadataArgs.gate,
-          workspaceFeatureFlagsMap,
+          context.featureFlags,
         );
       })
       .map((workspaceRelationMetadataArgs) => {
@@ -163,7 +155,9 @@ export class StandardRelationFactory {
         );
 
         return {
-          relationType: workspaceRelationMetadataArgs.type,
+          // TODO: Will be removed when we drop RelationMetadata
+          relationType:
+            workspaceRelationMetadataArgs.type as unknown as RelationMetadataType,
           fromObjectMetadataId: fromObjectMetadata?.id,
           toObjectMetadataId: toObjectMetadata?.id,
           fromFieldMetadataId: fromFieldMetadata?.id,

packages/twenty-server/src/engine/workspace-manager/workspace-sync-metadata/interfaces/comparator.interface.ts

@@ -1,3 +1,5 @@
+import { FieldMetadataType } from 'twenty-shared/types';
+
 import { FieldMetadataEntity } from 'src/engine/metadata-modules/field-metadata/field-metadata.entity';
 import { IndexMetadataEntity } from 'src/engine/metadata-modules/index-metadata/index-metadata.entity';
 import { RelationMetadataEntity } from 'src/engine/metadata-modules/relation-metadata/relation-metadata.entity';
@@ -52,6 +54,20 @@ export type FieldComparatorResult =
     >
   | ComparatorDeleteResult<FieldMetadataEntity>;
 
+export type FieldRelationComparatorResult =
+  | ComparatorSkipResult
+  | ComparatorCreateResult<
+      Partial<ComputedPartialFieldMetadata<FieldMetadataType.RELATION>> & {
+        id: string;
+      }
+    >
+  | ComparatorUpdateResult<
+      Partial<ComputedPartialFieldMetadata<FieldMetadataType.RELATION>> & {
+        id: string;
+      }
+    >
+  | ComparatorDeleteResult<FieldMetadataEntity<FieldMetadataType.RELATION>>;
+
 export type RelationComparatorResult =
   | ComparatorCreateResult<Partial<RelationMetadataEntity>>
   | ComparatorDeleteResult<RelationMetadataEntity>

packages/twenty-server/src/engine/workspace-manager/workspace-sync-metadata/interfaces/partial-field-metadata.interface.ts

@@ -5,8 +5,10 @@ import { WorkspaceDynamicRelationMetadataArgsFactory } from 'src/engine/twenty-o
 
 import { ObjectMetadataEntity } from 'src/engine/metadata-modules/object-metadata/object-metadata.entity';
 
-export type PartialFieldMetadata = Omit<
-  FieldMetadataInterface,
+export type PartialFieldMetadata<
+  T extends FieldMetadataType = FieldMetadataType,
+> = Omit<
+  FieldMetadataInterface<T>,
   'id' | 'label' | 'description' | 'objectMetadataId'
 > & {
   standardId: string;
@@ -31,6 +33,10 @@ export type PartialComputedFieldMetadata = {
   objectMetadataId?: string;
 };
 
-export type ComputedPartialFieldMetadata = {
-  [K in keyof PartialFieldMetadata]: ExcludeFunctions<PartialFieldMetadata[K]>;
+export type ComputedPartialFieldMetadata<
+  T extends FieldMetadataType = FieldMetadataType,
+> = {
+  [K in keyof PartialFieldMetadata<T>]: ExcludeFunctions<
+    PartialFieldMetadata<T>[K]
+  >;
 };

packages/twenty-server/src/engine/workspace-manager/workspace-sync-metadata/interfaces/updater-action.type.ts

@@ -0,0 +1 @@
+export type UpdaterAction = 'create' | 'update' | 'delete';

packages/twenty-server/src/engine/workspace-manager/workspace-sync-metadata/interfaces/updater-options.interface.ts

@@ -0,0 +1,5 @@
+import { UpdaterAction } from 'src/engine/workspace-manager/workspace-sync-metadata/interfaces/updater-action.type';
+
+export interface UpdaterOptions {
+  actions: UpdaterAction[];
+}

packages/twenty-server/src/engine/workspace-manager/workspace-sync-metadata/interfaces/workspace-sync-context.interface.ts

@@ -1,4 +1,7 @@
+import { FeatureFlagMap } from 'src/engine/core-modules/feature-flag/interfaces/feature-flag-map.interface';
+
 export interface WorkspaceSyncContext {
   workspaceId: string;
   dataSourceId: string;
+  featureFlags: FeatureFlagMap;
 }

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

@@ -1,5 +1,7 @@
 import { Injectable } from '@nestjs/common';
 
+import { FieldMetadataType } from 'twenty-shared/types';
+import { capitalize } from 'twenty-shared/utils';
 import {
   EntityManager,
   EntityTarget,
@@ -10,12 +12,13 @@ import {
 } from 'typeorm';
 import { DeepPartial } from 'typeorm/common/DeepPartial';
 import { v4 as uuidV4 } from 'uuid';
-import { capitalize } from 'twenty-shared/utils';
-import { FieldMetadataType } from 'twenty-shared/types';
 
 import { PartialFieldMetadata } from 'src/engine/workspace-manager/workspace-sync-metadata/interfaces/partial-field-metadata.interface';
 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';
 import { FieldMetadataEntity } from 'src/engine/metadata-modules/field-metadata/field-metadata.entity';
@@ -25,63 +28,77 @@ import { IndexMetadataEntity } from 'src/engine/metadata-modules/index-metadata/
 import { ObjectMetadataEntity } from 'src/engine/metadata-modules/object-metadata/object-metadata.entity';
 import { RelationMetadataEntity } from 'src/engine/metadata-modules/relation-metadata/relation-metadata.entity';
 import { CompositeFieldMetadataType } from 'src/engine/metadata-modules/workspace-migration/factories/composite-column-action.factory';
+import { isFieldMetadataEntityOfType } from 'src/engine/utils/is-field-metadata-of-type.util';
 import { FieldMetadataUpdate } from 'src/engine/workspace-manager/workspace-migration-builder/factories/workspace-migration-field.factory';
 import { ObjectMetadataUpdate } from 'src/engine/workspace-manager/workspace-migration-builder/factories/workspace-migration-object.factory';
 import { WorkspaceSyncStorage } from 'src/engine/workspace-manager/workspace-sync-metadata/storage/workspace-sync.storage';
 
 @Injectable()
 export class WorkspaceMetadataUpdaterService {
+  constructor(private readonly featureFlagService: FeatureFlagService) {}
+
   async updateObjectMetadata(
     manager: EntityManager,
     storage: WorkspaceSyncStorage,
+    options?: UpdaterOptions,
   ): Promise<{
     createdObjectMetadataCollection: ObjectMetadataEntity[];
     updatedObjectMetadataCollection: ObjectMetadataUpdate[];
   }> {
     const objectMetadataRepository =
       manager.getRepository(ObjectMetadataEntity);
+    let createdObjectMetadataCollection: ObjectMetadataEntity[] = [];
+    let updatedObjectMetadataCollection: ObjectMetadataUpdate[] = [];
 
     /**
      * Create object metadata
      */
-    const createdPartialObjectMetadataCollection =
-      await objectMetadataRepository.save(
-        storage.objectMetadataCreateCollection.map((objectMetadata) => ({
-          ...objectMetadata,
-          isActive: true,
-        })) as DeepPartial<ObjectMetadataEntity>[],
+    if (!options || options.actions.includes('create')) {
+      const createdPartialObjectMetadataCollection =
+        await objectMetadataRepository.save(
+          storage.objectMetadataCreateCollection.map((objectMetadata) => ({
+            ...objectMetadata,
+            isActive: true,
+          })) as DeepPartial<ObjectMetadataEntity>[],
+        );
+      const identifiers = createdPartialObjectMetadataCollection.map(
+        (object) => object.id,
       );
-    const identifiers = createdPartialObjectMetadataCollection.map(
-      (object) => object.id,
-    );
-    const createdObjectMetadataCollection = await manager.find(
-      ObjectMetadataEntity,
-      {
-        where: { id: In(identifiers) },
-        relations: ['dataSource', 'fields'],
-      },
-    );
+
+      createdObjectMetadataCollection = await manager.find(
+        ObjectMetadataEntity,
+        {
+          where: { id: In(identifiers) },
+          relations: ['dataSource', 'fields'],
+        },
+      );
+    }
 
     /**
      * Update object metadata
      */
-    const updatedObjectMetadataCollection = await this.updateEntities(
-      manager,
-      ObjectMetadataEntity,
-      storage.objectMetadataUpdateCollection,
-      [
-        'fields',
-        'dataSourceId',
-        'workspaceId',
-        'labelIdentifierFieldMetadataId',
-        'imageIdentifierFieldMetadataId',
-      ],
-    );
+    if (!options || options.actions.includes('update')) {
+      updatedObjectMetadataCollection = await this.updateEntities(
+        manager,
+        ObjectMetadataEntity,
+        storage.objectMetadataUpdateCollection,
+        [
+          'fields',
+          'dataSourceId',
+          'workspaceId',
+          'labelIdentifierFieldMetadataId',
+          'imageIdentifierFieldMetadataId',
+        ],
+      );
+    }
 
     /**
      * Delete object metadata
      */
-    if (storage.objectMetadataDeleteCollection.length > 0) {
+    if (
+      storage.objectMetadataDeleteCollection.length > 0 &&
+      (!options || options.actions.includes('delete'))
+    ) {
       await objectMetadataRepository.delete(
         storage.objectMetadataDeleteCollection.map((object) => object.id),
       );
@@ -121,6 +138,7 @@ export class WorkspaceMetadataUpdaterService {
   async updateFieldMetadata(
     manager: EntityManager,
     storage: WorkspaceSyncStorage,
+    options?: UpdaterOptions,
   ): Promise<{
     createdFieldMetadataCollection: FieldMetadataEntity[];
     updatedFieldMetadataCollection: FieldMetadataUpdate[];
@@ -130,26 +148,32 @@ export class WorkspaceMetadataUpdaterService {
       IndexFieldMetadataEntity,
     );
     const indexMetadataRepository = manager.getRepository(IndexMetadataEntity);
+    let createdFieldMetadataCollection: FieldMetadataEntity[] = [];
+    let updatedFieldMetadataCollection: FieldMetadataUpdate[] = [];
 
     /**
      * Update field metadata
      */
-    const updatedFieldMetadataCollection =
-      await this.updateEntities<FieldMetadataEntity>(
-        manager,
-        FieldMetadataEntity,
-        storage.fieldMetadataUpdateCollection,
-        ['objectMetadataId', 'workspaceId'],
-      );
+    if (!options || options.actions.includes('update')) {
+      updatedFieldMetadataCollection =
+        await this.updateEntities<FieldMetadataEntity>(
+          manager,
+          FieldMetadataEntity,
+          storage.fieldMetadataUpdateCollection,
+          ['objectMetadataId', 'workspaceId'],
+        );
+    }
 
     /**
      * Create field metadata
      */
-    const createdFieldMetadataCollection = await fieldMetadataRepository.save(
-      storage.fieldMetadataCreateCollection.map((field) =>
-        this.prepareFieldMetadataForCreation(field),
-      ) as DeepPartial<FieldMetadataEntity>[],
-    );
+    if (!options || options.actions.includes('create')) {
+      createdFieldMetadataCollection = await fieldMetadataRepository.save(
+        storage.fieldMetadataCreateCollection.map((field) =>
+          this.prepareFieldMetadataForCreation(field),
+        ) as DeepPartial<FieldMetadataEntity>[],
+      );
+    }
 
     /**
      * Delete field metadata
@@ -160,7 +184,10 @@ export class WorkspaceMetadataUpdaterService {
         (field) => field.type !== FieldMetadataType.RELATION,
       );
 
-    if (fieldMetadataDeleteCollectionWithoutRelationType.length > 0) {
+    if (
+      fieldMetadataDeleteCollectionWithoutRelationType.length > 0 &&
+      (!options || options.actions.includes('delete'))
+    ) {
       await this.deleteIndexFieldMetadata(
         fieldMetadataDeleteCollectionWithoutRelationType,
         indexFieldMetadataRepository,
@@ -181,6 +208,68 @@ export class WorkspaceMetadataUpdaterService {
     };
   }
 
+  async updateFieldRelationMetadata(
+    manager: EntityManager,
+    storage: WorkspaceSyncStorage,
+    options?: UpdaterOptions,
+  ): Promise<{
+    createdFieldRelationMetadataCollection: FieldMetadataUpdate<FieldMetadataType.RELATION>[];
+    updatedFieldRelationMetadataCollection: FieldMetadataUpdate<FieldMetadataType.RELATION>[];
+    deletedFieldRelationMetadataCollection: FieldMetadataUpdate<FieldMetadataType.RELATION>[];
+  }> {
+    let createdFieldRelationMetadataCollection: FieldMetadataUpdate<FieldMetadataType.RELATION>[] =
+      [];
+    let updatedFieldRelationMetadataCollection: FieldMetadataUpdate<FieldMetadataType.RELATION>[] =
+      [];
+    let deletedFieldRelationMetadataCollection: FieldMetadataUpdate<FieldMetadataType.RELATION>[] =
+      [];
+
+    /**
+     * Create field relation metadata
+     */
+    if (!options || options.actions.includes('create')) {
+      createdFieldRelationMetadataCollection = await this.updateEntities<
+        FieldMetadataEntity<FieldMetadataType.RELATION>
+      >(
+        manager,
+        FieldMetadataEntity,
+        storage.fieldRelationMetadataCreateCollection,
+        ['objectMetadataId', 'workspaceId'],
+      );
+    }
+
+    /**
+     * Update field relation metadata
+     */
+    if (!options || options.actions.includes('update')) {
+      updatedFieldRelationMetadataCollection = await this.updateEntities<
+        FieldMetadataEntity<FieldMetadataType.RELATION>
+      >(
+        manager,
+        FieldMetadataEntity,
+        storage.fieldRelationMetadataUpdateCollection,
+        ['objectMetadataId', 'workspaceId'],
+      );
+    }
+
+    if (!options || options.actions.includes('delete')) {
+      deletedFieldRelationMetadataCollection = await this.updateEntities<
+        FieldMetadataEntity<FieldMetadataType.RELATION>
+      >(
+        manager,
+        FieldMetadataEntity,
+        storage.fieldRelationMetadataDeleteCollection,
+        ['objectMetadataId', 'workspaceId'],
+      );
+    }
+
+    return {
+      createdFieldRelationMetadataCollection,
+      updatedFieldRelationMetadataCollection,
+      deletedFieldRelationMetadataCollection,
+    };
+  }
+
   async deleteIndexFieldMetadata(
     fieldMetadataDeleteCollectionWithoutRelationType: Partial<FieldMetadataEntity>[],
     indexFieldMetadataRepository: Repository<IndexFieldMetadataEntity>,
@@ -276,6 +365,15 @@ 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,
@@ -288,6 +386,15 @@ export class WorkspaceMetadataUpdaterService {
         const fieldMetadata = originalObjectMetadataCollection
           .find((object) => object.id === indexMetadata.objectMetadataId)
           ?.fields.find((field) => {
+            if (
+              isNewRelationEnabled &&
+              isFieldMetadataEntityOfType(field, FieldMetadataType.RELATION)
+            ) {
+              if (field.settings?.joinColumnName === column) {
+                return true;
+              }
+            }
+
             if (field.name === column) {
               return true;
             }

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

@@ -0,0 +1,267 @@
+import { Injectable, Logger } from '@nestjs/common';
+
+import { FieldMetadataType } from 'twenty-shared/types';
+import { EntityManager } from 'typeorm';
+
+import { WorkspaceMigrationBuilderAction } from 'src/engine/workspace-manager/workspace-migration-builder/interfaces/workspace-migration-builder-action.interface';
+import {
+  ComparatorAction,
+  FieldRelationComparatorResult,
+} from 'src/engine/workspace-manager/workspace-sync-metadata/interfaces/comparator.interface';
+import { WorkspaceSyncContext } from 'src/engine/workspace-manager/workspace-sync-metadata/interfaces/workspace-sync-context.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 { WorkspaceMigrationEntity } from 'src/engine/metadata-modules/workspace-migration/workspace-migration.entity';
+import { CustomWorkspaceEntity } from 'src/engine/twenty-orm/custom.workspace-entity';
+import { WorkspaceMigrationFieldRelationFactory } from 'src/engine/workspace-manager/workspace-migration-builder/factories/workspace-migration-field-relation.factory';
+import {
+  FieldMetadataUpdate,
+  WorkspaceMigrationFieldFactory,
+} from 'src/engine/workspace-manager/workspace-migration-builder/factories/workspace-migration-field.factory';
+import { WorkspaceFieldRelationComparator } from 'src/engine/workspace-manager/workspace-sync-metadata/comparators/workspace-field-relation.comparator';
+import { StandardFieldRelationFactory } from 'src/engine/workspace-manager/workspace-sync-metadata/factories/standard-field-relation.factory';
+import { WorkspaceMetadataUpdaterService } from 'src/engine/workspace-manager/workspace-sync-metadata/services/workspace-metadata-updater.service';
+import { standardObjectMetadataDefinitions } from 'src/engine/workspace-manager/workspace-sync-metadata/standard-objects';
+import { WorkspaceSyncStorage } from 'src/engine/workspace-manager/workspace-sync-metadata/storage/workspace-sync.storage';
+import { mapObjectMetadataByUniqueIdentifier } from 'src/engine/workspace-manager/workspace-sync-metadata/utils/sync-metadata.util';
+
+@Injectable()
+export class WorkspaceSyncFieldMetadataRelationService {
+  private readonly logger = new Logger(
+    WorkspaceSyncFieldMetadataRelationService.name,
+  );
+
+  constructor(
+    private readonly standardFieldRelationFactory: StandardFieldRelationFactory,
+    private readonly workspaceFieldRelationComparator: WorkspaceFieldRelationComparator,
+    private readonly workspaceMetadataUpdaterService: WorkspaceMetadataUpdaterService,
+    private readonly workspaceMigrationFieldFactory: WorkspaceMigrationFieldFactory,
+    private readonly workspaceMigrationFieldRelationFactory: WorkspaceMigrationFieldRelationFactory,
+  ) {}
+
+  async synchronize(
+    context: WorkspaceSyncContext,
+    manager: EntityManager,
+    storage: WorkspaceSyncStorage,
+  ): Promise<Partial<WorkspaceMigrationEntity>[]> {
+    let originalObjectMetadataCollection =
+      await this.getOriginalObjectMetadataCollection(context, manager);
+
+    const customObjectMetadataCollection =
+      originalObjectMetadataCollection.filter(
+        (objectMetadata) => objectMetadata.isCustom,
+      );
+
+    // Create map of object metadata & field metadata by unique identifier
+    const originalObjectMetadataMapByName = mapObjectMetadataByUniqueIdentifier(
+      originalObjectMetadataCollection,
+      // Relation are based on the singular name
+      (objectMetadata) => objectMetadata.nameSingular,
+    );
+
+    await this.synchronizeStandardObjectRelationFields(
+      context,
+      originalObjectMetadataCollection,
+      originalObjectMetadataMapByName,
+      storage,
+    );
+
+    await this.synchronizeCustomObjectRelationFields(
+      context,
+      customObjectMetadataCollection,
+      originalObjectMetadataMapByName,
+      storage,
+    );
+
+    this.logger.log('Updating workspace metadata');
+
+    // Save field metadata to DB
+    const metadataFieldUpdaterResult =
+      await this.workspaceMetadataUpdaterService.updateFieldRelationMetadata(
+        manager,
+        storage,
+      );
+
+    this.logger.log('Generating migrations');
+
+    const updateFieldWorkspaceMigrations =
+      await this.workspaceMigrationFieldFactory.create(
+        originalObjectMetadataCollection,
+        [
+          // Both of them are update as field where created in WorkspaceSyncFieldMetadataService
+          ...metadataFieldUpdaterResult.createdFieldRelationMetadataCollection,
+          ...metadataFieldUpdaterResult.updatedFieldRelationMetadataCollection,
+          ...metadataFieldUpdaterResult.deletedFieldRelationMetadataCollection,
+        ] as FieldMetadataUpdate[],
+        WorkspaceMigrationBuilderAction.UPDATE,
+      );
+
+    // Resync updated object metadata
+    originalObjectMetadataCollection =
+      await this.getOriginalObjectMetadataCollection(context, manager);
+
+    const deletedFieldRelationMetadataCollection =
+      metadataFieldUpdaterResult.deletedFieldRelationMetadataCollection.map(
+        (field) => field.altered,
+      );
+
+    const deleteFieldRelationWorkspaceMigrations =
+      await this.workspaceMigrationFieldRelationFactory.create(
+        originalObjectMetadataCollection,
+        deletedFieldRelationMetadataCollection,
+        WorkspaceMigrationBuilderAction.DELETE,
+      );
+
+    const createdFieldRelationMetadataCollection =
+      metadataFieldUpdaterResult.createdFieldRelationMetadataCollection.map(
+        (field) => field.altered,
+      );
+
+    const createFieldRelationWorkspaceMigrations =
+      await this.workspaceMigrationFieldRelationFactory.create(
+        originalObjectMetadataCollection,
+        createdFieldRelationMetadataCollection,
+        WorkspaceMigrationBuilderAction.CREATE,
+      );
+
+    const updateFieldRelationWorkspaceMigrations =
+      await this.workspaceMigrationFieldRelationFactory.create(
+        originalObjectMetadataCollection,
+        metadataFieldUpdaterResult.updatedFieldRelationMetadataCollection,
+        WorkspaceMigrationBuilderAction.UPDATE,
+      );
+
+    // TODO: Should we handle deletion of relation here?
+
+    this.logger.log('Saving migrations');
+
+    return [
+      ...updateFieldWorkspaceMigrations,
+      ...deleteFieldRelationWorkspaceMigrations,
+      ...createFieldRelationWorkspaceMigrations,
+      ...updateFieldRelationWorkspaceMigrations,
+    ];
+  }
+
+  private async synchronizeStandardObjectRelationFields(
+    context: WorkspaceSyncContext,
+    originalObjectMetadataCollection: ObjectMetadataEntity[],
+    originalObjectMetadataMapByName: Record<string, ObjectMetadataEntity>,
+    storage: WorkspaceSyncStorage,
+  ): Promise<void> {
+    // Create standard field metadata map
+    const standardFieldMetadataRelationCollection =
+      this.standardFieldRelationFactory.createFieldRelationForStandardObject(
+        standardObjectMetadataDefinitions,
+        context,
+        originalObjectMetadataMapByName,
+      );
+
+    // Create map of original and standard object metadata by standard ids
+    const originalObjectMetadataMap = mapObjectMetadataByUniqueIdentifier(
+      originalObjectMetadataCollection,
+    );
+
+    // Loop over all standard objects and compare them with the objects in DB
+    for (const [
+      standardObjectId,
+      standardFieldMetadataCollection,
+    ] of standardFieldMetadataRelationCollection) {
+      const originalObjectMetadata =
+        originalObjectMetadataMap[standardObjectId];
+
+      const originalFieldRelationMetadataCollection =
+        (originalObjectMetadata?.fields.filter(
+          (field) => field.type === FieldMetadataType.RELATION,
+        ) ?? []) as FieldMetadataEntity<FieldMetadataType.RELATION>[];
+
+      if (originalFieldRelationMetadataCollection.length === 0) {
+        continue;
+      }
+
+      const fieldComparatorResults =
+        this.workspaceFieldRelationComparator.compare(
+          originalFieldRelationMetadataCollection,
+          standardFieldMetadataCollection,
+        );
+
+      this.storeComparatorResults(fieldComparatorResults, storage);
+    }
+  }
+
+  private async synchronizeCustomObjectRelationFields(
+    context: WorkspaceSyncContext,
+    customObjectMetadataCollection: ObjectMetadataEntity[],
+    originalObjectMetadataMapByName: Record<string, ObjectMetadataEntity>,
+    storage: WorkspaceSyncStorage,
+  ): Promise<void> {
+    // Create standard field metadata collection
+    const customFieldMetadataRelationCollection =
+      this.standardFieldRelationFactory.createFieldRelationForCustomObject(
+        customObjectMetadataCollection.map((objectMetadata) => ({
+          object: objectMetadata,
+          metadata: CustomWorkspaceEntity,
+        })),
+        context,
+        originalObjectMetadataMapByName,
+      );
+
+    // Loop over all custom objects from the DB and compare their fields with standard fields
+    for (const customObjectMetadata of customObjectMetadataCollection) {
+      /**
+       * COMPARE FIELD METADATA
+       */
+      const fieldComparatorResults =
+        this.workspaceFieldRelationComparator.compare(
+          customObjectMetadata.fields as FieldMetadataEntity<FieldMetadataType.RELATION>[],
+          customFieldMetadataRelationCollection,
+        );
+
+      this.storeComparatorResults(fieldComparatorResults, storage);
+    }
+  }
+
+  private async getOriginalObjectMetadataCollection(
+    context: WorkspaceSyncContext,
+    manager: EntityManager,
+  ): Promise<ObjectMetadataEntity[]> {
+    const objectMetadataRepository =
+      manager.getRepository(ObjectMetadataEntity);
+
+    const originalObjectMetadataCollection =
+      await objectMetadataRepository.find({
+        where: {
+          workspaceId: context.workspaceId,
+          fields: {
+            type: FieldMetadataType.RELATION,
+          },
+        },
+        relations: ['dataSource', 'fields'],
+      });
+
+    return originalObjectMetadataCollection;
+  }
+
+  private storeComparatorResults(
+    fieldComparatorResults: FieldRelationComparatorResult[],
+    storage: WorkspaceSyncStorage,
+  ): void {
+    for (const fieldComparatorResult of fieldComparatorResults) {
+      switch (fieldComparatorResult.action) {
+        case ComparatorAction.CREATE: {
+          storage.addCreateFieldRelationMetadata(fieldComparatorResult.object);
+          break;
+        }
+        case ComparatorAction.UPDATE: {
+          storage.addUpdateFieldRelationMetadata(fieldComparatorResult.object);
+          break;
+        }
+        case ComparatorAction.DELETE: {
+          storage.addDeleteFieldRelationMetadata(fieldComparatorResult.object);
+          break;
+        }
+      }
+    }
+  }
+}

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

@@ -2,7 +2,6 @@ import { Injectable, Logger } from '@nestjs/common';
 
 import { EntityManager } from 'typeorm';
 
-import { FeatureFlagMap } from 'src/engine/core-modules/feature-flag/interfaces/feature-flag-map.interface';
 import { WorkspaceMigrationBuilderAction } from 'src/engine/workspace-manager/workspace-migration-builder/interfaces/workspace-migration-builder-action.interface';
 import {
   ComparatorAction,
@@ -37,7 +36,6 @@ export class WorkspaceSyncFieldMetadataService {
     context: WorkspaceSyncContext,
     manager: EntityManager,
     storage: WorkspaceSyncStorage,
-    workspaceFeatureFlagsMap: FeatureFlagMap,
   ): Promise<Partial<WorkspaceMigrationEntity>[]> {
     const objectMetadataRepository =
       manager.getRepository(ObjectMetadataEntity);
@@ -61,14 +59,12 @@ export class WorkspaceSyncFieldMetadataService {
       originalObjectMetadataCollection,
       customObjectMetadataCollection,
       storage,
-      workspaceFeatureFlagsMap,
     );
 
     await this.synchronizeCustomObjectFields(
       context,
       customObjectMetadataCollection,
       storage,
-      workspaceFeatureFlagsMap,
     );
 
     this.logger.log('Updating workspace metadata');
@@ -121,14 +117,12 @@ export class WorkspaceSyncFieldMetadataService {
     originalObjectMetadataCollection: ObjectMetadataEntity[],
     customObjectMetadataCollection: ObjectMetadataEntity[],
     storage: WorkspaceSyncStorage,
-    workspaceFeatureFlagsMap: FeatureFlagMap,
   ): Promise<void> {
     // Create standard field metadata map
     const standardObjectStandardFieldMetadataMap =
       this.standardFieldFactory.create(
         standardObjectMetadataDefinitions,
         context,
-        workspaceFeatureFlagsMap,
       );
 
     // Create map of original and standard object metadata by standard ids
@@ -145,6 +139,7 @@ export class WorkspaceSyncFieldMetadataService {
         originalObjectMetadataMap[standardObjectId];
 
       const computedStandardFieldMetadataCollection = computeStandardFields(
+        context,
         standardFieldMetadataCollection,
         originalObjectMetadata,
         // We need to provide this for generated relations with custom objects
@@ -161,24 +156,46 @@ export class WorkspaceSyncFieldMetadataService {
     }
   }
 
+  synchronizeCustomObject(
+    context: WorkspaceSyncContext,
+    customObjectMetadata: ObjectMetadataEntity,
+  ): FieldComparatorResult[] {
+    // Create standard field metadata collection
+    const customObjectStandardFieldMetadataCollection =
+      this.standardFieldFactory.create(CustomWorkspaceEntity, context);
+
+    const standardFieldMetadataCollection = computeStandardFields(
+      context,
+      customObjectStandardFieldMetadataCollection,
+      customObjectMetadata,
+    );
+
+    /**
+     * COMPARE FIELD METADATA
+     */
+    const fieldComparatorResults = this.workspaceFieldComparator.compare(
+      customObjectMetadata.id,
+      customObjectMetadata.fields,
+      standardFieldMetadataCollection,
+    );
+
+    return fieldComparatorResults;
+  }
+
   private async synchronizeCustomObjectFields(
     context: WorkspaceSyncContext,
     customObjectMetadataCollection: ObjectMetadataEntity[],
     storage: WorkspaceSyncStorage,
-    workspaceFeatureFlagsMap: FeatureFlagMap,
   ): Promise<void> {
     // Create standard field metadata collection
     const customObjectStandardFieldMetadataCollection =
-      this.standardFieldFactory.create(
-        CustomWorkspaceEntity,
-        context,
-        workspaceFeatureFlagsMap,
-      );
+      this.standardFieldFactory.create(CustomWorkspaceEntity, context);
 
     // Loop over all custom objects from the DB and compare their fields with standard fields
     for (const customObjectMetadata of customObjectMetadataCollection) {
       // Also, maybe it's better to refactor a bit and move generation part into a separate module ?
       const standardFieldMetadataCollection = computeStandardFields(
+        context,
         customObjectStandardFieldMetadataCollection,
         customObjectMetadata,
       );

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

@@ -2,7 +2,6 @@ import { Injectable, Logger } from '@nestjs/common';
 
 import { Any, EntityManager } from 'typeorm';
 
-import { FeatureFlagMap } from 'src/engine/core-modules/feature-flag/interfaces/feature-flag-map.interface';
 import { WorkspaceMigrationBuilderAction } from 'src/engine/workspace-manager/workspace-migration-builder/interfaces/workspace-migration-builder-action.interface';
 import { ComparatorAction } from 'src/engine/workspace-manager/workspace-sync-metadata/interfaces/comparator.interface';
 import { WorkspaceSyncContext } from 'src/engine/workspace-manager/workspace-sync-metadata/interfaces/workspace-sync-context.interface';
@@ -33,7 +32,6 @@ export class WorkspaceSyncIndexMetadataService {
     context: WorkspaceSyncContext,
     manager: EntityManager,
     storage: WorkspaceSyncStorage,
-    workspaceFeatureFlagsMap: FeatureFlagMap,
   ): Promise<Partial<WorkspaceMigrationEntity>[]> {
     this.logger.log('Syncing index metadata');
 
@@ -89,7 +87,6 @@ export class WorkspaceSyncIndexMetadataService {
       context,
       originalStandardObjectMetadataMap,
       originalCustomObjectMetadataMap,
-      workspaceFeatureFlagsMap,
     );
 
     const indexComparatorResults = this.workspaceIndexComparator.compare(

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

@@ -3,7 +3,6 @@ import { Injectable } from '@nestjs/common';
 import { EntityManager, Repository } from 'typeorm';
 import { FieldMetadataType } from 'twenty-shared/types';
 
-import { FeatureFlagMap } from 'src/engine/core-modules/feature-flag/interfaces/feature-flag-map.interface';
 import { WorkspaceSyncContext } from 'src/engine/workspace-manager/workspace-sync-metadata/interfaces/workspace-sync-context.interface';
 
 import { FieldMetadataEntity } from 'src/engine/metadata-modules/field-metadata/field-metadata.entity';
@@ -21,7 +20,6 @@ export class WorkspaceSyncObjectMetadataIdentifiersService {
     context: WorkspaceSyncContext,
     manager: EntityManager,
     _storage: WorkspaceSyncStorage,
-    workspaceFeatureFlagsMap: FeatureFlagMap,
   ): Promise<void> {
     const objectMetadataRepository =
       manager.getRepository(ObjectMetadataEntity);
@@ -32,10 +30,8 @@ export class WorkspaceSyncObjectMetadataIdentifiersService {
         objectMetadataRepository,
       );
 
-    const standardObjectMetadataMap = this.createStandardObjectMetadataMap(
-      context,
-      workspaceFeatureFlagsMap,
-    );
+    const standardObjectMetadataMap =
+      this.createStandardObjectMetadataMap(context);
 
     await this.processObjectMetadataCollection(
       originalObjectMetadataCollection,
@@ -56,12 +52,10 @@ export class WorkspaceSyncObjectMetadataIdentifiersService {
 
   private createStandardObjectMetadataMap(
     context: WorkspaceSyncContext,
-    workspaceFeatureFlagsMap: FeatureFlagMap,
   ): Record<string, any> {
     const standardObjectMetadataCollection = this.standardObjectFactory.create(
       standardObjectMetadataDefinitions,
       context,
-      workspaceFeatureFlagsMap,
     );
 
     return mapObjectMetadataByUniqueIdentifier(

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

@@ -2,7 +2,6 @@ import { Injectable, Logger } from '@nestjs/common';
 
 import { EntityManager } from 'typeorm';
 
-import { FeatureFlagMap } from 'src/engine/core-modules/feature-flag/interfaces/feature-flag-map.interface';
 import { WorkspaceMigrationBuilderAction } from 'src/engine/workspace-manager/workspace-migration-builder/interfaces/workspace-migration-builder-action.interface';
 import { ComparatorAction } from 'src/engine/workspace-manager/workspace-sync-metadata/interfaces/comparator.interface';
 import { WorkspaceSyncContext } from 'src/engine/workspace-manager/workspace-sync-metadata/interfaces/workspace-sync-context.interface';
@@ -33,7 +32,6 @@ export class WorkspaceSyncObjectMetadataService {
     context: WorkspaceSyncContext,
     manager: EntityManager,
     storage: WorkspaceSyncStorage,
-    workspaceFeatureFlagsMap: FeatureFlagMap,
   ): Promise<Partial<WorkspaceMigrationEntity>[]> {
     const objectMetadataRepository =
       manager.getRepository(ObjectMetadataEntity);
@@ -83,7 +81,6 @@ export class WorkspaceSyncObjectMetadataService {
     const standardObjectMetadataCollection = this.standardObjectFactory.create(
       standardObjectMetadataDefinitions,
       context,
-      workspaceFeatureFlagsMap,
     );
 
     // Create map of original and standard object metadata by standard ids