feat: refactor folder structure (#4498)

* feat: wip refactor folder structure

* Fix

* fix position

---------

Co-authored-by: Charles Bochet <charles@twenty.com>

packages/twenty-server/src/engine-metadata/relation-metadata/dtos/create-relation.input.ts

@@ -0,0 +1,80 @@
+import { Field, HideField, InputType } from '@nestjs/graphql';
+
+import { BeforeCreateOne } from '@ptc-org/nestjs-query-graphql';
+import {
+  IsEnum,
+  IsNotEmpty,
+  IsOptional,
+  IsString,
+  IsUUID,
+} from 'class-validator';
+
+import { BeforeCreateOneRelation } from 'src/engine-metadata/relation-metadata/hooks/before-create-one-relation.hook';
+import { RelationMetadataType } from 'src/engine-metadata/relation-metadata/relation-metadata.entity';
+
+@InputType()
+@BeforeCreateOne(BeforeCreateOneRelation)
+export class CreateRelationInput {
+  @IsEnum(RelationMetadataType)
+  @IsNotEmpty()
+  @Field(() => RelationMetadataType)
+  relationType: RelationMetadataType;
+
+  @IsUUID()
+  @IsNotEmpty()
+  @Field()
+  fromObjectMetadataId: string;
+
+  @IsUUID()
+  @IsNotEmpty()
+  @Field()
+  toObjectMetadataId: string;
+
+  @IsString()
+  @IsNotEmpty()
+  @Field()
+  fromName: string;
+
+  @IsString()
+  @IsNotEmpty()
+  @Field()
+  toName: string;
+
+  @IsString()
+  @IsNotEmpty()
+  @Field()
+  fromLabel: string;
+
+  @IsString()
+  @IsNotEmpty()
+  @Field()
+  toLabel: string;
+
+  @IsString()
+  @IsOptional()
+  @Field({ nullable: true })
+  fromIcon?: string;
+
+  @IsString()
+  @IsOptional()
+  @Field({ nullable: true })
+  toIcon?: string;
+
+  @IsString()
+  @IsOptional()
+  @Field({ nullable: true, deprecationReason: 'Use fromDescription instead' })
+  description?: string;
+
+  @IsString()
+  @IsOptional()
+  @Field({ nullable: true })
+  fromDescription?: string;
+
+  @IsString()
+  @IsOptional()
+  @Field({ nullable: true })
+  toDescription?: string;
+
+  @HideField()
+  workspaceId: string;
+}

packages/twenty-server/src/engine-metadata/relation-metadata/dtos/relation-metadata.dto.ts

@@ -0,0 +1,71 @@
+import {
+  ObjectType,
+  ID,
+  Field,
+  HideField,
+  registerEnumType,
+} from '@nestjs/graphql';
+
+import { CreateDateColumn, UpdateDateColumn } from 'typeorm';
+import {
+  Authorize,
+  BeforeDeleteOne,
+  IDField,
+  QueryOptions,
+  Relation,
+} from '@ptc-org/nestjs-query-graphql';
+
+import { ObjectMetadataDTO } from 'src/engine-metadata/object-metadata/dtos/object-metadata.dto';
+import { RelationMetadataType } from 'src/engine-metadata/relation-metadata/relation-metadata.entity';
+import { BeforeDeleteOneRelation } from 'src/engine-metadata/relation-metadata/hooks/before-delete-one-field.hook';
+
+registerEnumType(RelationMetadataType, {
+  name: 'RelationMetadataType',
+  description: 'Type of the relation',
+});
+
+@ObjectType('relation')
+@Authorize({
+  authorize: (context: any) => ({
+    workspaceId: { eq: context?.req?.user?.workspace?.id },
+  }),
+})
+@QueryOptions({
+  defaultResultSize: 10,
+  disableFilter: true,
+  disableSort: true,
+  maxResultsSize: 1000,
+})
+@BeforeDeleteOne(BeforeDeleteOneRelation)
+@Relation('fromObjectMetadata', () => ObjectMetadataDTO)
+@Relation('toObjectMetadata', () => ObjectMetadataDTO)
+export class RelationMetadataDTO {
+  @IDField(() => ID)
+  id: string;
+
+  @Field(() => RelationMetadataType)
+  relationType: RelationMetadataType;
+
+  @Field()
+  fromObjectMetadataId: string;
+
+  @Field()
+  toObjectMetadataId: string;
+
+  @Field()
+  fromFieldMetadataId: string;
+
+  @Field()
+  toFieldMetadataId: string;
+
+  @HideField()
+  workspaceId: string;
+
+  @Field()
+  @CreateDateColumn()
+  createdAt: Date;
+
+  @Field()
+  @UpdateDateColumn()
+  updatedAt: Date;
+}

packages/twenty-server/src/engine-metadata/relation-metadata/hooks/before-create-one-relation.hook.ts

@@ -0,0 +1,28 @@
+import { Injectable, UnauthorizedException } from '@nestjs/common';
+
+import {
+  BeforeCreateOneHook,
+  CreateOneInputType,
+} from '@ptc-org/nestjs-query-graphql';
+
+import { CreateRelationInput } from 'src/engine-metadata/relation-metadata/dtos/create-relation.input';
+
+@Injectable()
+export class BeforeCreateOneRelation<T extends CreateRelationInput>
+  implements BeforeCreateOneHook<T, any>
+{
+  async run(
+    instance: CreateOneInputType<T>,
+    context: any,
+  ): Promise<CreateOneInputType<T>> {
+    const workspaceId = context?.req?.user?.workspace?.id;
+
+    if (!workspaceId) {
+      throw new UnauthorizedException();
+    }
+
+    instance.input.workspaceId = workspaceId;
+
+    return instance;
+  }
+}

packages/twenty-server/src/engine-metadata/relation-metadata/hooks/before-delete-one-field.hook.ts

@@ -0,0 +1,55 @@
+import {
+  BadRequestException,
+  Injectable,
+  UnauthorizedException,
+} from '@nestjs/common';
+
+import {
+  BeforeDeleteOneHook,
+  DeleteOneInputType,
+} from '@ptc-org/nestjs-query-graphql';
+
+import { RelationMetadataService } from 'src/engine-metadata/relation-metadata/relation-metadata.service';
+
+@Injectable()
+export class BeforeDeleteOneRelation implements BeforeDeleteOneHook<any> {
+  constructor(readonly relationMetadataService: RelationMetadataService) {}
+
+  async run(
+    instance: DeleteOneInputType,
+    context: any,
+  ): Promise<DeleteOneInputType> {
+    const workspaceId = context?.req?.user?.workspace?.id;
+
+    if (!workspaceId) {
+      throw new UnauthorizedException();
+    }
+
+    const relationMetadata =
+      await this.relationMetadataService.findOneWithinWorkspace(workspaceId, {
+        where: {
+          id: instance.id.toString(),
+        },
+      });
+
+    if (!relationMetadata) {
+      throw new BadRequestException('Relation does not exist');
+    }
+
+    if (
+      !relationMetadata.toFieldMetadata.isCustom ||
+      !relationMetadata.fromFieldMetadata.isCustom
+    ) {
+      throw new BadRequestException("Standard Relations can't be deleted");
+    }
+
+    if (
+      relationMetadata.toFieldMetadata.isActive ||
+      relationMetadata.fromFieldMetadata.isActive
+    ) {
+      throw new BadRequestException("Active relations can't be deleted");
+    }
+
+    return instance;
+  }
+}

packages/twenty-server/src/engine-metadata/relation-metadata/relation-metadata.entity.ts

@@ -0,0 +1,98 @@
+import {
+  Column,
+  CreateDateColumn,
+  Entity,
+  JoinColumn,
+  ManyToOne,
+  OneToOne,
+  PrimaryGeneratedColumn,
+  UpdateDateColumn,
+} from 'typeorm';
+
+import { RelationMetadataInterface } from 'src/engine-metadata/field-metadata/interfaces/relation-metadata.interface';
+
+import { FieldMetadataEntity } from 'src/engine-metadata/field-metadata/field-metadata.entity';
+import { ObjectMetadataEntity } from 'src/engine-metadata/object-metadata/object-metadata.entity';
+
+export enum RelationMetadataType {
+  ONE_TO_ONE = 'ONE_TO_ONE',
+  ONE_TO_MANY = 'ONE_TO_MANY',
+  MANY_TO_MANY = 'MANY_TO_MANY',
+}
+
+export enum RelationOnDeleteAction {
+  CASCADE = 'CASCADE',
+  RESTRICT = 'RESTRICT',
+  SET_NULL = 'SET_NULL',
+  NO_ACTION = 'NO_ACTION',
+}
+
+@Entity('relationMetadata')
+export class RelationMetadataEntity implements RelationMetadataInterface {
+  @PrimaryGeneratedColumn('uuid')
+  id: string;
+
+  @Column({ nullable: false })
+  relationType: RelationMetadataType;
+
+  @Column({
+    nullable: false,
+    default: RelationOnDeleteAction.SET_NULL,
+    type: 'enum',
+    enum: RelationOnDeleteAction,
+  })
+  onDeleteAction: RelationOnDeleteAction;
+
+  @Column({ nullable: false, type: 'uuid' })
+  fromObjectMetadataId: string;
+
+  @Column({ nullable: false, type: 'uuid' })
+  toObjectMetadataId: string;
+
+  @Column({ nullable: false, type: 'uuid' })
+  fromFieldMetadataId: string;
+
+  @Column({ nullable: false, type: 'uuid' })
+  toFieldMetadataId: string;
+
+  @Column({ nullable: false, type: 'uuid' })
+  workspaceId: string;
+
+  @ManyToOne(
+    () => ObjectMetadataEntity,
+    (object: ObjectMetadataEntity) => object.fromRelations,
+    {
+      onDelete: 'CASCADE',
+    },
+  )
+  fromObjectMetadata: ObjectMetadataEntity;
+
+  @ManyToOne(
+    () => ObjectMetadataEntity,
+    (object: ObjectMetadataEntity) => object.toRelations,
+    {
+      onDelete: 'CASCADE',
+    },
+  )
+  toObjectMetadata: ObjectMetadataEntity;
+
+  @OneToOne(
+    () => FieldMetadataEntity,
+    (field: FieldMetadataEntity) => field.fromRelationMetadata,
+  )
+  @JoinColumn()
+  fromFieldMetadata: FieldMetadataEntity;
+
+  @OneToOne(
+    () => FieldMetadataEntity,
+    (field: FieldMetadataEntity) => field.toRelationMetadata,
+  )
+  @JoinColumn()
+  toFieldMetadata: FieldMetadataEntity;
+
+  @CreateDateColumn()
+  createdAt: Date;
+
+  @UpdateDateColumn()
+  updatedAt: Date;
+}

packages/twenty-server/src/engine-metadata/relation-metadata/relation-metadata.module.ts

@@ -0,0 +1,53 @@
+import { Module } from '@nestjs/common';
+
+import {
+  NestjsQueryGraphQLModule,
+  PagingStrategies,
+} from '@ptc-org/nestjs-query-graphql';
+import { NestjsQueryTypeOrmModule } from '@ptc-org/nestjs-query-typeorm';
+
+import { JwtAuthGuard } from 'src/engine/guards/jwt.auth.guard';
+import { FieldMetadataModule } from 'src/engine-metadata/field-metadata/field-metadata.module';
+import { ObjectMetadataModule } from 'src/engine-metadata/object-metadata/object-metadata.module';
+import { WorkspaceMigrationModule } from 'src/engine-metadata/workspace-migration/workspace-migration.module';
+import { WorkspaceMigrationRunnerModule } from 'src/engine/workspace-manager/workspace-migration-runner/workspace-migration-runner.module';
+
+import { RelationMetadataService } from './relation-metadata.service';
+import { RelationMetadataEntity } from './relation-metadata.entity';
+
+import { CreateRelationInput } from './dtos/create-relation.input';
+import { RelationMetadataDTO } from './dtos/relation-metadata.dto';
+
+@Module({
+  imports: [
+    NestjsQueryGraphQLModule.forFeature({
+      imports: [
+        NestjsQueryTypeOrmModule.forFeature(
+          [RelationMetadataEntity],
+          'metadata',
+        ),
+        ObjectMetadataModule,
+        FieldMetadataModule,
+        WorkspaceMigrationRunnerModule,
+        WorkspaceMigrationModule,
+      ],
+      services: [RelationMetadataService],
+      resolvers: [
+        {
+          EntityClass: RelationMetadataEntity,
+          DTOClass: RelationMetadataDTO,
+          ServiceClass: RelationMetadataService,
+          CreateDTOClass: CreateRelationInput,
+          pagingStrategy: PagingStrategies.CURSOR,
+          create: { many: { disabled: true } },
+          update: { disabled: true },
+          delete: { many: { disabled: true } },
+          guards: [JwtAuthGuard],
+        },
+      ],
+    }),
+  ],
+  providers: [RelationMetadataService],
+  exports: [RelationMetadataService],
+})
+export class RelationMetadataModule {}

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

@@ -0,0 +1,335 @@
+import {
+  BadRequestException,
+  ConflictException,
+  Injectable,
+  NotFoundException,
+} from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+
+import { TypeOrmQueryService } from '@ptc-org/nestjs-query-typeorm';
+import { FindOneOptions, In, Repository } from 'typeorm';
+import camelCase from 'lodash.camelcase';
+import { v4 as uuidV4 } from 'uuid';
+
+import { ObjectMetadataService } from 'src/engine-metadata/object-metadata/object-metadata.service';
+import { FieldMetadataService } from 'src/engine-metadata/field-metadata/field-metadata.service';
+import { CreateRelationInput } from 'src/engine-metadata/relation-metadata/dtos/create-relation.input';
+import { WorkspaceMigrationRunnerService } from 'src/engine/workspace-manager/workspace-migration-runner/workspace-migration-runner.service';
+import { WorkspaceMigrationService } from 'src/engine-metadata/workspace-migration/workspace-migration.service';
+import { FieldMetadataType } from 'src/engine-metadata/field-metadata/field-metadata.entity';
+import { WorkspaceMigrationColumnActionType } from 'src/engine-metadata/workspace-migration/workspace-migration.entity';
+import { ObjectMetadataEntity } from 'src/engine-metadata/object-metadata/object-metadata.entity';
+import { createCustomColumnName } from 'src/engine-metadata/utils/create-custom-column-name.util';
+import { computeObjectTargetTable } from 'src/engine-workspace/utils/compute-object-target-table.util';
+import { createRelationForeignKeyColumnName } from 'src/engine-metadata/relation-metadata/utils/create-relation-foreign-key-column-name.util';
+import { generateMigrationName } from 'src/engine-metadata/workspace-migration/utils/generate-migration-name.util';
+
+import {
+  RelationMetadataEntity,
+  RelationMetadataType,
+  RelationOnDeleteAction,
+} from './relation-metadata.entity';
+
+@Injectable()
+export class RelationMetadataService extends TypeOrmQueryService<RelationMetadataEntity> {
+  constructor(
+    @InjectRepository(RelationMetadataEntity, 'metadata')
+    private readonly relationMetadataRepository: Repository<RelationMetadataEntity>,
+    private readonly objectMetadataService: ObjectMetadataService,
+    private readonly fieldMetadataService: FieldMetadataService,
+    private readonly workspaceMigrationService: WorkspaceMigrationService,
+    private readonly workspaceMigrationRunnerService: WorkspaceMigrationRunnerService,
+  ) {
+    super(relationMetadataRepository);
+  }
+
+  override async createOne(
+    relationMetadataInput: CreateRelationInput,
+  ): Promise<RelationMetadataEntity> {
+    const objectMetadataMap = await this.getObjectMetadataMap(
+      relationMetadataInput,
+    );
+
+    await this.validateCreateRelationMetadataInput(
+      relationMetadataInput,
+      objectMetadataMap,
+    );
+
+    // NOTE: this logic is called to create relation through metadata graphql endpoint (so only for custom field relations)
+    const isCustom = true;
+    const baseColumnName = `${camelCase(relationMetadataInput.toName)}Id`;
+    const foreignKeyColumnName = createRelationForeignKeyColumnName(
+      relationMetadataInput.toName,
+      isCustom,
+    );
+
+    const fromId = uuidV4();
+    const toId = uuidV4();
+
+    await this.fieldMetadataService.createMany([
+      this.createFieldMetadataForRelationMetadata(
+        relationMetadataInput,
+        'from',
+        isCustom,
+        fromId,
+      ),
+      this.createFieldMetadataForRelationMetadata(
+        relationMetadataInput,
+        'to',
+        isCustom,
+        toId,
+      ),
+      this.createForeignKeyFieldMetadata(
+        relationMetadataInput,
+        baseColumnName,
+        foreignKeyColumnName,
+      ),
+    ]);
+
+    const createdRelationMetadata = await super.createOne({
+      ...relationMetadataInput,
+      fromFieldMetadataId: fromId,
+      toFieldMetadataId: toId,
+    });
+
+    await this.createWorkspaceCustomMigration(
+      relationMetadataInput,
+      objectMetadataMap,
+      foreignKeyColumnName,
+    );
+
+    await this.workspaceMigrationRunnerService.executeMigrationFromPendingMigrations(
+      relationMetadataInput.workspaceId,
+    );
+
+    return createdRelationMetadata;
+  }
+
+  private async validateCreateRelationMetadataInput(
+    relationMetadataInput: CreateRelationInput,
+    objectMetadataMap: { [key: string]: ObjectMetadataEntity },
+  ) {
+    if (
+      relationMetadataInput.relationType === RelationMetadataType.MANY_TO_MANY
+    ) {
+      throw new BadRequestException(
+        'Many to many relations are not supported yet',
+      );
+    }
+
+    if (
+      objectMetadataMap[relationMetadataInput.fromObjectMetadataId] ===
+        undefined ||
+      objectMetadataMap[relationMetadataInput.toObjectMetadataId] === undefined
+    ) {
+      throw new NotFoundException(
+        'Can\t find an existing object matching with fromObjectMetadataId or toObjectMetadataId',
+      );
+    }
+
+    await this.checkIfFieldMetadataRelationNameExists(
+      relationMetadataInput,
+      objectMetadataMap,
+      'from',
+    );
+    await this.checkIfFieldMetadataRelationNameExists(
+      relationMetadataInput,
+      objectMetadataMap,
+      'to',
+    );
+  }
+
+  private async checkIfFieldMetadataRelationNameExists(
+    relationMetadataInput: CreateRelationInput,
+    objectMetadataMap: { [key: string]: ObjectMetadataEntity },
+    relationDirection: 'from' | 'to',
+  ) {
+    const fieldAlreadyExists =
+      await this.fieldMetadataService.findOneWithinWorkspace(
+        relationMetadataInput.workspaceId,
+        {
+          where: {
+            name: relationMetadataInput[`${relationDirection}Name`],
+            objectMetadataId:
+              relationMetadataInput[`${relationDirection}ObjectMetadataId`],
+          },
+        },
+      );
+
+    if (fieldAlreadyExists) {
+      throw new ConflictException(
+        `Field on ${
+          objectMetadataMap[
+            relationMetadataInput[`${relationDirection}ObjectMetadataId`]
+          ].nameSingular
+        } already exists`,
+      );
+    }
+  }
+
+  private async createWorkspaceCustomMigration(
+    relationMetadataInput: CreateRelationInput,
+    objectMetadataMap: { [key: string]: ObjectMetadataEntity },
+    foreignKeyColumnName: string,
+  ) {
+    await this.workspaceMigrationService.createCustomMigration(
+      generateMigrationName(`create-${relationMetadataInput.fromName}`),
+      relationMetadataInput.workspaceId,
+      [
+        // Create the column
+        {
+          name: computeObjectTargetTable(
+            objectMetadataMap[relationMetadataInput.toObjectMetadataId],
+          ),
+          action: 'alter',
+          columns: [
+            {
+              action: WorkspaceMigrationColumnActionType.CREATE,
+              columnName: foreignKeyColumnName,
+              columnType: 'uuid',
+              isNullable: true,
+            },
+          ],
+        },
+        // Create the foreignKey
+        {
+          name: computeObjectTargetTable(
+            objectMetadataMap[relationMetadataInput.toObjectMetadataId],
+          ),
+          action: 'alter',
+          columns: [
+            {
+              action: WorkspaceMigrationColumnActionType.CREATE_FOREIGN_KEY,
+              columnName: foreignKeyColumnName,
+              referencedTableName: computeObjectTargetTable(
+                objectMetadataMap[relationMetadataInput.fromObjectMetadataId],
+              ),
+              referencedTableColumnName: 'id',
+              isUnique:
+                relationMetadataInput.relationType ===
+                RelationMetadataType.ONE_TO_ONE,
+              onDelete: RelationOnDeleteAction.SET_NULL,
+            },
+          ],
+        },
+      ],
+    );
+  }
+
+  private createFieldMetadataForRelationMetadata(
+    relationMetadataInput: CreateRelationInput,
+    relationDirection: 'from' | 'to',
+    isCustom: boolean,
+    id?: string,
+  ) {
+    return {
+      ...(id && { id: id }),
+      name: relationMetadataInput[`${relationDirection}Name`],
+      label: relationMetadataInput[`${relationDirection}Label`],
+      description: relationMetadataInput[`${relationDirection}Description`],
+      icon: relationMetadataInput[`${relationDirection}Icon`],
+      isCustom: true,
+      targetColumnMap:
+        relationDirection === 'to'
+          ? isCustom
+            ? createCustomColumnName(relationMetadataInput.toName)
+            : relationMetadataInput.toName
+          : {},
+      isActive: true,
+      isNullable: true,
+      type: FieldMetadataType.RELATION,
+      objectMetadataId:
+        relationMetadataInput[`${relationDirection}ObjectMetadataId`],
+      workspaceId: relationMetadataInput.workspaceId,
+    };
+  }
+
+  private createForeignKeyFieldMetadata(
+    relationMetadataInput: CreateRelationInput,
+    baseColumnName: string,
+    foreignKeyColumnName: string,
+  ) {
+    return {
+      name: baseColumnName,
+      label: `${relationMetadataInput.toLabel} Foreign Key`,
+      description: relationMetadataInput.toDescription
+        ? `${relationMetadataInput.toDescription} Foreign Key`
+        : undefined,
+      icon: undefined,
+      isCustom: true,
+      targetColumnMap: { value: foreignKeyColumnName },
+      isActive: true,
+      isNullable: true,
+      isSystem: true,
+      type: FieldMetadataType.UUID,
+      objectMetadataId: relationMetadataInput.toObjectMetadataId,
+      workspaceId: relationMetadataInput.workspaceId,
+    };
+  }
+
+  private async getObjectMetadataMap(
+    relationMetadataInput: CreateRelationInput,
+  ): Promise<{ [key: string]: ObjectMetadataEntity }> {
+    const objectMetadataEntries =
+      await this.objectMetadataService.findManyWithinWorkspace(
+        relationMetadataInput.workspaceId,
+        {
+          where: {
+            id: In([
+              relationMetadataInput.fromObjectMetadataId,
+              relationMetadataInput.toObjectMetadataId,
+            ]),
+          },
+        },
+      );
+
+    return objectMetadataEntries.reduce(
+      (acc, curr) => {
+        acc[curr.id] = curr;
+
+        return acc;
+      },
+      {} as { [key: string]: ObjectMetadataEntity },
+    );
+  }
+
+  public async findOneWithinWorkspace(
+    workspaceId: string,
+    options: FindOneOptions<RelationMetadataEntity>,
+  ) {
+    return this.relationMetadataRepository.findOne({
+      ...options,
+      where: {
+        ...options.where,
+        workspaceId,
+      },
+      relations: ['fromFieldMetadata', 'toFieldMetadata'],
+    });
+  }
+
+  override async deleteOne(id: string): Promise<RelationMetadataEntity> {
+    // TODO: This logic is duplicated with the BeforeDeleteOneRelation hook
+    const relationMetadata = await this.relationMetadataRepository.findOne({
+      where: { id },
+      relations: ['fromFieldMetadata', 'toFieldMetadata'],
+    });
+
+    if (!relationMetadata) {
+      throw new NotFoundException('Relation does not exist');
+    }
+
+    const deletedRelationMetadata = super.deleteOne(id);
+
+    // TODO: Move to a cdc scheduler
+    this.fieldMetadataService.deleteMany({
+      id: {
+        in: [
+          relationMetadata.fromFieldMetadataId,
+          relationMetadata.toFieldMetadataId,
+        ],
+      },
+    });
+
+    return deletedRelationMetadata;
+  }
+}

packages/twenty-server/src/engine-metadata/relation-metadata/types/relation-to-delete.ts

@@ -0,0 +1,14 @@
+export type RelationToDelete = {
+  id: string;
+  fromFieldMetadataId: string;
+  toFieldMetadataId: string;
+  fromFieldMetadataName: string;
+  toFieldMetadataName: string;
+  fromObjectMetadataId: string;
+  toObjectMetadataId: string;
+  fromObjectName: string;
+  toObjectName: string;
+  toFieldMetadataIsCustom: boolean;
+  toObjectMetadataIsCustom: boolean;
+  direction: string;
+};

packages/twenty-server/src/engine-metadata/relation-metadata/utils/create-relation-foreign-key-column-name.util.ts

@@ -0,0 +1,15 @@
+import { createCustomColumnName } from 'src/engine-metadata/utils/create-custom-column-name.util';
+import { camelCase } from 'src/utils/camel-case';
+
+export const createRelationForeignKeyColumnName = (
+  name: string,
+  isCustom: boolean,
+) => {
+  const baseColumnName = `${camelCase(name)}Id`;
+
+  const foreignKeyColumnName = isCustom
+    ? createCustomColumnName(baseColumnName)
+    : baseColumnName;
+
+  return foreignKeyColumnName;
+};

packages/twenty-server/src/engine-metadata/relation-metadata/utils/create-relation-foreign-key-field-metadata-name.util.ts

@@ -0,0 +1,5 @@
+import { camelCase } from 'src/utils/camel-case';
+
+export const createRelationForeignKeyFieldMetadataName = (name: string) => {
+  return `${camelCase(name)}Id`;
+};