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

packages/twenty-server/src/database/typeorm-seeds/workspace/calendar-event-participants.ts

@@ -2,7 +2,7 @@ import { EntityManager } from 'typeorm';
 
 import { DEV_SEED_PERSON_IDS } from 'src/database/typeorm-seeds/workspace/people';
 import { DEV_SEED_WORKSPACE_MEMBER_IDS } from 'src/database/typeorm-seeds/workspace/workspace-members';
-import { CalendarEventParticipantResponseStatus } from 'src/modules/calendar/standard-objects/calendar-event-participant.object-metadata';
+import { CalendarEventParticipantResponseStatus } from 'src/modules/calendar/standard-objects/calendar-event-participant.workspace-entity';
 
 const tableName = 'calendarEventParticipant';
 

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: [

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 { ConnectedAccountWorkspaceEntity } from 'src/modules/connected-account/standard-objects/connected-account.workspace-entity';
-import { MessageChannelObjectMetadata } from 'src/modules/messaging/standard-objects/message-channel.object-metadata';
+import { MessageChannelWorkspaceEntity } from 'src/modules/messaging/standard-objects/message-channel.workspace-entity';
-import { CalendarChannelObjectMetadata } from 'src/modules/calendar/standard-objects/calendar-channel.object-metadata';
+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,
+      ConnectedAccountWorkspaceEntity,
-      MessageChannelObjectMetadata,
+      MessageChannelWorkspaceEntity,
-      CalendarChannelObjectMetadata,
+      CalendarChannelWorkspaceEntity,
     ]),
     HttpModule,
     UserWorkspaceModule,

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,
   ) {}
 

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;

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],
 })

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,

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 { TimelineCalendarEventVisibility } from 'src/engine/core-modules/calendar/dtos/timeline-calendar-event.dto';
-import {
-  TimelineCalendarEvent,
-  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 { InjectWorkspaceRepository } from 'src/engine/twenty-orm/decorators/inject-workspace-repository.decorator';
-import { ObjectRecord } from 'src/engine/workspace-manager/workspace-sync-metadata/types/object-record';
+import { WorkspaceRepository } from 'src/engine/twenty-orm/repository/workspace.repository';
-import { CalendarEventParticipantObjectMetadata } from 'src/modules/calendar/standard-objects/calendar-event-participant.object-metadata';
+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 =
+    const calendarEventIds = await this.calendarEventRepository.find({
-      this.workspaceDataSourceService.getSchemaName(workspaceId);
+      where: {
+        calendarEventParticipants: {
+          person: {
+            id: Any(personIds),
+          },
+        },
+      },
+      select: {
+        id: true,
+        startsAt: true,
+      },
+      skip: offset,
+      take: pageSize,
+      order: {
+        startsAt: 'DESC',
+      },
+    });
 
-    const calendarEvents: Omit<TimelineCalendarEvent, 'participants'>[] =
+    const ids = calendarEventIds.map(({ id }) => id);
-      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,
-      );
 
