fix: multiple twenty orm issues & show an example of use (#5439)

This PR is fixing some issues and adding enhancement in TwentyORM: - [x] Composite fields in nested relations are not formatted properly - [x] Passing operators like `Any` in `where` condition is breaking the query - [x] Ability to auto load workspace-entities based on a regex path I've also introduced an example of use for `CalendarEventService`: https://github.com/twentyhq/twenty/pull/5439/files#diff-3a7dffc0dea57345d10e70c648e911f98fe237248bcea124dafa9c8deb1db748R15
2024-05-20 11:01:47 +02:00
parent 81e8f49033
commit 8b5f79ddbf
147 changed files with 1108 additions and 1101 deletions
--- a/packages/twenty-server/src/engine/api/graphql/workspace-query-runner/workspace-query-runner.module.ts
+++ b/packages/twenty-server/src/engine/api/graphql/workspace-query-runner/workspace-query-runner.module.ts
@ -9,7 +9,7 @@ import { RecordPositionListener } from 'src/engine/api/graphql/workspace-query-r
 import { AuthModule } from 'src/engine/core-modules/auth/auth.module';
 import { FeatureFlagEntity } from 'src/engine/core-modules/feature-flag/feature-flag.entity';
 import { Workspace } from 'src/engine/core-modules/workspace/workspace.entity';
-import { WorkspaceMemberObjectMetadata } from 'src/modules/workspace-member/standard-objects/workspace-member.object-metadata';
+import { WorkspaceMemberWorkspaceEntity } from 'src/modules/workspace-member/standard-objects/workspace-member.workspace-entity';
 import { ObjectMetadataRepositoryModule } from 'src/engine/object-metadata-repository/object-metadata-repository.module';
 import { TelemetryListener } from 'src/engine/api/graphql/workspace-query-runner/listeners/telemetry.listener';
 import { AnalyticsModule } from 'src/engine/core-modules/analytics/analytics.module';
@ -25,7 +25,7 @@ import { EntityEventsToDbListener } from './listeners/entity-events-to-db.listen
    WorkspaceDataSourceModule,
    WorkspacePreQueryHookModule,
    TypeOrmModule.forFeature([Workspace, FeatureFlagEntity], 'core'),
-    ObjectMetadataRepositoryModule.forFeature([WorkspaceMemberObjectMetadata]),
+    ObjectMetadataRepositoryModule.forFeature([WorkspaceMemberWorkspaceEntity]),
    AnalyticsModule,
  ],
  providers: [
--- a/packages/twenty-server/src/engine/core-modules/auth/auth.module.ts
+++ b/packages/twenty-server/src/engine/core-modules/auth/auth.module.ts
@ -24,9 +24,9 @@ import { FileUploadModule } from 'src/engine/core-modules/file/file-upload/file-
 import { MicrosoftAuthController } from 'src/engine/core-modules/auth/controllers/microsoft-auth.controller';
 import { AppTokenService } from 'src/engine/core-modules/app-token/services/app-token.service';
 import { ObjectMetadataRepositoryModule } from 'src/engine/object-metadata-repository/object-metadata-repository.module';
-import { ConnectedAccountObjectMetadata } from 'src/modules/connected-account/standard-objects/connected-account.object-metadata';
-import { MessageChannelObjectMetadata } from 'src/modules/messaging/standard-objects/message-channel.object-metadata';
-import { CalendarChannelObjectMetadata } from 'src/modules/calendar/standard-objects/calendar-channel.object-metadata';
+import { ConnectedAccountWorkspaceEntity } from 'src/modules/connected-account/standard-objects/connected-account.workspace-entity';
+import { MessageChannelWorkspaceEntity } from 'src/modules/messaging/standard-objects/message-channel.workspace-entity';
+import { CalendarChannelWorkspaceEntity } from 'src/modules/calendar/standard-objects/calendar-channel.workspace-entity';

 import { AuthResolver } from './auth.resolver';

@ -57,9 +57,9 @@ const jwtModule = JwtModule.registerAsync({
      'core',
    ),
    ObjectMetadataRepositoryModule.forFeature([
-      ConnectedAccountObjectMetadata,
-      MessageChannelObjectMetadata,
-      CalendarChannelObjectMetadata,
+      ConnectedAccountWorkspaceEntity,
+      MessageChannelWorkspaceEntity,
+      CalendarChannelWorkspaceEntity,
    ]),
    HttpModule,
    UserWorkspaceModule,
--- a/packages/twenty-server/src/engine/core-modules/auth/services/google-apis.service.ts
+++ b/packages/twenty-server/src/engine/core-modules/auth/services/google-apis.service.ts
@ -17,20 +17,20 @@ import {
 } from 'src/modules/calendar/jobs/google-calendar-sync.job';
 import { CalendarChannelRepository } from 'src/modules/calendar/repositories/calendar-channel.repository';
 import {
-  CalendarChannelObjectMetadata,
+  CalendarChannelWorkspaceEntity,
  CalendarChannelVisibility,
-} from 'src/modules/calendar/standard-objects/calendar-channel.object-metadata';
+} from 'src/modules/calendar/standard-objects/calendar-channel.workspace-entity';
 import { ConnectedAccountRepository } from 'src/modules/connected-account/repositories/connected-account.repository';
 import {
-  ConnectedAccountObjectMetadata,
+  ConnectedAccountWorkspaceEntity,
  ConnectedAccountProvider,
-} from 'src/modules/connected-account/standard-objects/connected-account.object-metadata';
+} from 'src/modules/connected-account/standard-objects/connected-account.workspace-entity';
 import { MessageChannelRepository } from 'src/modules/messaging/repositories/message-channel.repository';
 import {
-  MessageChannelObjectMetadata,
+  MessageChannelWorkspaceEntity,
  MessageChannelType,
  MessageChannelVisibility,
-} from 'src/modules/messaging/standard-objects/message-channel.object-metadata';
+} from 'src/modules/messaging/standard-objects/message-channel.workspace-entity';
 import {
  GmailFullSyncJobData,
  GmailFullSyncJob,
@ -48,11 +48,11 @@ export class GoogleAPIsService {
    private readonly environmentService: EnvironmentService,
    @InjectRepository(FeatureFlagEntity, 'core')
    private readonly featureFlagRepository: Repository<FeatureFlagEntity>,
-    @InjectObjectMetadataRepository(ConnectedAccountObjectMetadata)
+    @InjectObjectMetadataRepository(ConnectedAccountWorkspaceEntity)
    private readonly connectedAccountRepository: ConnectedAccountRepository,
-    @InjectObjectMetadataRepository(MessageChannelObjectMetadata)
+    @InjectObjectMetadataRepository(MessageChannelWorkspaceEntity)
    private readonly messageChannelRepository: MessageChannelRepository,
-    @InjectObjectMetadataRepository(CalendarChannelObjectMetadata)
+    @InjectObjectMetadataRepository(CalendarChannelWorkspaceEntity)
    private readonly calendarChannelRepository: CalendarChannelRepository,
  ) {}

--- a/packages/twenty-server/src/engine/core-modules/billing/listeners/billing-workspace-member.listener.ts
+++ b/packages/twenty-server/src/engine/core-modules/billing/listeners/billing-workspace-member.listener.ts
@ -4,7 +4,7 @@ import { OnEvent } from '@nestjs/event-emitter';
 import { MessageQueue } from 'src/engine/integrations/message-queue/message-queue.constants';
 import { MessageQueueService } from 'src/engine/integrations/message-queue/services/message-queue.service';
 import { ObjectRecordCreateEvent } from 'src/engine/integrations/event-emitter/types/object-record-create.event';
-import { WorkspaceMemberObjectMetadata } from 'src/modules/workspace-member/standard-objects/workspace-member.object-metadata';
+import { WorkspaceMemberWorkspaceEntity } from 'src/modules/workspace-member/standard-objects/workspace-member.workspace-entity';
 import {
  UpdateSubscriptionJob,
  UpdateSubscriptionJobData,
@ -22,7 +22,7 @@ export class BillingWorkspaceMemberListener {
  @OnEvent('workspaceMember.created')
  @OnEvent('workspaceMember.deleted')
  async handleCreateOrDeleteEvent(
-    payload: ObjectRecordCreateEvent<WorkspaceMemberObjectMetadata>,
+    payload: ObjectRecordCreateEvent<WorkspaceMemberWorkspaceEntity>,
  ) {
    if (!this.environmentService.get('IS_BILLING_ENABLED')) {
      return;
--- a/packages/twenty-server/src/engine/core-modules/calendar/timeline-calendar-event.module.ts
+++ b/packages/twenty-server/src/engine/core-modules/calendar/timeline-calendar-event.module.ts
@ -1,12 +1,20 @@
 import { Module } from '@nestjs/common';

-import { WorkspaceDataSourceModule } from 'src/engine/workspace-datasource/workspace-datasource.module';
 import { UserModule } from 'src/engine/core-modules/user/user.module';
 import { TimelineCalendarEventResolver } from 'src/engine/core-modules/calendar/timeline-calendar-event.resolver';
 import { TimelineCalendarEventService } from 'src/engine/core-modules/calendar/timeline-calendar-event.service';
+import { TwentyORMModule } from 'src/engine/twenty-orm/twenty-orm.module';
+import { CalendarEventWorkspaceEntity } from 'src/modules/calendar/standard-objects/calendar-event.workspace-entity';
+import { PersonWorkspaceEntity } from 'src/modules/person/standard-objects/person.workspace-entity';

@Module({
-  imports: [WorkspaceDataSourceModule, UserModule],
+  imports: [
+    TwentyORMModule.forFeature([
+      CalendarEventWorkspaceEntity,
+      PersonWorkspaceEntity,
+    ]),
+    UserModule,
+  ],
  exports: [],
  providers: [TimelineCalendarEventResolver, TimelineCalendarEventService],
 })
--- a/packages/twenty-server/src/engine/core-modules/calendar/timeline-calendar-event.resolver.ts
+++ b/packages/twenty-server/src/engine/core-modules/calendar/timeline-calendar-event.resolver.ts
@ -5,14 +5,11 @@ import { Max } from 'class-validator';

 import { User } from 'src/engine/core-modules/user/user.entity';
 import { AuthUser } from 'src/engine/decorators/auth/auth-user.decorator';
-import { AuthWorkspace } from 'src/engine/decorators/auth/auth-workspace.decorator';
 import { JwtAuthGuard } from 'src/engine/guards/jwt.auth.guard';
 import { TIMELINE_CALENDAR_EVENTS_MAX_PAGE_SIZE } from 'src/engine/core-modules/calendar/constants/calendar.constants';
 import { TimelineCalendarEventsWithTotal } from 'src/engine/core-modules/calendar/dtos/timeline-calendar-events-with-total.dto';
 import { TimelineCalendarEventService } from 'src/engine/core-modules/calendar/timeline-calendar-event.service';
 import { UserService } from 'src/engine/core-modules/user/services/user.service';
-import { Workspace } from 'src/engine/core-modules/workspace/workspace.entity';
-import { NotFoundError } from 'src/engine/utils/graphql-errors.util';
 import { UUIDScalarType } from 'src/engine/api/graphql/workspace-schema-builder/graphql-types/scalars';

@ArgsType()
@ -51,21 +48,12 @@ export class TimelineCalendarEventResolver {

  @Query(() => TimelineCalendarEventsWithTotal)
  async getTimelineCalendarEventsFromPersonId(
-    @AuthWorkspace() { id: workspaceId }: Workspace,
    @AuthUser() user: User,
    @Args()
    { personId, page, pageSize }: GetTimelineCalendarEventsFromPersonIdArgs,
  ) {
-    const workspaceMember = await this.userService.loadWorkspaceMember(user);
-
-    if (!workspaceMember) {
-      throw new NotFoundError('Workspace member not found');
-    }
-
    const timelineCalendarEvents =
      await this.timelineCalendarEventService.getCalendarEventsFromPersonIds(
-        workspaceMember.id,
-        workspaceId,
        [personId],
        page,
        pageSize,
@ -76,21 +64,12 @@ export class TimelineCalendarEventResolver {

  @Query(() => TimelineCalendarEventsWithTotal)
  async getTimelineCalendarEventsFromCompanyId(
-    @AuthWorkspace() { id: workspaceId }: Workspace,
    @AuthUser() user: User,
    @Args()
    { companyId, page, pageSize }: GetTimelineCalendarEventsFromCompanyIdArgs,
  ) {
-    const workspaceMember = await this.userService.loadWorkspaceMember(user);
-
-    if (!workspaceMember) {
-      throw new NotFoundError('Workspace member not found');
-    }
-
    const timelineCalendarEvents =
      await this.timelineCalendarEventService.getCalendarEventsFromCompanyId(
-        workspaceMember.id,
-        workspaceId,
        companyId,
        page,
        pageSize,
--- a/packages/twenty-server/src/engine/core-modules/calendar/timeline-calendar-event.service.ts
+++ b/packages/twenty-server/src/engine/core-modules/calendar/timeline-calendar-event.service.ts
@ -1,272 +1,159 @@
 import { Injectable } from '@nestjs/common';

-import groupBy from 'lodash.groupby';
+import { Any } from 'typeorm';
+import omit from 'lodash.omit';

 import { TIMELINE_CALENDAR_EVENTS_DEFAULT_PAGE_SIZE } from 'src/engine/core-modules/calendar/constants/calendar.constants';
-import { TimelineCalendarEventParticipant } from 'src/engine/core-modules/calendar/dtos/timeline-calendar-event-participant.dto';
-import {
-  TimelineCalendarEvent,
-  TimelineCalendarEventVisibility,
-} from 'src/engine/core-modules/calendar/dtos/timeline-calendar-event.dto';
+import { TimelineCalendarEventVisibility } from 'src/engine/core-modules/calendar/dtos/timeline-calendar-event.dto';
 import { TimelineCalendarEventsWithTotal } from 'src/engine/core-modules/calendar/dtos/timeline-calendar-events-with-total.dto';
-import { WorkspaceDataSourceService } from 'src/engine/workspace-datasource/workspace-datasource.service';
-import { ObjectRecord } from 'src/engine/workspace-manager/workspace-sync-metadata/types/object-record';
-import { CalendarEventParticipantObjectMetadata } from 'src/modules/calendar/standard-objects/calendar-event-participant.object-metadata';
+import { InjectWorkspaceRepository } from 'src/engine/twenty-orm/decorators/inject-workspace-repository.decorator';
+import { WorkspaceRepository } from 'src/engine/twenty-orm/repository/workspace.repository';
+import { CalendarEventWorkspaceEntity } from 'src/modules/calendar/standard-objects/calendar-event.workspace-entity';
+import { PersonWorkspaceEntity } from 'src/modules/person/standard-objects/person.workspace-entity';

-type TimelineCalendarEventParticipantWithPersonInformation =
-  ObjectRecord<CalendarEventParticipantObjectMetadata> & {
-    personFirstName: string;
-    personLastName: string;
-    personAvatarUrl: string;
-    workspaceMemberFirstName: string;
-    workspaceMemberLastName: string;
-    workspaceMemberAvatarUrl: string;
-  };
@Injectable()
 export class TimelineCalendarEventService {
  constructor(
-    private readonly workspaceDataSourceService: WorkspaceDataSourceService,
+    @InjectWorkspaceRepository(CalendarEventWorkspaceEntity)
+    private readonly calendarEventRepository: WorkspaceRepository<CalendarEventWorkspaceEntity>,
+    @InjectWorkspaceRepository(PersonWorkspaceEntity)
+    private readonly personRepository: WorkspaceRepository<PersonWorkspaceEntity>,
  ) {}

+  // TODO: Align return type with the entities to avoid mapping
  async getCalendarEventsFromPersonIds(
-    workspaceMemberId: string,
-    workspaceId: string,
    personIds: string[],
    page = 1,
    pageSize: number = TIMELINE_CALENDAR_EVENTS_DEFAULT_PAGE_SIZE,
  ): Promise<TimelineCalendarEventsWithTotal> {
    const offset = (page - 1) * pageSize;

-    const dataSourceSchema =
-      this.workspaceDataSourceService.getSchemaName(workspaceId);
+    const calendarEventIds = await this.calendarEventRepository.find({
+      where: {
+        calendarEventParticipants: {
+          person: {
+            id: Any(personIds),
+          },
+        },
+      },
+      select: {
+        id: true,
+        startsAt: true,
+      },
+      skip: offset,
+      take: pageSize,
+      order: {
+        startsAt: 'DESC',
+      },
+    });

-    const calendarEvents: Omit<TimelineCalendarEvent, 'participants'>[] =
-      await this.workspaceDataSourceService.executeRawQuery(
-        `SELECT
-            "calendarEvent".*
-        FROM
-            ${dataSourceSchema}."calendarEvent" "calendarEvent"
-        LEFT JOIN
-            ${dataSourceSchema}."calendarEventParticipant" "calendarEventParticipant" ON "calendarEvent".id = "calendarEventParticipant"."calendarEventId"
-        LEFT JOIN
-            ${dataSourceSchema}."person" "person" ON "calendarEventParticipant"."personId" = "person".id
-        WHERE
-            "calendarEventParticipant"."personId" = ANY($1)
-        GROUP BY
-            "calendarEvent".id
-        ORDER BY
-            "calendarEvent"."startsAt" DESC
-        LIMIT $2
-        OFFSET $3`,
-        [personIds, pageSize, offset],
-        workspaceId,
-      );
+    const ids = calendarEventIds.map(({ id }) => id);

-    if (!calendarEvents) {
+    if (ids.length <= 0) {
      return {
        totalNumberOfCalendarEvents: 0,
        timelineCalendarEvents: [],
      };
    }

-    const calendarEventParticipants: TimelineCalendarEventParticipantWithPersonInformation[] =
-      await this.workspaceDataSourceService.executeRawQuery(
-        `SELECT
-            "calendarEventParticipant".*,
-            "person"."nameFirstName" as "personFirstName",
-            "person"."nameLastName" as "personLastName",
-            "person"."avatarUrl" as "personAvatarUrl",
-            "workspaceMember"."nameFirstName" as "workspaceMemberFirstName",
-            "workspaceMember"."nameLastName" as "workspaceMemberLastName",
-            "workspaceMember"."avatarUrl" as "workspaceMemberAvatarUrl"
-        FROM
-            ${dataSourceSchema}."calendarEventParticipant" "calendarEventParticipant"
-        LEFT JOIN
-            ${dataSourceSchema}."person" "person" ON "calendarEventParticipant"."personId" = "person".id
-        LEFT JOIN
-            ${dataSourceSchema}."workspaceMember" "workspaceMember" ON "calendarEventParticipant"."workspaceMemberId" = "workspaceMember".id
-        WHERE
-            "calendarEventParticipant"."calendarEventId" = ANY($1)`,
-        [calendarEvents.map((event) => event.id)],
-        workspaceId,
-      );
+    // We've split the query into two parts, because we want to fetch all the participants without any filtering
+    const [events, total] = await this.calendarEventRepository.findAndCount({
+      where: {
+        id: Any(ids),
+      },
+      relations: {
+        calendarEventParticipants: {
+          person: true,
+          workspaceMember: true,
+        },
+        calendarChannelEventAssociations: {
+          calendarChannel: true,
+        },
+      },
+    });

-    const formattedCalendarEventParticipants: TimelineCalendarEventParticipant[] =
-      calendarEventParticipants.map((participant) => {
-        const firstName =
-          participant.personFirstName ||
-          participant.workspaceMemberFirstName ||
-          '';
+    // Keep events in the same order as they ids were returned
+    const orderedEvents = events.sort(
+      (a, b) => ids.indexOf(a.id) - ids.indexOf(b.id),
+    );

-        const lastName =
-          participant.personLastName ||
-          participant.workspaceMemberLastName ||
-          '';
-
-        const displayName =
-          firstName || participant.displayName || participant.handle;
-
-        const avatarUrl =
-          participant.personAvatarUrl ||
-          participant.workspaceMemberAvatarUrl ||
-          '';
-
-        return {
-          calendarEventId: participant.calendarEventId,
-          personId: participant.personId,
-          workspaceMemberId: participant.workspaceMemberId,
-          firstName,
-          lastName,
-          displayName,
-          avatarUrl,
+    const timelineCalendarEvents = orderedEvents.map((event) => {
+      const participants = event.calendarEventParticipants.map(
+        (participant) => ({
+          calendarEventId: event.id,
+          personId: participant.person?.id,
+          workspaceMemberId: participant.workspaceMember?.id,
+          firstName:
+            participant.person?.name.firstName ||
+            participant.workspaceMember?.name.firstName ||
+            '',
+          lastName:
+            participant.person?.name.lastName ||
+            participant.workspaceMember?.name.lastName ||
+            '',
+          displayName:
+            participant.person?.name.firstName ||
+            participant.person?.name.lastName ||
+            participant.workspaceMember?.name.firstName ||
+            participant.workspaceMember?.name.lastName ||
+            '',
+          avatarUrl:
+            participant.person?.avatarUrl ||
+            participant.workspaceMember?.avatarUrl ||
+            '',
          handle: participant.handle,
-        };
-      });
-
-    const calendarEventParticipantsByEventId: {
-      [calendarEventId: string]: TimelineCalendarEventParticipant[];
-    } = groupBy(formattedCalendarEventParticipants, 'calendarEventId');
-
-    const totalNumberOfCalendarEvents: { count: number }[] =
-      await this.workspaceDataSourceService.executeRawQuery(
-        `
-      SELECT
-          COUNT(DISTINCT "calendarEventId")
-      FROM
-          ${dataSourceSchema}."calendarEventParticipant" "calendarEventParticipant"
-      WHERE
-          "calendarEventParticipant"."personId" = ANY($1)
-      `,
-        [personIds],
-        workspaceId,
+        }),
      );
-
-    const timelineCalendarEvents = calendarEvents.map((event) => {
-      const participants = calendarEventParticipantsByEventId[event.id] || [];
+      const visibility = event.calendarChannelEventAssociations.some(
+        (association) => association.calendarChannel.visibility === 'METADATA',
+      )
+        ? TimelineCalendarEventVisibility.METADATA
+        : TimelineCalendarEventVisibility.SHARE_EVERYTHING;

      return {
-        ...event,
+        ...omit(event, [
+          'calendarEventParticipants',
+          'calendarChannelEventAssociations',
+        ]),
+        startsAt: event.startsAt as unknown as Date,
+        endsAt: event.endsAt as unknown as Date,
        participants,
+        visibility,
      };
    });

-    const calendarEventIdsWithWorkspaceMemberInParticipants =
-      await this.workspaceDataSourceService.executeRawQuery(
-        `
-      SELECT
-          "calendarEventId"
-      FROM
-          ${dataSourceSchema}."calendarEventParticipant" "calendarEventParticipant"
-      WHERE
-          "calendarEventParticipant"."workspaceMemberId" = $1
-      `,
-        [workspaceMemberId],
-        workspaceId,
-      );
-
-    const calendarEventIdsWithWorkspaceMemberInParticipantsFormatted =
-      calendarEventIdsWithWorkspaceMemberInParticipants.map(
-        (event: { calendarEventId: string }) => event.calendarEventId,
-      );
-
-    const calendarEventIdsToFetchVisibilityFor = timelineCalendarEvents
-      .filter(
-        (event) =>
-          !calendarEventIdsWithWorkspaceMemberInParticipantsFormatted.includes(
-            event.id,
-          ),
-      )
-      .map((event) => event.id);
-
-    const calendarEventIdsForWhichVisibilityIsMetadata:
-      | {
-          id: string;
-        }[]
-      | undefined = await this.workspaceDataSourceService.executeRawQuery(
-      `
-      SELECT
-          "calendarChannelEventAssociation"."calendarEventId" AS "id"
-      FROM
-          ${dataSourceSchema}."calendarChannel" "calendarChannel"
-      LEFT JOIN
-          ${dataSourceSchema}."calendarChannelEventAssociation" "calendarChannelEventAssociation" ON "calendarChannel".id = "calendarChannelEventAssociation"."calendarChannelId"
-      WHERE
-          "calendarChannelEventAssociation"."calendarEventId" = ANY($1)
-      AND
-          "calendarChannel"."visibility" = 'METADATA'
-      `,
-      [calendarEventIdsToFetchVisibilityFor],
-      workspaceId,
-    );
-
-    if (!calendarEventIdsForWhichVisibilityIsMetadata) {
-      throw new Error('Failed to fetch calendar event visibility');
-    }
-
-    const calendarEventIdsForWhichVisibilityIsMetadataMap = new Map(
-      calendarEventIdsForWhichVisibilityIsMetadata.map((event) => [
-        event.id,
-        TimelineCalendarEventVisibility.METADATA,
-      ]),
-    );
-
-    timelineCalendarEvents.forEach((event) => {
-      event.visibility =
-        calendarEventIdsForWhichVisibilityIsMetadataMap.get(event.id) ??
-        TimelineCalendarEventVisibility.SHARE_EVERYTHING;
-
-      if (event.visibility === TimelineCalendarEventVisibility.METADATA) {
-        event.title = '';
-        event.description = '';
-        event.location = '';
-        event.conferenceSolution = '';
-        event.conferenceLink = { label: '', url: '' };
-      }
-    });
-
    return {
-      totalNumberOfCalendarEvents: totalNumberOfCalendarEvents[0].count,
+      totalNumberOfCalendarEvents: total,
      timelineCalendarEvents,
    };
  }

  async getCalendarEventsFromCompanyId(
-    workspaceMemberId: string,
-    workspaceId: string,
    companyId: string,
    page = 1,
    pageSize: number = TIMELINE_CALENDAR_EVENTS_DEFAULT_PAGE_SIZE,
  ): Promise<TimelineCalendarEventsWithTotal> {
-    const dataSourceSchema =
-      this.workspaceDataSourceService.getSchemaName(workspaceId);
+    const personIds = await this.personRepository.find({
+      where: {
+        company: {
+          id: companyId,
+        },
+      },
+      select: {
+        id: true,
+      },
+    });

-    const personIds = await this.workspaceDataSourceService.executeRawQuery(
-      `
-        SELECT 
-            p."id"
-        FROM
-            ${dataSourceSchema}."person" p
-        WHERE
-            p."companyId" = $1
-        `,
-      [companyId],
-      workspaceId,
-    );
-
-    if (!personIds) {
+    if (personIds.length <= 0) {
      return {
        totalNumberOfCalendarEvents: 0,
        timelineCalendarEvents: [],
      };
    }

-    const formattedPersonIds = personIds.map(
-      (personId: { id: string }) => personId.id,
-    );
+    const formattedPersonIds = personIds.map(({ id }) => id);

    const messageThreads = await this.getCalendarEventsFromPersonIds(
-      workspaceMemberId,
-      workspaceId,
      formattedPersonIds,
      page,
      pageSize,
--- a/packages/twenty-server/src/engine/core-modules/core-engine.module.ts
+++ b/packages/twenty-server/src/engine/core-modules/core-engine.module.ts
@ -10,6 +10,7 @@ import { TimelineMessagingModule } from 'src/engine/core-modules/messaging/timel
 import { TimelineCalendarEventModule } from 'src/engine/core-modules/calendar/timeline-calendar-event.module';
 import { BillingModule } from 'src/engine/core-modules/billing/billing.module';
 import { HealthModule } from 'src/engine/core-modules/health/health.module';
+import { TwentyORMModule } from 'src/engine/twenty-orm/twenty-orm.module';

 import { AnalyticsModule } from './analytics/analytics.module';
 import { FileModule } from './file/file.module';
@ -17,6 +18,9 @@ import { ClientConfigModule } from './client-config/client-config.module';

@Module({
  imports: [
+    TwentyORMModule.register({
+      workspaceEntities: ['dist/src/**/*.workspace-entity{.ts,.js}'],
+    }),
    HealthModule,
    AnalyticsModule,
    AuthModule,
--- a/packages/twenty-server/src/engine/core-modules/user-workspace/user-workspace.service.ts
+++ b/packages/twenty-server/src/engine/core-modules/user-workspace/user-workspace.service.ts
@ -10,7 +10,7 @@ import { DataSourceService } from 'src/engine/metadata-modules/data-source/data-
 import { User } from 'src/engine/core-modules/user/user.entity';
 import { WorkspaceDataSourceService } from 'src/engine/workspace-datasource/workspace-datasource.service';
 import { ObjectRecordCreateEvent } from 'src/engine/integrations/event-emitter/types/object-record-create.event';
-import { WorkspaceMemberObjectMetadata } from 'src/modules/workspace-member/standard-objects/workspace-member.object-metadata';
+import { WorkspaceMemberWorkspaceEntity } from 'src/modules/workspace-member/standard-objects/workspace-member.workspace-entity';
 import { assert } from 'src/utils/assert';

 export class UserWorkspaceService extends TypeOrmQueryService<UserWorkspace> {
@ -59,7 +59,7 @@ export class UserWorkspaceService extends TypeOrmQueryService<UserWorkspace> {
      `Error while creating workspace member ${user.email} on workspace ${workspaceId}`,
    );
    const payload =
-      new ObjectRecordCreateEvent<WorkspaceMemberObjectMetadata>();
+      new ObjectRecordCreateEvent<WorkspaceMemberWorkspaceEntity>();

    payload.workspaceId = workspaceId;
    payload.properties = {
--- a/packages/twenty-server/src/engine/core-modules/user/services/user.service.ts
+++ b/packages/twenty-server/src/engine/core-modules/user/services/user.service.ts
@ -10,7 +10,7 @@ import { WorkspaceMember } from 'src/engine/core-modules/user/dtos/workspace-mem
 import { DataSourceService } from 'src/engine/metadata-modules/data-source/data-source.service';
 import { TypeORMService } from 'src/database/typeorm/typeorm.service';
 import { DataSourceEntity } from 'src/engine/metadata-modules/data-source/data-source.entity';
-import { WorkspaceMemberObjectMetadata } from 'src/modules/workspace-member/standard-objects/workspace-member.object-metadata';
+import { WorkspaceMemberWorkspaceEntity } from 'src/modules/workspace-member/standard-objects/workspace-member.workspace-entity';
 import { ObjectRecordDeleteEvent } from 'src/engine/integrations/event-emitter/types/object-record-delete.event';
 import { ObjectRecord } from 'src/engine/workspace-manager/workspace-sync-metadata/types/object-record';
 import { WorkspaceService } from 'src/engine/core-modules/workspace/services/workspace.service';
@ -113,7 +113,7 @@ export class UserService extends TypeOrmQueryService<User> {
      `SELECT * FROM ${dataSourceMetadata.schema}."workspaceMember"`,
    );
    const workspaceMember = workspaceMembers.filter(
-      (member: ObjectRecord<WorkspaceMemberObjectMetadata>) =>
+      (member: ObjectRecord<WorkspaceMemberWorkspaceEntity>) =>
        member.userId === userId,
    )?.[0];

@ -129,7 +129,7 @@ export class UserService extends TypeOrmQueryService<User> {
      `DELETE FROM ${dataSourceMetadata.schema}."workspaceMember" WHERE "userId" = '${userId}'`,
    );
    const payload =
-      new ObjectRecordDeleteEvent<WorkspaceMemberObjectMetadata>();
+      new ObjectRecordDeleteEvent<WorkspaceMemberWorkspaceEntity>();

    payload.workspaceId = workspaceId;
    payload.properties = {
--- a/packages/twenty-server/src/engine/core-modules/workspace/workspace-workspace-member.listener.ts
+++ b/packages/twenty-server/src/engine/core-modules/workspace/workspace-workspace-member.listener.ts
@ -3,7 +3,7 @@ import { OnEvent } from '@nestjs/event-emitter';

 import { MessageQueue } from 'src/engine/integrations/message-queue/message-queue.constants';
 import { MessageQueueService } from 'src/engine/integrations/message-queue/services/message-queue.service';
-import { WorkspaceMemberObjectMetadata } from 'src/modules/workspace-member/standard-objects/workspace-member.object-metadata';
+import { WorkspaceMemberWorkspaceEntity } from 'src/modules/workspace-member/standard-objects/workspace-member.workspace-entity';
 import { ObjectRecordDeleteEvent } from 'src/engine/integrations/event-emitter/types/object-record-delete.event';
 import {
  HandleWorkspaceMemberDeletedJob,
@ -19,7 +19,7 @@ export class WorkspaceWorkspaceMemberListener {

  @OnEvent('workspaceMember.deleted')
  async handleDeleteEvent(
-    payload: ObjectRecordDeleteEvent<WorkspaceMemberObjectMetadata>,
+    payload: ObjectRecordDeleteEvent<WorkspaceMemberWorkspaceEntity>,
  ) {
    const userId = payload.properties.before.userId;

--- a/packages/twenty-server/src/engine/metadata-modules/workspace-migration/utils/field-metadata-type-to-column-type.util.ts
+++ b/packages/twenty-server/src/engine/metadata-modules/workspace-migration/utils/field-metadata-type-to-column-type.util.ts
@ -26,7 +26,7 @@ export const fieldMetadataTypeToColumnType = <Type extends FieldMetadataType>(
    case FieldMetadataType.DATE_TIME:
      return 'timestamptz';
    case FieldMetadataType.DATE:
-      return 'date';
+      return 'datetime';
    case FieldMetadataType.RATING:
    case FieldMetadataType.SELECT:
    case FieldMetadataType.MULTI_SELECT:
--- a/packages/twenty-server/src/engine/object-metadata-repository/metadata-to-repository.mapping.ts
+++ b/packages/twenty-server/src/engine/object-metadata-repository/metadata-to-repository.mapping.ts
@ -18,24 +18,24 @@ import { AttachmentRepository } from 'src/modules/attachment/repositories/attach
 import { CommentRepository } from 'src/modules/activity/repositories/comment.repository';

 export const metadataToRepositoryMapping = {
-  AuditLogObjectMetadata: AuditLogRepository,
-  BlocklistObjectMetadata: BlocklistRepository,
-  CalendarChannelEventAssociationObjectMetadata:
+  AuditLogWorkspaceEntity: AuditLogRepository,
+  BlocklistWorkspaceEntity: BlocklistRepository,
+  CalendarChannelEventAssociationWorkspaceEntity:
    CalendarChannelEventAssociationRepository,
-  CalendarChannelObjectMetadata: CalendarChannelRepository,
-  CalendarEventParticipantObjectMetadata: CalendarEventParticipantRepository,
-  CalendarEventObjectMetadata: CalendarEventRepository,
-  CompanyObjectMetadata: CompanyRepository,
-  ConnectedAccountObjectMetadata: ConnectedAccountRepository,
-  MessageChannelMessageAssociationObjectMetadata:
+  CalendarChannelWorkspaceEntity: CalendarChannelRepository,
+  CalendarEventParticipantWorkspaceEntity: CalendarEventParticipantRepository,
+  CalendarEventWorkspaceEntity: CalendarEventRepository,
+  CompanyWorkspaceEntity: CompanyRepository,
+  ConnectedAccountWorkspaceEntity: ConnectedAccountRepository,
+  MessageChannelMessageAssociationWorkspaceEntity:
    MessageChannelMessageAssociationRepository,
-  MessageChannelObjectMetadata: MessageChannelRepository,
-  MessageObjectMetadata: MessageRepository,
-  MessageParticipantObjectMetadata: MessageParticipantRepository,
-  MessageThreadObjectMetadata: MessageThreadRepository,
-  PersonObjectMetadata: PersonRepository,
-  TimelineActivityObjectMetadata: TimelineActivityRepository,
-  WorkspaceMemberObjectMetadata: WorkspaceMemberRepository,
-  AttachmentObjectMetadata: AttachmentRepository,
-  CommentObjectMetadata: CommentRepository,
+  MessageChannelWorkspaceEntity: MessageChannelRepository,
+  MessageWorkspaceEntity: MessageRepository,
+  MessageParticipantWorkspaceEntity: MessageParticipantRepository,
+  MessageThreadWorkspaceEntity: MessageThreadRepository,
+  PersonWorkspaceEntity: PersonRepository,
+  TimelineActivityWorkspaceEntity: TimelineActivityRepository,
+  WorkspaceMemberWorkspaceEntity: WorkspaceMemberRepository,
+  AttachmentWorkspaceEntity: AttachmentRepository,
+  CommentWorkspaceEntity: CommentRepository,
 };
--- a/packages/twenty-server/src/engine/twenty-orm/custom.workspace-entity.ts
+++ b/packages/twenty-server/src/engine/twenty-orm/custom.workspace-entity.ts
@ -3,11 +3,11 @@ import {
  RelationMetadataType,
  RelationOnDeleteAction,
 } from 'src/engine/metadata-modules/relation-metadata/relation-metadata.entity';
-import { ActivityTargetObjectMetadata } from 'src/modules/activity/standard-objects/activity-target.object-metadata';
-import { FavoriteObjectMetadata } from 'src/modules/favorite/standard-objects/favorite.object-metadata';
-import { AttachmentObjectMetadata } from 'src/modules/attachment/standard-objects/attachment.object-metadata';
+import { ActivityTargetWorkspaceEntity } from 'src/modules/activity/standard-objects/activity-target.workspace-entity';
+import { FavoriteWorkspaceEntity } from 'src/modules/favorite/standard-objects/favorite.workspace-entity';
+import { AttachmentWorkspaceEntity } from 'src/modules/attachment/standard-objects/attachment.workspace-entity';
 import { CUSTOM_OBJECT_STANDARD_FIELD_IDS } from 'src/engine/workspace-manager/workspace-sync-metadata/constants/standard-field-ids';
-import { TimelineActivityObjectMetadata } from 'src/modules/timeline/standard-objects/timeline-activity.object-metadata';
+import { TimelineActivityWorkspaceEntity } from 'src/modules/timeline/standard-objects/timeline-activity.workspace-entity';
 import { WorkspaceField } from 'src/engine/twenty-orm/decorators/workspace-field.decorator';
 import { WorkspaceIsNullable } from 'src/engine/twenty-orm/decorators/workspace-is-nullable.decorator';
 import { WorkspaceIsSystem } from 'src/engine/twenty-orm/decorators/workspace-is-system.decorator';
@ -45,11 +45,11 @@ export class CustomWorkspaceEntity extends BaseWorkspaceEntity {
    description: (objectMetadata) =>
      `Activities tied to the ${objectMetadata.labelSingular}`,
    icon: 'IconCheckbox',
-    inverseSideTarget: () => ActivityTargetObjectMetadata,
+    inverseSideTarget: () => ActivityTargetWorkspaceEntity,
    onDelete: RelationOnDeleteAction.CASCADE,
  })
  @WorkspaceIsNullable()
-  activityTargets: ActivityTargetObjectMetadata[];
+  activityTargets: ActivityTargetWorkspaceEntity[];

  @WorkspaceRelation({
    standardId: CUSTOM_OBJECT_STANDARD_FIELD_IDS.favorites,
@ -58,12 +58,12 @@ export class CustomWorkspaceEntity extends BaseWorkspaceEntity {
    description: (objectMetadata) =>
      `Favorites tied to the ${objectMetadata.labelSingular}`,
    icon: 'IconHeart',
-    inverseSideTarget: () => FavoriteObjectMetadata,
+    inverseSideTarget: () => FavoriteWorkspaceEntity,
    onDelete: RelationOnDeleteAction.CASCADE,
  })
  @WorkspaceIsNullable()
  @WorkspaceIsSystem()
-  favorites: FavoriteObjectMetadata[];
+  favorites: FavoriteWorkspaceEntity[];

  @WorkspaceRelation({
    standardId: CUSTOM_OBJECT_STANDARD_FIELD_IDS.attachments,
@ -72,11 +72,11 @@ export class CustomWorkspaceEntity extends BaseWorkspaceEntity {
    description: (objectMetadata) =>
      `Attachments tied to the ${objectMetadata.labelSingular}`,
    icon: 'IconFileImport',
-    inverseSideTarget: () => AttachmentObjectMetadata,
+    inverseSideTarget: () => AttachmentWorkspaceEntity,
    onDelete: RelationOnDeleteAction.CASCADE,
  })
  @WorkspaceIsNullable()
-  attachments: AttachmentObjectMetadata[];
+  attachments: AttachmentWorkspaceEntity[];

  @WorkspaceRelation({
    standardId: CUSTOM_OBJECT_STANDARD_FIELD_IDS.timelineActivities,
@ -85,10 +85,10 @@ export class CustomWorkspaceEntity extends BaseWorkspaceEntity {
    description: (objectMetadata) =>
      `Timeline Activities tied to the ${objectMetadata.labelSingular}`,
    icon: 'IconIconTimelineEvent',
-    inverseSideTarget: () => TimelineActivityObjectMetadata,
+    inverseSideTarget: () => TimelineActivityWorkspaceEntity,
    onDelete: RelationOnDeleteAction.CASCADE,
  })
  @WorkspaceIsNullable()
  @WorkspaceIsSystem()
-  timelineActivities: TimelineActivityObjectMetadata[];
+  timelineActivities: TimelineActivityWorkspaceEntity[];
 }
--- a/packages/twenty-server/src/engine/twenty-orm/decorators/workspace-entity.decorator.ts
+++ b/packages/twenty-server/src/engine/twenty-orm/decorators/workspace-entity.decorator.ts
--- a/packages/twenty-server/src/engine/twenty-orm/entity-manager/entity.manager.ts
+++ b/packages/twenty-server/src/engine/twenty-orm/entity-manager/entity.manager.ts
@ -9,7 +9,9 @@ export class WorkspaceEntityManager extends EntityManager {
    // find already created repository instance and return it if found
    const repoFromMap = this.repositories.get(target);

-    if (repoFromMap) return repoFromMap as WorkspaceRepository<Entity>;
+    if (repoFromMap) {
+      return repoFromMap as WorkspaceRepository<Entity>;
+    }

    const newRepository = new WorkspaceRepository<Entity>(
      target,
--- a/packages/twenty-server/src/engine/twenty-orm/factories/entity-schema-column.factory.ts
+++ b/packages/twenty-server/src/engine/twenty-orm/factories/entity-schema-column.factory.ts
@ -3,6 +3,7 @@ import { Injectable } from '@nestjs/common';
 import { ColumnType, EntitySchemaColumnOptions } from 'typeorm';

 import { WorkspaceFieldMetadataArgs } from 'src/engine/twenty-orm/interfaces/workspace-field-metadata-args.interface';
+import { WorkspaceRelationMetadataArgs } from 'src/engine/twenty-orm/interfaces/workspace-relation-metadata-args.interface';

 import { fieldMetadataTypeToColumnType } from 'src/engine/metadata-modules/workspace-migration/utils/field-metadata-type-to-column-type.util';
 import { isEnumFieldMetadataType } from 'src/engine/metadata-modules/field-metadata/utils/is-enum-field-metadata-type.util';
@ -20,6 +21,7 @@ type EntitySchemaColumnMap = {
 export class EntitySchemaColumnFactory {
  create(
    fieldMetadataArgsCollection: WorkspaceFieldMetadataArgs[],
+    relationMetadataArgsCollection: WorkspaceRelationMetadataArgs[],
  ): EntitySchemaColumnMap {
    let entitySchemaColumnMap: EntitySchemaColumnMap = {};

@ -53,6 +55,16 @@ export class EntitySchemaColumnFactory {
        default: defaultValue,
      };

+      for (const relationMetadataArgs of relationMetadataArgsCollection) {
+        if (relationMetadataArgs.joinColumn) {
+          entitySchemaColumnMap[relationMetadataArgs.joinColumn] = {
+            name: relationMetadataArgs.joinColumn,
+            type: 'uuid',
+            nullable: relationMetadataArgs.isNullable,
+          };
+        }
+      }
+
      if (isEnumFieldMetadataType(fieldMetadataArgs.type)) {
        const values = fieldMetadataArgs.options?.map((option) => option.value);

--- a/packages/twenty-server/src/engine/twenty-orm/factories/entity-schema-relation.factory.ts
+++ b/packages/twenty-server/src/engine/twenty-orm/factories/entity-schema-relation.factory.ts
@ -15,11 +15,14 @@ type EntitySchemaRelationMap = {
@Injectable()
 export class EntitySchemaRelationFactory {
  create(
+    // eslint-disable-next-line @typescript-eslint/ban-types
+    target: Function,
    relationMetadataArgsCollection: WorkspaceRelationMetadataArgs[],
  ): EntitySchemaRelationMap {
    const entitySchemaRelationMap: EntitySchemaRelationMap = {};

    for (const relationMetadataArgs of relationMetadataArgsCollection) {
+      const objectName = convertClassNameToObjectMetadataName(target.name);
      const oppositeTarget = relationMetadataArgs.inverseSideTarget();
      const oppositeObjectName = convertClassNameToObjectMetadataName(
        oppositeTarget.name,
@ -30,7 +33,7 @@ export class EntitySchemaRelationFactory {
      entitySchemaRelationMap[relationMetadataArgs.name] = {
        type: relationType,
        target: oppositeObjectName,
-        inverseSide: relationMetadataArgs.inverseSideFieldKey,
+        inverseSide: relationMetadataArgs.inverseSideFieldKey ?? objectName,
        joinColumn: relationMetadataArgs.joinColumn
          ? {
              name: relationMetadataArgs.joinColumn,
--- a/packages/twenty-server/src/engine/twenty-orm/factories/entity-schema.factory.ts
+++ b/packages/twenty-server/src/engine/twenty-orm/factories/entity-schema.factory.ts
@ -28,9 +28,11 @@ export class EntitySchemaFactory {

    const columns = this.entitySchemaColumnFactory.create(
      fieldMetadataArgsCollection,
+      relationMetadataArgsCollection,
    );

    const relations = this.entitySchemaRelationFactory.create(
+      target,
      relationMetadataArgsCollection,
    );

--- a/packages/twenty-server/src/engine/twenty-orm/interfaces/twenty-orm-options.interface.ts
+++ b/packages/twenty-server/src/engine/twenty-orm/interfaces/twenty-orm-options.interface.ts
@ -3,7 +3,7 @@ import { FactoryProvider, ModuleMetadata, Type } from '@nestjs/common';
 import { BaseWorkspaceEntity } from 'src/engine/twenty-orm/base.workspace-entity';

 export interface TwentyORMOptions {
-  workspaceEntities: Type<BaseWorkspaceEntity>[];
+  workspaceEntities: (Type<BaseWorkspaceEntity> | string)[];
 }

 export type TwentyORMModuleAsyncOptions = {
--- a/packages/twenty-server/src/engine/twenty-orm/repository/workspace.repository.ts
+++ b/packages/twenty-server/src/engine/twenty-orm/repository/workspace.repository.ts
@ -21,6 +21,7 @@ import { ObjectLiteralStorage } from 'src/engine/twenty-orm/storage/object-liter
 import { compositeTypeDefintions } from 'src/engine/metadata-modules/field-metadata/composite-types';
 import { computeCompositeColumnName } from 'src/engine/metadata-modules/field-metadata/utils/compute-column-name.util';
 import { isCompositeFieldMetadataType } from 'src/engine/metadata-modules/field-metadata/utils/is-composite-field-metadata-type.util';
+import { isPlainObject } from 'src/utils/is-plain-object';

 export class WorkspaceRepository<
  Entity extends ObjectLiteral,
@ -492,7 +493,7 @@ export class WorkspaceRepository<
      const fieldMetadataArgs = compositeFieldMetadataArgsMap.get(key);

      if (!fieldMetadataArgs) {
-        if (typeof value === 'object') {
+        if (isPlainObject(value)) {
          newData[key] = this.formatData(value);
        } else {
          newData[key] = value;
@ -524,25 +525,30 @@ export class WorkspaceRepository<
    return newData as T;
  }

-  private formatResult<T>(data: T): T {
+  private formatResult<T>(
+    data: T,
+    target = ObjectLiteralStorage.getObjectLiteral(this.target as any),
+  ): T {
    if (!data) {
      return data;
    }

    if (Array.isArray(data)) {
-      return data.map((item) => this.formatResult(item)) as T;
+      return data.map((item) => this.formatResult(item, target)) as T;
    }

-    const objectLiteral = ObjectLiteralStorage.getObjectLiteral(
-      this.target as any,
-    );
+    if (!isPlainObject(data)) {
+      return data;
+    }

-    if (!objectLiteral) {
+    if (!target) {
      throw new Error('Object literal is missing');
    }

    const fieldMetadataArgsCollection =
-      metadataArgsStorage.filterFields(objectLiteral);
+      metadataArgsStorage.filterFields(target);
+    const relationMetadataArgsCollection =
+      metadataArgsStorage.filterRelations(target);
    const compositeFieldMetadataArgsCollection =
      fieldMetadataArgsCollection.filter((fieldMetadataArg) =>
        isCompositeFieldMetadataType(fieldMetadataArg.type),
@ -565,13 +571,20 @@ export class WorkspaceRepository<
        ]);
      }),
    );
+    const relationMetadataArgsMap = new Map(
+      relationMetadataArgsCollection.map((relationMetadataArgs) => [
+        relationMetadataArgs.name,
+        relationMetadataArgs,
+      ]),
+    );
    const newData: object = {};

    for (const [key, value] of Object.entries(data)) {
      const compositePropertyArgs = compositeFieldMetadataArgsMap.get(key);
+      const relationMetadataArgs = relationMetadataArgsMap.get(key);

-      if (!compositePropertyArgs) {
-        if (typeof value === 'object') {
+      if (!compositePropertyArgs && !relationMetadataArgs) {
+        if (isPlainObject(value)) {
          newData[key] = this.formatResult(value);
        } else {
          newData[key] = value;
@ -579,6 +592,18 @@ export class WorkspaceRepository<
        continue;
      }

+      if (relationMetadataArgs) {
+        newData[key] = this.formatResult(
+          value,
+          relationMetadataArgs.inverseSideTarget() as any,
+        );
+        continue;
+      }
+
+      if (!compositePropertyArgs) {
+        continue;
+      }
+
      const { parentField, ...compositeProperty } = compositePropertyArgs;

      if (!newData[parentField]) {
--- a/packages/twenty-server/src/engine/twenty-orm/twenty-orm-core.module.ts
+++ b/packages/twenty-server/src/engine/twenty-orm/twenty-orm-core.module.ts
@ -5,12 +5,16 @@ import {
  Module,
  OnApplicationShutdown,
  Provider,
+  Type,
 } from '@nestjs/common';
 import {
  ConfigurableModuleClass,
  MODULE_OPTIONS_TOKEN,
 } from '@nestjs/common/cache/cache.module-definition';

+import { importClassesFromDirectories } from 'typeorm/util/DirectoryExportedClassesLoader';
+import { Logger as TypeORMLogger } from 'typeorm/logger/Logger';
+
 import {
  TwentyORMModuleAsyncOptions,
  TwentyORMOptions,
@ -23,6 +27,9 @@ import { DataSourceModule } from 'src/engine/metadata-modules/data-source/data-s
 import { EntitySchemaFactory } from 'src/engine/twenty-orm/factories/entity-schema.factory';
 import { DataSourceStorage } from 'src/engine/twenty-orm/storage/data-source.storage';
 import { ScopedWorkspaceDatasourceFactory } from 'src/engine/twenty-orm/factories/scoped-workspace-datasource.factory';
+import { BaseWorkspaceEntity } from 'src/engine/twenty-orm/base.workspace-entity';
+import { splitClassesAndStrings } from 'src/engine/twenty-orm/utils/split-classes-and-strings.util';
+import { CustomWorkspaceEntity } from 'src/engine/twenty-orm/custom.workspace-entity';

@Global()
@Module({
@ -34,10 +41,12 @@ export class TwentyORMCoreModule
  extends ConfigurableModuleClass
  implements OnApplicationShutdown
 {
-  private readonly logger = new Logger(TwentyORMCoreModule.name);
+  private static readonly logger = new Logger(TwentyORMCoreModule.name);

  static register(options: TwentyORMOptions): DynamicModule {
    const dynamicModule = super.register(options);
+
+    console.log('register', options);
    const providers: Provider[] = [
      {
        provide: TWENTY_ORM_WORKSPACE_DATASOURCE,
@ -45,7 +54,11 @@ export class TwentyORMCoreModule
          entitySchemaFactory: EntitySchemaFactory,
          scopedWorkspaceDatasourceFactory: ScopedWorkspaceDatasourceFactory,
        ) => {
-          const entities = options.workspaceEntities.map((entityClass) =>
+          const workspaceEntities = await this.loadEntities(
+            options.workspaceEntities,
+          );
+
+          const entities = workspaceEntities.map((entityClass) =>
            entitySchemaFactory.create(entityClass),
          );

@ -80,7 +93,11 @@ export class TwentyORMCoreModule
          scopedWorkspaceDatasourceFactory: ScopedWorkspaceDatasourceFactory,
          options: TwentyORMOptions,
        ) => {
-          const entities = options.workspaceEntities.map((entityClass) =>
+          const workspaceEntities = await this.loadEntities(
+            options.workspaceEntities,
+          );
+
+          const entities = workspaceEntities.map((entityClass) =>
            entitySchemaFactory.create(entityClass),
          );

@ -123,4 +140,29 @@ export class TwentyORMCoreModule
      }
    }
  }
+
+  private static async loadEntities(
+    workspaceEntities: (Type<BaseWorkspaceEntity> | string)[],
+  ): Promise<Type<BaseWorkspaceEntity>[]> {
+    const [entityClassesOrSchemas, entityDirectories] = splitClassesAndStrings(
+      workspaceEntities || [],
+    );
+    const importedEntities = await importClassesFromDirectories(
+      // Only `log` function is used under importClassesFromDirectories function
+      this.logger as unknown as TypeORMLogger,
+      entityDirectories,
+    );
+    const entities = [
+      ...entityClassesOrSchemas,
+      ...(importedEntities as Type<BaseWorkspaceEntity>[]),
+    ];
+
+    return entities.filter(
+      (entity) =>
+        // Filter out CustomWorkspaceEntity as it's a partial entity handled separately
+        entity.name !== CustomWorkspaceEntity.name &&
+        // Filter out BaseWorkspaceEntity as it's a base entity and should not be included in the workspace entities
+        entity.name !== BaseWorkspaceEntity.name,
+    );
+  }
 }
--- a/packages/twenty-server/src/engine/twenty-orm/utils/split-classes-and-strings.util.ts
+++ b/packages/twenty-server/src/engine/twenty-orm/utils/split-classes-and-strings.util.ts
@ -0,0 +1,8 @@
+export const splitClassesAndStrings = <T>(
+  classesAndStrings: (string | T)[],
+): [T[], string[]] => {
+  return [
+    classesAndStrings.filter((cls): cls is T => typeof cls !== 'string'),
+    classesAndStrings.filter((str): str is string => typeof str === 'string'),
+  ];
+};
--- a/packages/twenty-server/src/engine/workspace-manager/workspace-sync-metadata/comparators/workspace-field.comparator.ts
+++ b/packages/twenty-server/src/engine/workspace-manager/workspace-sync-metadata/comparators/workspace-field.comparator.ts
@ -7,7 +7,7 @@ import {
  FieldComparatorResult,
 } from 'src/engine/workspace-manager/workspace-sync-metadata/interfaces/comparator.interface';
 import { ComputedPartialFieldMetadata } from 'src/engine/workspace-manager/workspace-sync-metadata/interfaces/partial-field-metadata.interface';
-import { ComputedPartialObjectMetadata } from 'src/engine/workspace-manager/workspace-sync-metadata/interfaces/partial-object-metadata.interface';
+import { ComputedPartialWorkspaceEntity } from 'src/engine/workspace-manager/workspace-sync-metadata/interfaces/partial-object-metadata.interface';

 import { ObjectMetadataEntity } from 'src/engine/metadata-modules/object-metadata/object-metadata.entity';
 import { transformMetadataForComparison } from 'src/engine/workspace-manager/workspace-sync-metadata/comparators/utils/transform-metadata-for-comparison.util';
@ -36,7 +36,7 @@ export class WorkspaceFieldComparator {

  public compare(
    originalObjectMetadata: ObjectMetadataEntity,
-    standardObjectMetadata: ComputedPartialObjectMetadata,
+    standardObjectMetadata: ComputedPartialWorkspaceEntity,
  ): FieldComparatorResult[] {
    const result: FieldComparatorResult[] = [];
    const fieldPropertiesToUpdateMap: Record<
--- a/packages/twenty-server/src/engine/workspace-manager/workspace-sync-metadata/comparators/workspace-object.comparator.ts
+++ b/packages/twenty-server/src/engine/workspace-manager/workspace-sync-metadata/comparators/workspace-object.comparator.ts
@ -7,7 +7,7 @@ import {
  ComparatorAction,
  ObjectComparatorResult,
 } from 'src/engine/workspace-manager/workspace-sync-metadata/interfaces/comparator.interface';
-import { ComputedPartialObjectMetadata } from 'src/engine/workspace-manager/workspace-sync-metadata/interfaces/partial-object-metadata.interface';
+import { ComputedPartialWorkspaceEntity } from 'src/engine/workspace-manager/workspace-sync-metadata/interfaces/partial-object-metadata.interface';

 import { transformMetadataForComparison } from 'src/engine/workspace-manager/workspace-sync-metadata/comparators/utils/transform-metadata-for-comparison.util';
 import { ObjectMetadataEntity } from 'src/engine/metadata-modules/object-metadata/object-metadata.entity';
@ -28,7 +28,7 @@ export class WorkspaceObjectComparator {

  public compare(
    originalObjectMetadata: ObjectMetadataEntity | undefined,
-    standardObjectMetadata: ComputedPartialObjectMetadata,
+    standardObjectMetadata: ComputedPartialWorkspaceEntity,
  ): ObjectComparatorResult {
    // If the object doesn't exist in the original metadata, we need to create it
    if (!originalObjectMetadata) {
@ -38,7 +38,8 @@ export class WorkspaceObjectComparator {
      };
    }

-    const objectPropertiesToUpdate: Partial<ComputedPartialObjectMetadata> = {};
+    const objectPropertiesToUpdate: Partial<ComputedPartialWorkspaceEntity> =
+      {};

    // Only compare properties that are not ignored
    const partialOriginalObjectMetadata = transformMetadataForComparison(
--- a/packages/twenty-server/src/engine/workspace-manager/workspace-sync-metadata/factories/standard-object.factory.ts
+++ b/packages/twenty-server/src/engine/workspace-manager/workspace-sync-metadata/factories/standard-object.factory.ts
@ -1,7 +1,7 @@
 import { Injectable } from '@nestjs/common';

 import { WorkspaceSyncContext } from 'src/engine/workspace-manager/workspace-sync-metadata/interfaces/workspace-sync-context.interface';
-import { PartialObjectMetadata } from 'src/engine/workspace-manager/workspace-sync-metadata/interfaces/partial-object-metadata.interface';
+import { PartialWorkspaceEntity } from 'src/engine/workspace-manager/workspace-sync-metadata/interfaces/partial-object-metadata.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';
@ -18,19 +18,19 @@ export class StandardObjectFactory {
    standardObjectMetadataDefinitions: (typeof BaseWorkspaceEntity)[],
    context: WorkspaceSyncContext,
    workspaceFeatureFlagsMap: FeatureFlagMap,
-  ): PartialObjectMetadata[] {
+  ): PartialWorkspaceEntity[] {
    return standardObjectMetadataDefinitions
      .map((metadata) =>
        this.createObjectMetadata(metadata, context, workspaceFeatureFlagsMap),
      )
-      .filter((metadata): metadata is PartialObjectMetadata => !!metadata);
+      .filter((metadata): metadata is PartialWorkspaceEntity => !!metadata);
  }

  private createObjectMetadata(
    target: typeof BaseWorkspaceEntity,
    context: WorkspaceSyncContext,
    workspaceFeatureFlagsMap: FeatureFlagMap,
-  ): PartialObjectMetadata | undefined {
+  ): PartialWorkspaceEntity | undefined {
    const workspaceEntityMetadataArgs =
      metadataArgsStorage.filterEntities(target);

--- a/packages/twenty-server/src/engine/workspace-manager/workspace-sync-metadata/interfaces/comparator.interface.ts
+++ b/packages/twenty-server/src/engine/workspace-manager/workspace-sync-metadata/interfaces/comparator.interface.ts
@ -2,7 +2,7 @@ import { FieldMetadataEntity } from 'src/engine/metadata-modules/field-metadata/
 import { RelationMetadataEntity } from 'src/engine/metadata-modules/relation-metadata/relation-metadata.entity';

 import { ComputedPartialFieldMetadata } from './partial-field-metadata.interface';
-import { ComputedPartialObjectMetadata } from './partial-object-metadata.interface';
+import { ComputedPartialWorkspaceEntity } from './partial-object-metadata.interface';

 export const enum ComparatorAction {
  SKIP = 'SKIP',
@ -32,9 +32,9 @@ export interface ComparatorDeleteResult<T> {

 export type ObjectComparatorResult =
  | ComparatorSkipResult
-  | ComparatorCreateResult<ComputedPartialObjectMetadata>
+  | ComparatorCreateResult<ComputedPartialWorkspaceEntity>
  | ComparatorUpdateResult<
-      Partial<ComputedPartialObjectMetadata> & { id: string }
+      Partial<ComputedPartialWorkspaceEntity> & { id: string }
    >;

 export type FieldComparatorResult =
--- a/packages/twenty-server/src/engine/workspace-manager/workspace-sync-metadata/interfaces/mapped-metadata.interface.ts
+++ b/packages/twenty-server/src/engine/workspace-manager/workspace-sync-metadata/interfaces/mapped-metadata.interface.ts
@ -1,13 +1,13 @@
 import { PartialFieldMetadata } from 'src/engine/workspace-manager/workspace-sync-metadata/interfaces/partial-field-metadata.interface';
-import { PartialObjectMetadata } from 'src/engine/workspace-manager/workspace-sync-metadata/interfaces/partial-object-metadata.interface';
+import { PartialWorkspaceEntity } from 'src/engine/workspace-manager/workspace-sync-metadata/interfaces/partial-object-metadata.interface';

 import { ObjectMetadataEntity } from 'src/engine/metadata-modules/object-metadata/object-metadata.entity';
 import { FieldMetadataEntity } from 'src/engine/metadata-modules/field-metadata/field-metadata.entity';

 export type MappedFieldMetadata = Record<string, PartialFieldMetadata>;

-export interface MappedObjectMetadata
-  extends Omit<PartialObjectMetadata, 'fields'> {
+export interface MappedWorkspaceEntity
+  extends Omit<PartialWorkspaceEntity, 'fields'> {
  fields: MappedFieldMetadata;
 }

--- a/packages/twenty-server/src/engine/workspace-manager/workspace-sync-metadata/interfaces/partial-object-metadata.interface.ts
+++ b/packages/twenty-server/src/engine/workspace-manager/workspace-sync-metadata/interfaces/partial-object-metadata.interface.ts
@ -5,7 +5,7 @@ import {
 } from 'src/engine/workspace-manager/workspace-sync-metadata/interfaces/partial-field-metadata.interface';
 import { ObjectMetadataInterface } from 'src/engine/metadata-modules/field-metadata/interfaces/object-metadata.interface';

-export type PartialObjectMetadata = Omit<
+export type PartialWorkspaceEntity = Omit<
  ObjectMetadataInterface,
  'id' | 'standardId' | 'fromRelations' | 'toRelations' | 'fields' | 'isActive'
 > & {
@ -16,8 +16,8 @@ export type PartialObjectMetadata = Omit<
  fields: (PartialFieldMetadata | PartialComputedFieldMetadata)[];
 };

-export type ComputedPartialObjectMetadata = Omit<
-  PartialObjectMetadata,
+export type ComputedPartialWorkspaceEntity = Omit<
+  PartialWorkspaceEntity,
  'standardId' | 'fields'
 > & {
  standardId: string | null;
--- a/packages/twenty-server/src/engine/workspace-manager/workspace-sync-metadata/standard-objects/index.ts
+++ b/packages/twenty-server/src/engine/workspace-manager/workspace-sync-metadata/standard-objects/index.ts
@ -1,61 +1,61 @@
-import { ActivityTargetObjectMetadata } from 'src/modules/activity/standard-objects/activity-target.object-metadata';
-import { ActivityObjectMetadata } from 'src/modules/activity/standard-objects/activity.object-metadata';
-import { ApiKeyObjectMetadata } from 'src/modules/api-key/standard-objects/api-key.object-metadata';
-import { AttachmentObjectMetadata } from 'src/modules/attachment/standard-objects/attachment.object-metadata';
-import { BlocklistObjectMetadata } from 'src/modules/connected-account/standard-objects/blocklist.object-metadata';
-import { CalendarEventObjectMetadata } from 'src/modules/calendar/standard-objects/calendar-event.object-metadata';
-import { CalendarChannelObjectMetadata } from 'src/modules/calendar/standard-objects/calendar-channel.object-metadata';
-import { CalendarEventParticipantObjectMetadata } from 'src/modules/calendar/standard-objects/calendar-event-participant.object-metadata';
-import { CommentObjectMetadata } from 'src/modules/activity/standard-objects/comment.object-metadata';
-import { CompanyObjectMetadata } from 'src/modules/company/standard-objects/company.object-metadata';
-import { ConnectedAccountObjectMetadata } from 'src/modules/connected-account/standard-objects/connected-account.object-metadata';
-import { FavoriteObjectMetadata } from 'src/modules/favorite/standard-objects/favorite.object-metadata';
-import { MessageChannelMessageAssociationObjectMetadata } from 'src/modules/messaging/standard-objects/message-channel-message-association.object-metadata';
-import { MessageChannelObjectMetadata } from 'src/modules/messaging/standard-objects/message-channel.object-metadata';
-import { MessageParticipantObjectMetadata } from 'src/modules/messaging/standard-objects/message-participant.object-metadata';
-import { MessageThreadObjectMetadata } from 'src/modules/messaging/standard-objects/message-thread.object-metadata';
-import { MessageObjectMetadata } from 'src/modules/messaging/standard-objects/message.object-metadata';
-import { OpportunityObjectMetadata } from 'src/modules/opportunity/standard-objects/opportunity.object-metadata';
-import { PersonObjectMetadata } from 'src/modules/person/standard-objects/person.object-metadata';
-import { ViewFieldObjectMetadata } from 'src/modules/view/standard-objects/view-field.object-metadata';
-import { ViewFilterObjectMetadata } from 'src/modules/view/standard-objects/view-filter.object-metadata';
-import { ViewSortObjectMetadata } from 'src/modules/view/standard-objects/view-sort.object-metadata';
-import { ViewObjectMetadata } from 'src/modules/view/standard-objects/view.object-metadata';
-import { WebhookObjectMetadata } from 'src/modules/webhook/standard-objects/webhook.object-metadata';
-import { WorkspaceMemberObjectMetadata } from 'src/modules/workspace-member/standard-objects/workspace-member.object-metadata';
-import { CalendarChannelEventAssociationObjectMetadata } from 'src/modules/calendar/standard-objects/calendar-channel-event-association.object-metadata';
-import { AuditLogObjectMetadata } from 'src/modules/timeline/standard-objects/audit-log.object-metadata';
-import { TimelineActivityObjectMetadata } from 'src/modules/timeline/standard-objects/timeline-activity.object-metadata';
-import { BehavioralEventObjectMetadata } from 'src/modules/timeline/standard-objects/behavioral-event.object-metadata';
+import { ActivityTargetWorkspaceEntity } from 'src/modules/activity/standard-objects/activity-target.workspace-entity';
+import { ActivityWorkspaceEntity } from 'src/modules/activity/standard-objects/activity.workspace-entity';
+import { ApiKeyWorkspaceEntity } from 'src/modules/api-key/standard-objects/api-key.workspace-entity';
+import { AttachmentWorkspaceEntity } from 'src/modules/attachment/standard-objects/attachment.workspace-entity';
+import { BlocklistWorkspaceEntity } from 'src/modules/connected-account/standard-objects/blocklist.workspace-entity';
+import { CalendarEventWorkspaceEntity } from 'src/modules/calendar/standard-objects/calendar-event.workspace-entity';
+import { CalendarChannelWorkspaceEntity } from 'src/modules/calendar/standard-objects/calendar-channel.workspace-entity';
+import { CalendarEventParticipantWorkspaceEntity } from 'src/modules/calendar/standard-objects/calendar-event-participant.workspace-entity';
+import { CommentWorkspaceEntity } from 'src/modules/activity/standard-objects/comment.workspace-entity';
+import { CompanyWorkspaceEntity } from 'src/modules/company/standard-objects/company.workspace-entity';
+import { ConnectedAccountWorkspaceEntity } from 'src/modules/connected-account/standard-objects/connected-account.workspace-entity';
+import { FavoriteWorkspaceEntity } from 'src/modules/favorite/standard-objects/favorite.workspace-entity';
+import { MessageChannelMessageAssociationWorkspaceEntity } from 'src/modules/messaging/standard-objects/message-channel-message-association.workspace-entity';
+import { MessageChannelWorkspaceEntity } from 'src/modules/messaging/standard-objects/message-channel.workspace-entity';
+import { MessageParticipantWorkspaceEntity } from 'src/modules/messaging/standard-objects/message-participant.workspace-entity';
+import { MessageThreadWorkspaceEntity } from 'src/modules/messaging/standard-objects/message-thread.workspace-entity';
+import { MessageWorkspaceEntity } from 'src/modules/messaging/standard-objects/message.workspace-entity';
+import { OpportunityWorkspaceEntity } from 'src/modules/opportunity/standard-objects/opportunity.workspace-entity';
+import { PersonWorkspaceEntity } from 'src/modules/person/standard-objects/person.workspace-entity';
+import { ViewFieldWorkspaceEntity } from 'src/modules/view/standard-objects/view-field.workspace-entity';
+import { ViewFilterWorkspaceEntity } from 'src/modules/view/standard-objects/view-filter.workspace-entity';
+import { ViewSortWorkspaceEntity } from 'src/modules/view/standard-objects/view-sort.workspace-entity';
+import { ViewWorkspaceEntity } from 'src/modules/view/standard-objects/view.workspace-entity';
+import { WebhookWorkspaceEntity } from 'src/modules/webhook/standard-objects/webhook.workspace-entity';
+import { WorkspaceMemberWorkspaceEntity } from 'src/modules/workspace-member/standard-objects/workspace-member.workspace-entity';
+import { CalendarChannelEventAssociationWorkspaceEntity } from 'src/modules/calendar/standard-objects/calendar-channel-event-association.workspace-entity';
+import { AuditLogWorkspaceEntity } from 'src/modules/timeline/standard-objects/audit-log.workspace-entity';
+import { TimelineActivityWorkspaceEntity } from 'src/modules/timeline/standard-objects/timeline-activity.workspace-entity';
+import { BehavioralEventWorkspaceEntity } from 'src/modules/timeline/standard-objects/behavioral-event.workspace-entity';

 export const standardObjectMetadataDefinitions = [
-  ActivityTargetObjectMetadata,
-  ActivityObjectMetadata,
-  ApiKeyObjectMetadata,
-  AuditLogObjectMetadata,
-  AttachmentObjectMetadata,
-  BehavioralEventObjectMetadata,
-  BlocklistObjectMetadata,
-  CalendarEventObjectMetadata,
-  CalendarChannelObjectMetadata,
-  CalendarChannelEventAssociationObjectMetadata,
-  CalendarEventParticipantObjectMetadata,
-  CommentObjectMetadata,
-  CompanyObjectMetadata,
-  ConnectedAccountObjectMetadata,
-  FavoriteObjectMetadata,
-  OpportunityObjectMetadata,
-  PersonObjectMetadata,
-  TimelineActivityObjectMetadata,
-  ViewFieldObjectMetadata,
-  ViewFilterObjectMetadata,
-  ViewSortObjectMetadata,
-  ViewObjectMetadata,
-  WebhookObjectMetadata,
-  WorkspaceMemberObjectMetadata,
-  MessageThreadObjectMetadata,
-  MessageObjectMetadata,
-  MessageChannelObjectMetadata,
-  MessageParticipantObjectMetadata,
-  MessageChannelMessageAssociationObjectMetadata,
+  ActivityTargetWorkspaceEntity,
+  ActivityWorkspaceEntity,
+  ApiKeyWorkspaceEntity,
+  AuditLogWorkspaceEntity,
+  AttachmentWorkspaceEntity,
+  BehavioralEventWorkspaceEntity,
+  BlocklistWorkspaceEntity,
+  CalendarEventWorkspaceEntity,
+  CalendarChannelWorkspaceEntity,
+  CalendarChannelEventAssociationWorkspaceEntity,
+  CalendarEventParticipantWorkspaceEntity,
+  CommentWorkspaceEntity,
+  CompanyWorkspaceEntity,
+  ConnectedAccountWorkspaceEntity,
+  FavoriteWorkspaceEntity,
+  OpportunityWorkspaceEntity,
+  PersonWorkspaceEntity,
+  TimelineActivityWorkspaceEntity,
+  ViewFieldWorkspaceEntity,
+  ViewFilterWorkspaceEntity,
+  ViewSortWorkspaceEntity,
+  ViewWorkspaceEntity,
+  WebhookWorkspaceEntity,
+  WorkspaceMemberWorkspaceEntity,
+  MessageThreadWorkspaceEntity,
+  MessageWorkspaceEntity,
+  MessageChannelWorkspaceEntity,
+  MessageParticipantWorkspaceEntity,
+  MessageChannelMessageAssociationWorkspaceEntity,
 ];
--- a/packages/twenty-server/src/engine/workspace-manager/workspace-sync-metadata/storage/workspace-sync.storage.ts
+++ b/packages/twenty-server/src/engine/workspace-manager/workspace-sync-metadata/storage/workspace-sync.storage.ts
@ -1,4 +1,4 @@
-import { ComputedPartialObjectMetadata } from 'src/engine/workspace-manager/workspace-sync-metadata/interfaces/partial-object-metadata.interface';
+import { ComputedPartialWorkspaceEntity } from 'src/engine/workspace-manager/workspace-sync-metadata/interfaces/partial-object-metadata.interface';
 import { ComputedPartialFieldMetadata } from 'src/engine/workspace-manager/workspace-sync-metadata/interfaces/partial-field-metadata.interface';

 import { ObjectMetadataEntity } from 'src/engine/metadata-modules/object-metadata/object-metadata.entity';
@ -7,9 +7,9 @@ import { RelationMetadataEntity } from 'src/engine/metadata-modules/relation-met

 export class WorkspaceSyncStorage {
  // Object metadata
-  private readonly _objectMetadataCreateCollection: ComputedPartialObjectMetadata[] =
+  private readonly _objectMetadataCreateCollection: ComputedPartialWorkspaceEntity[] =
    [];
-  private readonly _objectMetadataUpdateCollection: (Partial<ComputedPartialObjectMetadata> & {
+  private readonly _objectMetadataUpdateCollection: (Partial<ComputedPartialWorkspaceEntity> & {
    id: string;
  })[] = [];
  private readonly _objectMetadataDeleteCollection: ObjectMetadataEntity[] = [];
@ -68,12 +68,12 @@ export class WorkspaceSyncStorage {
    return this._relationMetadataDeleteCollection;
  }

-  addCreateObjectMetadata(object: ComputedPartialObjectMetadata) {
+  addCreateObjectMetadata(object: ComputedPartialWorkspaceEntity) {
    this._objectMetadataCreateCollection.push(object);
  }

  addUpdateObjectMetadata(
-    object: Partial<ComputedPartialObjectMetadata> & { id: string },
+    object: Partial<ComputedPartialWorkspaceEntity> & { id: string },
  ) {
    this._objectMetadataUpdateCollection.push(object);
  }
--- a/packages/twenty-server/src/engine/workspace-manager/workspace-sync-metadata/types/object-record.ts
+++ b/packages/twenty-server/src/engine/workspace-manager/workspace-sync-metadata/types/object-record.ts
@ -1,9 +1,19 @@
+import { ObjectLiteral } from 'typeorm';
+
 import { BaseWorkspaceEntity } from 'src/engine/twenty-orm/base.workspace-entity';

-export type ObjectRecord<T extends BaseWorkspaceEntity> = {
+export type ObjectRecord<T extends ObjectLiteral> = {
  [K in keyof T as T[K] extends BaseWorkspaceEntity
    ? `${Extract<K, string>}Id`
-    : K]: T[K] extends BaseWorkspaceEntity ? string : T[K];
+    : K]: T[K] extends BaseWorkspaceEntity
+    ? string
+    : T[K] extends BaseWorkspaceEntity[]
+      ? string[]
+      : T[K];
 } & {
-  [K in keyof T]: T[K] extends BaseWorkspaceEntity ? ObjectRecord<T[K]> : T[K];
+  [K in keyof T]: T[K] extends BaseWorkspaceEntity
+    ? ObjectRecord<T[K]>
+    : T[K] extends BaseWorkspaceEntity[]
+      ? ObjectRecord<T[K][number]>[]
+      : T[K];
 };
--- a/packages/twenty-server/src/engine/workspace-manager/workspace-sync-metadata/utils/compute-standard-object.util.ts
+++ b/packages/twenty-server/src/engine/workspace-manager/workspace-sync-metadata/utils/compute-standard-object.util.ts
@ -1,6 +1,6 @@
 import {
-  ComputedPartialObjectMetadata,
-  PartialObjectMetadata,
+  ComputedPartialWorkspaceEntity,
+  PartialWorkspaceEntity,
 } from 'src/engine/workspace-manager/workspace-sync-metadata/interfaces/partial-object-metadata.interface';
 import { ComputedPartialFieldMetadata } from 'src/engine/workspace-manager/workspace-sync-metadata/interfaces/partial-field-metadata.interface';

@ -12,12 +12,12 @@ import {
 } from 'src/engine/workspace-manager/workspace-sync-metadata/utils/create-deterministic-uuid.util';

 export const computeStandardObject = (
-  standardObjectMetadata: Omit<PartialObjectMetadata, 'standardId'> & {
+  standardObjectMetadata: Omit<PartialWorkspaceEntity, 'standardId'> & {
    standardId: string | null;
  },
  originalObjectMetadata: ObjectMetadataEntity,
  customObjectMetadataCollection: ObjectMetadataEntity[] = [],
-): ComputedPartialObjectMetadata => {
+): ComputedPartialWorkspaceEntity => {
  const fields: ComputedPartialFieldMetadata[] = [];

  for (const partialFieldMetadata of standardObjectMetadata.fields) {
--- a/packages/twenty-server/src/engine/workspace-manager/workspace-sync-metadata/utils/convert-class-to-object-metadata-name.util.ts
+++ b/packages/twenty-server/src/engine/workspace-manager/workspace-sync-metadata/utils/convert-class-to-object-metadata-name.util.ts
@ -1,7 +1,8 @@
 import { camelCase } from 'src/utils/camel-case';

+const classSuffix = 'WorkspaceEntity';
+
 export const convertClassNameToObjectMetadataName = (name: string): string => {
-  const classSuffix = 'ObjectMetadata';
  let objectName = camelCase(name);

  if (objectName.endsWith(classSuffix)) {