-    if (!calendarEvents) {
+    if (ids.length <= 0) {
       return {
         totalNumberOfCalendarEvents: 0,
         timelineCalendarEvents: [],
       };
     }
 
-    const calendarEventParticipants: TimelineCalendarEventParticipantWithPersonInformation[] =
+    // We've split the query into two parts, because we want to fetch all the participants without any filtering
-      await this.workspaceDataSourceService.executeRawQuery(
+    const [events, total] = await this.calendarEventRepository.findAndCount({
-        `SELECT
+      where: {
-            "calendarEventParticipant".*,
+        id: Any(ids),
-            "person"."nameFirstName" as "personFirstName",
+      },
-            "person"."nameLastName" as "personLastName",
+      relations: {
-            "person"."avatarUrl" as "personAvatarUrl",
+        calendarEventParticipants: {
-            "workspaceMember"."nameFirstName" as "workspaceMemberFirstName",
+          person: true,
-            "workspaceMember"."nameLastName" as "workspaceMemberLastName",
+          workspaceMember: true,
-            "workspaceMember"."avatarUrl" as "workspaceMemberAvatarUrl"
+        },
-        FROM
+        calendarChannelEventAssociations: {
-            ${dataSourceSchema}."calendarEventParticipant" "calendarEventParticipant"
+          calendarChannel: true,
-        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,
-      );
 
-    const formattedCalendarEventParticipants: TimelineCalendarEventParticipant[] =
+    // Keep events in the same order as they ids were returned
-      calendarEventParticipants.map((participant) => {
+    const orderedEvents = events.sort(
-        const firstName =
+      (a, b) => ids.indexOf(a.id) - ids.indexOf(b.id),
-          participant.personFirstName ||
+    );
-          participant.workspaceMemberFirstName ||
-          '';
 
-        const lastName =
+    const timelineCalendarEvents = orderedEvents.map((event) => {
-          participant.personLastName ||
+      const participants = event.calendarEventParticipants.map(
-          participant.workspaceMemberLastName ||
+        (participant) => ({
-          '';
+          calendarEventId: event.id,
-
+          personId: participant.person?.id,
-        const displayName =
+          workspaceMemberId: participant.workspaceMember?.id,
-          firstName || participant.displayName || participant.handle;
+          firstName:
-
+            participant.person?.name.firstName ||
-        const avatarUrl =
+            participant.workspaceMember?.name.firstName ||
-          participant.personAvatarUrl ||
+            '',
-          participant.workspaceMemberAvatarUrl ||
+          lastName:
-          '';
+            participant.person?.name.lastName ||
-
+            participant.workspaceMember?.name.lastName ||
-        return {
+            '',
-          calendarEventId: participant.calendarEventId,
+          displayName:
-          personId: participant.personId,
+            participant.person?.name.firstName ||
-          workspaceMemberId: participant.workspaceMemberId,
+            participant.person?.name.lastName ||
-          firstName,
+            participant.workspaceMember?.name.firstName ||
-          lastName,
+            participant.workspaceMember?.name.lastName ||
-          displayName,
+            '',
-          avatarUrl,
+          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 visibility = event.calendarChannelEventAssociations.some(
-    const timelineCalendarEvents = calendarEvents.map((event) => {
+        (association) => association.calendarChannel.visibility === 'METADATA',
-      const participants = calendarEventParticipantsByEventId[event.id] || [];
+      )
+        ? 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 =
+    const personIds = await this.personRepository.find({
-      this.workspaceDataSourceService.getSchemaName(workspaceId);
+      where: {
+        company: {
+          id: companyId,
+        },
+      },
+      select: {
+        id: true,
+      },
+    });
 
-    const personIds = await this.workspaceDataSourceService.executeRawQuery(
+    if (personIds.length <= 0) {
-      `
-        SELECT 
-            p."id"
-        FROM
-            ${dataSourceSchema}."person" p
-        WHERE
-            p."companyId" = $1
-        `,
-      [companyId],
-      workspaceId,
-    );
-
-    if (!personIds) {
       return {
         totalNumberOfCalendarEvents: 0,
         timelineCalendarEvents: [],
       };
     }
 
-    const formattedPersonIds = personIds.map(
+    const formattedPersonIds = personIds.map(({ id }) => id);
-      (personId: { id: string }) => personId.id,
-    );
 
     const messageThreads = await this.getCalendarEventsFromPersonIds(
-      workspaceMemberId,
-      workspaceId,
       formattedPersonIds,
       page,
       pageSize,

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,

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 = {

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 = {

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;
 

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:

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,
+  AuditLogWorkspaceEntity: AuditLogRepository,
-  BlocklistObjectMetadata: BlocklistRepository,
+  BlocklistWorkspaceEntity: BlocklistRepository,
-  CalendarChannelEventAssociationObjectMetadata:
+  CalendarChannelEventAssociationWorkspaceEntity:
     CalendarChannelEventAssociationRepository,
-  CalendarChannelObjectMetadata: CalendarChannelRepository,
+  CalendarChannelWorkspaceEntity: CalendarChannelRepository,
-  CalendarEventParticipantObjectMetadata: CalendarEventParticipantRepository,
+  CalendarEventParticipantWorkspaceEntity: CalendarEventParticipantRepository,
-  CalendarEventObjectMetadata: CalendarEventRepository,
+  CalendarEventWorkspaceEntity: CalendarEventRepository,
-  CompanyObjectMetadata: CompanyRepository,
+  CompanyWorkspaceEntity: CompanyRepository,
-  ConnectedAccountObjectMetadata: ConnectedAccountRepository,
+  ConnectedAccountWorkspaceEntity: ConnectedAccountRepository,
-  MessageChannelMessageAssociationObjectMetadata:
+  MessageChannelMessageAssociationWorkspaceEntity:
     MessageChannelMessageAssociationRepository,
-  MessageChannelObjectMetadata: MessageChannelRepository,
+  MessageChannelWorkspaceEntity: MessageChannelRepository,
-  MessageObjectMetadata: MessageRepository,
+  MessageWorkspaceEntity: MessageRepository,
-  MessageParticipantObjectMetadata: MessageParticipantRepository,
+  MessageParticipantWorkspaceEntity: MessageParticipantRepository,
-  MessageThreadObjectMetadata: MessageThreadRepository,
+  MessageThreadWorkspaceEntity: MessageThreadRepository,
-  PersonObjectMetadata: PersonRepository,
+  PersonWorkspaceEntity: PersonRepository,
-  TimelineActivityObjectMetadata: TimelineActivityRepository,
+  TimelineActivityWorkspaceEntity: TimelineActivityRepository,
-  WorkspaceMemberObjectMetadata: WorkspaceMemberRepository,
+  WorkspaceMemberWorkspaceEntity: WorkspaceMemberRepository,
-  AttachmentObjectMetadata: AttachmentRepository,
+  AttachmentWorkspaceEntity: AttachmentRepository,
-  CommentObjectMetadata: CommentRepository,
+  CommentWorkspaceEntity: CommentRepository,
 };

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 { ActivityTargetWorkspaceEntity } from 'src/modules/activity/standard-objects/activity-target.workspace-entity';
-import { FavoriteObjectMetadata } from 'src/modules/favorite/standard-objects/favorite.object-metadata';
+import { FavoriteWorkspaceEntity } from 'src/modules/favorite/standard-objects/favorite.workspace-entity';
-import { AttachmentObjectMetadata } from 'src/modules/attachment/standard-objects/attachment.object-metadata';
+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[];
 }

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,

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);
 

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,

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,
     );
 

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 = {

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(
+    if (!isPlainObject(data)) {
-      this.target as any,
+      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 (!compositePropertyArgs && !relationMetadataArgs) {
-        if (typeof value === 'object') {
+        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]) {

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,
+    );
+  }
 }

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'),
+  ];
+};

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<

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(

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);
 

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 =

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
+export interface MappedWorkspaceEntity
-  extends Omit<PartialObjectMetadata, 'fields'> {
+  extends Omit<PartialWorkspaceEntity, 'fields'> {
   fields: MappedFieldMetadata;
 }
 

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<
+export type ComputedPartialWorkspaceEntity = Omit<
-  PartialObjectMetadata,
+  PartialWorkspaceEntity,
   'standardId' | 'fields'
 > & {
   standardId: string | null;

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 { ActivityTargetWorkspaceEntity } from 'src/modules/activity/standard-objects/activity-target.workspace-entity';
-import { ActivityObjectMetadata } from 'src/modules/activity/standard-objects/activity.object-metadata';
+import { ActivityWorkspaceEntity } from 'src/modules/activity/standard-objects/activity.workspace-entity';
-import { ApiKeyObjectMetadata } from 'src/modules/api-key/standard-objects/api-key.object-metadata';
+import { ApiKeyWorkspaceEntity } from 'src/modules/api-key/standard-objects/api-key.workspace-entity';
-import { AttachmentObjectMetadata } from 'src/modules/attachment/standard-objects/attachment.object-metadata';
+import { AttachmentWorkspaceEntity } from 'src/modules/attachment/standard-objects/attachment.workspace-entity';
-import { BlocklistObjectMetadata } from 'src/modules/connected-account/standard-objects/blocklist.object-metadata';
+import { BlocklistWorkspaceEntity } from 'src/modules/connected-account/standard-objects/blocklist.workspace-entity';
-import { CalendarEventObjectMetadata } from 'src/modules/calendar/standard-objects/calendar-event.object-metadata';
+import { CalendarEventWorkspaceEntity } from 'src/modules/calendar/standard-objects/calendar-event.workspace-entity';
-import { CalendarChannelObjectMetadata } from 'src/modules/calendar/standard-objects/calendar-channel.object-metadata';
+import { CalendarChannelWorkspaceEntity } from 'src/modules/calendar/standard-objects/calendar-channel.workspace-entity';
-import { CalendarEventParticipantObjectMetadata } from 'src/modules/calendar/standard-objects/calendar-event-participant.object-metadata';
+import { CalendarEventParticipantWorkspaceEntity } from 'src/modules/calendar/standard-objects/calendar-event-participant.workspace-entity';
-import { CommentObjectMetadata } from 'src/modules/activity/standard-objects/comment.object-metadata';
+import { CommentWorkspaceEntity } from 'src/modules/activity/standard-objects/comment.workspace-entity';
-import { CompanyObjectMetadata } from 'src/modules/company/standard-objects/company.object-metadata';
+import { CompanyWorkspaceEntity } from 'src/modules/company/standard-objects/company.workspace-entity';
-import { ConnectedAccountObjectMetadata } from 'src/modules/connected-account/standard-objects/connected-account.object-metadata';
+import { ConnectedAccountWorkspaceEntity } from 'src/modules/connected-account/standard-objects/connected-account.workspace-entity';
-import { FavoriteObjectMetadata } from 'src/modules/favorite/standard-objects/favorite.object-metadata';
+import { FavoriteWorkspaceEntity } from 'src/modules/favorite/standard-objects/favorite.workspace-entity';
-import { MessageChannelMessageAssociationObjectMetadata } from 'src/modules/messaging/standard-objects/message-channel-message-association.object-metadata';
+import { MessageChannelMessageAssociationWorkspaceEntity } from 'src/modules/messaging/standard-objects/message-channel-message-association.workspace-entity';
-import { MessageChannelObjectMetadata } from 'src/modules/messaging/standard-objects/message-channel.object-metadata';
+import { MessageChannelWorkspaceEntity } from 'src/modules/messaging/standard-objects/message-channel.workspace-entity';
-import { MessageParticipantObjectMetadata } from 'src/modules/messaging/standard-objects/message-participant.object-metadata';
+import { MessageParticipantWorkspaceEntity } from 'src/modules/messaging/standard-objects/message-participant.workspace-entity';
-import { MessageThreadObjectMetadata } from 'src/modules/messaging/standard-objects/message-thread.object-metadata';
+import { MessageThreadWorkspaceEntity } from 'src/modules/messaging/standard-objects/message-thread.workspace-entity';
-import { MessageObjectMetadata } from 'src/modules/messaging/standard-objects/message.object-metadata';
+import { MessageWorkspaceEntity } from 'src/modules/messaging/standard-objects/message.workspace-entity';
-import { OpportunityObjectMetadata } from 'src/modules/opportunity/standard-objects/opportunity.object-metadata';
+import { OpportunityWorkspaceEntity } from 'src/modules/opportunity/standard-objects/opportunity.workspace-entity';
-import { PersonObjectMetadata } from 'src/modules/person/standard-objects/person.object-metadata';
+import { PersonWorkspaceEntity } from 'src/modules/person/standard-objects/person.workspace-entity';
-import { ViewFieldObjectMetadata } from 'src/modules/view/standard-objects/view-field.object-metadata';
+import { ViewFieldWorkspaceEntity } from 'src/modules/view/standard-objects/view-field.workspace-entity';
-import { ViewFilterObjectMetadata } from 'src/modules/view/standard-objects/view-filter.object-metadata';
+import { ViewFilterWorkspaceEntity } from 'src/modules/view/standard-objects/view-filter.workspace-entity';
-import { ViewSortObjectMetadata } from 'src/modules/view/standard-objects/view-sort.object-metadata';
+import { ViewSortWorkspaceEntity } from 'src/modules/view/standard-objects/view-sort.workspace-entity';
-import { ViewObjectMetadata } from 'src/modules/view/standard-objects/view.object-metadata';
+import { ViewWorkspaceEntity } from 'src/modules/view/standard-objects/view.workspace-entity';
-import { WebhookObjectMetadata } from 'src/modules/webhook/standard-objects/webhook.object-metadata';
+import { WebhookWorkspaceEntity } from 'src/modules/webhook/standard-objects/webhook.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 { CalendarChannelEventAssociationObjectMetadata } from 'src/modules/calendar/standard-objects/calendar-channel-event-association.object-metadata';
+import { CalendarChannelEventAssociationWorkspaceEntity } from 'src/modules/calendar/standard-objects/calendar-channel-event-association.workspace-entity';
-import { AuditLogObjectMetadata } from 'src/modules/timeline/standard-objects/audit-log.object-metadata';
+import { AuditLogWorkspaceEntity } from 'src/modules/timeline/standard-objects/audit-log.workspace-entity';
-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 { BehavioralEventObjectMetadata } from 'src/modules/timeline/standard-objects/behavioral-event.object-metadata';
+import { BehavioralEventWorkspaceEntity } from 'src/modules/timeline/standard-objects/behavioral-event.workspace-entity';
 
 export const standardObjectMetadataDefinitions = [
-  ActivityTargetObjectMetadata,
+  ActivityTargetWorkspaceEntity,
-  ActivityObjectMetadata,
+  ActivityWorkspaceEntity,
-  ApiKeyObjectMetadata,
+  ApiKeyWorkspaceEntity,
-  AuditLogObjectMetadata,
+  AuditLogWorkspaceEntity,
-  AttachmentObjectMetadata,
+  AttachmentWorkspaceEntity,
-  BehavioralEventObjectMetadata,
+  BehavioralEventWorkspaceEntity,
-  BlocklistObjectMetadata,
+  BlocklistWorkspaceEntity,
-  CalendarEventObjectMetadata,
+  CalendarEventWorkspaceEntity,
-  CalendarChannelObjectMetadata,
+  CalendarChannelWorkspaceEntity,
-  CalendarChannelEventAssociationObjectMetadata,
+  CalendarChannelEventAssociationWorkspaceEntity,
-  CalendarEventParticipantObjectMetadata,
+  CalendarEventParticipantWorkspaceEntity,
-  CommentObjectMetadata,
+  CommentWorkspaceEntity,
-  CompanyObjectMetadata,
+  CompanyWorkspaceEntity,
-  ConnectedAccountObjectMetadata,
+  ConnectedAccountWorkspaceEntity,
-  FavoriteObjectMetadata,
+  FavoriteWorkspaceEntity,
-  OpportunityObjectMetadata,
+  OpportunityWorkspaceEntity,
-  PersonObjectMetadata,
+  PersonWorkspaceEntity,
-  TimelineActivityObjectMetadata,
+  TimelineActivityWorkspaceEntity,
-  ViewFieldObjectMetadata,
+  ViewFieldWorkspaceEntity,
-  ViewFilterObjectMetadata,
+  ViewFilterWorkspaceEntity,
-  ViewSortObjectMetadata,
+  ViewSortWorkspaceEntity,
-  ViewObjectMetadata,
+  ViewWorkspaceEntity,
-  WebhookObjectMetadata,
+  WebhookWorkspaceEntity,
-  WorkspaceMemberObjectMetadata,
+  WorkspaceMemberWorkspaceEntity,
-  MessageThreadObjectMetadata,
+  MessageThreadWorkspaceEntity,
-  MessageObjectMetadata,
+  MessageWorkspaceEntity,
-  MessageChannelObjectMetadata,
+  MessageChannelWorkspaceEntity,
-  MessageParticipantObjectMetadata,
+  MessageParticipantWorkspaceEntity,
-  MessageChannelMessageAssociationObjectMetadata,
+  MessageChannelMessageAssociationWorkspaceEntity,
 ];

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);
   }

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];
 };

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

@@ -1,6 +1,6 @@
 import {
-  ComputedPartialObjectMetadata,
+  ComputedPartialWorkspaceEntity,
-  PartialObjectMetadata,
+  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) {

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)) {

packages/twenty-server/src/modules/activity/standard-objects/activity-target.workspace-entity.ts

@@ -3,11 +3,11 @@ import { Relation } from 'src/engine/workspace-manager/workspace-sync-metadata/i
 import { ACTIVITY_TARGET_STANDARD_FIELD_IDS } from 'src/engine/workspace-manager/workspace-sync-metadata/constants/standard-field-ids';
 import { STANDARD_OBJECT_IDS } from 'src/engine/workspace-manager/workspace-sync-metadata/constants/standard-object-ids';
 import { CustomWorkspaceEntity } from 'src/engine/twenty-orm/custom.workspace-entity';
-import { ActivityObjectMetadata } from 'src/modules/activity/standard-objects/activity.object-metadata';
+import { ActivityWorkspaceEntity } from 'src/modules/activity/standard-objects/activity.workspace-entity';
-import { CompanyObjectMetadata } from 'src/modules/company/standard-objects/company.object-metadata';
+import { CompanyWorkspaceEntity } from 'src/modules/company/standard-objects/company.workspace-entity';
-import { OpportunityObjectMetadata } from 'src/modules/opportunity/standard-objects/opportunity.object-metadata';
+import { OpportunityWorkspaceEntity } from 'src/modules/opportunity/standard-objects/opportunity.workspace-entity';
-import { PersonObjectMetadata } from 'src/modules/person/standard-objects/person.object-metadata';
+import { PersonWorkspaceEntity } from 'src/modules/person/standard-objects/person.workspace-entity';
-import { WorkspaceEntity } from 'src/engine/twenty-orm/decorators/workspace-object.decorator';
+import { WorkspaceEntity } from 'src/engine/twenty-orm/decorators/workspace-entity.decorator';
 import { WorkspaceIsSystem } from 'src/engine/twenty-orm/decorators/workspace-is-system.decorator';
 import { WorkspaceIsNotAuditLogged } from 'src/engine/twenty-orm/decorators/workspace-is-not-audit-logged.decorator';
 import { WorkspaceIsNullable } from 'src/engine/twenty-orm/decorators/workspace-is-nullable.decorator';
@@ -26,7 +26,7 @@ import { BaseWorkspaceEntity } from 'src/engine/twenty-orm/base.workspace-entity
 })
 @WorkspaceIsSystem()
 @WorkspaceIsNotAuditLogged()
-export class ActivityTargetObjectMetadata extends BaseWorkspaceEntity {
+export class ActivityTargetWorkspaceEntity extends BaseWorkspaceEntity {
   @WorkspaceRelation({
     standardId: ACTIVITY_TARGET_STANDARD_FIELD_IDS.activity,
     type: RelationMetadataType.MANY_TO_ONE,
@@ -34,11 +34,11 @@ export class ActivityTargetObjectMetadata extends BaseWorkspaceEntity {
     description: 'ActivityTarget activity',
     icon: 'IconNotes',
     joinColumn: 'activityId',
-    inverseSideTarget: () => ActivityObjectMetadata,
+    inverseSideTarget: () => ActivityWorkspaceEntity,
     inverseSideFieldKey: 'activityTargets',
   })
   @WorkspaceIsNullable()
-  activity: Relation<ActivityObjectMetadata>;
+  activity: Relation<ActivityWorkspaceEntity>;
 
   @WorkspaceRelation({
     standardId: ACTIVITY_TARGET_STANDARD_FIELD_IDS.person,
@@ -47,11 +47,11 @@ export class ActivityTargetObjectMetadata extends BaseWorkspaceEntity {
     description: 'ActivityTarget person',
     icon: 'IconUser',
     joinColumn: 'personId',
-    inverseSideTarget: () => PersonObjectMetadata,
+    inverseSideTarget: () => PersonWorkspaceEntity,
     inverseSideFieldKey: 'activityTargets',
   })
   @WorkspaceIsNullable()
-  person: Relation<PersonObjectMetadata>;
+  person: Relation<PersonWorkspaceEntity>;
 
   @WorkspaceRelation({
     standardId: ACTIVITY_TARGET_STANDARD_FIELD_IDS.company,
@@ -60,11 +60,11 @@ export class ActivityTargetObjectMetadata extends BaseWorkspaceEntity {
     description: 'ActivityTarget company',
     icon: 'IconBuildingSkyscraper',
     joinColumn: 'companyId',
-    inverseSideTarget: () => CompanyObjectMetadata,
+    inverseSideTarget: () => CompanyWorkspaceEntity,
     inverseSideFieldKey: 'activityTargets',
   })
   @WorkspaceIsNullable()
-  company: Relation<CompanyObjectMetadata>;
+  company: Relation<CompanyWorkspaceEntity>;
 
   @WorkspaceRelation({
     standardId: ACTIVITY_TARGET_STANDARD_FIELD_IDS.opportunity,
@@ -73,11 +73,11 @@ export class ActivityTargetObjectMetadata extends BaseWorkspaceEntity {
     description: 'ActivityTarget opportunity',
     icon: 'IconTargetArrow',
     joinColumn: 'opportunityId',
-    inverseSideTarget: () => OpportunityObjectMetadata,
+    inverseSideTarget: () => OpportunityWorkspaceEntity,
     inverseSideFieldKey: 'activityTargets',
   })
   @WorkspaceIsNullable()
-  opportunity: Relation<OpportunityObjectMetadata>;
+  opportunity: Relation<OpportunityWorkspaceEntity>;
 
   @WorkspaceDynamicRelation({
     type: RelationMetadataType.MANY_TO_ONE,

packages/twenty-server/src/modules/activity/standard-objects/activity.workspace-entity.ts

@@ -7,11 +7,11 @@ import {
 } from 'src/engine/metadata-modules/relation-metadata/relation-metadata.entity';
 import { ACTIVITY_STANDARD_FIELD_IDS } from 'src/engine/workspace-manager/workspace-sync-metadata/constants/standard-field-ids';
 import { STANDARD_OBJECT_IDS } from 'src/engine/workspace-manager/workspace-sync-metadata/constants/standard-object-ids';
-import { ActivityTargetObjectMetadata } from 'src/modules/activity/standard-objects/activity-target.object-metadata';
+import { ActivityTargetWorkspaceEntity } from 'src/modules/activity/standard-objects/activity-target.workspace-entity';
-import { AttachmentObjectMetadata } from 'src/modules/attachment/standard-objects/attachment.object-metadata';
+import { AttachmentWorkspaceEntity } from 'src/modules/attachment/standard-objects/attachment.workspace-entity';
-import { CommentObjectMetadata } from 'src/modules/activity/standard-objects/comment.object-metadata';
+import { CommentWorkspaceEntity } from 'src/modules/activity/standard-objects/comment.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 { WorkspaceEntity } from 'src/engine/twenty-orm/decorators/workspace-object.decorator';
+import { WorkspaceEntity } from 'src/engine/twenty-orm/decorators/workspace-entity.decorator';
 import { WorkspaceIsNotAuditLogged } from 'src/engine/twenty-orm/decorators/workspace-is-not-audit-logged.decorator';
 import { WorkspaceIsSystem } from 'src/engine/twenty-orm/decorators/workspace-is-system.decorator';
 import { WorkspaceField } from 'src/engine/twenty-orm/decorators/workspace-field.decorator';
@@ -29,7 +29,7 @@ import { BaseWorkspaceEntity } from 'src/engine/twenty-orm/base.workspace-entity
 })
 @WorkspaceIsNotAuditLogged()
 @WorkspaceIsSystem()
-export class ActivityObjectMetadata extends BaseWorkspaceEntity {
+export class ActivityWorkspaceEntity extends BaseWorkspaceEntity {
   @WorkspaceField({
     standardId: ACTIVITY_STANDARD_FIELD_IDS.title,
     type: FieldMetadataType.TEXT,
@@ -94,11 +94,11 @@ export class ActivityObjectMetadata extends BaseWorkspaceEntity {
     description: 'Activity targets',
     icon: 'IconCheckbox',
     type: RelationMetadataType.ONE_TO_MANY,
-    inverseSideTarget: () => ActivityTargetObjectMetadata,
+    inverseSideTarget: () => ActivityTargetWorkspaceEntity,
     onDelete: RelationOnDeleteAction.SET_NULL,
   })
   @WorkspaceIsNullable()
-  activityTargets: Relation<ActivityTargetObjectMetadata[]>;
+  activityTargets: Relation<ActivityTargetWorkspaceEntity[]>;
 
   @WorkspaceRelation({
     standardId: ACTIVITY_STANDARD_FIELD_IDS.attachments,
@@ -106,11 +106,11 @@ export class ActivityObjectMetadata extends BaseWorkspaceEntity {
     description: 'Activity attachments',
     icon: 'IconFileImport',
     type: RelationMetadataType.ONE_TO_MANY,
-    inverseSideTarget: () => AttachmentObjectMetadata,
+    inverseSideTarget: () => AttachmentWorkspaceEntity,
     onDelete: RelationOnDeleteAction.SET_NULL,
   })
   @WorkspaceIsNullable()
-  attachments: Relation<AttachmentObjectMetadata[]>;
+  attachments: Relation<AttachmentWorkspaceEntity[]>;
 
   @WorkspaceRelation({
     standardId: ACTIVITY_STANDARD_FIELD_IDS.comments,
@@ -118,11 +118,11 @@ export class ActivityObjectMetadata extends BaseWorkspaceEntity {
     description: 'Activity comments',
     icon: 'IconComment',
     type: RelationMetadataType.ONE_TO_MANY,
-    inverseSideTarget: () => CommentObjectMetadata,
+    inverseSideTarget: () => CommentWorkspaceEntity,
     onDelete: RelationOnDeleteAction.CASCADE,
   })
   @WorkspaceIsNullable()
-  comments: Relation<CommentObjectMetadata[]>;
+  comments: Relation<CommentWorkspaceEntity[]>;
 
   @WorkspaceRelation({
     standardId: ACTIVITY_STANDARD_FIELD_IDS.author,
@@ -130,13 +130,13 @@ export class ActivityObjectMetadata extends BaseWorkspaceEntity {
     description: 'Activity author',
     icon: 'IconUserCircle',
     type: RelationMetadataType.MANY_TO_ONE,
-    inverseSideTarget: () => WorkspaceMemberObjectMetadata,
+    inverseSideTarget: () => WorkspaceMemberWorkspaceEntity,
     inverseSideFieldKey: 'authoredActivities',
     onDelete: RelationOnDeleteAction.SET_NULL,
     joinColumn: 'authorId',
   })
   @WorkspaceIsNullable()
-  author: Relation<WorkspaceMemberObjectMetadata>;
+  author: Relation<WorkspaceMemberWorkspaceEntity>;
 
   @WorkspaceRelation({
     standardId: ACTIVITY_STANDARD_FIELD_IDS.assignee,
@@ -144,11 +144,11 @@ export class ActivityObjectMetadata extends BaseWorkspaceEntity {
     description: 'Activity assignee',
     icon: 'IconUserCircle',
     type: RelationMetadataType.MANY_TO_ONE,
-    inverseSideTarget: () => WorkspaceMemberObjectMetadata,
+    inverseSideTarget: () => WorkspaceMemberWorkspaceEntity,
     inverseSideFieldKey: 'assignedActivities',
     onDelete: RelationOnDeleteAction.SET_NULL,
     joinColumn: 'assigneeId',
   })
   @WorkspaceIsNullable()
-  assignee: Relation<WorkspaceMemberObjectMetadata>;
+  assignee: Relation<WorkspaceMemberWorkspaceEntity>;
 }

packages/twenty-server/src/modules/activity/standard-objects/comment.workspace-entity.ts

@@ -3,9 +3,9 @@ import { Relation } from 'src/engine/workspace-manager/workspace-sync-metadata/i
 import { FieldMetadataType } from 'src/engine/metadata-modules/field-metadata/field-metadata.entity';
 import { COMMENT_STANDARD_FIELD_IDS } from 'src/engine/workspace-manager/workspace-sync-metadata/constants/standard-field-ids';
 import { STANDARD_OBJECT_IDS } from 'src/engine/workspace-manager/workspace-sync-metadata/constants/standard-object-ids';
-import { ActivityObjectMetadata } from 'src/modules/activity/standard-objects/activity.object-metadata';
+import { ActivityWorkspaceEntity } from 'src/modules/activity/standard-objects/activity.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 { WorkspaceEntity } from 'src/engine/twenty-orm/decorators/workspace-object.decorator';
+import { WorkspaceEntity } from 'src/engine/twenty-orm/decorators/workspace-entity.decorator';
 import { WorkspaceIsSystem } from 'src/engine/twenty-orm/decorators/workspace-is-system.decorator';
 import { WorkspaceIsNotAuditLogged } from 'src/engine/twenty-orm/decorators/workspace-is-not-audit-logged.decorator';
 import { WorkspaceField } from 'src/engine/twenty-orm/decorators/workspace-field.decorator';
@@ -23,7 +23,7 @@ import { BaseWorkspaceEntity } from 'src/engine/twenty-orm/base.workspace-entity
 })
 @WorkspaceIsSystem()
 @WorkspaceIsNotAuditLogged()
-export class CommentObjectMetadata extends BaseWorkspaceEntity {
+export class CommentWorkspaceEntity extends BaseWorkspaceEntity {
   @WorkspaceField({
     standardId: COMMENT_STANDARD_FIELD_IDS.body,
     type: FieldMetadataType.TEXT,
@@ -40,10 +40,10 @@ export class CommentObjectMetadata extends BaseWorkspaceEntity {
     description: 'Comment author',
     icon: 'IconCircleUser',
     joinColumn: 'authorId',
-    inverseSideTarget: () => WorkspaceMemberObjectMetadata,
+    inverseSideTarget: () => WorkspaceMemberWorkspaceEntity,
     inverseSideFieldKey: 'authoredComments',
   })
-  author: Relation<WorkspaceMemberObjectMetadata>;
+  author: Relation<WorkspaceMemberWorkspaceEntity>;
 
   @WorkspaceRelation({
     standardId: COMMENT_STANDARD_FIELD_IDS.activity,
@@ -52,8 +52,8 @@ export class CommentObjectMetadata extends BaseWorkspaceEntity {
     description: 'Comment activity',
     icon: 'IconNotes',
     joinColumn: 'activityId',
-    inverseSideTarget: () => ActivityObjectMetadata,
+    inverseSideTarget: () => ActivityWorkspaceEntity,
     inverseSideFieldKey: 'comments',
   })
-  activity: Relation<ActivityObjectMetadata>;
+  activity: Relation<ActivityWorkspaceEntity>;
 }

packages/twenty-server/src/modules/api-key/standard-objects/api-key.workspace-entity.ts

@@ -4,7 +4,7 @@ import { WorkspaceField } from 'src/engine/twenty-orm/decorators/workspace-field
 import { WorkspaceIsNotAuditLogged } from 'src/engine/twenty-orm/decorators/workspace-is-not-audit-logged.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';
-import { WorkspaceEntity } from 'src/engine/twenty-orm/decorators/workspace-object.decorator';
+import { WorkspaceEntity } from 'src/engine/twenty-orm/decorators/workspace-entity.decorator';
 import { API_KEY_STANDARD_FIELD_IDS } from 'src/engine/workspace-manager/workspace-sync-metadata/constants/standard-field-ids';
 import { STANDARD_OBJECT_IDS } from 'src/engine/workspace-manager/workspace-sync-metadata/constants/standard-object-ids';
 
@@ -18,7 +18,7 @@ import { STANDARD_OBJECT_IDS } from 'src/engine/workspace-manager/workspace-sync
 })
 @WorkspaceIsSystem()
 @WorkspaceIsNotAuditLogged()
-export class ApiKeyObjectMetadata extends BaseWorkspaceEntity {
+export class ApiKeyWorkspaceEntity extends BaseWorkspaceEntity {
   @WorkspaceField({
     standardId: API_KEY_STANDARD_FIELD_IDS.name,
     type: FieldMetadataType.TEXT,

packages/twenty-server/src/modules/attachment/standard-objects/attachment.workspace-entity.ts

@@ -4,12 +4,12 @@ import { FieldMetadataType } from 'src/engine/metadata-modules/field-metadata/fi
 import { ATTACHMENT_STANDARD_FIELD_IDS } from 'src/engine/workspace-manager/workspace-sync-metadata/constants/standard-field-ids';
 import { STANDARD_OBJECT_IDS } from 'src/engine/workspace-manager/workspace-sync-metadata/constants/standard-object-ids';
 import { CustomWorkspaceEntity } from 'src/engine/twenty-orm/custom.workspace-entity';
-import { ActivityObjectMetadata } from 'src/modules/activity/standard-objects/activity.object-metadata';
+import { ActivityWorkspaceEntity } from 'src/modules/activity/standard-objects/activity.workspace-entity';
-import { CompanyObjectMetadata } from 'src/modules/company/standard-objects/company.object-metadata';
+import { CompanyWorkspaceEntity } from 'src/modules/company/standard-objects/company.workspace-entity';
-import { OpportunityObjectMetadata } from 'src/modules/opportunity/standard-objects/opportunity.object-metadata';
+import { OpportunityWorkspaceEntity } from 'src/modules/opportunity/standard-objects/opportunity.workspace-entity';
-import { PersonObjectMetadata } from 'src/modules/person/standard-objects/person.object-metadata';
+import { PersonWorkspaceEntity } from 'src/modules/person/standard-objects/person.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 { WorkspaceEntity } from 'src/engine/twenty-orm/decorators/workspace-object.decorator';
+import { WorkspaceEntity } from 'src/engine/twenty-orm/decorators/workspace-entity.decorator';
 import { WorkspaceIsSystem } from 'src/engine/twenty-orm/decorators/workspace-is-system.decorator';
 import { WorkspaceIsNotAuditLogged } from 'src/engine/twenty-orm/decorators/workspace-is-not-audit-logged.decorator';
 import { WorkspaceField } from 'src/engine/twenty-orm/decorators/workspace-field.decorator';
@@ -29,7 +29,7 @@ import { BaseWorkspaceEntity } from 'src/engine/twenty-orm/base.workspace-entity
 })
 @WorkspaceIsSystem()
 @WorkspaceIsNotAuditLogged()
-export class AttachmentObjectMetadata extends BaseWorkspaceEntity {
+export class AttachmentWorkspaceEntity extends BaseWorkspaceEntity {
   @WorkspaceField({
     standardId: ATTACHMENT_STANDARD_FIELD_IDS.name,
     type: FieldMetadataType.TEXT,
@@ -64,10 +64,10 @@ export class AttachmentObjectMetadata extends BaseWorkspaceEntity {
     description: 'Attachment author',
     icon: 'IconCircleUser',
     joinColumn: 'authorId',
-    inverseSideTarget: () => WorkspaceMemberObjectMetadata,
+    inverseSideTarget: () => WorkspaceMemberWorkspaceEntity,
     inverseSideFieldKey: 'authoredAttachments',
   })
-  author: Relation<WorkspaceMemberObjectMetadata>;
+  author: Relation<WorkspaceMemberWorkspaceEntity>;
 
   @WorkspaceRelation({
     standardId: ATTACHMENT_STANDARD_FIELD_IDS.activity,
@@ -76,11 +76,11 @@ export class AttachmentObjectMetadata extends BaseWorkspaceEntity {
     description: 'Attachment activity',
     icon: 'IconNotes',
     joinColumn: 'activityId',
-    inverseSideTarget: () => ActivityObjectMetadata,
+    inverseSideTarget: () => ActivityWorkspaceEntity,
     inverseSideFieldKey: 'attachments',
   })
   @WorkspaceIsNullable()
-  activity: Relation<ActivityObjectMetadata>;
+  activity: Relation<ActivityWorkspaceEntity>;
 
   @WorkspaceRelation({
     standardId: ATTACHMENT_STANDARD_FIELD_IDS.person,
@@ -89,11 +89,11 @@ export class AttachmentObjectMetadata extends BaseWorkspaceEntity {
     description: 'Attachment person',
     icon: 'IconUser',
     joinColumn: 'personId',
-    inverseSideTarget: () => PersonObjectMetadata,
+    inverseSideTarget: () => PersonWorkspaceEntity,
     inverseSideFieldKey: 'attachments',
   })
   @WorkspaceIsNullable()
-  person: Relation<PersonObjectMetadata>;
+  person: Relation<PersonWorkspaceEntity>;
 
   @WorkspaceRelation({
     standardId: ATTACHMENT_STANDARD_FIELD_IDS.company,
@@ -102,11 +102,11 @@ export class AttachmentObjectMetadata extends BaseWorkspaceEntity {
     description: 'Attachment company',
     icon: 'IconBuildingSkyscraper',
     joinColumn: 'companyId',
-    inverseSideTarget: () => CompanyObjectMetadata,
+    inverseSideTarget: () => CompanyWorkspaceEntity,
     inverseSideFieldKey: 'attachments',
   })
   @WorkspaceIsNullable()
-  company: Relation<CompanyObjectMetadata>;
+  company: Relation<CompanyWorkspaceEntity>;
 
   @WorkspaceRelation({
     standardId: ATTACHMENT_STANDARD_FIELD_IDS.opportunity,
@@ -115,11 +115,11 @@ export class AttachmentObjectMetadata extends BaseWorkspaceEntity {
     description: 'Attachment opportunity',
     icon: 'IconBuildingSkyscraper',
     joinColumn: 'opportunityId',
-    inverseSideTarget: () => OpportunityObjectMetadata,
+    inverseSideTarget: () => OpportunityWorkspaceEntity,
     inverseSideFieldKey: 'attachments',
   })
   @WorkspaceIsNullable()
-  opportunity: Relation<OpportunityObjectMetadata>;
+  opportunity: Relation<OpportunityWorkspaceEntity>;
 
   @WorkspaceDynamicRelation({
     type: RelationMetadataType.MANY_TO_ONE,

packages/twenty-server/src/modules/calendar-messaging-participant/listeners/participant-person.listener.ts

@@ -14,7 +14,7 @@ import {
   UnmatchParticipantJobData,
   UnmatchParticipantJob,
 } from 'src/modules/calendar-messaging-participant/jobs/unmatch-participant.job';
-import { PersonObjectMetadata } from 'src/modules/person/standard-objects/person.object-metadata';
+import { PersonWorkspaceEntity } from 'src/modules/person/standard-objects/person.workspace-entity';
 
 @Injectable()
 export class ParticipantPersonListener {
@@ -25,7 +25,7 @@ export class ParticipantPersonListener {
 
   @OnEvent('person.created')
   async handleCreatedEvent(
-    payload: ObjectRecordCreateEvent<PersonObjectMetadata>,
+    payload: ObjectRecordCreateEvent<PersonWorkspaceEntity>,
   ) {
     if (payload.properties.after.email === null) {
       return;
@@ -43,7 +43,7 @@ export class ParticipantPersonListener {
 
   @OnEvent('person.updated')
   async handleUpdatedEvent(
-    payload: ObjectRecordUpdateEvent<PersonObjectMetadata>,
+    payload: ObjectRecordUpdateEvent<PersonWorkspaceEntity>,
   ) {
     if (
       objectRecordUpdateEventChangedProperties(

packages/twenty-server/src/modules/calendar-messaging-participant/listeners/participant-workspace-member.listener.ts

@@ -14,7 +14,7 @@ import {
   UnmatchParticipantJobData,
   UnmatchParticipantJob,
 } from 'src/modules/calendar-messaging-participant/jobs/unmatch-participant.job';
-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';
 
 @Injectable()
 export class ParticipantWorkspaceMemberListener {
@@ -25,7 +25,7 @@ export class ParticipantWorkspaceMemberListener {
 
   @OnEvent('workspaceMember.created')
   async handleCreatedEvent(
-    payload: ObjectRecordCreateEvent<WorkspaceMemberObjectMetadata>,
+    payload: ObjectRecordCreateEvent<WorkspaceMemberWorkspaceEntity>,
   ) {
     if (payload.properties.after.userEmail === null) {
       return;
@@ -43,7 +43,7 @@ export class ParticipantWorkspaceMemberListener {
 
   @OnEvent('workspaceMember.updated')
   async handleUpdatedEvent(
-    payload: ObjectRecordUpdateEvent<WorkspaceMemberObjectMetadata>,
+    payload: ObjectRecordUpdateEvent<WorkspaceMemberWorkspaceEntity>,
   ) {
     if (
       objectRecordUpdateEventChangedProperties(

packages/twenty-server/src/modules/calendar-messaging-participant/services/add-person-id-and-workspace-member-id/add-person-id-and-workspace-member-id.module.ts

@@ -3,12 +3,12 @@ import { Module } from '@nestjs/common';
 import { ObjectMetadataRepositoryModule } from 'src/engine/object-metadata-repository/object-metadata-repository.module';
 import { WorkspaceDataSourceModule } from 'src/engine/workspace-datasource/workspace-datasource.module';
 import { AddPersonIdAndWorkspaceMemberIdService } from 'src/modules/calendar-messaging-participant/services/add-person-id-and-workspace-member-id/add-person-id-and-workspace-member-id.service';
-import { PersonObjectMetadata } from 'src/modules/person/standard-objects/person.object-metadata';
+import { PersonWorkspaceEntity } from 'src/modules/person/standard-objects/person.workspace-entity';
 
 @Module({
   imports: [
     WorkspaceDataSourceModule,
-    ObjectMetadataRepositoryModule.forFeature([PersonObjectMetadata]),
+    ObjectMetadataRepositoryModule.forFeature([PersonWorkspaceEntity]),
   ],
   providers: [AddPersonIdAndWorkspaceMemberIdService],
   exports: [AddPersonIdAndWorkspaceMemberIdService],

packages/twenty-server/src/modules/calendar-messaging-participant/services/add-person-id-and-workspace-member-id/add-person-id-and-workspace-member-id.service.ts

@@ -5,13 +5,13 @@ import { EntityManager } from 'typeorm';
 import { InjectObjectMetadataRepository } from 'src/engine/object-metadata-repository/object-metadata-repository.decorator';
 import { WorkspaceDataSourceService } from 'src/engine/workspace-datasource/workspace-datasource.service';
 import { PersonRepository } from 'src/modules/person/repositories/person.repository';
-import { PersonObjectMetadata } from 'src/modules/person/standard-objects/person.object-metadata';
+import { PersonWorkspaceEntity } from 'src/modules/person/standard-objects/person.workspace-entity';
 
 @Injectable()
 export class AddPersonIdAndWorkspaceMemberIdService {
   constructor(
     private readonly workspaceDataSourceService: WorkspaceDataSourceService,
-    @InjectObjectMetadataRepository(PersonObjectMetadata)
+    @InjectObjectMetadataRepository(PersonWorkspaceEntity)
     private readonly personRepository: PersonRepository,
   ) {}
 

packages/twenty-server/src/modules/calendar/commands/calendar-commands.module.ts

@@ -3,14 +3,14 @@ import { Module } from '@nestjs/common';
 import { ObjectMetadataRepositoryModule } from 'src/engine/object-metadata-repository/object-metadata-repository.module';
 import { GoogleCalendarSyncCommand } from 'src/modules/calendar/commands/google-calendar-sync.command';
 import { WorkspaceGoogleCalendarSyncModule } from 'src/modules/calendar/services/workspace-google-calendar-sync/workspace-google-calendar-sync.module';
-import { CalendarChannelObjectMetadata } from 'src/modules/calendar/standard-objects/calendar-channel.object-metadata';
+import { CalendarChannelWorkspaceEntity } from 'src/modules/calendar/standard-objects/calendar-channel.workspace-entity';
-import { ConnectedAccountObjectMetadata } from 'src/modules/connected-account/standard-objects/connected-account.object-metadata';
+import { ConnectedAccountWorkspaceEntity } from 'src/modules/connected-account/standard-objects/connected-account.workspace-entity';
 
 @Module({
   imports: [
     ObjectMetadataRepositoryModule.forFeature([
-      ConnectedAccountObjectMetadata,
+      ConnectedAccountWorkspaceEntity,
-      CalendarChannelObjectMetadata,
+      CalendarChannelWorkspaceEntity,
     ]),
     WorkspaceGoogleCalendarSyncModule,
   ],

packages/twenty-server/src/modules/calendar/jobs/blocklist-item-delete-calendar-events.job.ts

@@ -6,10 +6,10 @@ import { InjectObjectMetadataRepository } from 'src/engine/object-metadata-repos
 import { CalendarChannelEventAssociationRepository } from 'src/modules/calendar/repositories/calendar-channel-event-association.repository';
 import { CalendarChannelRepository } from 'src/modules/calendar/repositories/calendar-channel.repository';
 import { CalendarEventCleanerService } from 'src/modules/calendar/services/calendar-event-cleaner/calendar-event-cleaner.service';
-import { CalendarChannelEventAssociationObjectMetadata } from 'src/modules/calendar/standard-objects/calendar-channel-event-association.object-metadata';
+import { CalendarChannelEventAssociationWorkspaceEntity } from 'src/modules/calendar/standard-objects/calendar-channel-event-association.workspace-entity';
-import { CalendarChannelObjectMetadata } from 'src/modules/calendar/standard-objects/calendar-channel.object-metadata';
+import { CalendarChannelWorkspaceEntity } from 'src/modules/calendar/standard-objects/calendar-channel.workspace-entity';
 import { BlocklistRepository } from 'src/modules/connected-account/repositories/blocklist.repository';
-import { BlocklistObjectMetadata } from 'src/modules/connected-account/standard-objects/blocklist.object-metadata';
+import { BlocklistWorkspaceEntity } from 'src/modules/connected-account/standard-objects/blocklist.workspace-entity';
 
 export type BlocklistItemDeleteCalendarEventsJobData = {
   workspaceId: string;
@@ -25,13 +25,13 @@ export class BlocklistItemDeleteCalendarEventsJob
   );
 
   constructor(
-    @InjectObjectMetadataRepository(CalendarChannelObjectMetadata)
+    @InjectObjectMetadataRepository(CalendarChannelWorkspaceEntity)
     private readonly calendarChannelRepository: CalendarChannelRepository,
     @InjectObjectMetadataRepository(
-      CalendarChannelEventAssociationObjectMetadata,
+      CalendarChannelEventAssociationWorkspaceEntity,
     )
     private readonly calendarChannelEventAssociationRepository: CalendarChannelEventAssociationRepository,
-    @InjectObjectMetadataRepository(BlocklistObjectMetadata)
+    @InjectObjectMetadataRepository(BlocklistWorkspaceEntity)
     private readonly blocklistRepository: BlocklistRepository,
     private readonly calendarEventCleanerService: CalendarEventCleanerService,
   ) {}

packages/twenty-server/src/modules/calendar/jobs/blocklist-reimport-calendar-events.job.ts

@@ -5,7 +5,7 @@ import { MessageQueueJob } from 'src/engine/integrations/message-queue/interface
 import { InjectObjectMetadataRepository } from 'src/engine/object-metadata-repository/object-metadata-repository.decorator';
 import { GoogleCalendarSyncService } from 'src/modules/calendar/services/google-calendar-sync/google-calendar-sync.service';
 import { ConnectedAccountRepository } from 'src/modules/connected-account/repositories/connected-account.repository';
-import { ConnectedAccountObjectMetadata } from 'src/modules/connected-account/standard-objects/connected-account.object-metadata';
+import { ConnectedAccountWorkspaceEntity } from 'src/modules/connected-account/standard-objects/connected-account.workspace-entity';
 
 export type BlocklistReimportCalendarEventsJobData = {
   workspaceId: string;
@@ -20,7 +20,7 @@ export class BlocklistReimportCalendarEventsJob
   private readonly logger = new Logger(BlocklistReimportCalendarEventsJob.name);
 
   constructor(
-    @InjectObjectMetadataRepository(ConnectedAccountObjectMetadata)
+    @InjectObjectMetadataRepository(ConnectedAccountWorkspaceEntity)
     private readonly connectedAccountRepository: ConnectedAccountRepository,
     private readonly googleCalendarSyncService: GoogleCalendarSyncService,
   ) {}

packages/twenty-server/src/modules/calendar/jobs/calendar-create-company-and-contact-after-sync.job.ts

@@ -5,8 +5,8 @@ import { MessageQueueJob } from 'src/engine/integrations/message-queue/interface
 import { InjectObjectMetadataRepository } from 'src/engine/object-metadata-repository/object-metadata-repository.decorator';
 import { CalendarChannelRepository } from 'src/modules/calendar/repositories/calendar-channel.repository';
 import { CalendarEventParticipantRepository } from 'src/modules/calendar/repositories/calendar-event-participant.repository';
-import { CalendarChannelObjectMetadata } from 'src/modules/calendar/standard-objects/calendar-channel.object-metadata';
+import { CalendarChannelWorkspaceEntity } from 'src/modules/calendar/standard-objects/calendar-channel.workspace-entity';
-import { CalendarEventParticipantObjectMetadata } from 'src/modules/calendar/standard-objects/calendar-event-participant.object-metadata';
+import { CalendarEventParticipantWorkspaceEntity } from 'src/modules/calendar/standard-objects/calendar-event-participant.workspace-entity';
 import { CreateCompanyAndContactService } from 'src/modules/connected-account/auto-companies-and-contacts-creation/services/create-company-and-contact.service';
 
 export type CalendarCreateCompanyAndContactAfterSyncJobData = {
@@ -23,9 +23,9 @@ export class CalendarCreateCompanyAndContactAfterSyncJob
   );
   constructor(
     private readonly createCompanyAndContactService: CreateCompanyAndContactService,
-    @InjectObjectMetadataRepository(CalendarChannelObjectMetadata)
+    @InjectObjectMetadataRepository(CalendarChannelWorkspaceEntity)
     private readonly calendarChannelService: CalendarChannelRepository,
-    @InjectObjectMetadataRepository(CalendarEventParticipantObjectMetadata)
+    @InjectObjectMetadataRepository(CalendarEventParticipantWorkspaceEntity)
     private readonly calendarEventParticipantRepository: CalendarEventParticipantRepository,
   ) {}
 

packages/twenty-server/src/modules/calendar/jobs/calendar-job.module.ts

@@ -8,22 +8,22 @@ import { DeleteConnectedAccountAssociatedCalendarDataJob } from 'src/modules/cal
 import { GoogleCalendarSyncJob } from 'src/modules/calendar/jobs/google-calendar-sync.job';
 import { CalendarEventCleanerModule } from 'src/modules/calendar/services/calendar-event-cleaner/calendar-event-cleaner.module';
 import { GoogleCalendarSyncModule } from 'src/modules/calendar/services/google-calendar-sync/google-calendar-sync.module';
-import { CalendarChannelEventAssociationObjectMetadata } from 'src/modules/calendar/standard-objects/calendar-channel-event-association.object-metadata';
+import { CalendarChannelEventAssociationWorkspaceEntity } from 'src/modules/calendar/standard-objects/calendar-channel-event-association.workspace-entity';
-import { CalendarChannelObjectMetadata } from 'src/modules/calendar/standard-objects/calendar-channel.object-metadata';
+import { CalendarChannelWorkspaceEntity } from 'src/modules/calendar/standard-objects/calendar-channel.workspace-entity';
-import { CalendarEventParticipantObjectMetadata } from 'src/modules/calendar/standard-objects/calendar-event-participant.object-metadata';
+import { CalendarEventParticipantWorkspaceEntity } from 'src/modules/calendar/standard-objects/calendar-event-participant.workspace-entity';
 import { AutoCompaniesAndContactsCreationModule } from 'src/modules/connected-account/auto-companies-and-contacts-creation/auto-companies-and-contacts-creation.module';
 import { GoogleAPIRefreshAccessTokenModule } from 'src/modules/connected-account/services/google-api-refresh-access-token/google-api-refresh-access-token.module';
-import { BlocklistObjectMetadata } from 'src/modules/connected-account/standard-objects/blocklist.object-metadata';
+import { BlocklistWorkspaceEntity } from 'src/modules/connected-account/standard-objects/blocklist.workspace-entity';
-import { ConnectedAccountObjectMetadata } from 'src/modules/connected-account/standard-objects/connected-account.object-metadata';
+import { ConnectedAccountWorkspaceEntity } from 'src/modules/connected-account/standard-objects/connected-account.workspace-entity';
 
 @Module({
   imports: [
     ObjectMetadataRepositoryModule.forFeature([
-      CalendarChannelObjectMetadata,
+      CalendarChannelWorkspaceEntity,
-      CalendarChannelEventAssociationObjectMetadata,
+      CalendarChannelEventAssociationWorkspaceEntity,
-      CalendarEventParticipantObjectMetadata,
+      CalendarEventParticipantWorkspaceEntity,
-      ConnectedAccountObjectMetadata,
+      ConnectedAccountWorkspaceEntity,
-      BlocklistObjectMetadata,
+      BlocklistWorkspaceEntity,
     ]),
     CalendarEventCleanerModule,
     AutoCompaniesAndContactsCreationModule,

packages/twenty-server/src/modules/calendar/listeners/calendar-blocklist.listener.ts

@@ -14,7 +14,7 @@ import {
   BlocklistReimportCalendarEventsJobData,
   BlocklistReimportCalendarEventsJob,
 } from 'src/modules/calendar/jobs/blocklist-reimport-calendar-events.job';
-import { BlocklistObjectMetadata } from 'src/modules/connected-account/standard-objects/blocklist.object-metadata';
+import { BlocklistWorkspaceEntity } from 'src/modules/connected-account/standard-objects/blocklist.workspace-entity';
 
 @Injectable()
 export class CalendarBlocklistListener {
@@ -25,7 +25,7 @@ export class CalendarBlocklistListener {
 
   @OnEvent('blocklist.created')
   async handleCreatedEvent(
-    payload: ObjectRecordCreateEvent<BlocklistObjectMetadata>,
+    payload: ObjectRecordCreateEvent<BlocklistWorkspaceEntity>,
   ) {
     await this.messageQueueService.add<BlocklistItemDeleteCalendarEventsJobData>(
       BlocklistItemDeleteCalendarEventsJob.name,
@@ -38,7 +38,7 @@ export class CalendarBlocklistListener {
 
   @OnEvent('blocklist.deleted')
   async handleDeletedEvent(
-    payload: ObjectRecordDeleteEvent<BlocklistObjectMetadata>,
+    payload: ObjectRecordDeleteEvent<BlocklistWorkspaceEntity>,
   ) {
     await this.messageQueueService.add<BlocklistReimportCalendarEventsJobData>(
       BlocklistReimportCalendarEventsJob.name,
@@ -52,7 +52,7 @@ export class CalendarBlocklistListener {
 
   @OnEvent('blocklist.updated')
   async handleUpdatedEvent(
-    payload: ObjectRecordUpdateEvent<BlocklistObjectMetadata>,
+    payload: ObjectRecordUpdateEvent<BlocklistWorkspaceEntity>,
   ) {
     await this.messageQueueService.add<BlocklistItemDeleteCalendarEventsJobData>(
       BlocklistItemDeleteCalendarEventsJob.name,

packages/twenty-server/src/modules/calendar/listeners/calendar-channel.listener.ts

@@ -9,7 +9,7 @@ import {
   CalendarCreateCompanyAndContactAfterSyncJobData,
   CalendarCreateCompanyAndContactAfterSyncJob,
 } from 'src/modules/calendar/jobs/calendar-create-company-and-contact-after-sync.job';
-import { MessageChannelObjectMetadata } from 'src/modules/messaging/standard-objects/message-channel.object-metadata';
+import { MessageChannelWorkspaceEntity } from 'src/modules/messaging/standard-objects/message-channel.workspace-entity';
 
 @Injectable()
 export class CalendarChannelListener {
@@ -20,7 +20,7 @@ export class CalendarChannelListener {
 
   @OnEvent('calendarChannel.updated')
   async handleUpdatedEvent(
-    payload: ObjectRecordUpdateEvent<MessageChannelObjectMetadata>,
+    payload: ObjectRecordUpdateEvent<MessageChannelWorkspaceEntity>,
   ) {
     if (
       objectRecordChangedProperties(

packages/twenty-server/src/modules/calendar/query-hooks/calendar-event/calendar-event-find-many.pre-query.hook.ts

@@ -8,7 +8,7 @@ import { WorkspacePreQueryHook } from 'src/engine/api/graphql/workspace-query-ru
 import { FindManyResolverArgs } from 'src/engine/api/graphql/workspace-resolver-builder/interfaces/workspace-resolvers-builder.interface';
 
 import { InjectObjectMetadataRepository } from 'src/engine/object-metadata-repository/object-metadata-repository.decorator';
-import { CalendarChannelEventAssociationObjectMetadata } from 'src/modules/calendar/standard-objects/calendar-channel-event-association.object-metadata';
+import { CalendarChannelEventAssociationWorkspaceEntity } from 'src/modules/calendar/standard-objects/calendar-channel-event-association.workspace-entity';
 import { CalendarChannelEventAssociationRepository } from 'src/modules/calendar/repositories/calendar-channel-event-association.repository';
 import { CanAccessCalendarEventService } from 'src/modules/calendar/query-hooks/calendar-event/services/can-access-calendar-event.service';
 
@@ -18,7 +18,7 @@ export class CalendarEventFindManyPreQueryHook
 {
   constructor(
     @InjectObjectMetadataRepository(
-      CalendarChannelEventAssociationObjectMetadata,
+      CalendarChannelEventAssociationWorkspaceEntity,
     )
     private readonly calendarChannelEventAssociationRepository: CalendarChannelEventAssociationRepository,
     private readonly canAccessCalendarEventService: CanAccessCalendarEventService,

packages/twenty-server/src/modules/calendar/query-hooks/calendar-event/calendar-event-find-one.pre-query-hook.ts

@@ -10,13 +10,13 @@ import { FindOneResolverArgs } from 'src/engine/api/graphql/workspace-resolver-b
 import { InjectObjectMetadataRepository } from 'src/engine/object-metadata-repository/object-metadata-repository.decorator';
 import { CanAccessCalendarEventService } from 'src/modules/calendar/query-hooks/calendar-event/services/can-access-calendar-event.service';
 import { CalendarChannelEventAssociationRepository } from 'src/modules/calendar/repositories/calendar-channel-event-association.repository';
-import { CalendarChannelEventAssociationObjectMetadata } from 'src/modules/calendar/standard-objects/calendar-channel-event-association.object-metadata';
+import { CalendarChannelEventAssociationWorkspaceEntity } from 'src/modules/calendar/standard-objects/calendar-channel-event-association.workspace-entity';
 
 @Injectable()
 export class CalendarEventFindOnePreQueryHook implements WorkspacePreQueryHook {
   constructor(
     @InjectObjectMetadataRepository(
-      CalendarChannelEventAssociationObjectMetadata,
+      CalendarChannelEventAssociationWorkspaceEntity,
     )
     private readonly calendarChannelEventAssociationRepository: CalendarChannelEventAssociationRepository,
     private readonly canAccessCalendarEventService: CanAccessCalendarEventService,

packages/twenty-server/src/modules/calendar/query-hooks/calendar-event/services/can-access-calendar-event.service.ts

@@ -5,31 +5,31 @@ import groupBy from 'lodash.groupby';
 import { InjectObjectMetadataRepository } from 'src/engine/object-metadata-repository/object-metadata-repository.decorator';
 import { ObjectRecord } from 'src/engine/workspace-manager/workspace-sync-metadata/types/object-record';
 import { CalendarChannelRepository } from 'src/modules/calendar/repositories/calendar-channel.repository';
-import { CalendarChannelEventAssociationObjectMetadata } from 'src/modules/calendar/standard-objects/calendar-channel-event-association.object-metadata';
+import { CalendarChannelEventAssociationWorkspaceEntity } from 'src/modules/calendar/standard-objects/calendar-channel-event-association.workspace-entity';
 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 } from 'src/modules/connected-account/standard-objects/connected-account.object-metadata';
+import { ConnectedAccountWorkspaceEntity } from 'src/modules/connected-account/standard-objects/connected-account.workspace-entity';
 import { WorkspaceMemberRepository } from 'src/modules/workspace-member/repositories/workspace-member.repository';
-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';
 
 @Injectable()
 export class CanAccessCalendarEventService {
   constructor(
-    @InjectObjectMetadataRepository(CalendarChannelObjectMetadata)
+    @InjectObjectMetadataRepository(CalendarChannelWorkspaceEntity)
     private readonly calendarChannelRepository: CalendarChannelRepository,
-    @InjectObjectMetadataRepository(ConnectedAccountObjectMetadata)
+    @InjectObjectMetadataRepository(ConnectedAccountWorkspaceEntity)
     private readonly connectedAccountRepository: ConnectedAccountRepository,
-    @InjectObjectMetadataRepository(WorkspaceMemberObjectMetadata)
+    @InjectObjectMetadataRepository(WorkspaceMemberWorkspaceEntity)
     private readonly workspaceMemberService: WorkspaceMemberRepository,
   ) {}
 
   public async canAccessCalendarEvent(
     userId: string,
     workspaceId: string,
-    calendarChannelCalendarEventAssociations: ObjectRecord<CalendarChannelEventAssociationObjectMetadata>[],
+    calendarChannelCalendarEventAssociations: ObjectRecord<CalendarChannelEventAssociationWorkspaceEntity>[],
   ) {
     const calendarChannels = await this.calendarChannelRepository.getByIds(
       calendarChannelCalendarEventAssociations.map(

packages/twenty-server/src/modules/calendar/query-hooks/calendar-query-hook.module.ts

@@ -1,10 +1,10 @@
 import { Module } from '@nestjs/common';
 
 import { ObjectMetadataRepositoryModule } from 'src/engine/object-metadata-repository/object-metadata-repository.module';
-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 { ConnectedAccountObjectMetadata } from 'src/modules/connected-account/standard-objects/connected-account.object-metadata';
+import { ConnectedAccountWorkspaceEntity } from 'src/modules/connected-account/standard-objects/connected-account.workspace-entity';
-import { CalendarChannelEventAssociationObjectMetadata } from 'src/modules/calendar/standard-objects/calendar-channel-event-association.object-metadata';
+import { CalendarChannelEventAssociationWorkspaceEntity } from 'src/modules/calendar/standard-objects/calendar-channel-event-association.workspace-entity';
-import { CalendarChannelObjectMetadata } from 'src/modules/calendar/standard-objects/calendar-channel.object-metadata';
+import { CalendarChannelWorkspaceEntity } from 'src/modules/calendar/standard-objects/calendar-channel.workspace-entity';
 import { CalendarEventFindManyPreQueryHook } from 'src/modules/calendar/query-hooks/calendar-event/calendar-event-find-many.pre-query.hook';
 import { CalendarEventFindOnePreQueryHook } from 'src/modules/calendar/query-hooks/calendar-event/calendar-event-find-one.pre-query-hook';
 import { CanAccessCalendarEventService } from 'src/modules/calendar/query-hooks/calendar-event/services/can-access-calendar-event.service';
@@ -12,10 +12,10 @@ import { CanAccessCalendarEventService } from 'src/modules/calendar/query-hooks/
 @Module({
   imports: [
     ObjectMetadataRepositoryModule.forFeature([
-      CalendarChannelEventAssociationObjectMetadata,
+      CalendarChannelEventAssociationWorkspaceEntity,
-      CalendarChannelObjectMetadata,
+      CalendarChannelWorkspaceEntity,
-      ConnectedAccountObjectMetadata,
+      ConnectedAccountWorkspaceEntity,
-      WorkspaceMemberObjectMetadata,
+      WorkspaceMemberWorkspaceEntity,
     ]),
   ],
   providers: [

packages/twenty-server/src/modules/calendar/repositories/calendar-channel-event-association.repository.ts

@@ -4,7 +4,7 @@ import { EntityManager } from 'typeorm';
 
 import { WorkspaceDataSourceService } from 'src/engine/workspace-datasource/workspace-datasource.service';
 import { ObjectRecord } from 'src/engine/workspace-manager/workspace-sync-metadata/types/object-record';
-import { CalendarChannelEventAssociationObjectMetadata } from 'src/modules/calendar/standard-objects/calendar-channel-event-association.object-metadata';
+import { CalendarChannelEventAssociationWorkspaceEntity } from 'src/modules/calendar/standard-objects/calendar-channel-event-association.workspace-entity';
 import { getFlattenedValuesAndValuesStringForBatchRawQuery } from 'src/modules/calendar/utils/get-flattened-values-and-values-string-for-batch-raw-query.util';
 
 @Injectable()
@@ -18,7 +18,7 @@ export class CalendarChannelEventAssociationRepository {
     calendarChannelId: string,
     workspaceId: string,
     transactionManager?: EntityManager,
-  ): Promise<ObjectRecord<CalendarChannelEventAssociationObjectMetadata>[]> {
+  ): Promise<ObjectRecord<CalendarChannelEventAssociationWorkspaceEntity>[]> {
     if (eventExternalIds.length === 0) {
       return [];
     }
@@ -56,7 +56,7 @@ export class CalendarChannelEventAssociationRepository {
     calendarChannelIds: string[],
     workspaceId: string,
     transactionManager?: EntityManager,
-  ): Promise<ObjectRecord<CalendarChannelEventAssociationObjectMetadata>[]> {
+  ): Promise<ObjectRecord<CalendarChannelEventAssociationWorkspaceEntity>[]> {
     if (calendarChannelIds.length === 0) {
       return [];
     }
@@ -117,7 +117,7 @@ export class CalendarChannelEventAssociationRepository {
     calendarEventIds: string[],
     workspaceId: string,
     transactionManager?: EntityManager,
-  ): Promise<ObjectRecord<CalendarChannelEventAssociationObjectMetadata>[]> {
+  ): Promise<ObjectRecord<CalendarChannelEventAssociationWorkspaceEntity>[]> {
     if (calendarEventIds.length === 0) {
       return [];
     }
@@ -136,7 +136,7 @@ export class CalendarChannelEventAssociationRepository {
 
   public async saveCalendarChannelEventAssociations(
     calendarChannelEventAssociations: Omit<
-      ObjectRecord<CalendarChannelEventAssociationObjectMetadata>,
+      ObjectRecord<CalendarChannelEventAssociationWorkspaceEntity>,
       'id' | 'createdAt' | 'updatedAt' | 'calendarChannel' | 'calendarEvent'
     >[],
     workspaceId: string,

packages/twenty-server/src/modules/calendar/repositories/calendar-channel.repository.ts

@@ -3,7 +3,7 @@ import { Injectable } from '@nestjs/common';
 import { EntityManager } from 'typeorm';
 
 import { WorkspaceDataSourceService } from 'src/engine/workspace-datasource/workspace-datasource.service';
-import { CalendarChannelObjectMetadata } from 'src/modules/calendar/standard-objects/calendar-channel.object-metadata';
+import { CalendarChannelWorkspaceEntity } from 'src/modules/calendar/standard-objects/calendar-channel.workspace-entity';
 import { ObjectRecord } from 'src/engine/workspace-manager/workspace-sync-metadata/types/object-record';
 
 @Injectable()
@@ -15,7 +15,7 @@ export class CalendarChannelRepository {
   public async getAll(
     workspaceId: string,
     transactionManager?: EntityManager,
-  ): Promise<ObjectRecord<CalendarChannelObjectMetadata>[]> {
+  ): Promise<ObjectRecord<CalendarChannelWorkspaceEntity>[]> {
     const dataSourceSchema =
       this.workspaceDataSourceService.getSchemaName(workspaceId);
 
@@ -29,7 +29,7 @@ export class CalendarChannelRepository {
 
   public async create(
     calendarChannel: Pick<
-      ObjectRecord<CalendarChannelObjectMetadata>,
+      ObjectRecord<CalendarChannelWorkspaceEntity>,
       'id' | 'connectedAccountId' | 'handle' | 'visibility'
     >,
     workspaceId: string,
@@ -55,7 +55,7 @@ export class CalendarChannelRepository {
     connectedAccountId: string,
     workspaceId: string,
     transactionManager?: EntityManager,
-  ): Promise<ObjectRecord<CalendarChannelObjectMetadata>[]> {
+  ): Promise<ObjectRecord<CalendarChannelWorkspaceEntity>[]> {
     const dataSourceSchema =
       this.workspaceDataSourceService.getSchemaName(workspaceId);
 
@@ -70,7 +70,7 @@ export class CalendarChannelRepository {
   public async getFirstByConnectedAccountId(
     connectedAccountId: string,
     workspaceId: string,
-  ): Promise<ObjectRecord<CalendarChannelObjectMetadata> | undefined> {
+  ): Promise<ObjectRecord<CalendarChannelWorkspaceEntity> | undefined> {
     const calendarChannels = await this.getByConnectedAccountId(
       connectedAccountId,
       workspaceId,
@@ -83,7 +83,7 @@ export class CalendarChannelRepository {
     ids: string[],
     workspaceId: string,
     transactionManager?: EntityManager,
-  ): Promise<ObjectRecord<CalendarChannelObjectMetadata>[]> {
+  ): Promise<ObjectRecord<CalendarChannelWorkspaceEntity>[]> {
     const dataSourceSchema =
       this.workspaceDataSourceService.getSchemaName(workspaceId);
 
@@ -99,7 +99,7 @@ export class CalendarChannelRepository {
     workspaceMemberId: string,
     workspaceId: string,
     transactionManager?: EntityManager,
-  ): Promise<ObjectRecord<CalendarChannelObjectMetadata>[]> {
+  ): Promise<ObjectRecord<CalendarChannelWorkspaceEntity>[]> {
     const dataSourceSchema =
       this.workspaceDataSourceService.getSchemaName(workspaceId);
 

packages/twenty-server/src/modules/calendar/repositories/calendar-event-participant.repository.ts

@@ -5,7 +5,7 @@ import differenceWith from 'lodash.differencewith';
 
 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 { CalendarEventParticipantWorkspaceEntity } from 'src/modules/calendar/standard-objects/calendar-event-participant.workspace-entity';
 import { getFlattenedValuesAndValuesStringForBatchRawQuery } from 'src/modules/calendar/utils/get-flattened-values-and-values-string-for-batch-raw-query.util';
 import {
   CalendarEventParticipant,
@@ -22,7 +22,7 @@ export class CalendarEventParticipantRepository {
     handles: string[],
     workspaceId: string,
     transactionManager?: EntityManager,
-  ): Promise<ObjectRecord<CalendarEventParticipantObjectMetadata>[]> {
+  ): Promise<ObjectRecord<CalendarEventParticipantWorkspaceEntity>[]> {
     const dataSourceSchema =
       this.workspaceDataSourceService.getSchemaName(workspaceId);
 
@@ -104,7 +104,7 @@ export class CalendarEventParticipantRepository {
     calendarEventParticipantIds: string[],
     workspaceId: string,
     transactionManager?: EntityManager,
-  ): Promise<ObjectRecord<CalendarEventParticipantObjectMetadata>[]> {
+  ): Promise<ObjectRecord<CalendarEventParticipantWorkspaceEntity>[]> {
     if (calendarEventParticipantIds.length === 0) {
       return [];
     }
@@ -124,7 +124,7 @@ export class CalendarEventParticipantRepository {
     calendarEventIds: string[],
     workspaceId: string,
     transactionManager?: EntityManager,
-  ): Promise<ObjectRecord<CalendarEventParticipantObjectMetadata>[]> {
+  ): Promise<ObjectRecord<CalendarEventParticipantWorkspaceEntity>[]> {
     if (calendarEventIds.length === 0) {
       return [];
     }

packages/twenty-server/src/modules/calendar/repositories/calendar-event.repository.ts

@@ -4,10 +4,10 @@ import { EntityManager } from 'typeorm';
 
 import { WorkspaceDataSourceService } from 'src/engine/workspace-datasource/workspace-datasource.service';
 import { ObjectRecord } from 'src/engine/workspace-manager/workspace-sync-metadata/types/object-record';
-import { CalendarEventObjectMetadata } from 'src/modules/calendar/standard-objects/calendar-event.object-metadata';
+import { CalendarEventWorkspaceEntity } from 'src/modules/calendar/standard-objects/calendar-event.workspace-entity';
 import { getFlattenedValuesAndValuesStringForBatchRawQuery } from 'src/modules/calendar/utils/get-flattened-values-and-values-string-for-batch-raw-query.util';
 import { CalendarEvent } from 'src/modules/calendar/types/calendar-event';
-import { CalendarEventParticipantObjectMetadata } from 'src/modules/calendar/standard-objects/calendar-event-participant.object-metadata';
+import { CalendarEventParticipantWorkspaceEntity } from 'src/modules/calendar/standard-objects/calendar-event-participant.workspace-entity';
 
 @Injectable()
 export class CalendarEventRepository {
@@ -19,7 +19,7 @@ export class CalendarEventRepository {
     calendarEventIds: string[],
     workspaceId: string,
     transactionManager?: EntityManager,
-  ): Promise<ObjectRecord<CalendarEventObjectMetadata>[]> {
+  ): Promise<ObjectRecord<CalendarEventWorkspaceEntity>[]> {
     if (calendarEventIds.length === 0) {
       return [];
     }
@@ -39,7 +39,7 @@ export class CalendarEventRepository {
     iCalUIDs: string[],
     workspaceId: string,
     transactionManager?: EntityManager,
-  ): Promise<ObjectRecord<CalendarEventObjectMetadata>[]> {
+  ): Promise<ObjectRecord<CalendarEventWorkspaceEntity>[]> {
     if (iCalUIDs.length === 0) {
       return [];
     }
@@ -80,7 +80,7 @@ export class CalendarEventRepository {
     offset: number,
     workspaceId: string,
     transactionManager?: EntityManager,
-  ): Promise<ObjectRecord<CalendarEventParticipantObjectMetadata>[]> {
+  ): Promise<ObjectRecord<CalendarEventParticipantWorkspaceEntity>[]> {
     const dataSourceSchema =
       this.workspaceDataSourceService.getSchemaName(workspaceId);
 

packages/twenty-server/src/modules/calendar/services/calendar-event-cleaner/calendar-event-cleaner.module.ts

@@ -2,11 +2,11 @@ import { Module } from '@nestjs/common';
 
 import { ObjectMetadataRepositoryModule } from 'src/engine/object-metadata-repository/object-metadata-repository.module';
 import { CalendarEventCleanerService } from 'src/modules/calendar/services/calendar-event-cleaner/calendar-event-cleaner.service';
-import { CalendarEventObjectMetadata } from 'src/modules/calendar/standard-objects/calendar-event.object-metadata';
+import { CalendarEventWorkspaceEntity } from 'src/modules/calendar/standard-objects/calendar-event.workspace-entity';
 
 @Module({
   imports: [
-    ObjectMetadataRepositoryModule.forFeature([CalendarEventObjectMetadata]),
+    ObjectMetadataRepositoryModule.forFeature([CalendarEventWorkspaceEntity]),
   ],
   providers: [CalendarEventCleanerService],
   exports: [CalendarEventCleanerService],

packages/twenty-server/src/modules/calendar/services/calendar-event-cleaner/calendar-event-cleaner.service.ts

@@ -2,13 +2,13 @@ import { Injectable } from '@nestjs/common';
 
 import { InjectObjectMetadataRepository } from 'src/engine/object-metadata-repository/object-metadata-repository.decorator';
 import { CalendarEventRepository } from 'src/modules/calendar/repositories/calendar-event.repository';
-import { CalendarEventObjectMetadata } from 'src/modules/calendar/standard-objects/calendar-event.object-metadata';
+import { CalendarEventWorkspaceEntity } from 'src/modules/calendar/standard-objects/calendar-event.workspace-entity';
 import { deleteUsingPagination } from 'src/modules/messaging/services/thread-cleaner/utils/delete-using-pagination.util';
 
 @Injectable()
 export class CalendarEventCleanerService {
   constructor(
-    @InjectObjectMetadataRepository(CalendarEventObjectMetadata)
+    @InjectObjectMetadataRepository(CalendarEventWorkspaceEntity)
     private readonly calendarEventRepository: CalendarEventRepository,
   ) {}
 

packages/twenty-server/src/modules/calendar/services/calendar-event-participant/calendar-event-participant.module.ts

@@ -4,12 +4,12 @@ import { ObjectMetadataRepositoryModule } from 'src/engine/object-metadata-repos
 import { WorkspaceDataSourceModule } from 'src/engine/workspace-datasource/workspace-datasource.module';
 import { AddPersonIdAndWorkspaceMemberIdModule } from 'src/modules/calendar-messaging-participant/services/add-person-id-and-workspace-member-id/add-person-id-and-workspace-member-id.module';
 import { CalendarEventParticipantService } from 'src/modules/calendar/services/calendar-event-participant/calendar-event-participant.service';
-import { PersonObjectMetadata } from 'src/modules/person/standard-objects/person.object-metadata';
+import { PersonWorkspaceEntity } from 'src/modules/person/standard-objects/person.workspace-entity';
 
 @Module({
   imports: [
     WorkspaceDataSourceModule,
-    ObjectMetadataRepositoryModule.forFeature([PersonObjectMetadata]),
+    ObjectMetadataRepositoryModule.forFeature([PersonWorkspaceEntity]),
     AddPersonIdAndWorkspaceMemberIdModule,
   ],
   providers: [CalendarEventParticipantService],

packages/twenty-server/src/modules/calendar/services/calendar-event-participant/calendar-event-participant.service.ts

@@ -4,12 +4,12 @@ import { EntityManager } from 'typeorm';
 
 import { InjectObjectMetadataRepository } from 'src/engine/object-metadata-repository/object-metadata-repository.decorator';
 import { PersonRepository } from 'src/modules/person/repositories/person.repository';
-import { PersonObjectMetadata } from 'src/modules/person/standard-objects/person.object-metadata';
+import { PersonWorkspaceEntity } from 'src/modules/person/standard-objects/person.workspace-entity';
 import { WorkspaceDataSourceService } from 'src/engine/workspace-datasource/workspace-datasource.service';
 import { getFlattenedValuesAndValuesStringForBatchRawQuery } from 'src/modules/calendar/utils/get-flattened-values-and-values-string-for-batch-raw-query.util';
 import { CalendarEventParticipant } from 'src/modules/calendar/types/calendar-event';
 import { CalendarEventParticipantRepository } from 'src/modules/calendar/repositories/calendar-event-participant.repository';
-import { CalendarEventParticipantObjectMetadata } from 'src/modules/calendar/standard-objects/calendar-event-participant.object-metadata';
+import { CalendarEventParticipantWorkspaceEntity } from 'src/modules/calendar/standard-objects/calendar-event-participant.workspace-entity';
 import { AddPersonIdAndWorkspaceMemberIdService } from 'src/modules/calendar-messaging-participant/services/add-person-id-and-workspace-member-id/add-person-id-and-workspace-member-id.service';
 import { ObjectRecord } from 'src/engine/workspace-manager/workspace-sync-metadata/types/object-record';
 
@@ -17,15 +17,15 @@ import { ObjectRecord } from 'src/engine/workspace-manager/workspace-sync-metada
 export class CalendarEventParticipantService {
   constructor(
     private readonly workspaceDataSourceService: WorkspaceDataSourceService,
-    @InjectObjectMetadataRepository(CalendarEventParticipantObjectMetadata)
+    @InjectObjectMetadataRepository(CalendarEventParticipantWorkspaceEntity)
     private readonly calendarEventParticipantRepository: CalendarEventParticipantRepository,
-    @InjectObjectMetadataRepository(PersonObjectMetadata)
+    @InjectObjectMetadataRepository(PersonWorkspaceEntity)
     private readonly personRepository: PersonRepository,
     private readonly addPersonIdAndWorkspaceMemberIdService: AddPersonIdAndWorkspaceMemberIdService,
   ) {}
 
   public async updateCalendarEventParticipantsAfterPeopleCreation(
-    createdPeople: ObjectRecord<PersonObjectMetadata>[],
+    createdPeople: ObjectRecord<PersonWorkspaceEntity>[],
     workspaceId: string,
     transactionManager?: EntityManager,
   ): Promise<void> {

packages/twenty-server/src/modules/calendar/services/google-calendar-sync/google-calendar-sync.module.ts

@@ -8,27 +8,27 @@ import { CalendarEventCleanerModule } from 'src/modules/calendar/services/calend
 import { CalendarEventParticipantModule } from 'src/modules/calendar/services/calendar-event-participant/calendar-event-participant.module';
 import { GoogleCalendarSyncService } from 'src/modules/calendar/services/google-calendar-sync/google-calendar-sync.service';
 import { CalendarProvidersModule } from 'src/modules/calendar/services/providers/calendar-providers.module';
-import { CalendarChannelEventAssociationObjectMetadata } from 'src/modules/calendar/standard-objects/calendar-channel-event-association.object-metadata';
+import { CalendarChannelEventAssociationWorkspaceEntity } from 'src/modules/calendar/standard-objects/calendar-channel-event-association.workspace-entity';
-import { CalendarChannelObjectMetadata } from 'src/modules/calendar/standard-objects/calendar-channel.object-metadata';
+import { CalendarChannelWorkspaceEntity } from 'src/modules/calendar/standard-objects/calendar-channel.workspace-entity';
-import { CalendarEventParticipantObjectMetadata } from 'src/modules/calendar/standard-objects/calendar-event-participant.object-metadata';
+import { CalendarEventParticipantWorkspaceEntity } from 'src/modules/calendar/standard-objects/calendar-event-participant.workspace-entity';
-import { CalendarEventObjectMetadata } from 'src/modules/calendar/standard-objects/calendar-event.object-metadata';
+import { CalendarEventWorkspaceEntity } from 'src/modules/calendar/standard-objects/calendar-event.workspace-entity';
-import { BlocklistObjectMetadata } from 'src/modules/connected-account/standard-objects/blocklist.object-metadata';
+import { BlocklistWorkspaceEntity } from 'src/modules/connected-account/standard-objects/blocklist.workspace-entity';
-import { ConnectedAccountObjectMetadata } from 'src/modules/connected-account/standard-objects/connected-account.object-metadata';
+import { ConnectedAccountWorkspaceEntity } from 'src/modules/connected-account/standard-objects/connected-account.workspace-entity';
-import { PersonObjectMetadata } from 'src/modules/person/standard-objects/person.object-metadata';
+import { PersonWorkspaceEntity } from 'src/modules/person/standard-objects/person.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';
 
 @Module({
   imports: [
     CalendarProvidersModule,
     ObjectMetadataRepositoryModule.forFeature([
-      ConnectedAccountObjectMetadata,
+      ConnectedAccountWorkspaceEntity,
-      CalendarEventObjectMetadata,
+      CalendarEventWorkspaceEntity,
-      CalendarChannelObjectMetadata,
+      CalendarChannelWorkspaceEntity,
-      CalendarChannelEventAssociationObjectMetadata,
+      CalendarChannelEventAssociationWorkspaceEntity,
-      CalendarEventParticipantObjectMetadata,
+      CalendarEventParticipantWorkspaceEntity,
-      BlocklistObjectMetadata,
+      BlocklistWorkspaceEntity,
-      PersonObjectMetadata,
+      PersonWorkspaceEntity,
-      WorkspaceMemberObjectMetadata,
+      WorkspaceMemberWorkspaceEntity,
     ]),
     CalendarEventParticipantModule,
     TypeOrmModule.forFeature([FeatureFlagEntity], 'core'),

packages/twenty-server/src/modules/calendar/services/google-calendar-sync/google-calendar-sync.service.ts

@@ -17,13 +17,13 @@ import { WorkspaceDataSourceService } from 'src/engine/workspace-datasource/work
 import { CalendarEventRepository } from 'src/modules/calendar/repositories/calendar-event.repository';
 import { formatGoogleCalendarEvent } from 'src/modules/calendar/utils/format-google-calendar-event.util';
 import { CalendarEventParticipantRepository } from 'src/modules/calendar/repositories/calendar-event-participant.repository';
-import { ConnectedAccountObjectMetadata } from 'src/modules/connected-account/standard-objects/connected-account.object-metadata';
+import { ConnectedAccountWorkspaceEntity } from 'src/modules/connected-account/standard-objects/connected-account.workspace-entity';
 import { InjectObjectMetadataRepository } from 'src/engine/object-metadata-repository/object-metadata-repository.decorator';
-import { CalendarEventObjectMetadata } from 'src/modules/calendar/standard-objects/calendar-event.object-metadata';
+import { CalendarEventWorkspaceEntity } from 'src/modules/calendar/standard-objects/calendar-event.workspace-entity';
-import { CalendarChannelObjectMetadata } from 'src/modules/calendar/standard-objects/calendar-channel.object-metadata';
+import { CalendarChannelWorkspaceEntity } from 'src/modules/calendar/standard-objects/calendar-channel.workspace-entity';
-import { CalendarChannelEventAssociationObjectMetadata } from 'src/modules/calendar/standard-objects/calendar-channel-event-association.object-metadata';
+import { CalendarChannelEventAssociationWorkspaceEntity } from 'src/modules/calendar/standard-objects/calendar-channel-event-association.workspace-entity';
-import { CalendarEventParticipantObjectMetadata } from 'src/modules/calendar/standard-objects/calendar-event-participant.object-metadata';
+import { CalendarEventParticipantWorkspaceEntity } from 'src/modules/calendar/standard-objects/calendar-event-participant.workspace-entity';
-import { BlocklistObjectMetadata } from 'src/modules/connected-account/standard-objects/blocklist.object-metadata';
+import { BlocklistWorkspaceEntity } from 'src/modules/connected-account/standard-objects/blocklist.workspace-entity';
 import { CalendarEventCleanerService } from 'src/modules/calendar/services/calendar-event-cleaner/calendar-event-cleaner.service';
 import { CalendarEventParticipantService } from 'src/modules/calendar/services/calendar-event-participant/calendar-event-participant.service';
 import { CalendarEventWithParticipants } from 'src/modules/calendar/types/calendar-event';
@@ -42,19 +42,19 @@ export class GoogleCalendarSyncService {
 
   constructor(
     private readonly googleCalendarClientProvider: GoogleCalendarClientProvider,
-    @InjectObjectMetadataRepository(ConnectedAccountObjectMetadata)
+    @InjectObjectMetadataRepository(ConnectedAccountWorkspaceEntity)
     private readonly connectedAccountRepository: ConnectedAccountRepository,
-    @InjectObjectMetadataRepository(CalendarEventObjectMetadata)
+    @InjectObjectMetadataRepository(CalendarEventWorkspaceEntity)
     private readonly calendarEventRepository: CalendarEventRepository,
-    @InjectObjectMetadataRepository(CalendarChannelObjectMetadata)
+    @InjectObjectMetadataRepository(CalendarChannelWorkspaceEntity)
     private readonly calendarChannelRepository: CalendarChannelRepository,
     @InjectObjectMetadataRepository(
-      CalendarChannelEventAssociationObjectMetadata,
+      CalendarChannelEventAssociationWorkspaceEntity,
     )
     private readonly calendarChannelEventAssociationRepository: CalendarChannelEventAssociationRepository,
-    @InjectObjectMetadataRepository(CalendarEventParticipantObjectMetadata)
+    @InjectObjectMetadataRepository(CalendarEventParticipantWorkspaceEntity)
     private readonly calendarEventParticipantsRepository: CalendarEventParticipantRepository,
-    @InjectObjectMetadataRepository(BlocklistObjectMetadata)
+    @InjectObjectMetadataRepository(BlocklistWorkspaceEntity)
     private readonly blocklistRepository: BlocklistRepository,
     @InjectRepository(FeatureFlagEntity, 'core')
     private readonly featureFlagRepository: Repository<FeatureFlagEntity>,
@@ -364,8 +364,8 @@ export class GoogleCalendarSyncService {
       eventExternalId: string;
       calendarChannelId: string;
     }[],
-    connectedAccount: ConnectedAccountObjectMetadata,
+    connectedAccount: ConnectedAccountWorkspaceEntity,
-    calendarChannel: CalendarChannelObjectMetadata,
+    calendarChannel: CalendarChannelWorkspaceEntity,
     workspaceId: string,
   ): Promise<void> {
     const dataSourceMetadata =

packages/twenty-server/src/modules/calendar/services/workspace-google-calendar-sync/workspace-google-calendar-sync.module.ts

@@ -2,11 +2,11 @@ import { Module } from '@nestjs/common';
 
 import { ObjectMetadataRepositoryModule } from 'src/engine/object-metadata-repository/object-metadata-repository.module';
 import { WorkspaceGoogleCalendarSyncService } from 'src/modules/calendar/services/workspace-google-calendar-sync/workspace-google-calendar-sync.service';
-import { CalendarChannelObjectMetadata } from 'src/modules/calendar/standard-objects/calendar-channel.object-metadata';
+import { CalendarChannelWorkspaceEntity } from 'src/modules/calendar/standard-objects/calendar-channel.workspace-entity';
 
 @Module({
   imports: [
-    ObjectMetadataRepositoryModule.forFeature([CalendarChannelObjectMetadata]),
+    ObjectMetadataRepositoryModule.forFeature([CalendarChannelWorkspaceEntity]),
   ],
   providers: [WorkspaceGoogleCalendarSyncService],
   exports: [WorkspaceGoogleCalendarSyncService],

packages/twenty-server/src/modules/calendar/services/workspace-google-calendar-sync/workspace-google-calendar-sync.service.ts

@@ -9,12 +9,12 @@ import {
   GoogleCalendarSyncJob,
 } from 'src/modules/calendar/jobs/google-calendar-sync.job';
 import { CalendarChannelRepository } from 'src/modules/calendar/repositories/calendar-channel.repository';
-import { CalendarChannelObjectMetadata } from 'src/modules/calendar/standard-objects/calendar-channel.object-metadata';
+import { CalendarChannelWorkspaceEntity } from 'src/modules/calendar/standard-objects/calendar-channel.workspace-entity';
 
 @Injectable()
 export class WorkspaceGoogleCalendarSyncService {
   constructor(
-    @InjectObjectMetadataRepository(CalendarChannelObjectMetadata)
+    @InjectObjectMetadataRepository(CalendarChannelWorkspaceEntity)
     private readonly calendarChannelRepository: CalendarChannelRepository,
     @InjectMessageQueue(MessageQueue.calendarQueue)
     private readonly messageQueueService: MessageQueueService,

packages/twenty-server/src/modules/calendar/standard-objects/calendar-channel-event-association.workspace-entity.ts

@@ -3,15 +3,15 @@ import { Relation } from 'src/engine/workspace-manager/workspace-sync-metadata/i
 import { FieldMetadataType } from 'src/engine/metadata-modules/field-metadata/field-metadata.entity';
 import { CALENDAR_CHANNEL_EVENT_ASSOCIATION_STANDARD_FIELD_IDS } from 'src/engine/workspace-manager/workspace-sync-metadata/constants/standard-field-ids';
 import { STANDARD_OBJECT_IDS } from 'src/engine/workspace-manager/workspace-sync-metadata/constants/standard-object-ids';
-import { CalendarEventObjectMetadata } from 'src/modules/calendar/standard-objects/calendar-event.object-metadata';
+import { CalendarEventWorkspaceEntity } from 'src/modules/calendar/standard-objects/calendar-event.workspace-entity';
-import { WorkspaceEntity } from 'src/engine/twenty-orm/decorators/workspace-object.decorator';
+import { WorkspaceEntity } from 'src/engine/twenty-orm/decorators/workspace-entity.decorator';
 import { WorkspaceIsSystem } from 'src/engine/twenty-orm/decorators/workspace-is-system.decorator';
 import { WorkspaceIsNotAuditLogged } from 'src/engine/twenty-orm/decorators/workspace-is-not-audit-logged.decorator';
-import { WorkspaceGate } from 'src/engine/twenty-orm/decorators/workspace-gate.decorator';
 import { WorkspaceRelation } from 'src/engine/twenty-orm/decorators/workspace-relation.decorator';
 import { RelationMetadataType } from 'src/engine/metadata-modules/relation-metadata/relation-metadata.entity';
 import { WorkspaceField } from 'src/engine/twenty-orm/decorators/workspace-field.decorator';
 import { BaseWorkspaceEntity } from 'src/engine/twenty-orm/base.workspace-entity';
+import { CalendarChannelWorkspaceEntity } from 'src/modules/calendar/standard-objects/calendar-channel.workspace-entity';
 
 @WorkspaceEntity({
   standardId: STANDARD_OBJECT_IDS.calendarChannelEventAssociation,
@@ -23,7 +23,7 @@ import { BaseWorkspaceEntity } from 'src/engine/twenty-orm/base.workspace-entity
 })
 @WorkspaceIsSystem()
 @WorkspaceIsNotAuditLogged()
-export class CalendarChannelEventAssociationObjectMetadata extends BaseWorkspaceEntity {
+export class CalendarChannelEventAssociationWorkspaceEntity extends BaseWorkspaceEntity {
   @WorkspaceField({
     standardId:
       CALENDAR_CHANNEL_EVENT_ASSOCIATION_STANDARD_FIELD_IDS.eventExternalId,
@@ -42,10 +42,10 @@ export class CalendarChannelEventAssociationObjectMetadata extends BaseWorkspace
     description: 'Channel ID',
     icon: 'IconCalendar',
     joinColumn: 'calendarChannelId',
-    inverseSideTarget: () => CalendarEventObjectMetadata,
+    inverseSideTarget: () => CalendarChannelWorkspaceEntity,
     inverseSideFieldKey: 'calendarChannelEventAssociations',
   })
-  calendarChannel: Relation<CalendarEventObjectMetadata>;
+  calendarChannel: Relation<CalendarChannelWorkspaceEntity>;
 
   @WorkspaceRelation({
     standardId:
@@ -55,8 +55,8 @@ export class CalendarChannelEventAssociationObjectMetadata extends BaseWorkspace
     description: 'Event ID',
     icon: 'IconCalendar',
     joinColumn: 'calendarEventId',
-    inverseSideTarget: () => CalendarEventObjectMetadata,
+    inverseSideTarget: () => CalendarEventWorkspaceEntity,
     inverseSideFieldKey: 'calendarChannelEventAssociations',
   })
-  calendarEvent: Relation<CalendarEventObjectMetadata>;
+  calendarEvent: Relation<CalendarEventWorkspaceEntity>;
 }

packages/twenty-server/src/modules/calendar/standard-objects/calendar-channel.workspace-entity.ts

@@ -7,10 +7,10 @@ import {
 import { FieldMetadataType } from 'src/engine/metadata-modules/field-metadata/field-metadata.entity';
 import { CALENDAR_CHANNEL_STANDARD_FIELD_IDS } from 'src/engine/workspace-manager/workspace-sync-metadata/constants/standard-field-ids';
 import { STANDARD_OBJECT_IDS } from 'src/engine/workspace-manager/workspace-sync-metadata/constants/standard-object-ids';
-import { ConnectedAccountObjectMetadata } from 'src/modules/connected-account/standard-objects/connected-account.object-metadata';
+import { ConnectedAccountWorkspaceEntity } from 'src/modules/connected-account/standard-objects/connected-account.workspace-entity';
-import { CalendarChannelEventAssociationObjectMetadata } from 'src/modules/calendar/standard-objects/calendar-channel-event-association.object-metadata';
+import { CalendarChannelEventAssociationWorkspaceEntity } from 'src/modules/calendar/standard-objects/calendar-channel-event-association.workspace-entity';
 import { BaseWorkspaceEntity } from 'src/engine/twenty-orm/base.workspace-entity';
-import { WorkspaceEntity } from 'src/engine/twenty-orm/decorators/workspace-object.decorator';
+import { WorkspaceEntity } from 'src/engine/twenty-orm/decorators/workspace-entity.decorator';
 import { WorkspaceIsSystem } from 'src/engine/twenty-orm/decorators/workspace-is-system.decorator';
 import { WorkspaceIsNotAuditLogged } from 'src/engine/twenty-orm/decorators/workspace-is-not-audit-logged.decorator';
 import { WorkspaceField } from 'src/engine/twenty-orm/decorators/workspace-field.decorator';
@@ -31,7 +31,7 @@ export enum CalendarChannelVisibility {
 })
 @WorkspaceIsSystem()
 @WorkspaceIsNotAuditLogged()
-export class CalendarChannelObjectMetadata extends BaseWorkspaceEntity {
+export class CalendarChannelWorkspaceEntity extends BaseWorkspaceEntity {
   @WorkspaceField({
     standardId: CALENDAR_CHANNEL_STANDARD_FIELD_IDS.handle,
     type: FieldMetadataType.TEXT,
@@ -103,10 +103,10 @@ export class CalendarChannelObjectMetadata extends BaseWorkspaceEntity {
     description: 'Connected Account',
     icon: 'IconUserCircle',
     joinColumn: 'connectedAccountId',
-    inverseSideTarget: () => ConnectedAccountObjectMetadata,
+    inverseSideTarget: () => ConnectedAccountWorkspaceEntity,
     inverseSideFieldKey: 'calendarChannels',
   })
-  connectedAccount: Relation<ConnectedAccountObjectMetadata>;
+  connectedAccount: Relation<ConnectedAccountWorkspaceEntity>;
 
   @WorkspaceRelation({
     standardId:
@@ -115,10 +115,10 @@ export class CalendarChannelObjectMetadata extends BaseWorkspaceEntity {
     label: 'Calendar Channel Event Associations',
     description: 'Calendar Channel Event Associations',
     icon: 'IconCalendar',
-    inverseSideTarget: () => CalendarChannelEventAssociationObjectMetadata,
+    inverseSideTarget: () => CalendarChannelEventAssociationWorkspaceEntity,
     onDelete: RelationOnDeleteAction.CASCADE,
   })
   calendarChannelEventAssociations: Relation<
-    CalendarChannelEventAssociationObjectMetadata[]
+    CalendarChannelEventAssociationWorkspaceEntity[]
   >;
 }

packages/twenty-server/src/modules/calendar/standard-objects/calendar-event-participant.workspace-entity.ts

@@ -3,11 +3,11 @@ import { Relation } from 'src/engine/workspace-manager/workspace-sync-metadata/i
 import { FieldMetadataType } from 'src/engine/metadata-modules/field-metadata/field-metadata.entity';
 import { CALENDAR_EVENT_PARTICIPANT_STANDARD_FIELD_IDS } from 'src/engine/workspace-manager/workspace-sync-metadata/constants/standard-field-ids';
 import { STANDARD_OBJECT_IDS } from 'src/engine/workspace-manager/workspace-sync-metadata/constants/standard-object-ids';
-import { CalendarEventObjectMetadata } from 'src/modules/calendar/standard-objects/calendar-event.object-metadata';
+import { CalendarEventWorkspaceEntity } from 'src/modules/calendar/standard-objects/calendar-event.workspace-entity';
-import { PersonObjectMetadata } from 'src/modules/person/standard-objects/person.object-metadata';
+import { PersonWorkspaceEntity } from 'src/modules/person/standard-objects/person.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 { BaseWorkspaceEntity } from 'src/engine/twenty-orm/base.workspace-entity';
-import { WorkspaceEntity } from 'src/engine/twenty-orm/decorators/workspace-object.decorator';
+import { WorkspaceEntity } from 'src/engine/twenty-orm/decorators/workspace-entity.decorator';
 import { WorkspaceIsSystem } from 'src/engine/twenty-orm/decorators/workspace-is-system.decorator';
 import { WorkspaceIsNotAuditLogged } from 'src/engine/twenty-orm/decorators/workspace-is-not-audit-logged.decorator';
 import { WorkspaceField } from 'src/engine/twenty-orm/decorators/workspace-field.decorator';
@@ -32,7 +32,7 @@ export enum CalendarEventParticipantResponseStatus {
 })
 @WorkspaceIsSystem()
 @WorkspaceIsNotAuditLogged()
-export class CalendarEventParticipantObjectMetadata extends BaseWorkspaceEntity {
+export class CalendarEventParticipantWorkspaceEntity extends BaseWorkspaceEntity {
   @WorkspaceField({
     standardId: CALENDAR_EVENT_PARTICIPANT_STANDARD_FIELD_IDS.handle,
     type: FieldMetadataType.TEXT,
@@ -104,10 +104,10 @@ export class CalendarEventParticipantObjectMetadata extends BaseWorkspaceEntity
     description: 'Event ID',
     icon: 'IconCalendar',
     joinColumn: 'calendarEventId',
-    inverseSideTarget: () => CalendarEventObjectMetadata,
+    inverseSideTarget: () => CalendarEventWorkspaceEntity,
     inverseSideFieldKey: 'calendarEventParticipants',
   })
-  calendarEvent: Relation<CalendarEventObjectMetadata>;
+  calendarEvent: Relation<CalendarEventWorkspaceEntity>;
 
   @WorkspaceRelation({
     standardId: CALENDAR_EVENT_PARTICIPANT_STANDARD_FIELD_IDS.person,
@@ -116,11 +116,11 @@ export class CalendarEventParticipantObjectMetadata extends BaseWorkspaceEntity
     description: 'Person',
     icon: 'IconUser',
     joinColumn: 'personId',
-    inverseSideTarget: () => PersonObjectMetadata,
+    inverseSideTarget: () => PersonWorkspaceEntity,
     inverseSideFieldKey: 'calendarEventParticipants',
   })
   @WorkspaceIsNullable()
-  person: Relation<PersonObjectMetadata>;
+  person: Relation<PersonWorkspaceEntity>;
 
   @WorkspaceRelation({
     standardId: CALENDAR_EVENT_PARTICIPANT_STANDARD_FIELD_IDS.workspaceMember,
@@ -129,9 +129,9 @@ export class CalendarEventParticipantObjectMetadata extends BaseWorkspaceEntity
     description: 'Workspace Member',
     icon: 'IconUser',
     joinColumn: 'workspaceMemberId',
-    inverseSideTarget: () => WorkspaceMemberObjectMetadata,
+    inverseSideTarget: () => WorkspaceMemberWorkspaceEntity,
     inverseSideFieldKey: 'calendarEventParticipants',
   })
   @WorkspaceIsNullable()
-  workspaceMember: Relation<WorkspaceMemberObjectMetadata>;
+  workspaceMember: Relation<WorkspaceMemberWorkspaceEntity>;
 }

packages/twenty-server/src/modules/calendar/standard-objects/calendar-event.workspace-entity.ts

@@ -5,13 +5,13 @@ import {
   RelationMetadataType,
   RelationOnDeleteAction,
 } from 'src/engine/metadata-modules/relation-metadata/relation-metadata.entity';
-import { CalendarChannelEventAssociationObjectMetadata } from 'src/modules/calendar/standard-objects/calendar-channel-event-association.object-metadata';
+import { CalendarChannelEventAssociationWorkspaceEntity } from 'src/modules/calendar/standard-objects/calendar-channel-event-association.workspace-entity';
-import { CalendarEventParticipantObjectMetadata } from 'src/modules/calendar/standard-objects/calendar-event-participant.object-metadata';
+import { CalendarEventParticipantWorkspaceEntity } from 'src/modules/calendar/standard-objects/calendar-event-participant.workspace-entity';
 import { STANDARD_OBJECT_IDS } from 'src/engine/workspace-manager/workspace-sync-metadata/constants/standard-object-ids';
 import { CALENDAR_EVENT_STANDARD_FIELD_IDS } from 'src/engine/workspace-manager/workspace-sync-metadata/constants/standard-field-ids';
 import { LinkMetadata } from 'src/engine/metadata-modules/field-metadata/composite-types/link.composite-type';
 import { BaseWorkspaceEntity } from 'src/engine/twenty-orm/base.workspace-entity';
-import { WorkspaceEntity } from 'src/engine/twenty-orm/decorators/workspace-object.decorator';
+import { WorkspaceEntity } from 'src/engine/twenty-orm/decorators/workspace-entity.decorator';
 import { WorkspaceIsSystem } from 'src/engine/twenty-orm/decorators/workspace-is-system.decorator';
 import { WorkspaceIsNotAuditLogged } from 'src/engine/twenty-orm/decorators/workspace-is-not-audit-logged.decorator';
 import { WorkspaceField } from 'src/engine/twenty-orm/decorators/workspace-field.decorator';
@@ -28,7 +28,7 @@ import { WorkspaceRelation } from 'src/engine/twenty-orm/decorators/workspace-re
 })
 @WorkspaceIsSystem()
 @WorkspaceIsNotAuditLogged()
-export class CalendarEventObjectMetadata extends BaseWorkspaceEntity {
+export class CalendarEventWorkspaceEntity extends BaseWorkspaceEntity {
   @WorkspaceField({
     standardId: CALENDAR_EVENT_STANDARD_FIELD_IDS.title,
     type: FieldMetadataType.TEXT,
@@ -158,11 +158,11 @@ export class CalendarEventObjectMetadata extends BaseWorkspaceEntity {
     label: 'Calendar Channel Event Associations',
     description: 'Calendar Channel Event Associations',
     icon: 'IconCalendar',
-    inverseSideTarget: () => CalendarChannelEventAssociationObjectMetadata,
+    inverseSideTarget: () => CalendarChannelEventAssociationWorkspaceEntity,
     onDelete: RelationOnDeleteAction.CASCADE,
   })
   calendarChannelEventAssociations: Relation<
-    CalendarChannelEventAssociationObjectMetadata[]
+    CalendarChannelEventAssociationWorkspaceEntity[]
   >;
 
   @WorkspaceRelation({
@@ -171,8 +171,10 @@ export class CalendarEventObjectMetadata extends BaseWorkspaceEntity {
     label: 'Event Participants',
     description: 'Event Participants',
     icon: 'IconUserCircle',
-    inverseSideTarget: () => CalendarEventParticipantObjectMetadata,
+    inverseSideTarget: () => CalendarEventParticipantWorkspaceEntity,
     onDelete: RelationOnDeleteAction.CASCADE,
   })
-  calendarEventParticipants: Relation<CalendarEventParticipantObjectMetadata[]>;
+  calendarEventParticipants: Relation<
+    CalendarEventParticipantWorkspaceEntity[]
+  >;
 }

packages/twenty-server/src/modules/calendar/types/calendar-event.ts

@@ -1,9 +1,9 @@
-import { CalendarEventParticipantObjectMetadata } from 'src/modules/calendar/standard-objects/calendar-event-participant.object-metadata';
+import { CalendarEventParticipantWorkspaceEntity } from 'src/modules/calendar/standard-objects/calendar-event-participant.workspace-entity';
-import { CalendarEventObjectMetadata } from 'src/modules/calendar/standard-objects/calendar-event.object-metadata';
+import { CalendarEventWorkspaceEntity } from 'src/modules/calendar/standard-objects/calendar-event.workspace-entity';
 import { ObjectRecord } from 'src/engine/workspace-manager/workspace-sync-metadata/types/object-record';
 
 export type CalendarEvent = Omit<
-  ObjectRecord<CalendarEventObjectMetadata>,
+  ObjectRecord<CalendarEventWorkspaceEntity>,
   | 'createdAt'
   | 'updatedAt'
   | 'calendarChannelEventAssociations'
@@ -15,7 +15,7 @@ export type CalendarEvent = Omit<
 };
 
 export type CalendarEventParticipant = Omit<
-  ObjectRecord<CalendarEventParticipantObjectMetadata>,
+  ObjectRecord<CalendarEventParticipantWorkspaceEntity>,
   | 'id'
   | 'createdAt'
   | 'updatedAt'

packages/twenty-server/src/modules/calendar/utils/format-google-calendar-event.util.ts

@@ -1,7 +1,7 @@
 import { calendar_v3 as calendarV3 } from 'googleapis';
 import { v4 } from 'uuid';
 
-import { CalendarEventParticipantResponseStatus } from 'src/modules/calendar/standard-objects/calendar-event-participant.object-metadata';
+import { CalendarEventParticipantResponseStatus } from 'src/modules/calendar/standard-objects/calendar-event-participant.workspace-entity';
 import { CalendarEventWithParticipants } from 'src/modules/calendar/types/calendar-event';
 
 export const formatGoogleCalendarEvent = (

packages/twenty-server/src/modules/company/standard-objects/company.workspace-entity.ts

@@ -9,15 +9,15 @@ import {
 } from 'src/engine/metadata-modules/relation-metadata/relation-metadata.entity';
 import { COMPANY_STANDARD_FIELD_IDS } from 'src/engine/workspace-manager/workspace-sync-metadata/constants/standard-field-ids';
 import { STANDARD_OBJECT_IDS } from 'src/engine/workspace-manager/workspace-sync-metadata/constants/standard-object-ids';
-import { ActivityTargetObjectMetadata } from 'src/modules/activity/standard-objects/activity-target.object-metadata';
+import { ActivityTargetWorkspaceEntity } from 'src/modules/activity/standard-objects/activity-target.workspace-entity';
-import { AttachmentObjectMetadata } from 'src/modules/attachment/standard-objects/attachment.object-metadata';
+import { AttachmentWorkspaceEntity } from 'src/modules/attachment/standard-objects/attachment.workspace-entity';
-import { FavoriteObjectMetadata } from 'src/modules/favorite/standard-objects/favorite.object-metadata';
+import { FavoriteWorkspaceEntity } from 'src/modules/favorite/standard-objects/favorite.workspace-entity';
-import { OpportunityObjectMetadata } from 'src/modules/opportunity/standard-objects/opportunity.object-metadata';
+import { OpportunityWorkspaceEntity } from 'src/modules/opportunity/standard-objects/opportunity.workspace-entity';
-import { PersonObjectMetadata } from 'src/modules/person/standard-objects/person.object-metadata';
+import { PersonWorkspaceEntity } from 'src/modules/person/standard-objects/person.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 { TimelineActivityObjectMetadata } from 'src/modules/timeline/standard-objects/timeline-activity.object-metadata';
+import { TimelineActivityWorkspaceEntity } from 'src/modules/timeline/standard-objects/timeline-activity.workspace-entity';
 import { BaseWorkspaceEntity } from 'src/engine/twenty-orm/base.workspace-entity';
-import { WorkspaceEntity } from 'src/engine/twenty-orm/decorators/workspace-object.decorator';
+import { WorkspaceEntity } from 'src/engine/twenty-orm/decorators/workspace-entity.decorator';
 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';
@@ -31,7 +31,7 @@ import { WorkspaceRelation } from 'src/engine/twenty-orm/decorators/workspace-re
   description: 'A company',
   icon: 'IconBuildingSkyscraper',
 })
-export class CompanyObjectMetadata extends BaseWorkspaceEntity {
+export class CompanyWorkspaceEntity extends BaseWorkspaceEntity {
   @WorkspaceField({
     standardId: COMPANY_STANDARD_FIELD_IDS.name,
     type: FieldMetadataType.TEXT,
@@ -130,11 +130,11 @@ export class CompanyObjectMetadata extends BaseWorkspaceEntity {
     label: 'People',
     description: 'People linked to the company.',
     icon: 'IconUsers',
-    inverseSideTarget: () => PersonObjectMetadata,
+    inverseSideTarget: () => PersonWorkspaceEntity,
     onDelete: RelationOnDeleteAction.SET_NULL,
   })
   @WorkspaceIsNullable()
-  people: Relation<PersonObjectMetadata[]>;
+  people: Relation<PersonWorkspaceEntity[]>;
 
   @WorkspaceRelation({
     standardId: COMPANY_STANDARD_FIELD_IDS.accountOwner,
@@ -144,12 +144,12 @@ export class CompanyObjectMetadata extends BaseWorkspaceEntity {
       'Your team member responsible for managing the company account',
     icon: 'IconUserCircle',
     joinColumn: 'accountOwnerId',
-    inverseSideTarget: () => WorkspaceMemberObjectMetadata,
+    inverseSideTarget: () => WorkspaceMemberWorkspaceEntity,
     inverseSideFieldKey: 'accountOwnerForCompanies',
     onDelete: RelationOnDeleteAction.SET_NULL,
   })
   @WorkspaceIsNullable()
-  accountOwner: Relation<WorkspaceMemberObjectMetadata>;
+  accountOwner: Relation<WorkspaceMemberWorkspaceEntity>;
 
   @WorkspaceRelation({
     standardId: COMPANY_STANDARD_FIELD_IDS.activityTargets,
@@ -157,11 +157,11 @@ export class CompanyObjectMetadata extends BaseWorkspaceEntity {
     label: 'Activities',
     description: 'Activities tied to the company',
     icon: 'IconCheckbox',
-    inverseSideTarget: () => ActivityTargetObjectMetadata,
+    inverseSideTarget: () => ActivityTargetWorkspaceEntity,
     onDelete: RelationOnDeleteAction.CASCADE,
   })
   @WorkspaceIsNullable()
-  activityTargets: Relation<ActivityTargetObjectMetadata[]>;
+  activityTargets: Relation<ActivityTargetWorkspaceEntity[]>;
 
   @WorkspaceRelation({
     standardId: COMPANY_STANDARD_FIELD_IDS.opportunities,
@@ -169,11 +169,11 @@ export class CompanyObjectMetadata extends BaseWorkspaceEntity {
     label: 'Opportunities',
     description: 'Opportunities linked to the company.',
     icon: 'IconTargetArrow',
-    inverseSideTarget: () => OpportunityObjectMetadata,
+    inverseSideTarget: () => OpportunityWorkspaceEntity,
     onDelete: RelationOnDeleteAction.SET_NULL,
   })
   @WorkspaceIsNullable()
-  opportunities: Relation<OpportunityObjectMetadata[]>;
+  opportunities: Relation<OpportunityWorkspaceEntity[]>;
 
   @WorkspaceRelation({
     standardId: COMPANY_STANDARD_FIELD_IDS.favorites,
@@ -181,12 +181,12 @@ export class CompanyObjectMetadata extends BaseWorkspaceEntity {
     label: 'Favorites',
     description: 'Favorites linked to the company',
     icon: 'IconHeart',
-    inverseSideTarget: () => FavoriteObjectMetadata,
+    inverseSideTarget: () => FavoriteWorkspaceEntity,
     onDelete: RelationOnDeleteAction.CASCADE,
   })
   @WorkspaceIsNullable()
   @WorkspaceIsSystem()
-  favorites: Relation<FavoriteObjectMetadata[]>;
+  favorites: Relation<FavoriteWorkspaceEntity[]>;
 
   @WorkspaceRelation({
     standardId: COMPANY_STANDARD_FIELD_IDS.attachments,
@@ -194,11 +194,11 @@ export class CompanyObjectMetadata extends BaseWorkspaceEntity {
     label: 'Attachments',
     description: 'Attachments linked to the company',
     icon: 'IconFileImport',
-    inverseSideTarget: () => AttachmentObjectMetadata,
+    inverseSideTarget: () => AttachmentWorkspaceEntity,
     onDelete: RelationOnDeleteAction.CASCADE,
   })
   @WorkspaceIsNullable()
-  attachments: Relation<AttachmentObjectMetadata[]>;
+  attachments: Relation<AttachmentWorkspaceEntity[]>;
 
   @WorkspaceRelation({
     standardId: COMPANY_STANDARD_FIELD_IDS.timelineActivities,
@@ -206,10 +206,10 @@ export class CompanyObjectMetadata extends BaseWorkspaceEntity {
     label: 'Timeline Activities',
     description: 'Timeline Activities linked to the company',
     icon: 'IconIconTimelineEvent',
-    inverseSideTarget: () => TimelineActivityObjectMetadata,
+    inverseSideTarget: () => TimelineActivityWorkspaceEntity,
     onDelete: RelationOnDeleteAction.CASCADE,
   })
   @WorkspaceIsNullable()
   @WorkspaceIsSystem()
-  timelineActivities: Relation<TimelineActivityObjectMetadata[]>;
+  timelineActivities: Relation<TimelineActivityWorkspaceEntity[]>;
 }

packages/twenty-server/src/modules/connected-account/auto-companies-and-contacts-creation/auto-companies-and-contacts-creation.module.ts

@@ -5,11 +5,11 @@ import { CreateCompanyAndContactService } from 'src/modules/connected-account/au
 import { CreateCompanyModule } from 'src/modules/connected-account/auto-companies-and-contacts-creation/create-company/create-company.module';
 import { CreateContactModule } from 'src/modules/connected-account/auto-companies-and-contacts-creation/create-contact/create-contact.module';
 import { ObjectMetadataRepositoryModule } from 'src/engine/object-metadata-repository/object-metadata-repository.module';
-import { PersonObjectMetadata } from 'src/modules/person/standard-objects/person.object-metadata';
+import { PersonWorkspaceEntity } from 'src/modules/person/standard-objects/person.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 { MessageParticipantModule } from 'src/modules/messaging/services/message-participant/message-participant.module';
 import { WorkspaceDataSourceModule } from 'src/engine/workspace-datasource/workspace-datasource.module';
-import { CalendarEventParticipantObjectMetadata } from 'src/modules/calendar/standard-objects/calendar-event-participant.object-metadata';
+import { CalendarEventParticipantWorkspaceEntity } from 'src/modules/calendar/standard-objects/calendar-event-participant.workspace-entity';
 import { CalendarEventParticipantModule } from 'src/modules/calendar/services/calendar-event-participant/calendar-event-participant.module';
 import { FeatureFlagEntity } from 'src/engine/core-modules/feature-flag/feature-flag.entity';
 
@@ -18,9 +18,9 @@ import { FeatureFlagEntity } from 'src/engine/core-modules/feature-flag/feature-
     CreateContactModule,
     CreateCompanyModule,
     ObjectMetadataRepositoryModule.forFeature([
-      PersonObjectMetadata,
+      PersonWorkspaceEntity,
-      WorkspaceMemberObjectMetadata,
+      WorkspaceMemberWorkspaceEntity,
-      CalendarEventParticipantObjectMetadata,
+      CalendarEventParticipantWorkspaceEntity,
     ]),
     MessageParticipantModule,
     WorkspaceDataSourceModule,

packages/twenty-server/src/modules/connected-account/auto-companies-and-contacts-creation/create-company/create-company.module.ts

@@ -1,11 +1,13 @@
 import { Module } from '@nestjs/common';
 
 import { ObjectMetadataRepositoryModule } from 'src/engine/object-metadata-repository/object-metadata-repository.module';
-import { CompanyObjectMetadata } from 'src/modules/company/standard-objects/company.object-metadata';
+import { CompanyWorkspaceEntity } from 'src/modules/company/standard-objects/company.workspace-entity';
 import { CreateCompanyService } from 'src/modules/connected-account/auto-companies-and-contacts-creation/create-company/create-company.service';
 
 @Module({
-  imports: [ObjectMetadataRepositoryModule.forFeature([CompanyObjectMetadata])],
+  imports: [
+    ObjectMetadataRepositoryModule.forFeature([CompanyWorkspaceEntity]),
+  ],
   providers: [CreateCompanyService],
   exports: [CreateCompanyService],
 })

packages/twenty-server/src/modules/connected-account/auto-companies-and-contacts-creation/create-company/create-company.service.ts

@@ -7,13 +7,13 @@ import axios, { AxiosInstance } from 'axios';
 import { CompanyRepository } from 'src/modules/company/repositories/company.repository';
 import { getCompanyNameFromDomainName } from 'src/modules/calendar-messaging-participant/utils/get-company-name-from-domain-name.util';
 import { InjectObjectMetadataRepository } from 'src/engine/object-metadata-repository/object-metadata-repository.decorator';
-import { CompanyObjectMetadata } from 'src/modules/company/standard-objects/company.object-metadata';
+import { CompanyWorkspaceEntity } from 'src/modules/company/standard-objects/company.workspace-entity';
 @Injectable()
 export class CreateCompanyService {
   private readonly httpService: AxiosInstance;
 
   constructor(
-    @InjectObjectMetadataRepository(CompanyObjectMetadata)
+    @InjectObjectMetadataRepository(CompanyWorkspaceEntity)
     private readonly companyRepository: CompanyRepository,
   ) {
     this.httpService = axios.create({

packages/twenty-server/src/modules/connected-account/auto-companies-and-contacts-creation/create-contact/create-contact.module.ts

@@ -2,10 +2,10 @@ import { Module } from '@nestjs/common';
 
 import { ObjectMetadataRepositoryModule } from 'src/engine/object-metadata-repository/object-metadata-repository.module';
 import { CreateContactService } from 'src/modules/connected-account/auto-companies-and-contacts-creation/create-contact/create-contact.service';
-import { PersonObjectMetadata } from 'src/modules/person/standard-objects/person.object-metadata';
+import { PersonWorkspaceEntity } from 'src/modules/person/standard-objects/person.workspace-entity';
 
 @Module({
-  imports: [ObjectMetadataRepositoryModule.forFeature([PersonObjectMetadata])],
+  imports: [ObjectMetadataRepositoryModule.forFeature([PersonWorkspaceEntity])],
   providers: [CreateContactService],
   exports: [CreateContactService],
 })

packages/twenty-server/src/modules/connected-account/auto-companies-and-contacts-creation/create-contact/create-contact.service.ts

@@ -6,7 +6,7 @@ import { v4 } from 'uuid';
 import { PersonRepository } from 'src/modules/person/repositories/person.repository';
 import { getFirstNameAndLastNameFromHandleAndDisplayName } from 'src/modules/calendar-messaging-participant/utils/get-first-name-and-last-name-from-handle-and-display-name.util';
 import { InjectObjectMetadataRepository } from 'src/engine/object-metadata-repository/object-metadata-repository.decorator';
-import { PersonObjectMetadata } from 'src/modules/person/standard-objects/person.object-metadata';
+import { PersonWorkspaceEntity } from 'src/modules/person/standard-objects/person.workspace-entity';
 import { ObjectRecord } from 'src/engine/workspace-manager/workspace-sync-metadata/types/object-record';
 
 type ContactToCreate = {
@@ -26,7 +26,7 @@ type FormattedContactToCreate = {
 @Injectable()
 export class CreateContactService {
   constructor(
-    @InjectObjectMetadataRepository(PersonObjectMetadata)
+    @InjectObjectMetadataRepository(PersonWorkspaceEntity)
     private readonly personRepository: PersonRepository,
   ) {}
 
@@ -55,7 +55,7 @@ export class CreateContactService {
     contactsToCreate: ContactToCreate[],
     workspaceId: string,
     transactionManager?: EntityManager,
-  ): Promise<ObjectRecord<PersonObjectMetadata>[]> {
+  ): Promise<ObjectRecord<PersonWorkspaceEntity>[]> {
     if (contactsToCreate.length === 0) return [];
 
     const formattedContacts = this.formatContacts(contactsToCreate);

packages/twenty-server/src/modules/connected-account/auto-companies-and-contacts-creation/services/create-company-and-contact.service.ts

@@ -11,8 +11,8 @@ import { PersonRepository } from 'src/modules/person/repositories/person.reposit
 import { WorkspaceMemberRepository } from 'src/modules/workspace-member/repositories/workspace-member.repository';
 import { isWorkEmail } from 'src/utils/is-work-email';
 import { InjectObjectMetadataRepository } from 'src/engine/object-metadata-repository/object-metadata-repository.decorator';
-import { PersonObjectMetadata } from 'src/modules/person/standard-objects/person.object-metadata';
+import { PersonWorkspaceEntity } from 'src/modules/person/standard-objects/person.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 { getUniqueContactsAndHandles } from 'src/modules/connected-account/auto-companies-and-contacts-creation/utils/get-unique-contacts-and-handles.util';
 import { Contacts } from 'src/modules/connected-account/auto-companies-and-contacts-creation/types/contact.type';
 import { WorkspaceDataSourceService } from 'src/engine/workspace-datasource/workspace-datasource.service';
@@ -27,9 +27,9 @@ export class CreateCompanyAndContactService {
   constructor(
     private readonly createContactService: CreateContactService,
     private readonly createCompaniesService: CreateCompanyService,
-    @InjectObjectMetadataRepository(PersonObjectMetadata)
+    @InjectObjectMetadataRepository(PersonWorkspaceEntity)
     private readonly personRepository: PersonRepository,
-    @InjectObjectMetadataRepository(WorkspaceMemberObjectMetadata)
+    @InjectObjectMetadataRepository(WorkspaceMemberWorkspaceEntity)
     private readonly workspaceMemberRepository: WorkspaceMemberRepository,
     private readonly workspaceDataSourceService: WorkspaceDataSourceService,
     private readonly messageParticipantService: MessageParticipantService,
@@ -43,7 +43,7 @@ export class CreateCompanyAndContactService {
     contactsToCreate: Contacts,
     workspaceId: string,
     transactionManager?: EntityManager,
-  ): Promise<ObjectRecord<PersonObjectMetadata>[]> {
+  ): Promise<ObjectRecord<PersonWorkspaceEntity>[]> {
     if (!contactsToCreate || contactsToCreate.length === 0) {
       return [];
     }

packages/twenty-server/src/modules/connected-account/auto-companies-and-contacts-creation/utils/filter-out-contacts-from-company-or-workspace.util.ts

@@ -1,12 +1,12 @@
 import { getDomainNameFromHandle } from 'src/modules/calendar-messaging-participant/utils/get-domain-name-from-handle.util';
-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 { ObjectRecord } from 'src/engine/workspace-manager/workspace-sync-metadata/types/object-record';
 import { Contacts } from 'src/modules/connected-account/auto-companies-and-contacts-creation/types/contact.type';
 
 export function filterOutContactsFromCompanyOrWorkspace(
   contacts: Contacts,
   selfHandle: string,
-  workspaceMembers: ObjectRecord<WorkspaceMemberObjectMetadata>[],
+  workspaceMembers: ObjectRecord<WorkspaceMemberWorkspaceEntity>[],
 ): Contacts {
   const selfDomainName = getDomainNameFromHandle(selfHandle);
 

packages/twenty-server/src/modules/connected-account/repositories/blocklist.repository.ts

@@ -4,7 +4,7 @@ import { EntityManager } from 'typeorm';
 
 import { WorkspaceDataSourceService } from 'src/engine/workspace-datasource/workspace-datasource.service';
 import { ObjectRecord } from 'src/engine/workspace-manager/workspace-sync-metadata/types/object-record';
-import { BlocklistObjectMetadata } from 'src/modules/connected-account/standard-objects/blocklist.object-metadata';
+import { BlocklistWorkspaceEntity } from 'src/modules/connected-account/standard-objects/blocklist.workspace-entity';
 
 @Injectable()
 export class BlocklistRepository {
@@ -16,7 +16,7 @@ export class BlocklistRepository {
     id: string,
     workspaceId: string,
     transactionManager?: EntityManager,
-  ): Promise<ObjectRecord<BlocklistObjectMetadata> | null> {
+  ): Promise<ObjectRecord<BlocklistWorkspaceEntity> | null> {
     const dataSourceSchema =
       this.workspaceDataSourceService.getSchemaName(workspaceId);
 
@@ -39,7 +39,7 @@ export class BlocklistRepository {
     workspaceMemberId: string,
     workspaceId: string,
     transactionManager?: EntityManager,
-  ): Promise<ObjectRecord<BlocklistObjectMetadata>[]> {
+  ): Promise<ObjectRecord<BlocklistWorkspaceEntity>[]> {
     const dataSourceSchema =
       this.workspaceDataSourceService.getSchemaName(workspaceId);
 
@@ -56,7 +56,7 @@ export class BlocklistRepository {
     handle: string,
     workspaceId: string,
     transactionManager?: EntityManager,
-  ): Promise<ObjectRecord<BlocklistObjectMetadata>[]> {
+  ): Promise<ObjectRecord<BlocklistWorkspaceEntity>[]> {
     const dataSourceSchema =
       this.workspaceDataSourceService.getSchemaName(workspaceId);
 

packages/twenty-server/src/modules/connected-account/repositories/connected-account.repository.ts

@@ -3,7 +3,7 @@ import { Injectable, NotFoundException } from '@nestjs/common';
 import { EntityManager } from 'typeorm';
 
 import { WorkspaceDataSourceService } from 'src/engine/workspace-datasource/workspace-datasource.service';
-import { ConnectedAccountObjectMetadata } from 'src/modules/connected-account/standard-objects/connected-account.object-metadata';
+import { ConnectedAccountWorkspaceEntity } from 'src/modules/connected-account/standard-objects/connected-account.workspace-entity';
 import { ObjectRecord } from 'src/engine/workspace-manager/workspace-sync-metadata/types/object-record';
 
 @Injectable()
@@ -15,7 +15,7 @@ export class ConnectedAccountRepository {
   public async getAll(
     workspaceId: string,
     transactionManager?: EntityManager,
-  ): Promise<ObjectRecord<ConnectedAccountObjectMetadata>[]> {
+  ): Promise<ObjectRecord<ConnectedAccountWorkspaceEntity>[]> {
     const dataSourceSchema =
       this.workspaceDataSourceService.getSchemaName(workspaceId);
 
@@ -31,7 +31,7 @@ export class ConnectedAccountRepository {
     connectedAccountIds: string[],
     workspaceId: string,
     transactionManager?: EntityManager,
-  ): Promise<ObjectRecord<ConnectedAccountObjectMetadata>[]> {
+  ): Promise<ObjectRecord<ConnectedAccountWorkspaceEntity>[]> {
     const dataSourceSchema =
       this.workspaceDataSourceService.getSchemaName(workspaceId);
 
@@ -47,7 +47,7 @@ export class ConnectedAccountRepository {
     workspaceMemberId: string,
     workspaceId: string,
     transactionManager?: EntityManager,
-  ): Promise<ObjectRecord<ConnectedAccountObjectMetadata>[] | undefined> {
+  ): Promise<ObjectRecord<ConnectedAccountWorkspaceEntity>[] | undefined> {
     const dataSourceSchema =
       this.workspaceDataSourceService.getSchemaName(workspaceId);
 
@@ -67,7 +67,7 @@ export class ConnectedAccountRepository {
     workspaceMemberId: string,
     workspaceId: string,
     transactionManager?: EntityManager,
-  ): Promise<ObjectRecord<ConnectedAccountObjectMetadata>[] | undefined> {
+  ): Promise<ObjectRecord<ConnectedAccountWorkspaceEntity>[] | undefined> {
     const dataSourceSchema =
       this.workspaceDataSourceService.getSchemaName(workspaceId);
 
@@ -84,7 +84,7 @@ export class ConnectedAccountRepository {
 
   public async create(
     connectedAccount: Pick<
-      ObjectRecord<ConnectedAccountObjectMetadata>,
+      ObjectRecord<ConnectedAccountWorkspaceEntity>,
       | 'id'
       | 'handle'
       | 'provider'
@@ -94,7 +94,7 @@ export class ConnectedAccountRepository {
     >,
     workspaceId: string,
     transactionManager?: EntityManager,
-  ): Promise<ObjectRecord<ConnectedAccountObjectMetadata>> {
+  ): Promise<ObjectRecord<ConnectedAccountWorkspaceEntity>> {
     const dataSourceSchema =
       this.workspaceDataSourceService.getSchemaName(workspaceId);
 
@@ -135,7 +135,7 @@ export class ConnectedAccountRepository {
     connectedAccountId: string,
     workspaceId: string,
     transactionManager?: EntityManager,
-  ): Promise<ObjectRecord<ConnectedAccountObjectMetadata> | undefined> {
+  ): Promise<ObjectRecord<ConnectedAccountWorkspaceEntity> | undefined> {
     const dataSourceSchema =
       this.workspaceDataSourceService.getSchemaName(workspaceId);
 
@@ -154,7 +154,7 @@ export class ConnectedAccountRepository {
     connectedAccountId: string,
     workspaceId: string,
     transactionManager?: EntityManager,
-  ): Promise<ObjectRecord<ConnectedAccountObjectMetadata>> {
+  ): Promise<ObjectRecord<ConnectedAccountWorkspaceEntity>> {
     const connectedAccount = await this.getById(
       connectedAccountId,
       workspaceId,

packages/twenty-server/src/modules/connected-account/services/blocklist/blocklist-validation.module.ts

@@ -2,14 +2,14 @@ import { Module } from '@nestjs/common';
 
 import { ObjectMetadataRepositoryModule } from 'src/engine/object-metadata-repository/object-metadata-repository.module';
 import { BlocklistValidationService } from 'src/modules/connected-account/services/blocklist/blocklist-validation.service';
-import { BlocklistObjectMetadata } from 'src/modules/connected-account/standard-objects/blocklist.object-metadata';
+import { BlocklistWorkspaceEntity } from 'src/modules/connected-account/standard-objects/blocklist.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';
 
 @Module({
   imports: [
     ObjectMetadataRepositoryModule.forFeature([
-      BlocklistObjectMetadata,
+      BlocklistWorkspaceEntity,
-      WorkspaceMemberObjectMetadata,
+      WorkspaceMemberWorkspaceEntity,
     ]),
   ],
   providers: [BlocklistValidationService],

packages/twenty-server/src/modules/connected-account/services/blocklist/blocklist-validation.service.ts

@@ -10,12 +10,12 @@ import {
 import { InjectObjectMetadataRepository } from 'src/engine/object-metadata-repository/object-metadata-repository.decorator';
 import { isDomain } from 'src/engine/utils/is-domain';
 import { BlocklistRepository } from 'src/modules/connected-account/repositories/blocklist.repository';
-import { BlocklistObjectMetadata } from 'src/modules/connected-account/standard-objects/blocklist.object-metadata';
+import { BlocklistWorkspaceEntity } from 'src/modules/connected-account/standard-objects/blocklist.workspace-entity';
 import { WorkspaceMemberRepository } from 'src/modules/workspace-member/repositories/workspace-member.repository';
-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';
 
 export type BlocklistItem = Omit<
-  BlocklistObjectMetadata,
+  BlocklistWorkspaceEntity,
   'createdAt' | 'updatedAt' | 'workspaceMember'
 > & {
   createdAt: string;
@@ -26,9 +26,9 @@ export type BlocklistItem = Omit<
 @Injectable()
 export class BlocklistValidationService {
   constructor(
-    @InjectObjectMetadataRepository(BlocklistObjectMetadata)
+    @InjectObjectMetadataRepository(BlocklistWorkspaceEntity)
     private readonly blocklistRepository: BlocklistRepository,
-    @InjectObjectMetadataRepository(WorkspaceMemberObjectMetadata)
+    @InjectObjectMetadataRepository(WorkspaceMemberWorkspaceEntity)
     private readonly workspaceMemberRepository: WorkspaceMemberRepository,
   ) {}
 

packages/twenty-server/src/modules/connected-account/services/google-api-refresh-access-token/google-api-refresh-access-token.module.ts

@@ -2,11 +2,13 @@ import { Module } from '@nestjs/common';
 
 import { ObjectMetadataRepositoryModule } from 'src/engine/object-metadata-repository/object-metadata-repository.module';
 import { GoogleAPIRefreshAccessTokenService } from 'src/modules/connected-account/services/google-api-refresh-access-token/google-api-refresh-access-token.service';
-import { ConnectedAccountObjectMetadata } from 'src/modules/connected-account/standard-objects/connected-account.object-metadata';
+import { ConnectedAccountWorkspaceEntity } from 'src/modules/connected-account/standard-objects/connected-account.workspace-entity';
 
 @Module({
   imports: [
-    ObjectMetadataRepositoryModule.forFeature([ConnectedAccountObjectMetadata]),
+    ObjectMetadataRepositoryModule.forFeature([
+      ConnectedAccountWorkspaceEntity,
+    ]),
   ],
   providers: [GoogleAPIRefreshAccessTokenService],
   exports: [GoogleAPIRefreshAccessTokenService],

packages/twenty-server/src/modules/connected-account/services/google-api-refresh-access-token/google-api-refresh-access-token.service.ts

@@ -5,13 +5,13 @@ import axios from 'axios';
 import { EnvironmentService } from 'src/engine/integrations/environment/environment.service';
 import { InjectObjectMetadataRepository } from 'src/engine/object-metadata-repository/object-metadata-repository.decorator';
 import { ConnectedAccountRepository } from 'src/modules/connected-account/repositories/connected-account.repository';
-import { ConnectedAccountObjectMetadata } from 'src/modules/connected-account/standard-objects/connected-account.object-metadata';
+import { ConnectedAccountWorkspaceEntity } from 'src/modules/connected-account/standard-objects/connected-account.workspace-entity';
 
 @Injectable()
 export class GoogleAPIRefreshAccessTokenService {
   constructor(
     private readonly environmentService: EnvironmentService,
-    @InjectObjectMetadataRepository(ConnectedAccountObjectMetadata)
+    @InjectObjectMetadataRepository(ConnectedAccountWorkspaceEntity)
     private readonly connectedAccountRepository: ConnectedAccountRepository,
   ) {}
 

packages/twenty-server/src/modules/connected-account/standard-objects/blocklist.workspace-entity.ts

@@ -3,9 +3,9 @@ import { Relation } from 'src/engine/workspace-manager/workspace-sync-metadata/i
 import { FieldMetadataType } from 'src/engine/metadata-modules/field-metadata/field-metadata.entity';
 import { BLOCKLIST_STANDARD_FIELD_IDS } from 'src/engine/workspace-manager/workspace-sync-metadata/constants/standard-field-ids';
 import { STANDARD_OBJECT_IDS } from 'src/engine/workspace-manager/workspace-sync-metadata/constants/standard-object-ids';
-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 { BaseWorkspaceEntity } from 'src/engine/twenty-orm/base.workspace-entity';
-import { WorkspaceEntity } from 'src/engine/twenty-orm/decorators/workspace-object.decorator';
+import { WorkspaceEntity } from 'src/engine/twenty-orm/decorators/workspace-entity.decorator';
 import { WorkspaceIsSystem } from 'src/engine/twenty-orm/decorators/workspace-is-system.decorator';
 import { WorkspaceIsNotAuditLogged } from 'src/engine/twenty-orm/decorators/workspace-is-not-audit-logged.decorator';
 import { WorkspaceField } from 'src/engine/twenty-orm/decorators/workspace-field.decorator';
@@ -22,7 +22,7 @@ import { RelationMetadataType } from 'src/engine/metadata-modules/relation-metad
 })
 @WorkspaceIsSystem()
 @WorkspaceIsNotAuditLogged()
-export class BlocklistObjectMetadata extends BaseWorkspaceEntity {
+export class BlocklistWorkspaceEntity extends BaseWorkspaceEntity {
   @WorkspaceField({
     standardId: BLOCKLIST_STANDARD_FIELD_IDS.handle,
     type: FieldMetadataType.TEXT,
@@ -39,8 +39,8 @@ export class BlocklistObjectMetadata extends BaseWorkspaceEntity {
     description: 'WorkspaceMember',
     icon: 'IconCircleUser',
     joinColumn: 'workspaceMemberId',
-    inverseSideTarget: () => WorkspaceMemberObjectMetadata,
+    inverseSideTarget: () => WorkspaceMemberWorkspaceEntity,
     inverseSideFieldKey: 'blocklist',
   })
-  workspaceMember: Relation<WorkspaceMemberObjectMetadata>;
+  workspaceMember: Relation<WorkspaceMemberWorkspaceEntity>;
 }

packages/twenty-server/src/modules/connected-account/standard-objects/connected-account.workspace-entity.ts

@@ -7,11 +7,11 @@ import {
 } from 'src/engine/metadata-modules/relation-metadata/relation-metadata.entity';
 import { CONNECTED_ACCOUNT_STANDARD_FIELD_IDS } from 'src/engine/workspace-manager/workspace-sync-metadata/constants/standard-field-ids';
 import { STANDARD_OBJECT_IDS } from 'src/engine/workspace-manager/workspace-sync-metadata/constants/standard-object-ids';
-import { CalendarChannelObjectMetadata } from 'src/modules/calendar/standard-objects/calendar-channel.object-metadata';
+import { CalendarChannelWorkspaceEntity } from 'src/modules/calendar/standard-objects/calendar-channel.workspace-entity';
-import { MessageChannelObjectMetadata } from 'src/modules/messaging/standard-objects/message-channel.object-metadata';
+import { MessageChannelWorkspaceEntity } from 'src/modules/messaging/standard-objects/message-channel.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 { BaseWorkspaceEntity } from 'src/engine/twenty-orm/base.workspace-entity';
-import { WorkspaceEntity } from 'src/engine/twenty-orm/decorators/workspace-object.decorator';
+import { WorkspaceEntity } from 'src/engine/twenty-orm/decorators/workspace-entity.decorator';
 import { WorkspaceIsSystem } from 'src/engine/twenty-orm/decorators/workspace-is-system.decorator';
 import { WorkspaceIsNotAuditLogged } from 'src/engine/twenty-orm/decorators/workspace-is-not-audit-logged.decorator';
 import { WorkspaceField } from 'src/engine/twenty-orm/decorators/workspace-field.decorator';
@@ -32,7 +32,7 @@ export enum ConnectedAccountProvider {
 })
 @WorkspaceIsSystem()
 @WorkspaceIsNotAuditLogged()
-export class ConnectedAccountObjectMetadata extends BaseWorkspaceEntity {
+export class ConnectedAccountWorkspaceEntity extends BaseWorkspaceEntity {
   @WorkspaceField({
     standardId: CONNECTED_ACCOUNT_STANDARD_FIELD_IDS.handle,
     type: FieldMetadataType.TEXT,
@@ -95,10 +95,10 @@ export class ConnectedAccountObjectMetadata extends BaseWorkspaceEntity {
     description: 'Account Owner',
     icon: 'IconUserCircle',
     joinColumn: 'accountOwnerId',
-    inverseSideTarget: () => WorkspaceMemberObjectMetadata,
+    inverseSideTarget: () => WorkspaceMemberWorkspaceEntity,
     inverseSideFieldKey: 'connectedAccounts',
   })
-  accountOwner: Relation<WorkspaceMemberObjectMetadata>;
+  accountOwner: Relation<WorkspaceMemberWorkspaceEntity>;
 
   @WorkspaceRelation({
     standardId: CONNECTED_ACCOUNT_STANDARD_FIELD_IDS.messageChannels,
@@ -106,10 +106,10 @@ export class ConnectedAccountObjectMetadata extends BaseWorkspaceEntity {
     label: 'Message Channels',
     description: 'Message Channels',
     icon: 'IconMessage',
-    inverseSideTarget: () => MessageChannelObjectMetadata,
+    inverseSideTarget: () => MessageChannelWorkspaceEntity,
     onDelete: RelationOnDeleteAction.CASCADE,
   })
-  messageChannels: Relation<MessageChannelObjectMetadata[]>;
+  messageChannels: Relation<MessageChannelWorkspaceEntity[]>;
 
   @WorkspaceRelation({
     standardId: CONNECTED_ACCOUNT_STANDARD_FIELD_IDS.calendarChannels,
@@ -117,8 +117,8 @@ export class ConnectedAccountObjectMetadata extends BaseWorkspaceEntity {
     label: 'Calendar Channels',
     description: 'Calendar Channels',
     icon: 'IconCalendar',
-    inverseSideTarget: () => CalendarChannelObjectMetadata,
+    inverseSideTarget: () => CalendarChannelWorkspaceEntity,
     onDelete: RelationOnDeleteAction.CASCADE,
   })
-  calendarChannels: Relation<CalendarChannelObjectMetadata[]>;
+  calendarChannels: Relation<CalendarChannelWorkspaceEntity[]>;
 }

packages/twenty-server/src/modules/favorite/standard-objects/favorite.workspace-entity.ts

@@ -4,12 +4,12 @@ import { FieldMetadataType } from 'src/engine/metadata-modules/field-metadata/fi
 import { FAVORITE_STANDARD_FIELD_IDS } from 'src/engine/workspace-manager/workspace-sync-metadata/constants/standard-field-ids';
 import { STANDARD_OBJECT_IDS } from 'src/engine/workspace-manager/workspace-sync-metadata/constants/standard-object-ids';
 import { CustomWorkspaceEntity } from 'src/engine/twenty-orm/custom.workspace-entity';
-import { CompanyObjectMetadata } from 'src/modules/company/standard-objects/company.object-metadata';
+import { CompanyWorkspaceEntity } from 'src/modules/company/standard-objects/company.workspace-entity';
-import { OpportunityObjectMetadata } from 'src/modules/opportunity/standard-objects/opportunity.object-metadata';
+import { OpportunityWorkspaceEntity } from 'src/modules/opportunity/standard-objects/opportunity.workspace-entity';
-import { PersonObjectMetadata } from 'src/modules/person/standard-objects/person.object-metadata';
+import { PersonWorkspaceEntity } from 'src/modules/person/standard-objects/person.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 { BaseWorkspaceEntity } from 'src/engine/twenty-orm/base.workspace-entity';
-import { WorkspaceEntity } from 'src/engine/twenty-orm/decorators/workspace-object.decorator';
+import { WorkspaceEntity } from 'src/engine/twenty-orm/decorators/workspace-entity.decorator';
 import { WorkspaceIsNotAuditLogged } from 'src/engine/twenty-orm/decorators/workspace-is-not-audit-logged.decorator';
 import { WorkspaceIsSystem } from 'src/engine/twenty-orm/decorators/workspace-is-system.decorator';
 import { WorkspaceField } from 'src/engine/twenty-orm/decorators/workspace-field.decorator';
@@ -28,7 +28,7 @@ import { WorkspaceDynamicRelation } from 'src/engine/twenty-orm/decorators/works
 })
 @WorkspaceIsNotAuditLogged()
 @WorkspaceIsSystem()
-export class FavoriteObjectMetadata extends BaseWorkspaceEntity {
+export class FavoriteWorkspaceEntity extends BaseWorkspaceEntity {
   @WorkspaceField({
     standardId: FAVORITE_STANDARD_FIELD_IDS.position,
     type: FieldMetadataType.NUMBER,
@@ -48,9 +48,9 @@ export class FavoriteObjectMetadata extends BaseWorkspaceEntity {
     icon: 'IconCircleUser',
     joinColumn: 'workspaceMemberId',
     inverseSideFieldKey: 'favorites',
-    inverseSideTarget: () => WorkspaceMemberObjectMetadata,
+    inverseSideTarget: () => WorkspaceMemberWorkspaceEntity,
   })
-  workspaceMember: Relation<WorkspaceMemberObjectMetadata>;
+  workspaceMember: Relation<WorkspaceMemberWorkspaceEntity>;
 
   @WorkspaceRelation({
     standardId: FAVORITE_STANDARD_FIELD_IDS.person,
@@ -59,11 +59,11 @@ export class FavoriteObjectMetadata extends BaseWorkspaceEntity {
     description: 'Favorite person',
     icon: 'IconUser',
     joinColumn: 'personId',
-    inverseSideTarget: () => PersonObjectMetadata,
+    inverseSideTarget: () => PersonWorkspaceEntity,
     inverseSideFieldKey: 'favorites',
   })
   @WorkspaceIsNullable()
-  person: Relation<PersonObjectMetadata>;
+  person: Relation<PersonWorkspaceEntity>;
 
   @WorkspaceRelation({
     standardId: FAVORITE_STANDARD_FIELD_IDS.company,
@@ -72,11 +72,11 @@ export class FavoriteObjectMetadata extends BaseWorkspaceEntity {
     description: 'Favorite company',
     icon: 'IconBuildingSkyscraper',
     joinColumn: 'companyId',
-    inverseSideTarget: () => CompanyObjectMetadata,
+    inverseSideTarget: () => CompanyWorkspaceEntity,
     inverseSideFieldKey: 'favorites',
   })
   @WorkspaceIsNullable()
-  company: Relation<CompanyObjectMetadata>;
+  company: Relation<CompanyWorkspaceEntity>;
 
   @WorkspaceRelation({
     standardId: FAVORITE_STANDARD_FIELD_IDS.opportunity,
@@ -85,11 +85,11 @@ export class FavoriteObjectMetadata extends BaseWorkspaceEntity {
     description: 'Favorite opportunity',
     icon: 'IconTargetArrow',
     joinColumn: 'opportunityId',
-    inverseSideTarget: () => OpportunityObjectMetadata,
+    inverseSideTarget: () => OpportunityWorkspaceEntity,
     inverseSideFieldKey: 'favorites',
   })
   @WorkspaceIsNullable()
-  opportunity: Relation<OpportunityObjectMetadata>;
+  opportunity: Relation<OpportunityWorkspaceEntity>;
 
   @WorkspaceDynamicRelation({
     type: RelationMetadataType.MANY_TO_ONE,

packages/twenty-server/src/modules/messaging/crons/commands/messaging-cron-commands.module.ts

@@ -1,12 +1,14 @@
 import { Module } from '@nestjs/common';
 
 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 { ConnectedAccountWorkspaceEntity } from 'src/modules/connected-account/standard-objects/connected-account.workspace-entity';
 import { GmailFetchMessagesFromCacheCronCommand } from 'src/modules/messaging/crons/commands/gmail-fetch-messages-from-cache.cron.command';
 import { GmailPartialSyncCronCommand } from 'src/modules/messaging/crons/commands/gmail-partial-sync.cron.command';
 @Module({
   imports: [
-    ObjectMetadataRepositoryModule.forFeature([ConnectedAccountObjectMetadata]),
+    ObjectMetadataRepositoryModule.forFeature([
+      ConnectedAccountWorkspaceEntity,
+    ]),
   ],
   providers: [
     GmailPartialSyncCronCommand,

packages/twenty-server/src/modules/messaging/crons/jobs/gmail-fetch-messages-from-cache.cron.job.ts

@@ -9,7 +9,7 @@ import { Workspace } from 'src/engine/core-modules/workspace/workspace.entity';
 import { DataSourceEntity } from 'src/engine/metadata-modules/data-source/data-source.entity';
 import { InjectObjectMetadataRepository } from 'src/engine/object-metadata-repository/object-metadata-repository.decorator';
 import { MessageChannelRepository } from 'src/modules/messaging/repositories/message-channel.repository';
-import { MessageChannelObjectMetadata } from 'src/modules/messaging/standard-objects/message-channel.object-metadata';
+import { MessageChannelWorkspaceEntity } from 'src/modules/messaging/standard-objects/message-channel.workspace-entity';
 import { GmailFetchMessageContentFromCacheService } from 'src/modules/messaging/services/gmail-fetch-message-content-from-cache/gmail-fetch-message-content-from-cache.service';
 import { EnvironmentService } from 'src/engine/integrations/environment/environment.service';
 
@@ -22,7 +22,7 @@ export class GmailFetchMessagesFromCacheCronJob
     private readonly workspaceRepository: Repository<Workspace>,
     @InjectRepository(DataSourceEntity, 'metadata')
     private readonly dataSourceRepository: Repository<DataSourceEntity>,
-    @InjectObjectMetadataRepository(MessageChannelObjectMetadata)
+    @InjectObjectMetadataRepository(MessageChannelWorkspaceEntity)
     private readonly messageChannelRepository: MessageChannelRepository,
     private readonly gmailFetchMessageContentFromCacheService: GmailFetchMessageContentFromCacheService,
     private readonly environmentService: EnvironmentService,

packages/twenty-server/src/modules/messaging/crons/jobs/gmail-partial-sync.cron.job.ts

@@ -15,7 +15,7 @@ import { MessageQueue } from 'src/engine/integrations/message-queue/message-queu
 import { MessageQueueService } from 'src/engine/integrations/message-queue/services/message-queue.service';
 import { InjectObjectMetadataRepository } from 'src/engine/object-metadata-repository/object-metadata-repository.decorator';
 import { MessageChannelRepository } from 'src/modules/messaging/repositories/message-channel.repository';
-import { MessageChannelObjectMetadata } from 'src/modules/messaging/standard-objects/message-channel.object-metadata';
+import { MessageChannelWorkspaceEntity } from 'src/modules/messaging/standard-objects/message-channel.workspace-entity';
 import { EnvironmentService } from 'src/engine/integrations/environment/environment.service';
 
 @Injectable()
@@ -29,7 +29,7 @@ export class GmailPartialSyncCronJob implements MessageQueueJob<undefined> {
     private readonly dataSourceRepository: Repository<DataSourceEntity>,
     @Inject(MessageQueue.messagingQueue)
     private readonly messageQueueService: MessageQueueService,
-    @InjectObjectMetadataRepository(MessageChannelObjectMetadata)
+    @InjectObjectMetadataRepository(MessageChannelWorkspaceEntity)
     private readonly messageChannelRepository: MessageChannelRepository,
     private readonly environmentService: EnvironmentService,
   ) {}

packages/twenty-server/src/modules/messaging/crons/jobs/messaging-cron-job.module.ts

@@ -8,13 +8,13 @@ import { ObjectMetadataRepositoryModule } from 'src/engine/object-metadata-repos
 import { GmailFetchMessagesFromCacheCronJob } from 'src/modules/messaging/crons/jobs/gmail-fetch-messages-from-cache.cron.job';
 import { GmailPartialSyncCronJob } from 'src/modules/messaging/crons/jobs/gmail-partial-sync.cron.job';
 import { GmailFetchMessageContentFromCacheModule } from 'src/modules/messaging/services/gmail-fetch-message-content-from-cache/gmail-fetch-message-content-from-cache.module';
-import { MessageChannelObjectMetadata } from 'src/modules/messaging/standard-objects/message-channel.object-metadata';
+import { MessageChannelWorkspaceEntity } from 'src/modules/messaging/standard-objects/message-channel.workspace-entity';
 
 @Module({
   imports: [
     TypeOrmModule.forFeature([Workspace, FeatureFlagEntity], 'core'),
     TypeOrmModule.forFeature([DataSourceEntity], 'metadata'),
-    ObjectMetadataRepositoryModule.forFeature([MessageChannelObjectMetadata]),
+    ObjectMetadataRepositoryModule.forFeature([MessageChannelWorkspaceEntity]),
     GmailFetchMessageContentFromCacheModule,
   ],
   providers: [

packages/twenty-server/src/modules/messaging/jobs/blocklist-item-delete-messages.job.ts

@@ -4,12 +4,12 @@ import { MessageQueueJob } from 'src/engine/integrations/message-queue/interface
 
 import { InjectObjectMetadataRepository } from 'src/engine/object-metadata-repository/object-metadata-repository.decorator';
 import { BlocklistRepository } from 'src/modules/connected-account/repositories/blocklist.repository';
-import { BlocklistObjectMetadata } from 'src/modules/connected-account/standard-objects/blocklist.object-metadata';
+import { BlocklistWorkspaceEntity } from 'src/modules/connected-account/standard-objects/blocklist.workspace-entity';
 import { MessageChannelMessageAssociationRepository } from 'src/modules/messaging/repositories/message-channel-message-association.repository';
 import { MessageChannelRepository } from 'src/modules/messaging/repositories/message-channel.repository';
 import { ThreadCleanerService } from 'src/modules/messaging/services/thread-cleaner/thread-cleaner.service';
-import { MessageChannelMessageAssociationObjectMetadata } from 'src/modules/messaging/standard-objects/message-channel-message-association.object-metadata';
+import { MessageChannelMessageAssociationWorkspaceEntity } from 'src/modules/messaging/standard-objects/message-channel-message-association.workspace-entity';
-import { MessageChannelObjectMetadata } from 'src/modules/messaging/standard-objects/message-channel.object-metadata';
+import { MessageChannelWorkspaceEntity } from 'src/modules/messaging/standard-objects/message-channel.workspace-entity';
 
 export type BlocklistItemDeleteMessagesJobData = {
   workspaceId: string;
@@ -23,13 +23,13 @@ export class BlocklistItemDeleteMessagesJob
   private readonly logger = new Logger(BlocklistItemDeleteMessagesJob.name);
 
   constructor(
-    @InjectObjectMetadataRepository(MessageChannelObjectMetadata)
+    @InjectObjectMetadataRepository(MessageChannelWorkspaceEntity)
     private readonly messageChannelRepository: MessageChannelRepository,
     @InjectObjectMetadataRepository(
-      MessageChannelMessageAssociationObjectMetadata,
+      MessageChannelMessageAssociationWorkspaceEntity,
     )
     private readonly messageChannelMessageAssociationRepository: MessageChannelMessageAssociationRepository,
-    @InjectObjectMetadataRepository(BlocklistObjectMetadata)
+    @InjectObjectMetadataRepository(BlocklistWorkspaceEntity)
     private readonly blocklistRepository: BlocklistRepository,
     private readonly threadCleanerService: ThreadCleanerService,
   ) {}

packages/twenty-server/src/modules/messaging/jobs/blocklist-reimport-messages.job.ts

@@ -4,7 +4,7 @@ import { MessageQueueJob } from 'src/engine/integrations/message-queue/interface
 
 import { InjectObjectMetadataRepository } from 'src/engine/object-metadata-repository/object-metadata-repository.decorator';
 import { ConnectedAccountRepository } from 'src/modules/connected-account/repositories/connected-account.repository';
-import { ConnectedAccountObjectMetadata } from 'src/modules/connected-account/standard-objects/connected-account.object-metadata';
+import { ConnectedAccountWorkspaceEntity } from 'src/modules/connected-account/standard-objects/connected-account.workspace-entity';
 import { GmailFullSyncService } from 'src/modules/messaging/services/gmail-full-sync/gmail-full-sync.service';
 
 export type BlocklistReimportMessagesJobData = {
@@ -20,7 +20,7 @@ export class BlocklistReimportMessagesJob
   private readonly logger = new Logger(BlocklistReimportMessagesJob.name);
 
   constructor(
-    @InjectObjectMetadataRepository(ConnectedAccountObjectMetadata)
+    @InjectObjectMetadataRepository(ConnectedAccountWorkspaceEntity)
     private readonly connectedAccountRepository: ConnectedAccountRepository,
     private readonly gmailFullSyncService: GmailFullSyncService,
   ) {}

packages/twenty-server/src/modules/messaging/jobs/messaging-create-company-and-contact-after-sync.job.ts

@@ -6,8 +6,8 @@ import { InjectObjectMetadataRepository } from 'src/engine/object-metadata-repos
 import { CreateCompanyAndContactService } from 'src/modules/connected-account/auto-companies-and-contacts-creation/services/create-company-and-contact.service';
 import { MessageChannelRepository } from 'src/modules/messaging/repositories/message-channel.repository';
 import { MessageParticipantRepository } from 'src/modules/messaging/repositories/message-participant.repository';
-import { MessageChannelObjectMetadata } from 'src/modules/messaging/standard-objects/message-channel.object-metadata';
+import { MessageChannelWorkspaceEntity } from 'src/modules/messaging/standard-objects/message-channel.workspace-entity';
-import { MessageParticipantObjectMetadata } from 'src/modules/messaging/standard-objects/message-participant.object-metadata';
+import { MessageParticipantWorkspaceEntity } from 'src/modules/messaging/standard-objects/message-participant.workspace-entity';
 
 export type MessagingCreateCompanyAndContactAfterSyncJobData = {
   workspaceId: string;
@@ -23,9 +23,9 @@ export class MessagingCreateCompanyAndContactAfterSyncJob
   );
   constructor(
     private readonly createCompanyAndContactService: CreateCompanyAndContactService,
-    @InjectObjectMetadataRepository(MessageChannelObjectMetadata)
+    @InjectObjectMetadataRepository(MessageChannelWorkspaceEntity)
     private readonly messageChannelService: MessageChannelRepository,
-    @InjectObjectMetadataRepository(MessageParticipantObjectMetadata)
+    @InjectObjectMetadataRepository(MessageParticipantWorkspaceEntity)
     private readonly messageParticipantRepository: MessageParticipantRepository,
   ) {}
 

packages/twenty-server/src/modules/messaging/jobs/messaging-job.module.ts

@@ -3,8 +3,8 @@ import { Module } from '@nestjs/common';
 import { ObjectMetadataRepositoryModule } from 'src/engine/object-metadata-repository/object-metadata-repository.module';
 import { AutoCompaniesAndContactsCreationModule } from 'src/modules/connected-account/auto-companies-and-contacts-creation/auto-companies-and-contacts-creation.module';
 import { GoogleAPIRefreshAccessTokenModule } from 'src/modules/connected-account/services/google-api-refresh-access-token/google-api-refresh-access-token.module';
-import { BlocklistObjectMetadata } from 'src/modules/connected-account/standard-objects/blocklist.object-metadata';
+import { BlocklistWorkspaceEntity } from 'src/modules/connected-account/standard-objects/blocklist.workspace-entity';
-import { ConnectedAccountObjectMetadata } from 'src/modules/connected-account/standard-objects/connected-account.object-metadata';
+import { ConnectedAccountWorkspaceEntity } from 'src/modules/connected-account/standard-objects/connected-account.workspace-entity';
 import { BlocklistItemDeleteMessagesJob } from 'src/modules/messaging/jobs/blocklist-item-delete-messages.job';
 import { BlocklistReimportMessagesJob } from 'src/modules/messaging/jobs/blocklist-reimport-messages.job';
 import { DeleteConnectedAccountAssociatedMessagingDataJob } from 'src/modules/messaging/jobs/delete-connected-account-associated-messaging-data.job';
@@ -14,18 +14,18 @@ import { MessagingCreateCompanyAndContactAfterSyncJob } from 'src/modules/messag
 import { GmailFullSyncModule } from 'src/modules/messaging/services/gmail-full-sync/gmail-full-sync.module';
 import { GmailPartialSyncModule } from 'src/modules/messaging/services/gmail-partial-sync/gmail-partial-sync.module';
 import { ThreadCleanerModule } from 'src/modules/messaging/services/thread-cleaner/thread-cleaner.module';
-import { MessageChannelMessageAssociationObjectMetadata } from 'src/modules/messaging/standard-objects/message-channel-message-association.object-metadata';
+import { MessageChannelMessageAssociationWorkspaceEntity } from 'src/modules/messaging/standard-objects/message-channel-message-association.workspace-entity';
-import { MessageChannelObjectMetadata } from 'src/modules/messaging/standard-objects/message-channel.object-metadata';
+import { MessageChannelWorkspaceEntity } from 'src/modules/messaging/standard-objects/message-channel.workspace-entity';
-import { MessageParticipantObjectMetadata } from 'src/modules/messaging/standard-objects/message-participant.object-metadata';
+import { MessageParticipantWorkspaceEntity } from 'src/modules/messaging/standard-objects/message-participant.workspace-entity';
 
 @Module({
   imports: [
     ObjectMetadataRepositoryModule.forFeature([
-      ConnectedAccountObjectMetadata,
+      ConnectedAccountWorkspaceEntity,
-      MessageChannelObjectMetadata,
+      MessageChannelWorkspaceEntity,
-      MessageParticipantObjectMetadata,
+      MessageParticipantWorkspaceEntity,
-      MessageChannelMessageAssociationObjectMetadata,
+      MessageChannelMessageAssociationWorkspaceEntity,
-      BlocklistObjectMetadata,
+      BlocklistWorkspaceEntity,
     ]),
     GmailFullSyncModule,
     GmailPartialSyncModule,

packages/twenty-server/src/modules/messaging/listeners/messaging-blocklist.listener.ts

@@ -5,7 +5,7 @@ import { ObjectRecordCreateEvent } from 'src/engine/integrations/event-emitter/t
 import { ObjectRecordDeleteEvent } from 'src/engine/integrations/event-emitter/types/object-record-delete.event';
 import { MessageQueue } from 'src/engine/integrations/message-queue/message-queue.constants';
 import { MessageQueueService } from 'src/engine/integrations/message-queue/services/message-queue.service';
-import { BlocklistObjectMetadata } from 'src/modules/connected-account/standard-objects/blocklist.object-metadata';
+import { BlocklistWorkspaceEntity } from 'src/modules/connected-account/standard-objects/blocklist.workspace-entity';
 import {
   BlocklistReimportMessagesJob,
   BlocklistReimportMessagesJobData,
@@ -25,7 +25,7 @@ export class MessagingBlocklistListener {
 
   @OnEvent('blocklist.created')
   async handleCreatedEvent(
-    payload: ObjectRecordCreateEvent<BlocklistObjectMetadata>,
+    payload: ObjectRecordCreateEvent<BlocklistWorkspaceEntity>,
   ) {
     await this.messageQueueService.add<BlocklistItemDeleteMessagesJobData>(
       BlocklistItemDeleteMessagesJob.name,
@@ -38,7 +38,7 @@ export class MessagingBlocklistListener {
 
   @OnEvent('blocklist.deleted')
   async handleDeletedEvent(
-    payload: ObjectRecordDeleteEvent<BlocklistObjectMetadata>,
+    payload: ObjectRecordDeleteEvent<BlocklistWorkspaceEntity>,
   ) {
     await this.messageQueueService.add<BlocklistReimportMessagesJobData>(
       BlocklistReimportMessagesJob.name,
@@ -52,7 +52,7 @@ export class MessagingBlocklistListener {
 
   @OnEvent('blocklist.updated')
   async handleUpdatedEvent(
-    payload: ObjectRecordUpdateEvent<BlocklistObjectMetadata>,
+    payload: ObjectRecordUpdateEvent<BlocklistWorkspaceEntity>,
   ) {
     await this.messageQueueService.add<BlocklistItemDeleteMessagesJobData>(
       BlocklistItemDeleteMessagesJob.name,

packages/twenty-server/src/modules/messaging/listeners/messaging-connected-account.listener.ts

@@ -15,7 +15,7 @@ import {
   DeleteConnectedAccountAssociatedMessagingDataJobData,
   DeleteConnectedAccountAssociatedMessagingDataJob,
 } from 'src/modules/messaging/jobs/delete-connected-account-associated-messaging-data.job';
-import { ConnectedAccountObjectMetadata } from 'src/modules/connected-account/standard-objects/connected-account.object-metadata';
+import { ConnectedAccountWorkspaceEntity } from 'src/modules/connected-account/standard-objects/connected-account.workspace-entity';
 import { FeatureFlagEntity } from 'src/engine/core-modules/feature-flag/feature-flag.entity';
 
 @Injectable()
@@ -31,7 +31,7 @@ export class MessagingConnectedAccountListener {
 
   @OnEvent('connectedAccount.deleted')
   async handleDeletedEvent(
-    payload: ObjectRecordDeleteEvent<ConnectedAccountObjectMetadata>,
+    payload: ObjectRecordDeleteEvent<ConnectedAccountWorkspaceEntity>,
   ) {
     await this.messageQueueService.add<DeleteConnectedAccountAssociatedMessagingDataJobData>(
       DeleteConnectedAccountAssociatedMessagingDataJob.name,