feat: migrate ConnectedAccount infrastructure entities to metadata schema (#18784)

## Summary

- Migrates 4 entities (`connectedAccount`, `messageChannel`,
`calendarChannel`, `messageFolder`) from per-workspace schemas to the
shared `core` metadata schema
- Introduces a `IS_CONNECTED_ACCOUNT_MIGRATED` feature flag to control
the migration: when enabled, reads come from core metadata and all
writes are dual-written to both workspace and core
- Extracts 12 enums from workspace entity files to `twenty-shared` for
reuse across frontend and backend
- Creates new TypeORM entities, metadata services, GraphQL
resolvers/DTOs, and exception interceptors per entity
- Each entity owns its own data access module
(`ConnectedAccountDataAccessModule`, `MessageChannelDataAccessModule`,
`CalendarChannelDataAccessModule`, `MessageFolderDataAccessModule`) — no
umbrella infrastructure module
- Adds a 1.20 upgrade command that backfills data from workspace schemas
to core (preserving UUIDs) and enables the feature flag
- Replaces direct repository access with data access service calls
across ~50 files in messaging, calendar, and connected-account modules
- Adds `lastSignedInAt` and `oidcTokenClaims` fields to the new
`ConnectedAccountEntity`
- Drops unused `lastSyncHistoryId` field from the migrated connected
account entity

## Test plan

- [x] Lint passes (`npx nx lint:diff-with-main twenty-server`)
- [x] Typecheck passes (`npx nx typecheck twenty-server`)
- [x] All unit tests pass (477 suites, 4267 tests, 0 failures)
- [ ] Manual test: verify messaging sync works with feature flag
disabled (existing behavior)
- [ ] Manual test: run upgrade command on a workspace, verify data
backfilled to core tables
- [ ] Manual test: verify messaging/calendar sync works with feature
flag enabled (dual-write path)
- [ ] Manual test: verify GraphQL metadata resolvers return correct data
when flag enabled

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

@@ -59,6 +59,9 @@ import { WorkspaceInvitationModule } from 'src/engine/core-modules/workspace-inv
 import { WorkspaceEntity } from 'src/engine/core-modules/workspace/workspace.entity';
 import { WorkspaceModule } from 'src/engine/core-modules/workspace/workspace.module';
 import { DataSourceModule } from 'src/engine/metadata-modules/data-source/data-source.module';
+import { CalendarChannelDataAccessModule } from 'src/engine/metadata-modules/calendar-channel/data-access/calendar-channel-data-access.module';
+import { ConnectedAccountDataAccessModule } from 'src/engine/metadata-modules/connected-account/data-access/connected-account-data-access.module';
+import { MessageChannelDataAccessModule } from 'src/engine/metadata-modules/message-channel/data-access/message-channel-data-access.module';
 import { ObjectMetadataEntity } from 'src/engine/metadata-modules/object-metadata/object-metadata.entity';
 import { PermissionsModule } from 'src/engine/metadata-modules/permissions/permissions.module';
 import { UserRoleModule } from 'src/engine/metadata-modules/user-role/user-role.module';
@@ -104,6 +107,9 @@ import { JwtAuthStrategy } from './strategies/jwt.auth.strategy';
     ConnectedAccountModule,
     MessagingCommonModule,
     MessagingFolderSyncManagerModule,
+    CalendarChannelDataAccessModule,
+    ConnectedAccountDataAccessModule,
+    MessageChannelDataAccessModule,
     WorkspaceSSOModule,
     FeatureFlagModule,
     WorkspaceInvitationModule,

packages/twenty-server/src/engine/core-modules/auth/services/create-calendar-channel.service.ts

@@ -2,6 +2,7 @@ import { Injectable } from '@nestjs/common';
 
 import { v4 } from 'uuid';
 
+import { CalendarChannelDataAccessService } from 'src/engine/metadata-modules/calendar-channel/data-access/services/calendar-channel-data-access.service';
 import { type WorkspaceEntityManager } from 'src/engine/twenty-orm/entity-manager/workspace-entity-manager';
 import { GlobalWorkspaceOrmManager } from 'src/engine/twenty-orm/global-workspace-datasource/global-workspace-orm.manager';
 import { buildSystemAuthContext } from 'src/engine/twenty-orm/utils/build-system-auth-context.util';
@@ -9,7 +10,6 @@ import {
   CalendarChannelSyncStage,
   CalendarChannelSyncStatus,
   CalendarChannelVisibility,
-  type CalendarChannelWorkspaceEntity,
 } from 'src/modules/calendar/common/standard-objects/calendar-channel.workspace-entity';
 
 export type CreateCalendarChannelInput = {
@@ -25,6 +25,7 @@ export type CreateCalendarChannelInput = {
 export class CreateCalendarChannelService {
   constructor(
     private readonly globalWorkspaceOrmManager: GlobalWorkspaceOrmManager,
+    private readonly calendarChannelDataAccessService: CalendarChannelDataAccessService,
   ) {}
 
   async createCalendarChannel(
@@ -43,15 +44,12 @@ export class CreateCalendarChannelService {
 
     return this.globalWorkspaceOrmManager.executeInWorkspaceContext(
       async () => {
-        const calendarChannelRepository =
-          await this.globalWorkspaceOrmManager.getRepository<CalendarChannelWorkspaceEntity>(
-            workspaceId,
-            'calendarChannel',
-          );
+        const newCalendarChannelId = v4();
 
-        const newCalendarChannel = await calendarChannelRepository.save(
+        await this.calendarChannelDataAccessService.save(
+          workspaceId,
           {
-            id: v4(),
+            id: newCalendarChannelId,
             connectedAccountId,
             handle,
             visibility:
@@ -63,11 +61,10 @@ export class CreateCalendarChannelService {
               ? CalendarChannelSyncStage.CALENDAR_EVENT_LIST_FETCH_PENDING
               : CalendarChannelSyncStage.PENDING_CONFIGURATION,
           },
-          {},
           manager,
         );
 
-        return newCalendarChannel.id;
+        return newCalendarChannelId;
       },
       authContext,
     );

packages/twenty-server/src/engine/core-modules/auth/services/create-connected-account.service.ts

@@ -2,10 +2,10 @@ import { Injectable } from '@nestjs/common';
 
 import { type ConnectedAccountProvider } from 'twenty-shared/types';
 
+import { ConnectedAccountDataAccessService } from 'src/engine/metadata-modules/connected-account/data-access/services/connected-account-data-access.service';
 import { type WorkspaceEntityManager } from 'src/engine/twenty-orm/entity-manager/workspace-entity-manager';
 import { GlobalWorkspaceOrmManager } from 'src/engine/twenty-orm/global-workspace-datasource/global-workspace-orm.manager';
 import { buildSystemAuthContext } from 'src/engine/twenty-orm/utils/build-system-auth-context.util';
-import { type ConnectedAccountWorkspaceEntity } from 'src/modules/connected-account/standard-objects/connected-account.workspace-entity';
 
 export type CreateConnectedAccountInput = {
   workspaceId: string;
@@ -23,6 +23,7 @@ export type CreateConnectedAccountInput = {
 export class CreateConnectedAccountService {
   constructor(
     private readonly globalWorkspaceOrmManager: GlobalWorkspaceOrmManager,
+    private readonly connectedAccountDataAccessService: ConnectedAccountDataAccessService,
   ) {}
 
   async createConnectedAccount(
@@ -43,13 +44,8 @@ export class CreateConnectedAccountService {
     const authContext = buildSystemAuthContext(workspaceId);
 
     await this.globalWorkspaceOrmManager.executeInWorkspaceContext(async () => {
-      const connectedAccountRepository =
-        await this.globalWorkspaceOrmManager.getRepository<ConnectedAccountWorkspaceEntity>(
-          workspaceId,
-          'connectedAccount',
-        );
-
-      await connectedAccountRepository.save(
+      await this.connectedAccountDataAccessService.save(
+        workspaceId,
         {
           id: connectedAccountId,
           handle,
@@ -59,7 +55,6 @@ export class CreateConnectedAccountService {
           accountOwnerId,
           scopes,
         },
-        {},
         manager,
       );
     }, authContext);

packages/twenty-server/src/engine/core-modules/auth/services/create-message-channel.service.ts

@@ -3,6 +3,7 @@ import { Injectable } from '@nestjs/common';
 import { isDefined } from 'twenty-shared/utils';
 import { v4 } from 'uuid';
 
+import { MessageChannelDataAccessService } from 'src/engine/metadata-modules/message-channel/data-access/services/message-channel-data-access.service';
 import { type WorkspaceEntityManager } from 'src/engine/twenty-orm/entity-manager/workspace-entity-manager';
 import { GlobalWorkspaceOrmManager } from 'src/engine/twenty-orm/global-workspace-datasource/global-workspace-orm.manager';
 import { buildSystemAuthContext } from 'src/engine/twenty-orm/utils/build-system-auth-context.util';
@@ -29,6 +30,7 @@ export type CreateMessageChannelInput = {
 export class CreateMessageChannelService {
   constructor(
     private readonly globalWorkspaceOrmManager: GlobalWorkspaceOrmManager,
+    private readonly messageChannelDataAccessService: MessageChannelDataAccessService,
     private readonly syncMessageFoldersService: SyncMessageFoldersService,
   ) {}
 
@@ -48,15 +50,10 @@ export class CreateMessageChannelService {
 
     return this.globalWorkspaceOrmManager.executeInWorkspaceContext(
       async () => {
-        const messageChannelRepository =
-          await this.globalWorkspaceOrmManager.getRepository<MessageChannelWorkspaceEntity>(
-            workspaceId,
-            'messageChannel',
-          );
-
         const newMessageChannelId = v4();
 
-        await messageChannelRepository.insert(
+        await this.messageChannelDataAccessService.save(
+          workspaceId,
           {
             id: newMessageChannelId,
             connectedAccountId,
@@ -76,17 +73,19 @@ export class CreateMessageChannelService {
           manager,
         );
 
-        const createdMessageChannel = await messageChannelRepository.findOne({
-          where: { id: newMessageChannelId },
-          relations: ['connectedAccount', 'messageFolders'],
-        });
+        const createdMessageChannel =
+          await this.messageChannelDataAccessService.findOne(workspaceId, {
+            where: { id: newMessageChannelId },
+            relations: ['connectedAccount', 'messageFolders'],
+          });
 
         if (!isDefined(createdMessageChannel)) {
           throw new Error('Message channel not found');
         }
 
         await this.syncMessageFoldersService.syncMessageFolders({
-          messageChannel: createdMessageChannel,
+          messageChannel:
+            createdMessageChannel as unknown as MessageChannelWorkspaceEntity,
           workspaceId,
         });
 

packages/twenty-server/src/engine/core-modules/auth/services/google-apis.service.spec.ts

@@ -11,6 +11,9 @@ import { GoogleApisServiceAvailabilityService } from 'src/engine/core-modules/au
 import { GoogleAPIsService } from 'src/engine/core-modules/auth/services/google-apis.service';
 import { UpdateConnectedAccountOnReconnectService } from 'src/engine/core-modules/auth/services/update-connected-account-on-reconnect.service';
 import { FeatureFlagService } from 'src/engine/core-modules/feature-flag/services/feature-flag.service';
+import { CalendarChannelDataAccessService } from 'src/engine/metadata-modules/calendar-channel/data-access/services/calendar-channel-data-access.service';
+import { ConnectedAccountDataAccessService } from 'src/engine/metadata-modules/connected-account/data-access/services/connected-account-data-access.service';
+import { MessageChannelDataAccessService } from 'src/engine/metadata-modules/message-channel/data-access/services/message-channel-data-access.service';
 import { MessageQueue } from 'src/engine/core-modules/message-queue/message-queue.constants';
 import { getQueueToken } from 'src/engine/core-modules/message-queue/utils/get-queue-token.util';
 import { TwentyConfigService } from 'src/engine/core-modules/twenty-config/twenty-config.service';
@@ -36,22 +39,16 @@ describe('GoogleAPIsService', () => {
   let messagingChannelSyncStatusService: MessageChannelSyncStatusService;
   let createMessageChannelService: CreateMessageChannelService;
 
-  const mockConnectedAccountRepository = {
+  const mockConnectedAccountDataAccessService = {
     findOne: jest.fn(),
-    find: jest.fn(),
-    update: jest.fn(),
   };
 
-  const mockCalendarChannelRepository = {
-    findOne: jest.fn(),
+  const mockMessageChannelDataAccessService = {
     find: jest.fn(),
-    update: jest.fn(),
   };
 
-  const mockMessageChannelRepository = {
-    findOne: jest.fn(),
+  const mockCalendarChannelDataAccessService = {
     find: jest.fn(),
-    update: jest.fn(),
   };
 
   const mockWorkspaceMemberRepository = {
@@ -84,12 +81,6 @@ describe('GoogleAPIsService', () => {
             getRepository: jest
               .fn()
               .mockImplementation((_workspaceId, entity) => {
-                if (entity === 'connectedAccount')
-                  return mockConnectedAccountRepository;
-                if (entity === 'calendarChannel')
-                  return mockCalendarChannelRepository;
-                if (entity === 'messageChannel')
-                  return mockMessageChannelRepository;
                 if (entity === 'workspaceMember')
                   return mockWorkspaceMemberRepository;
 
@@ -188,6 +179,18 @@ describe('GoogleAPIsService', () => {
             isFeatureEnabled: jest.fn().mockResolvedValue(false),
           },
         },
+        {
+          provide: ConnectedAccountDataAccessService,
+          useValue: mockConnectedAccountDataAccessService,
+        },
+        {
+          provide: MessageChannelDataAccessService,
+          useValue: mockMessageChannelDataAccessService,
+        },
+        {
+          provide: CalendarChannelDataAccessService,
+          useValue: mockCalendarChannelDataAccessService,
+        },
       ],
     }).compile();
 
@@ -221,7 +224,7 @@ describe('GoogleAPIsService', () => {
         provider: ConnectedAccountProvider.GOOGLE,
       } as ConnectedAccountWorkspaceEntity;
 
-      mockConnectedAccountRepository.findOne.mockResolvedValue(
+      mockConnectedAccountDataAccessService.findOne.mockResolvedValue(
         existingConnectedAccount,
       );
 
@@ -237,11 +240,11 @@ describe('GoogleAPIsService', () => {
         syncStage: CalendarChannelSyncStage.FAILED,
       };
 
-      mockCalendarChannelRepository.find.mockResolvedValue([
+      mockCalendarChannelDataAccessService.find.mockResolvedValue([
         failedCalendarChannel,
       ]);
 
-      mockMessageChannelRepository.find.mockResolvedValue([]);
+      mockMessageChannelDataAccessService.find.mockResolvedValue([]);
 
       await service.refreshGoogleRefreshToken({
         handle: 'test@example.com',

packages/twenty-server/src/engine/core-modules/auth/services/google-apis.service.ts

@@ -18,6 +18,9 @@ import { InjectMessageQueue } from 'src/engine/core-modules/message-queue/decora
 import { MessageQueue } from 'src/engine/core-modules/message-queue/message-queue.constants';
 import { MessageQueueService } from 'src/engine/core-modules/message-queue/services/message-queue.service';
 import { TwentyConfigService } from 'src/engine/core-modules/twenty-config/twenty-config.service';
+import { CalendarChannelDataAccessService } from 'src/engine/metadata-modules/calendar-channel/data-access/services/calendar-channel-data-access.service';
+import { ConnectedAccountDataAccessService } from 'src/engine/metadata-modules/connected-account/data-access/services/connected-account-data-access.service';
+import { MessageChannelDataAccessService } from 'src/engine/metadata-modules/message-channel/data-access/services/message-channel-data-access.service';
 import { type WorkspaceEntityManager } from 'src/engine/twenty-orm/entity-manager/workspace-entity-manager';
 import { GlobalWorkspaceOrmManager } from 'src/engine/twenty-orm/global-workspace-datasource/global-workspace-orm.manager';
 import { buildSystemAuthContext } from 'src/engine/twenty-orm/utils/build-system-auth-context.util';
@@ -29,16 +32,14 @@ import { CalendarChannelSyncStatusService } from 'src/modules/calendar/common/se
 import {
   CalendarChannelSyncStage,
   type CalendarChannelVisibility,
-  type CalendarChannelWorkspaceEntity,
 } from 'src/modules/calendar/common/standard-objects/calendar-channel.workspace-entity';
 import { AccountsToReconnectService } from 'src/modules/connected-account/services/accounts-to-reconnect.service';
-import { type ConnectedAccountWorkspaceEntity } from 'src/modules/connected-account/standard-objects/connected-account.workspace-entity';
+
 import { MessageChannelSyncStatusService } from 'src/modules/messaging/common/services/message-channel-sync-status.service';
 import {
   MessageChannelSyncStage,
   MessageChannelSyncStatus,
   type MessageChannelVisibility,
-  type MessageChannelWorkspaceEntity,
 } from 'src/modules/messaging/common/standard-objects/message-channel.workspace-entity';
 import {
   MessagingMessageListFetchJob,
@@ -65,6 +66,9 @@ export class GoogleAPIsService {
     private readonly googleAPIScopesService: GoogleAPIScopesService,
     private readonly googleApisServiceAvailabilityService: GoogleApisServiceAvailabilityService,
     private readonly featureFlagService: FeatureFlagService,
+    private readonly connectedAccountDataAccessService: ConnectedAccountDataAccessService,
+    private readonly messageChannelDataAccessService: MessageChannelDataAccessService,
+    private readonly calendarChannelDataAccessService: CalendarChannelDataAccessService,
   ) {}
 
   async refreshGoogleRefreshToken(input: {
@@ -128,31 +132,14 @@ export class GoogleAPIsService {
 
     return this.globalWorkspaceOrmManager.executeInWorkspaceContext(
       async () => {
-        const connectedAccountRepository =
-          await this.globalWorkspaceOrmManager.getRepository<ConnectedAccountWorkspaceEntity>(
-            workspaceId,
-            'connectedAccount',
-          );
-
-        const connectedAccount = await connectedAccountRepository.findOne({
-          where: { handle, accountOwnerId: workspaceMemberId },
-        });
+        const connectedAccount =
+          await this.connectedAccountDataAccessService.findOne(workspaceId, {
+            where: { handle, accountOwnerId: workspaceMemberId },
+          });
 
         const existingAccountId = connectedAccount?.id;
         const newOrExistingConnectedAccountId = existingAccountId ?? v4();
 
-        const calendarChannelRepository =
-          await this.globalWorkspaceOrmManager.getRepository<CalendarChannelWorkspaceEntity>(
-            workspaceId,
-            'calendarChannel',
-          );
-
-        const messageChannelRepository =
-          await this.globalWorkspaceOrmManager.getRepository<MessageChannelWorkspaceEntity>(
-            workspaceId,
-            'messageChannel',
-          );
-
         const workspaceDataSource =
           await this.globalWorkspaceOrmManager.getGlobalWorkspaceDataSource();
 
@@ -200,7 +187,6 @@ export class GoogleAPIsService {
                   accessToken: input.accessToken,
                   refreshToken: input.refreshToken,
                   scopes,
-                  connectedAccount,
                   manager,
                 },
               );
@@ -229,9 +215,10 @@ export class GoogleAPIsService {
         );
 
         if (isMessagingEnabled) {
-          const messageChannels = await messageChannelRepository.find({
-            where: { connectedAccountId: newOrExistingConnectedAccountId },
-          });
+          const messageChannels =
+            await this.messageChannelDataAccessService.find(workspaceId, {
+              connectedAccountId: newOrExistingConnectedAccountId,
+            });
 
           if (!isMessagingAvailable && messageChannels.length > 0) {
             await this.messagingChannelSyncStatusService.markAsFailed(
@@ -261,9 +248,12 @@ export class GoogleAPIsService {
         }
 
         if (isCalendarEnabled) {
-          const calendarChannels = await calendarChannelRepository.find({
-            where: { connectedAccountId: newOrExistingConnectedAccountId },
-          });
+          const calendarChannels =
+            await this.calendarChannelDataAccessService.find(workspaceId, {
+              where: {
+                connectedAccountId: newOrExistingConnectedAccountId,
+              },
+            });
 
           if (!isCalendarAvailable && calendarChannels.length > 0) {
             await this.calendarChannelSyncStatusService.markAsFailedInsufficientPermissionsAndFlushCalendarEventsToImport(

packages/twenty-server/src/engine/core-modules/auth/services/microsoft-apis.service.spec.ts

@@ -8,6 +8,9 @@ import { CreateConnectedAccountService } from 'src/engine/core-modules/auth/serv
 import { CreateMessageChannelService } from 'src/engine/core-modules/auth/services/create-message-channel.service';
 import { MicrosoftAPIsService } from 'src/engine/core-modules/auth/services/microsoft-apis.service';
 import { UpdateConnectedAccountOnReconnectService } from 'src/engine/core-modules/auth/services/update-connected-account-on-reconnect.service';
+import { CalendarChannelDataAccessService } from 'src/engine/metadata-modules/calendar-channel/data-access/services/calendar-channel-data-access.service';
+import { ConnectedAccountDataAccessService } from 'src/engine/metadata-modules/connected-account/data-access/services/connected-account-data-access.service';
+import { MessageChannelDataAccessService } from 'src/engine/metadata-modules/message-channel/data-access/services/message-channel-data-access.service';
 import { MessageQueue } from 'src/engine/core-modules/message-queue/message-queue.constants';
 import { getQueueToken } from 'src/engine/core-modules/message-queue/utils/get-queue-token.util';
 import { TwentyConfigService } from 'src/engine/core-modules/twenty-config/twenty-config.service';
@@ -33,22 +36,16 @@ describe('MicrosoftAPIsService', () => {
   let calendarChannelSyncStatusService: CalendarChannelSyncStatusService;
   let createMessageChannelService: CreateMessageChannelService;
 
-  const mockConnectedAccountRepository = {
+  const mockConnectedAccountDataAccessService = {
     findOne: jest.fn(),
-    find: jest.fn(),
-    update: jest.fn(),
   };
 
-  const mockCalendarChannelRepository = {
-    findOne: jest.fn(),
+  const mockMessageChannelDataAccessService = {
     find: jest.fn(),
-    update: jest.fn(),
   };
 
-  const mockMessageChannelRepository = {
-    findOne: jest.fn(),
+  const mockCalendarChannelDataAccessService = {
     find: jest.fn(),
-    update: jest.fn(),
   };
 
   const mockWorkspaceMemberRepository = {
@@ -81,12 +78,6 @@ describe('MicrosoftAPIsService', () => {
             getRepository: jest
               .fn()
               .mockImplementation((_workspaceId, entity) => {
-                if (entity === 'connectedAccount')
-                  return mockConnectedAccountRepository;
-                if (entity === 'calendarChannel')
-                  return mockCalendarChannelRepository;
-                if (entity === 'messageChannel')
-                  return mockMessageChannelRepository;
                 if (entity === 'workspaceMember')
                   return mockWorkspaceMemberRepository;
 
@@ -162,6 +153,18 @@ describe('MicrosoftAPIsService', () => {
           provide: getQueueToken(MessageQueue.calendarQueue),
           useValue: mockCalendarQueueService,
         },
+        {
+          provide: ConnectedAccountDataAccessService,
+          useValue: mockConnectedAccountDataAccessService,
+        },
+        {
+          provide: MessageChannelDataAccessService,
+          useValue: mockMessageChannelDataAccessService,
+        },
+        {
+          provide: CalendarChannelDataAccessService,
+          useValue: mockCalendarChannelDataAccessService,
+        },
       ],
     }).compile();
 
@@ -195,7 +198,7 @@ describe('MicrosoftAPIsService', () => {
         provider: ConnectedAccountProvider.MICROSOFT,
       } as ConnectedAccountWorkspaceEntity;
 
-      mockConnectedAccountRepository.findOne.mockResolvedValue(
+      mockConnectedAccountDataAccessService.findOne.mockResolvedValue(
         existingConnectedAccount,
       );
 
@@ -211,11 +214,11 @@ describe('MicrosoftAPIsService', () => {
         syncStage: CalendarChannelSyncStage.FAILED,
       };
 
-      mockCalendarChannelRepository.find.mockResolvedValue([
+      mockCalendarChannelDataAccessService.find.mockResolvedValue([
         failedCalendarChannel,
       ]);
 
-      mockMessageChannelRepository.find.mockResolvedValue([
+      mockMessageChannelDataAccessService.find.mockResolvedValue([
         {
           id: 'message-channel-id',
           connectedAccountId: 'existing-account-id',

packages/twenty-server/src/engine/core-modules/auth/services/microsoft-apis.service.ts

@@ -12,6 +12,9 @@ import { InjectMessageQueue } from 'src/engine/core-modules/message-queue/decora
 import { MessageQueue } from 'src/engine/core-modules/message-queue/message-queue.constants';
 import { MessageQueueService } from 'src/engine/core-modules/message-queue/services/message-queue.service';
 import { TwentyConfigService } from 'src/engine/core-modules/twenty-config/twenty-config.service';
+import { CalendarChannelDataAccessService } from 'src/engine/metadata-modules/calendar-channel/data-access/services/calendar-channel-data-access.service';
+import { ConnectedAccountDataAccessService } from 'src/engine/metadata-modules/connected-account/data-access/services/connected-account-data-access.service';
+import { MessageChannelDataAccessService } from 'src/engine/metadata-modules/message-channel/data-access/services/message-channel-data-access.service';
 import { type WorkspaceEntityManager } from 'src/engine/twenty-orm/entity-manager/workspace-entity-manager';
 import { GlobalWorkspaceOrmManager } from 'src/engine/twenty-orm/global-workspace-datasource/global-workspace-orm.manager';
 import { buildSystemAuthContext } from 'src/engine/twenty-orm/utils/build-system-auth-context.util';
@@ -23,15 +26,13 @@ import { CalendarChannelSyncStatusService } from 'src/modules/calendar/common/se
 import {
   CalendarChannelSyncStage,
   type CalendarChannelVisibility,
-  type CalendarChannelWorkspaceEntity,
 } from 'src/modules/calendar/common/standard-objects/calendar-channel.workspace-entity';
 import { AccountsToReconnectService } from 'src/modules/connected-account/services/accounts-to-reconnect.service';
-import { type ConnectedAccountWorkspaceEntity } from 'src/modules/connected-account/standard-objects/connected-account.workspace-entity';
+
 import { MessageChannelSyncStatusService } from 'src/modules/messaging/common/services/message-channel-sync-status.service';
 import {
   MessageChannelSyncStage,
   type MessageChannelVisibility,
-  type MessageChannelWorkspaceEntity,
 } from 'src/modules/messaging/common/standard-objects/message-channel.workspace-entity';
 import {
   MessagingMessageListFetchJob,
@@ -55,6 +56,9 @@ export class MicrosoftAPIsService {
     private readonly createConnectedAccountService: CreateConnectedAccountService,
     private readonly updateConnectedAccountOnReconnectService: UpdateConnectedAccountOnReconnectService,
     private readonly twentyConfigService: TwentyConfigService,
+    private readonly connectedAccountDataAccessService: ConnectedAccountDataAccessService,
+    private readonly messageChannelDataAccessService: MessageChannelDataAccessService,
+    private readonly calendarChannelDataAccessService: CalendarChannelDataAccessService,
   ) {}
 
   async refreshMicrosoftRefreshToken(input: {
@@ -82,31 +86,14 @@ export class MicrosoftAPIsService {
 
     return this.globalWorkspaceOrmManager.executeInWorkspaceContext(
       async () => {
-        const connectedAccountRepository =
-          await this.globalWorkspaceOrmManager.getRepository<ConnectedAccountWorkspaceEntity>(
-            workspaceId,
-            'connectedAccount',
-          );
-
-        const connectedAccount = await connectedAccountRepository.findOne({
-          where: { handle, accountOwnerId: workspaceMemberId },
-        });
+        const connectedAccount =
+          await this.connectedAccountDataAccessService.findOne(workspaceId, {
+            where: { handle, accountOwnerId: workspaceMemberId },
+          });
 
         const existingAccountId = connectedAccount?.id;
         const newOrExistingConnectedAccountId = existingAccountId ?? v4();
 
-        const calendarChannelRepository =
-          await this.globalWorkspaceOrmManager.getRepository<CalendarChannelWorkspaceEntity>(
-            workspaceId,
-            'calendarChannel',
-          );
-
-        const messageChannelRepository =
-          await this.globalWorkspaceOrmManager.getRepository<MessageChannelWorkspaceEntity>(
-            workspaceId,
-            'messageChannel',
-          );
-
         const workspaceDataSource =
           await this.globalWorkspaceOrmManager.getGlobalWorkspaceDataSource();
 
@@ -156,7 +143,6 @@ export class MicrosoftAPIsService {
                   accessToken: input.accessToken,
                   refreshToken: input.refreshToken,
                   scopes,
-                  connectedAccount,
                   manager,
                 },
               );
@@ -197,11 +183,10 @@ export class MicrosoftAPIsService {
         if (
           this.twentyConfigService.get('MESSAGING_PROVIDER_MICROSOFT_ENABLED')
         ) {
-          const messageChannels = await messageChannelRepository.find({
-            where: {
+          const messageChannels =
+            await this.messageChannelDataAccessService.find(workspaceId, {
               connectedAccountId: newOrExistingConnectedAccountId,
-            },
-          });
+            });
 
           for (const messageChannel of messageChannels) {
             if (
@@ -222,11 +207,12 @@ export class MicrosoftAPIsService {
         if (
           this.twentyConfigService.get('CALENDAR_PROVIDER_MICROSOFT_ENABLED')
         ) {
-          const calendarChannels = await calendarChannelRepository.find({
-            where: {
-              connectedAccountId: newOrExistingConnectedAccountId,
-            },
-          });
+          const calendarChannels =
+            await this.calendarChannelDataAccessService.find(workspaceId, {
+              where: {
+                connectedAccountId: newOrExistingConnectedAccountId,
+              },
+            });
 
           for (const calendarChannel of calendarChannels) {
             if (

packages/twenty-server/src/engine/core-modules/auth/services/update-connected-account-on-reconnect.service.ts

@@ -1,9 +1,9 @@
 import { Injectable } from '@nestjs/common';
 
+import { ConnectedAccountDataAccessService } from 'src/engine/metadata-modules/connected-account/data-access/services/connected-account-data-access.service';
 import { type WorkspaceEntityManager } from 'src/engine/twenty-orm/entity-manager/workspace-entity-manager';
 import { GlobalWorkspaceOrmManager } from 'src/engine/twenty-orm/global-workspace-datasource/global-workspace-orm.manager';
 import { buildSystemAuthContext } from 'src/engine/twenty-orm/utils/build-system-auth-context.util';
-import { type ConnectedAccountWorkspaceEntity } from 'src/modules/connected-account/standard-objects/connected-account.workspace-entity';
 
 export type UpdateConnectedAccountOnReconnectInput = {
   workspaceId: string;
@@ -11,7 +11,6 @@ export type UpdateConnectedAccountOnReconnectInput = {
   accessToken: string;
   refreshToken: string;
   scopes: string[];
-  connectedAccount: ConnectedAccountWorkspaceEntity;
   manager: WorkspaceEntityManager;
 };
 
@@ -19,6 +18,7 @@ export type UpdateConnectedAccountOnReconnectInput = {
 export class UpdateConnectedAccountOnReconnectService {
   constructor(
     private readonly globalWorkspaceOrmManager: GlobalWorkspaceOrmManager,
+    private readonly connectedAccountDataAccessService: ConnectedAccountDataAccessService,
   ) {}
 
   async updateConnectedAccountOnReconnect(
@@ -30,19 +30,13 @@ export class UpdateConnectedAccountOnReconnectService {
       accessToken,
       refreshToken,
       scopes,
-      manager,
     } = input;
 
     const authContext = buildSystemAuthContext(workspaceId);
 
     await this.globalWorkspaceOrmManager.executeInWorkspaceContext(async () => {
-      const connectedAccountRepository =
-        await this.globalWorkspaceOrmManager.getRepository<ConnectedAccountWorkspaceEntity>(
-          workspaceId,
-          'connectedAccount',
-        );
-
-      await connectedAccountRepository.update(
+      await this.connectedAccountDataAccessService.update(
+        workspaceId,
         {
           id: connectedAccountId,
         },
@@ -52,7 +46,6 @@ export class UpdateConnectedAccountOnReconnectService {
           scopes,
           authFailedAt: null,
         },
-        manager,
       );
     }, authContext);
   }

packages/twenty-server/src/engine/core-modules/imap-smtp-caldav-connection/imap-smtp-caldav-connection.module.ts

@@ -3,6 +3,7 @@ import { Module } from '@nestjs/common';
 import { FeatureFlagModule } from 'src/engine/core-modules/feature-flag/feature-flag.module';
 import { ImapSmtpCaldavValidatorModule } from 'src/engine/core-modules/imap-smtp-caldav-connection/services/imap-smtp-caldav-connection-validator.module';
 import { MessageQueueModule } from 'src/engine/core-modules/message-queue/message-queue.module';
+import { ConnectedAccountDataAccessModule } from 'src/engine/metadata-modules/connected-account/data-access/connected-account-data-access.module';
 import { PermissionsModule } from 'src/engine/metadata-modules/permissions/permissions.module';
 import { TwentyORMModule } from 'src/engine/twenty-orm/twenty-orm.module';
 import { ConnectedAccountModule } from 'src/modules/connected-account/connected-account.module';
@@ -21,6 +22,7 @@ import { ImapSmtpCaldavService } from './services/imap-smtp-caldav-connection.se
     IMAPAPIsModule,
     MessagingImportManagerModule,
     MessageQueueModule,
+    ConnectedAccountDataAccessModule,
     TwentyORMModule,
     FeatureFlagModule,
     ImapSmtpCaldavValidatorModule,

packages/twenty-server/src/engine/core-modules/imap-smtp-caldav-connection/services/imap-smtp-caldav-connection.service.ts

@@ -6,6 +6,7 @@ import { createTransport } from 'nodemailer';
 import { ConnectedAccountProvider } from 'twenty-shared/types';
 
 import { UserInputError } from 'src/engine/core-modules/graphql/utils/graphql-errors.util';
+import { ConnectedAccountDataAccessService } from 'src/engine/metadata-modules/connected-account/data-access/services/connected-account-data-access.service';
 import {
   type AccountType,
   type ConnectionParameters,
@@ -21,6 +22,7 @@ export class ImapSmtpCaldavService {
 
   constructor(
     private readonly globalWorkspaceOrmManager: GlobalWorkspaceOrmManager,
+    private readonly connectedAccountDataAccessService: ConnectedAccountDataAccessService,
   ) {}
 
   async testImapConnection(
@@ -188,20 +190,15 @@ export class ImapSmtpCaldavService {
 
     return this.globalWorkspaceOrmManager.executeInWorkspaceContext(
       async () => {
-        const connectedAccountRepository =
-          await this.globalWorkspaceOrmManager.getRepository<ConnectedAccountWorkspaceEntity>(
-            workspaceId,
-            'connectedAccount',
-          );
+        const connectedAccount =
+          await this.connectedAccountDataAccessService.findOne(workspaceId, {
+            where: {
+              id: connectionId,
+              provider: ConnectedAccountProvider.IMAP_SMTP_CALDAV,
+            },
+          });
 
-        const connectedAccount = await connectedAccountRepository.findOne({
-          where: {
-            id: connectionId,
-            provider: ConnectedAccountProvider.IMAP_SMTP_CALDAV,
-          },
-        });
-
-        return connectedAccount;
+        return connectedAccount as ConnectedAccountWorkspaceEntity | null;
       },
       authContext,
     );

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

@@ -15,6 +15,7 @@ import { HttpTool } from 'src/engine/core-modules/tool/tools/http-tool/http-tool
 import { NavigateAppTool } from 'src/engine/core-modules/tool/tools/navigate-tool/navigate-app-tool';
 import { SearchHelpCenterTool } from 'src/engine/core-modules/tool/tools/search-help-center-tool/search-help-center-tool';
 import { WorkspaceManyOrAllFlatEntityMapsCacheModule } from 'src/engine/metadata-modules/flat-entity/services/workspace-many-or-all-flat-entity-maps-cache.module';
+import { ConnectedAccountDataAccessModule } from 'src/engine/metadata-modules/connected-account/data-access/connected-account-data-access.module';
 import { NavigationMenuItemModule } from 'src/engine/metadata-modules/navigation-menu-item/navigation-menu-item.module';
 import { ObjectMetadataModule } from 'src/engine/metadata-modules/object-metadata/object-metadata.module';
 import { ViewModule } from 'src/engine/metadata-modules/view/view.module';
@@ -35,6 +36,7 @@ import { MessagingSendManagerModule } from 'src/modules/messaging/message-outbou
     ViewModule,
     NavigationMenuItemModule,
     WorkspaceManyOrAllFlatEntityMapsCacheModule,
+    ConnectedAccountDataAccessModule,
   ],
   providers: [
     HttpTool,

packages/twenty-server/src/engine/core-modules/tool/tools/email-tool/email-composer.service.ts

@@ -20,11 +20,12 @@ import { EmailComposerResult } from 'src/engine/core-modules/tool/tools/email-to
 import { EmailToolInput } from 'src/engine/core-modules/tool/tools/email-tool/types/email-tool-input.type';
 import { parseCommaSeparatedEmails } from 'src/engine/core-modules/tool/tools/email-tool/utils/parse-comma-separated-emails.util';
 import { ToolExecutionContext } from 'src/engine/core-modules/tool/types/tool.type';
+import { ConnectedAccountDataAccessService } from 'src/engine/metadata-modules/connected-account/data-access/services/connected-account-data-access.service';
 import { GlobalWorkspaceOrmManager } from 'src/engine/twenty-orm/global-workspace-datasource/global-workspace-orm.manager';
 import { buildSystemAuthContext } from 'src/engine/twenty-orm/utils/build-system-auth-context.util';
-import { type ConnectedAccountWorkspaceEntity } from 'src/modules/connected-account/standard-objects/connected-account.workspace-entity';
 import { MessagingAccountAuthenticationService } from 'src/modules/messaging/message-import-manager/services/messaging-account-authentication.service';
 import { type MessageAttachment } from 'src/modules/messaging/message-import-manager/types/message';
+import { type ConnectedAccountWorkspaceEntity } from 'src/modules/connected-account/standard-objects/connected-account.workspace-entity';
 import { parseEmailBody } from 'src/utils/parse-email-body';
 import { streamToBuffer } from 'src/utils/stream-to-buffer';
 @Injectable()
@@ -33,6 +34,7 @@ export class EmailComposerService {
 
   constructor(
     private readonly globalWorkspaceOrmManager: GlobalWorkspaceOrmManager,
+    private readonly connectedAccountDataAccessService: ConnectedAccountDataAccessService,
     private readonly messagingAccountAuthenticationService: MessagingAccountAuthenticationService,
     @InjectRepository(FileEntity)
     private readonly fileRepository: Repository<FileEntity>,
@@ -54,20 +56,15 @@ export class EmailComposerService {
 
     return this.globalWorkspaceOrmManager.executeInWorkspaceContext(
       async () => {
-        const connectedAccountRepository =
-          await this.globalWorkspaceOrmManager.getRepository<ConnectedAccountWorkspaceEntity>(
-            workspaceId,
-            'connectedAccount',
-          );
-
-        const connectedAccount = await connectedAccountRepository.findOne({
-          where: { id: connectedAccountId },
-          relations: {
-            messageChannels: {
-              messageFolders: true,
+        const connectedAccount =
+          await this.connectedAccountDataAccessService.findOne(workspaceId, {
+            where: { id: connectedAccountId },
+            relations: {
+              messageChannels: {
+                messageFolders: true,
+              },
             },
-          },
-        });
+          });
 
         if (!isDefined(connectedAccount)) {
           throw new EmailToolException(
@@ -76,7 +73,7 @@ export class EmailComposerService {
           );
         }
 
-        return connectedAccount;
+        return connectedAccount as unknown as ConnectedAccountWorkspaceEntity;
       },
       authContext,
     );
@@ -89,12 +86,8 @@ export class EmailComposerService {
 
     return this.globalWorkspaceOrmManager.executeInWorkspaceContext(
       async () => {
-        const connectedAccountRepository =
-          await this.globalWorkspaceOrmManager.getRepository<ConnectedAccountWorkspaceEntity>(
-            workspaceId,
-            'connectedAccount',
-          );
-        const allAccounts = await connectedAccountRepository.find();
+        const allAccounts =
+          await this.connectedAccountDataAccessService.find(workspaceId);
 
         if (!allAccounts || allAccounts.length === 0) {
           throw new EmailToolException(
@@ -291,7 +284,7 @@ export class EmailComposerService {
       ...connectedAccount,
       accessToken,
       refreshToken,
-    };
+    } as unknown as ConnectedAccountWorkspaceEntity;
 
     const attachments = await this.getAttachments(files || [], workspaceId);
 

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

@@ -0,0 +1,26 @@
+import { Module } from '@nestjs/common';
+import { TypeOrmModule } from '@nestjs/typeorm';
+
+import { AuthModule } from 'src/engine/core-modules/auth/auth.module';
+import { FeatureFlagModule } from 'src/engine/core-modules/feature-flag/feature-flag.module';
+import { CalendarChannelMetadataService } from 'src/engine/metadata-modules/calendar-channel/calendar-channel-metadata.service';
+import { CalendarChannelEntity } from 'src/engine/metadata-modules/calendar-channel/entities/calendar-channel.entity';
+import { CalendarChannelGraphqlApiExceptionInterceptor } from 'src/engine/metadata-modules/calendar-channel/interceptors/calendar-channel-graphql-api-exception.interceptor';
+import { CalendarChannelResolver } from 'src/engine/metadata-modules/calendar-channel/resolvers/calendar-channel.resolver';
+import { PermissionsModule } from 'src/engine/metadata-modules/permissions/permissions.module';
+
+@Module({
+  imports: [
+    TypeOrmModule.forFeature([CalendarChannelEntity]),
+    AuthModule,
+    PermissionsModule,
+    FeatureFlagModule,
+  ],
+  providers: [
+    CalendarChannelMetadataService,
+    CalendarChannelResolver,
+    CalendarChannelGraphqlApiExceptionInterceptor,
+  ],
+  exports: [CalendarChannelMetadataService],
+})
+export class CalendarChannelMetadataModule {}

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

@@ -0,0 +1,77 @@
+import { Injectable } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+
+import { Repository } from 'typeorm';
+
+import {
+  CalendarChannelSyncStage,
+  CalendarChannelVisibility,
+} from 'twenty-shared/types';
+
+import { CalendarChannelDTO } from 'src/engine/metadata-modules/calendar-channel/dtos/calendar-channel.dto';
+import { CalendarChannelEntity } from 'src/engine/metadata-modules/calendar-channel/entities/calendar-channel.entity';
+
+@Injectable()
+export class CalendarChannelMetadataService {
+  constructor(
+    @InjectRepository(CalendarChannelEntity)
+    private readonly repository: Repository<CalendarChannelEntity>,
+  ) {}
+
+  async findAll(workspaceId: string): Promise<CalendarChannelDTO[]> {
+    return this.repository.find({ where: { workspaceId } });
+  }
+
+  async findByConnectedAccountId(
+    connectedAccountId: string,
+    workspaceId: string,
+  ): Promise<CalendarChannelDTO[]> {
+    return this.repository.find({
+      where: { connectedAccountId, workspaceId },
+    });
+  }
+
+  async findById(
+    id: string,
+    workspaceId: string,
+  ): Promise<CalendarChannelDTO | null> {
+    return this.repository.findOne({ where: { id, workspaceId } });
+  }
+
+  async create(
+    data: Partial<CalendarChannelEntity> & {
+      workspaceId: string;
+      handle: string;
+      connectedAccountId: string;
+      visibility: CalendarChannelVisibility;
+      syncStage: CalendarChannelSyncStage;
+    },
+  ): Promise<CalendarChannelDTO> {
+    const entity = this.repository.create(data);
+
+    return this.repository.save(entity);
+  }
+
+  async update(
+    id: string,
+    workspaceId: string,
+    data: Partial<CalendarChannelEntity>,
+  ): Promise<CalendarChannelDTO> {
+    await this.repository.update(
+      { id, workspaceId },
+      data as Record<string, unknown>,
+    );
+
+    return this.repository.findOneOrFail({ where: { id, workspaceId } });
+  }
+
+  async delete(id: string, workspaceId: string): Promise<CalendarChannelDTO> {
+    const entity = await this.repository.findOneOrFail({
+      where: { id, workspaceId },
+    });
+
+    await this.repository.delete({ id, workspaceId });
+
+    return entity;
+  }
+}

packages/twenty-server/src/engine/metadata-modules/calendar-channel/calendar-channel.exception.ts

@@ -0,0 +1,37 @@
+import { type MessageDescriptor } from '@lingui/core';
+import { msg } from '@lingui/core/macro';
+import { assertUnreachable } from 'twenty-shared/utils';
+
+import { CustomException } from 'src/utils/custom-exception';
+
+export enum CalendarChannelExceptionCode {
+  CALENDAR_CHANNEL_NOT_FOUND = 'CALENDAR_CHANNEL_NOT_FOUND',
+  INVALID_CALENDAR_CHANNEL_INPUT = 'INVALID_CALENDAR_CHANNEL_INPUT',
+}
+
+const getCalendarChannelExceptionUserFriendlyMessage = (
+  code: CalendarChannelExceptionCode,
+) => {
+  switch (code) {
+    case CalendarChannelExceptionCode.CALENDAR_CHANNEL_NOT_FOUND:
+      return msg`Calendar channel not found.`;
+    case CalendarChannelExceptionCode.INVALID_CALENDAR_CHANNEL_INPUT:
+      return msg`Invalid calendar channel input.`;
+    default:
+      assertUnreachable(code);
+  }
+};
+
+export class CalendarChannelException extends CustomException<CalendarChannelExceptionCode> {
+  constructor(
+    message: string,
+    code: CalendarChannelExceptionCode,
+    { userFriendlyMessage }: { userFriendlyMessage?: MessageDescriptor } = {},
+  ) {
+    super(message, code, {
+      userFriendlyMessage:
+        userFriendlyMessage ??
+        getCalendarChannelExceptionUserFriendlyMessage(code),
+    });
+  }
+}

packages/twenty-server/src/engine/metadata-modules/calendar-channel/data-access/calendar-channel-data-access.module.ts

@@ -0,0 +1,18 @@
+import { Module } from '@nestjs/common';
+import { TypeOrmModule } from '@nestjs/typeorm';
+
+import { FeatureFlagModule } from 'src/engine/core-modules/feature-flag/feature-flag.module';
+import { CalendarChannelDataAccessService } from 'src/engine/metadata-modules/calendar-channel/data-access/services/calendar-channel-data-access.service';
+import { CalendarChannelEntity } from 'src/engine/metadata-modules/calendar-channel/entities/calendar-channel.entity';
+import { ConnectedAccountDataAccessModule } from 'src/engine/metadata-modules/connected-account/data-access/connected-account-data-access.module';
+
+@Module({
+  imports: [
+    TypeOrmModule.forFeature([CalendarChannelEntity]),
+    FeatureFlagModule,
+    ConnectedAccountDataAccessModule,
+  ],
+  providers: [CalendarChannelDataAccessService],
+  exports: [CalendarChannelDataAccessService],
+})
+export class CalendarChannelDataAccessModule {}

packages/twenty-server/src/engine/metadata-modules/calendar-channel/data-access/services/calendar-channel-data-access.service.ts

@@ -0,0 +1,280 @@
+import { Injectable, Logger } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+
+import { FeatureFlagKey } from 'twenty-shared/types';
+import {
+  type FindManyOptions,
+  type FindOneOptions,
+  type FindOptionsWhere,
+  Repository,
+} from 'typeorm';
+
+import { FeatureFlagService } from 'src/engine/core-modules/feature-flag/services/feature-flag.service';
+import { CalendarChannelEntity } from 'src/engine/metadata-modules/calendar-channel/entities/calendar-channel.entity';
+import { ConnectedAccountDataAccessService } from 'src/engine/metadata-modules/connected-account/data-access/services/connected-account-data-access.service';
+import { type WorkspaceEntityManager } from 'src/engine/twenty-orm/entity-manager/workspace-entity-manager';
+import { GlobalWorkspaceOrmManager } from 'src/engine/twenty-orm/global-workspace-datasource/global-workspace-orm.manager';
+import { type CalendarChannelWorkspaceEntity } from 'src/modules/calendar/common/standard-objects/calendar-channel.workspace-entity';
+
+@Injectable()
+export class CalendarChannelDataAccessService {
+  private readonly logger = new Logger(CalendarChannelDataAccessService.name);
+
+  constructor(
+    @InjectRepository(CalendarChannelEntity)
+    private readonly coreRepository: Repository<CalendarChannelEntity>,
+    private readonly featureFlagService: FeatureFlagService,
+    private readonly globalWorkspaceOrmManager: GlobalWorkspaceOrmManager,
+    private readonly connectedAccountDataAccessService: ConnectedAccountDataAccessService,
+  ) {}
+
+  private async isMigrated(workspaceId: string): Promise<boolean> {
+    return this.featureFlagService.isFeatureEnabled(
+      FeatureFlagKey.IS_CONNECTED_ACCOUNT_MIGRATED,
+      workspaceId,
+    );
+  }
+
+  private async toCoreWhere(
+    workspaceId: string,
+    where: Record<string, unknown>,
+  ): Promise<Record<string, unknown>> {
+    const coreWhere: Record<string, unknown> = { ...where, workspaceId };
+
+    if (
+      coreWhere.connectedAccount &&
+      typeof coreWhere.connectedAccount === 'object'
+    ) {
+      const connectedAccountWhere = {
+        ...(coreWhere.connectedAccount as Record<string, unknown>),
+      };
+
+      if ('accountOwnerId' in connectedAccountWhere) {
+        const { accountOwnerId, ...restConnectedAccount } =
+          connectedAccountWhere;
+
+        const resolvedConnectedAccounts =
+          await this.connectedAccountDataAccessService.find(workspaceId, {
+            accountOwnerId,
+          } as never);
+
+        if (resolvedConnectedAccounts.length > 0) {
+          coreWhere.connectedAccountId = resolvedConnectedAccounts[0].id;
+        } else {
+          coreWhere.connectedAccountId = '00000000-0000-0000-0000-000000000000';
+        }
+
+        if (Object.keys(restConnectedAccount).length > 0) {
+          coreWhere.connectedAccount = restConnectedAccount;
+        } else {
+          delete coreWhere.connectedAccount;
+        }
+      }
+    }
+
+    return coreWhere;
+  }
+
+  async getWorkspaceRepository(workspaceId: string) {
+    return this.globalWorkspaceOrmManager.getRepository<CalendarChannelWorkspaceEntity>(
+      workspaceId,
+      'calendarChannel',
+    );
+  }
+
+  async findOne(
+    workspaceId: string,
+    options: FindOneOptions<CalendarChannelWorkspaceEntity>,
+  ): Promise<CalendarChannelWorkspaceEntity | null> {
+    if (await this.isMigrated(workspaceId)) {
+      const where = options.where as Record<string, unknown>;
+      const coreWhere = Array.isArray(where)
+        ? await Promise.all(
+            where.map((whereItem: Record<string, unknown>) =>
+              this.toCoreWhere(workspaceId, whereItem),
+            ),
+          )
+        : await this.toCoreWhere(workspaceId, where);
+
+      return this.coreRepository.findOne({
+        ...options,
+        where: coreWhere,
+      } as FindOneOptions<CalendarChannelEntity>) as unknown as Promise<CalendarChannelWorkspaceEntity | null>;
+    }
+
+    const workspaceRepository = await this.getWorkspaceRepository(workspaceId);
+
+    return workspaceRepository.findOne(options);
+  }
+
+  async find(
+    workspaceId: string,
+    whereOrOptions?:
+      | FindOptionsWhere<CalendarChannelWorkspaceEntity>
+      | FindManyOptions<CalendarChannelWorkspaceEntity>,
+  ): Promise<CalendarChannelWorkspaceEntity[]> {
+    if (
+      whereOrOptions !== undefined &&
+      typeof whereOrOptions === 'object' &&
+      whereOrOptions !== null &&
+      !Array.isArray(whereOrOptions) &&
+      'where' in whereOrOptions
+    ) {
+      const options =
+        whereOrOptions as FindManyOptions<CalendarChannelWorkspaceEntity>;
+
+      if (await this.isMigrated(workspaceId)) {
+        const { where } = options;
+
+        const coreWhere = Array.isArray(where)
+          ? await Promise.all(
+              where.map((whereItem) =>
+                this.toCoreWhere(
+                  workspaceId,
+                  whereItem as Record<string, unknown>,
+                ),
+              ),
+            )
+          : await this.toCoreWhere(
+              workspaceId,
+              where as Record<string, unknown>,
+            );
+
+        return this.coreRepository.find({
+          ...options,
+          where: coreWhere,
+        } as FindManyOptions<CalendarChannelEntity>) as unknown as Promise<
+          CalendarChannelWorkspaceEntity[]
+        >;
+      }
+
+      const workspaceRepository =
+        await this.getWorkspaceRepository(workspaceId);
+
+      return workspaceRepository.find(options);
+    }
+
+    const where = whereOrOptions as
+      | FindOptionsWhere<CalendarChannelWorkspaceEntity>
+      | undefined;
+
+    if (await this.isMigrated(workspaceId)) {
+      const coreWhere = where
+        ? await this.toCoreWhere(workspaceId, where as Record<string, unknown>)
+        : { workspaceId };
+
+      return this.coreRepository.find({
+        where: coreWhere,
+      } as FindManyOptions<CalendarChannelEntity>) as unknown as Promise<
+        CalendarChannelWorkspaceEntity[]
+      >;
+    }
+
+    const workspaceRepository = await this.getWorkspaceRepository(workspaceId);
+
+    return workspaceRepository.find({ where });
+  }
+
+  async save(
+    workspaceId: string,
+    data: Partial<CalendarChannelWorkspaceEntity>,
+    manager?: WorkspaceEntityManager,
+  ): Promise<void> {
+    const workspaceRepository = await this.getWorkspaceRepository(workspaceId);
+
+    await workspaceRepository.save(data, {}, manager);
+
+    if (await this.isMigrated(workspaceId)) {
+      try {
+        await this.coreRepository.save({
+          ...data,
+          workspaceId,
+        } as unknown as CalendarChannelEntity);
+      } catch (error) {
+        this.logger.error(
+          `Failed to dual-write calendarChannel to core: ${error}`,
+        );
+        throw error;
+      }
+    }
+  }
+
+  async update(
+    workspaceId: string,
+    where: FindOptionsWhere<CalendarChannelWorkspaceEntity>,
+    data: Partial<CalendarChannelWorkspaceEntity>,
+  ): Promise<void> {
+    const workspaceRepository = await this.getWorkspaceRepository(workspaceId);
+
+    await workspaceRepository.update(where, data);
+
+    if (await this.isMigrated(workspaceId)) {
+      try {
+        await this.coreRepository.update(
+          { ...where, workspaceId } as FindOptionsWhere<CalendarChannelEntity>,
+          data as Record<string, unknown>,
+        );
+      } catch (error) {
+        this.logger.error(
+          `Failed to dual-write calendarChannel update to core: ${error}`,
+        );
+        throw error;
+      }
+    }
+  }
+
+  async increment(
+    workspaceId: string,
+    where: FindOptionsWhere<CalendarChannelWorkspaceEntity>,
+    propertyPath: string,
+    value: number,
+  ): Promise<void> {
+    const workspaceRepository = await this.getWorkspaceRepository(workspaceId);
+
+    await workspaceRepository.increment(where, propertyPath, value, undefined, [
+      propertyPath,
+      'id',
+    ]);
+
+    if (await this.isMigrated(workspaceId)) {
+      try {
+        await this.coreRepository.increment(
+          {
+            ...where,
+            workspaceId,
+          } as FindOptionsWhere<CalendarChannelEntity>,
+          propertyPath,
+          value,
+        );
+      } catch (error) {
+        this.logger.error(
+          `Failed to dual-write calendarChannel increment to core: ${error}`,
+        );
+        throw error;
+      }
+    }
+  }
+
+  async delete(
+    workspaceId: string,
+    where: FindOptionsWhere<CalendarChannelWorkspaceEntity>,
+  ): Promise<void> {
+    const workspaceRepository = await this.getWorkspaceRepository(workspaceId);
+
+    await workspaceRepository.delete(where);
+
+    if (await this.isMigrated(workspaceId)) {
+      try {
+        await this.coreRepository.delete({
+          ...where,
+          workspaceId,
+        } as FindOptionsWhere<CalendarChannelEntity>);
+      } catch (error) {
+        this.logger.error(
+          `Failed to dual-write calendarChannel delete to core: ${error}`,
+        );
+        throw error;
+      }
+    }
+  }
+}

packages/twenty-server/src/engine/metadata-modules/calendar-channel/dtos/calendar-channel.dto.ts

@@ -0,0 +1,96 @@
+import { Field, HideField, ObjectType } from '@nestjs/graphql';
+
+import {
+  IsBoolean,
+  IsDateString,
+  IsEnum,
+  IsInt,
+  IsNotEmpty,
+  IsOptional,
+  IsString,
+  IsUUID,
+} from 'class-validator';
+import {
+  CalendarChannelContactAutoCreationPolicy,
+  CalendarChannelSyncStage,
+  CalendarChannelSyncStatus,
+  CalendarChannelVisibility,
+} from 'twenty-shared/types';
+
+import { UUIDScalarType } from 'src/engine/api/graphql/workspace-schema-builder/graphql-types/scalars';
+
+@ObjectType('CalendarChannel')
+export class CalendarChannelDTO {
+  @IsUUID()
+  @IsNotEmpty()
+  @Field(() => UUIDScalarType)
+  id: string;
+
+  @IsString()
+  @IsNotEmpty()
+  @Field()
+  handle: string;
+
+  @IsEnum(CalendarChannelSyncStatus)
+  @IsNotEmpty()
+  @Field(() => CalendarChannelSyncStatus)
+  syncStatus: CalendarChannelSyncStatus;
+
+  @IsEnum(CalendarChannelSyncStage)
+  @IsNotEmpty()
+  @Field(() => CalendarChannelSyncStage)
+  syncStage: CalendarChannelSyncStage;
+
+  @IsEnum(CalendarChannelVisibility)
+  @IsNotEmpty()
+  @Field(() => CalendarChannelVisibility)
+  visibility: CalendarChannelVisibility;
+
+  @IsBoolean()
+  @Field()
+  isContactAutoCreationEnabled: boolean;
+
+  @IsEnum(CalendarChannelContactAutoCreationPolicy)
+  @IsNotEmpty()
+  @Field(() => CalendarChannelContactAutoCreationPolicy)
+  contactAutoCreationPolicy: CalendarChannelContactAutoCreationPolicy;
+
+  @IsBoolean()
+  @Field()
+  isSyncEnabled: boolean;
+
+  @IsString()
+  @IsOptional()
+  @Field(() => String, { nullable: true })
+  syncCursor: string | null;
+
+  @IsDateString()
+  @IsOptional()
+  @Field(() => Date, { nullable: true })
+  syncedAt: Date | null;
+
+  @IsDateString()
+  @IsOptional()
+  @Field(() => Date, { nullable: true })
+  syncStageStartedAt: Date | null;
+
+  @IsInt()
+  @Field()
+  throttleFailureCount: number;
+
+  @IsUUID()
+  @IsNotEmpty()
+  @Field(() => UUIDScalarType)
+  connectedAccountId: string;
+
+  @HideField()
+  workspaceId: string;
+
+  @IsDateString()
+  @Field()
+  createdAt: Date;
+
+  @IsDateString()
+  @Field()
+  updatedAt: Date;
+}

packages/twenty-server/src/engine/metadata-modules/calendar-channel/dtos/create-calendar-channel.input.ts

@@ -0,0 +1,60 @@
+import { Field, InputType } from '@nestjs/graphql';
+
+import {
+  IsBoolean,
+  IsEnum,
+  IsNotEmpty,
+  IsOptional,
+  IsString,
+  IsUUID,
+} from 'class-validator';
+import {
+  CalendarChannelContactAutoCreationPolicy,
+  CalendarChannelSyncStage,
+  CalendarChannelVisibility,
+} from 'twenty-shared/types';
+
+import { UUIDScalarType } from 'src/engine/api/graphql/workspace-schema-builder/graphql-types/scalars';
+
+@InputType()
+export class CreateCalendarChannelInput {
+  @IsUUID()
+  @IsOptional()
+  @Field(() => UUIDScalarType, { nullable: true })
+  id?: string;
+
+  @IsString()
+  @IsNotEmpty()
+  @Field()
+  handle: string;
+
+  @IsEnum(CalendarChannelVisibility)
+  @IsNotEmpty()
+  @Field(() => CalendarChannelVisibility)
+  visibility: CalendarChannelVisibility;
+
+  @IsEnum(CalendarChannelSyncStage)
+  @IsNotEmpty()
+  @Field(() => CalendarChannelSyncStage)
+  syncStage: CalendarChannelSyncStage;
+
+  @IsUUID()
+  @IsNotEmpty()
+  @Field(() => UUIDScalarType)
+  connectedAccountId: string;
+
+  @IsBoolean()
+  @IsNotEmpty()
+  @Field()
+  isContactAutoCreationEnabled: boolean;
+
+  @IsEnum(CalendarChannelContactAutoCreationPolicy)
+  @IsNotEmpty()
+  @Field(() => CalendarChannelContactAutoCreationPolicy)
+  contactAutoCreationPolicy: CalendarChannelContactAutoCreationPolicy;
+
+  @IsBoolean()
+  @IsNotEmpty()
+  @Field()
+  isSyncEnabled: boolean;
+}

packages/twenty-server/src/engine/metadata-modules/calendar-channel/dtos/update-calendar-channel.input.ts

@@ -0,0 +1,53 @@
+import { Field, InputType } from '@nestjs/graphql';
+
+import { Type } from 'class-transformer';
+import {
+  IsBoolean,
+  IsEnum,
+  IsNotEmpty,
+  IsOptional,
+  IsUUID,
+  ValidateNested,
+} from 'class-validator';
+import {
+  CalendarChannelContactAutoCreationPolicy,
+  CalendarChannelVisibility,
+} from 'twenty-shared/types';
+
+import { UUIDScalarType } from 'src/engine/api/graphql/workspace-schema-builder/graphql-types/scalars';
+
+@InputType()
+export class UpdateCalendarChannelInputUpdates {
+  @IsOptional()
+  @IsEnum(CalendarChannelVisibility)
+  @Field(() => CalendarChannelVisibility, { nullable: true })
+  visibility?: CalendarChannelVisibility;
+
+  @IsOptional()
+  @IsBoolean()
+  @Field({ nullable: true })
+  isContactAutoCreationEnabled?: boolean;
+
+  @IsOptional()
+  @IsEnum(CalendarChannelContactAutoCreationPolicy)
+  @Field(() => CalendarChannelContactAutoCreationPolicy, { nullable: true })
+  contactAutoCreationPolicy?: CalendarChannelContactAutoCreationPolicy;
+
+  @IsOptional()
+  @IsBoolean()
+  @Field({ nullable: true })
+  isSyncEnabled?: boolean;
+}
+
+@InputType()
+export class UpdateCalendarChannelInput {
+  @IsUUID()
+  @IsNotEmpty()
+  @Field(() => UUIDScalarType)
+  id: string;
+
+  @Type(() => UpdateCalendarChannelInputUpdates)
+  @ValidateNested()
+  @Field(() => UpdateCalendarChannelInputUpdates)
+  update: UpdateCalendarChannelInputUpdates;
+}

packages/twenty-server/src/engine/metadata-modules/calendar-channel/entities/calendar-channel.entity.ts

@@ -0,0 +1,93 @@
+import {
+  Column,
+  CreateDateColumn,
+  Entity,
+  JoinColumn,
+  ManyToOne,
+  PrimaryGeneratedColumn,
+  type Relation,
+  UpdateDateColumn,
+} from 'typeorm';
+
+import {
+  CalendarChannelContactAutoCreationPolicy,
+  CalendarChannelSyncStage,
+  CalendarChannelSyncStatus,
+  CalendarChannelVisibility,
+} from 'twenty-shared/types';
+
+import { ConnectedAccountEntity } from 'src/engine/metadata-modules/connected-account/entities/connected-account.entity';
+import { WorkspaceRelatedEntity } from 'src/engine/workspace-manager/types/workspace-related-entity';
+
+@Entity({ name: 'calendarChannel', schema: 'core' })
+export class CalendarChannelEntity extends WorkspaceRelatedEntity {
+  @PrimaryGeneratedColumn('uuid')
+  id: string;
+
+  @Column({ type: 'varchar', nullable: false })
+  handle: string;
+
+  @Column({
+    type: 'enum',
+    enum: CalendarChannelSyncStatus,
+    nullable: false,
+    default: CalendarChannelSyncStatus.NOT_SYNCED,
+  })
+  syncStatus: CalendarChannelSyncStatus;
+
+  @Column({
+    type: 'enum',
+    enum: CalendarChannelSyncStage,
+    nullable: false,
+  })
+  syncStage: CalendarChannelSyncStage;
+
+  @Column({
+    type: 'enum',
+    enum: CalendarChannelVisibility,
+    nullable: false,
+  })
+  visibility: CalendarChannelVisibility;
+
+  @Column({ type: 'boolean', nullable: false })
+  isContactAutoCreationEnabled: boolean;
+
+  @Column({
+    type: 'enum',
+    enum: CalendarChannelContactAutoCreationPolicy,
+    nullable: false,
+  })
+  contactAutoCreationPolicy: CalendarChannelContactAutoCreationPolicy;
+
+  @Column({ type: 'boolean', nullable: false })
+  isSyncEnabled: boolean;
+
+  @Column({ type: 'varchar', nullable: true })
+  syncCursor: string | null;
+
+  @Column({ type: 'timestamptz', nullable: true })
+  syncedAt: Date | null;
+
+  @Column({ type: 'timestamptz', nullable: true })
+  syncStageStartedAt: Date | null;
+
+  @Column({ type: 'integer', nullable: false, default: 0 })
+  throttleFailureCount: number;
+
+  @Column({ type: 'uuid', nullable: false })
+  connectedAccountId: string;
+
+  @ManyToOne(
+    () => ConnectedAccountEntity,
+    (connectedAccount) => connectedAccount.calendarChannels,
+    { onDelete: 'CASCADE' },
+  )
+  @JoinColumn({ name: 'connectedAccountId' })
+  connectedAccount: Relation<ConnectedAccountEntity>;
+
+  @CreateDateColumn({ type: 'timestamptz' })
+  createdAt: Date;
+
+  @UpdateDateColumn({ type: 'timestamptz' })
+  updatedAt: Date;
+}

packages/twenty-server/src/engine/metadata-modules/calendar-channel/interceptors/calendar-channel-graphql-api-exception.interceptor.ts

@@ -0,0 +1,24 @@
+import {
+  type CallHandler,
+  type ExecutionContext,
+  Injectable,
+  type NestInterceptor,
+} from '@nestjs/common';
+
+import { type Observable, catchError } from 'rxjs';
+
+import { calendarChannelGraphqlApiExceptionHandler } from 'src/engine/metadata-modules/calendar-channel/utils/calendar-channel-graphql-api-exception-handler.util';
+
+@Injectable()
+export class CalendarChannelGraphqlApiExceptionInterceptor
+  implements NestInterceptor
+{
+  intercept(
+    _context: ExecutionContext,
+    next: CallHandler,
+  ): Observable<unknown> {
+    return next
+      .handle()
+      .pipe(catchError(calendarChannelGraphqlApiExceptionHandler));
+  }
+}

packages/twenty-server/src/engine/metadata-modules/calendar-channel/resolvers/calendar-channel.resolver.ts

@@ -0,0 +1,98 @@
+import { UseGuards, UseInterceptors } from '@nestjs/common';
+import { Args, Mutation, Query } from '@nestjs/graphql';
+
+import { PermissionFlagType } from 'twenty-shared/constants';
+import { FeatureFlagKey } from 'twenty-shared/types';
+
+import { UUIDScalarType } from 'src/engine/api/graphql/workspace-schema-builder/graphql-types/scalars';
+import { MetadataResolver } from 'src/engine/api/graphql/graphql-config/decorators/metadata-resolver.decorator';
+import { WorkspaceEntity } from 'src/engine/core-modules/workspace/workspace.entity';
+import { AuthWorkspace } from 'src/engine/decorators/auth/auth-workspace.decorator';
+import {
+  FeatureFlagGuard,
+  RequireFeatureFlag,
+} from 'src/engine/guards/feature-flag.guard';
+import { SettingsPermissionGuard } from 'src/engine/guards/settings-permission.guard';
+import { WorkspaceAuthGuard } from 'src/engine/guards/workspace-auth.guard';
+import { CalendarChannelMetadataService } from 'src/engine/metadata-modules/calendar-channel/calendar-channel-metadata.service';
+import { CalendarChannelDTO } from 'src/engine/metadata-modules/calendar-channel/dtos/calendar-channel.dto';
+import { CreateCalendarChannelInput } from 'src/engine/metadata-modules/calendar-channel/dtos/create-calendar-channel.input';
+import { UpdateCalendarChannelInput } from 'src/engine/metadata-modules/calendar-channel/dtos/update-calendar-channel.input';
+import { CalendarChannelGraphqlApiExceptionInterceptor } from 'src/engine/metadata-modules/calendar-channel/interceptors/calendar-channel-graphql-api-exception.interceptor';
+
+@UseGuards(WorkspaceAuthGuard, FeatureFlagGuard)
+@UseInterceptors(CalendarChannelGraphqlApiExceptionInterceptor)
+@MetadataResolver(() => CalendarChannelDTO)
+export class CalendarChannelResolver {
+  constructor(
+    private readonly calendarChannelMetadataService: CalendarChannelMetadataService,
+  ) {}
+
+  @Query(() => [CalendarChannelDTO])
+  @UseGuards(SettingsPermissionGuard(PermissionFlagType.CONNECTED_ACCOUNTS))
+  @RequireFeatureFlag(FeatureFlagKey.IS_CONNECTED_ACCOUNT_MIGRATED)
+  async calendarChannels(
+    @AuthWorkspace() workspace: WorkspaceEntity,
+    @Args('connectedAccountId', {
+      type: () => UUIDScalarType,
+      nullable: true,
+    })
+    connectedAccountId?: string,
+  ): Promise<CalendarChannelDTO[]> {
+    if (connectedAccountId) {
+      return this.calendarChannelMetadataService.findByConnectedAccountId(
+        connectedAccountId,
+        workspace.id,
+      );
+    }
+
+    return this.calendarChannelMetadataService.findAll(workspace.id);
+  }
+
+  @Query(() => CalendarChannelDTO, { nullable: true })
+  @UseGuards(SettingsPermissionGuard(PermissionFlagType.CONNECTED_ACCOUNTS))
+  @RequireFeatureFlag(FeatureFlagKey.IS_CONNECTED_ACCOUNT_MIGRATED)
+  async calendarChannel(
+    @Args('id', { type: () => UUIDScalarType }) id: string,
+    @AuthWorkspace() workspace: WorkspaceEntity,
+  ): Promise<CalendarChannelDTO | null> {
+    return this.calendarChannelMetadataService.findById(id, workspace.id);
+  }
+
+  @Mutation(() => CalendarChannelDTO)
+  @UseGuards(SettingsPermissionGuard(PermissionFlagType.CONNECTED_ACCOUNTS))
+  @RequireFeatureFlag(FeatureFlagKey.IS_CONNECTED_ACCOUNT_MIGRATED)
+  async createCalendarChannel(
+    @Args('input') input: CreateCalendarChannelInput,
+    @AuthWorkspace() workspace: WorkspaceEntity,
+  ): Promise<CalendarChannelDTO> {
+    return this.calendarChannelMetadataService.create({
+      ...input,
+      workspaceId: workspace.id,
+    });
+  }
+
+  @Mutation(() => CalendarChannelDTO)
+  @UseGuards(SettingsPermissionGuard(PermissionFlagType.CONNECTED_ACCOUNTS))
+  @RequireFeatureFlag(FeatureFlagKey.IS_CONNECTED_ACCOUNT_MIGRATED)
+  async updateCalendarChannel(
+    @Args('input') input: UpdateCalendarChannelInput,
+    @AuthWorkspace() workspace: WorkspaceEntity,
+  ): Promise<CalendarChannelDTO> {
+    return this.calendarChannelMetadataService.update(
+      input.id,
+      workspace.id,
+      input.update,
+    );
+  }
+
+  @Mutation(() => CalendarChannelDTO)
+  @UseGuards(SettingsPermissionGuard(PermissionFlagType.CONNECTED_ACCOUNTS))
+  @RequireFeatureFlag(FeatureFlagKey.IS_CONNECTED_ACCOUNT_MIGRATED)
+  async deleteCalendarChannel(
+    @Args('id', { type: () => UUIDScalarType }) id: string,
+    @AuthWorkspace() workspace: WorkspaceEntity,
+  ): Promise<CalendarChannelDTO> {
+    return this.calendarChannelMetadataService.delete(id, workspace.id);
+  }
+}

packages/twenty-server/src/engine/metadata-modules/calendar-channel/utils/calendar-channel-graphql-api-exception-handler.util.ts

@@ -0,0 +1,26 @@
+import { assertUnreachable } from 'twenty-shared/utils';
+
+import {
+  NotFoundError,
+  UserInputError,
+} from 'src/engine/core-modules/graphql/utils/graphql-errors.util';
+import {
+  CalendarChannelException,
+  CalendarChannelExceptionCode,
+} from 'src/engine/metadata-modules/calendar-channel/calendar-channel.exception';
+
+export const calendarChannelGraphqlApiExceptionHandler = (error: Error) => {
+  if (error instanceof CalendarChannelException) {
+    switch (error.code) {
+      case CalendarChannelExceptionCode.CALENDAR_CHANNEL_NOT_FOUND:
+        throw new NotFoundError(error);
+      case CalendarChannelExceptionCode.INVALID_CALENDAR_CHANNEL_INPUT:
+        throw new UserInputError(error);
+      default: {
+        return assertUnreachable(error.code);
+      }
+    }
+  }
+
+  throw error;
+};

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

@@ -0,0 +1,26 @@
+import { Module } from '@nestjs/common';
+import { TypeOrmModule } from '@nestjs/typeorm';
+
+import { AuthModule } from 'src/engine/core-modules/auth/auth.module';
+import { FeatureFlagModule } from 'src/engine/core-modules/feature-flag/feature-flag.module';
+import { ConnectedAccountMetadataService } from 'src/engine/metadata-modules/connected-account/connected-account-metadata.service';
+import { ConnectedAccountEntity } from 'src/engine/metadata-modules/connected-account/entities/connected-account.entity';
+import { ConnectedAccountGraphqlApiExceptionInterceptor } from 'src/engine/metadata-modules/connected-account/interceptors/connected-account-graphql-api-exception.interceptor';
+import { ConnectedAccountResolver } from 'src/engine/metadata-modules/connected-account/resolvers/connected-account.resolver';
+import { PermissionsModule } from 'src/engine/metadata-modules/permissions/permissions.module';
+
+@Module({
+  imports: [
+    TypeOrmModule.forFeature([ConnectedAccountEntity]),
+    AuthModule,
+    PermissionsModule,
+    FeatureFlagModule,
+  ],
+  providers: [
+    ConnectedAccountMetadataService,
+    ConnectedAccountResolver,
+    ConnectedAccountGraphqlApiExceptionInterceptor,
+  ],
+  exports: [ConnectedAccountMetadataService],
+})
+export class ConnectedAccountMetadataModule {}

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

@@ -0,0 +1,62 @@
+import { Injectable } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+
+import { Repository } from 'typeorm';
+
+import { ConnectedAccountDTO } from 'src/engine/metadata-modules/connected-account/dtos/connected-account.dto';
+import { ConnectedAccountEntity } from 'src/engine/metadata-modules/connected-account/entities/connected-account.entity';
+
+@Injectable()
+export class ConnectedAccountMetadataService {
+  constructor(
+    @InjectRepository(ConnectedAccountEntity)
+    private readonly repository: Repository<ConnectedAccountEntity>,
+  ) {}
+
+  async findAll(workspaceId: string): Promise<ConnectedAccountDTO[]> {
+    return this.repository.find({ where: { workspaceId } });
+  }
+
+  async findById(
+    id: string,
+    workspaceId: string,
+  ): Promise<ConnectedAccountDTO | null> {
+    return this.repository.findOne({ where: { id, workspaceId } });
+  }
+
+  async create(
+    data: Partial<ConnectedAccountEntity> & {
+      workspaceId: string;
+      handle: string;
+      provider: string;
+      userWorkspaceId: string;
+    },
+  ): Promise<ConnectedAccountDTO> {
+    const entity = this.repository.create(data);
+
+    return this.repository.save(entity);
+  }
+
+  async update(
+    id: string,
+    workspaceId: string,
+    data: Partial<ConnectedAccountEntity>,
+  ): Promise<ConnectedAccountDTO> {
+    await this.repository.update(
+      { id, workspaceId },
+      data as Record<string, unknown>,
+    );
+
+    return this.repository.findOneOrFail({ where: { id, workspaceId } });
+  }
+
+  async delete(id: string, workspaceId: string): Promise<ConnectedAccountDTO> {
+    const entity = await this.repository.findOneOrFail({
+      where: { id, workspaceId },
+    });
+
+    await this.repository.delete({ id, workspaceId });
+
+    return entity;
+  }
+}

packages/twenty-server/src/engine/metadata-modules/connected-account/connected-account.exception.ts

@@ -0,0 +1,37 @@
+import { type MessageDescriptor } from '@lingui/core';
+import { msg } from '@lingui/core/macro';
+import { assertUnreachable } from 'twenty-shared/utils';
+
+import { CustomException } from 'src/utils/custom-exception';
+
+export enum ConnectedAccountExceptionCode {
+  CONNECTED_ACCOUNT_NOT_FOUND = 'CONNECTED_ACCOUNT_NOT_FOUND',
+  INVALID_CONNECTED_ACCOUNT_INPUT = 'INVALID_CONNECTED_ACCOUNT_INPUT',
+}
+
+const getConnectedAccountExceptionUserFriendlyMessage = (
+  code: ConnectedAccountExceptionCode,
+) => {
+  switch (code) {
+    case ConnectedAccountExceptionCode.CONNECTED_ACCOUNT_NOT_FOUND:
+      return msg`Connected account not found.`;
+    case ConnectedAccountExceptionCode.INVALID_CONNECTED_ACCOUNT_INPUT:
+      return msg`Invalid connected account input.`;
+    default:
+      assertUnreachable(code);
+  }
+};
+
+export class ConnectedAccountException extends CustomException<ConnectedAccountExceptionCode> {
+  constructor(
+    message: string,
+    code: ConnectedAccountExceptionCode,
+    { userFriendlyMessage }: { userFriendlyMessage?: MessageDescriptor } = {},
+  ) {
+    super(message, code, {
+      userFriendlyMessage:
+        userFriendlyMessage ??
+        getConnectedAccountExceptionUserFriendlyMessage(code),
+    });
+  }
+}

packages/twenty-server/src/engine/metadata-modules/connected-account/data-access/connected-account-data-access.module.ts

@@ -0,0 +1,17 @@
+import { Module } from '@nestjs/common';
+import { TypeOrmModule } from '@nestjs/typeorm';
+
+import { FeatureFlagModule } from 'src/engine/core-modules/feature-flag/feature-flag.module';
+import { UserWorkspaceEntity } from 'src/engine/core-modules/user-workspace/user-workspace.entity';
+import { ConnectedAccountDataAccessService } from 'src/engine/metadata-modules/connected-account/data-access/services/connected-account-data-access.service';
+import { ConnectedAccountEntity } from 'src/engine/metadata-modules/connected-account/entities/connected-account.entity';
+
+@Module({
+  imports: [
+    TypeOrmModule.forFeature([ConnectedAccountEntity, UserWorkspaceEntity]),
+    FeatureFlagModule,
+  ],
+  providers: [ConnectedAccountDataAccessService],
+  exports: [ConnectedAccountDataAccessService],
+})
+export class ConnectedAccountDataAccessModule {}

packages/twenty-server/src/engine/metadata-modules/connected-account/data-access/services/connected-account-data-access.service.ts

@@ -0,0 +1,346 @@
+import { Injectable, Logger } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+
+import { isNonEmptyString } from '@sniptt/guards';
+
+import { FeatureFlagKey } from 'twenty-shared/types';
+import { isDefined } from 'twenty-shared/utils';
+import {
+  type FindOneOptions,
+  type FindOptionsWhere,
+  In,
+  Repository,
+} from 'typeorm';
+
+import { FeatureFlagService } from 'src/engine/core-modules/feature-flag/services/feature-flag.service';
+import { UserWorkspaceEntity } from 'src/engine/core-modules/user-workspace/user-workspace.entity';
+import { ConnectedAccountEntity } from 'src/engine/metadata-modules/connected-account/entities/connected-account.entity';
+import { type WorkspaceEntityManager } from 'src/engine/twenty-orm/entity-manager/workspace-entity-manager';
+import { GlobalWorkspaceOrmManager } from 'src/engine/twenty-orm/global-workspace-datasource/global-workspace-orm.manager';
+import { type ConnectedAccountWorkspaceEntity } from 'src/modules/connected-account/standard-objects/connected-account.workspace-entity';
+import { type WorkspaceMemberWorkspaceEntity } from 'src/modules/workspace-member/standard-objects/workspace-member.workspace-entity';
+
+@Injectable()
+export class ConnectedAccountDataAccessService {
+  private readonly logger = new Logger(ConnectedAccountDataAccessService.name);
+
+  constructor(
+    @InjectRepository(ConnectedAccountEntity)
+    private readonly coreRepository: Repository<ConnectedAccountEntity>,
+    @InjectRepository(UserWorkspaceEntity)
+    private readonly userWorkspaceRepository: Repository<UserWorkspaceEntity>,
+    private readonly featureFlagService: FeatureFlagService,
+    private readonly globalWorkspaceOrmManager: GlobalWorkspaceOrmManager,
+  ) {}
+
+  private async isMigrated(workspaceId: string): Promise<boolean> {
+    return this.featureFlagService.isFeatureEnabled(
+      FeatureFlagKey.IS_CONNECTED_ACCOUNT_MIGRATED,
+      workspaceId,
+    );
+  }
+
+  private async resolveUserWorkspaceId(
+    workspaceId: string,
+    workspaceMemberId: string,
+  ): Promise<string | null> {
+    const workspaceMemberRepository =
+      await this.globalWorkspaceOrmManager.getRepository<WorkspaceMemberWorkspaceEntity>(
+        workspaceId,
+        'workspaceMember',
+      );
+
+    const workspaceMember = await workspaceMemberRepository.findOne({
+      where: { id: workspaceMemberId },
+    });
+
+    if (!workspaceMember) {
+      return null;
+    }
+
+    const userWorkspace = await this.userWorkspaceRepository.findOne({
+      where: { userId: workspaceMember.userId, workspaceId },
+    });
+
+    return userWorkspace?.id ?? null;
+  }
+
+  private async toCore(
+    workspaceId: string,
+    data: Partial<ConnectedAccountWorkspaceEntity>,
+  ): Promise<Partial<ConnectedAccountEntity>> {
+    const {
+      handleAliases,
+      lastSyncHistoryId: _lastSyncHistoryId,
+      accountOwnerId,
+      ...rest
+    } = data as Record<string, unknown>;
+
+    const coreData: Record<string, unknown> = { ...rest };
+
+    if (handleAliases !== undefined) {
+      coreData.handleAliases = isNonEmptyString(handleAliases)
+        ? handleAliases.split(',').map((alias: string) => alias.trim())
+        : null;
+    }
+
+    if (accountOwnerId !== undefined) {
+      const userWorkspaceId = await this.resolveUserWorkspaceId(
+        workspaceId,
+        accountOwnerId as string,
+      );
+
+      if (!userWorkspaceId) {
+        this.logger.warn(
+          `Could not resolve userWorkspaceId for workspaceMember ${accountOwnerId}`,
+        );
+      }
+
+      coreData.userWorkspaceId = userWorkspaceId;
+    }
+
+    return coreData as Partial<ConnectedAccountEntity>;
+  }
+
+  private async toCoreWhere(
+    workspaceId: string,
+    where: Record<string, unknown>,
+  ): Promise<FindOptionsWhere<ConnectedAccountEntity>> {
+    const { accountOwnerId, ...rest } = where;
+    const coreWhere: Record<string, unknown> = { ...rest, workspaceId };
+
+    if (accountOwnerId !== undefined) {
+      const userWorkspaceId = await this.resolveUserWorkspaceId(
+        workspaceId,
+        accountOwnerId as string,
+      );
+
+      if (userWorkspaceId) {
+        coreWhere.userWorkspaceId = userWorkspaceId;
+      } else {
+        this.logger.warn(
+          `toCoreWhere: could not resolve userWorkspaceId for workspaceMember ${accountOwnerId}, returning empty result`,
+        );
+        coreWhere.id = '00000000-0000-0000-0000-000000000000';
+      }
+    }
+
+    return coreWhere as FindOptionsWhere<ConnectedAccountEntity>;
+  }
+
+  private async fromCoreEntities(
+    workspaceId: string,
+    entities: ConnectedAccountEntity[],
+  ): Promise<ConnectedAccountWorkspaceEntity[]> {
+    if (entities.length === 0) {
+      return [];
+    }
+
+    const userWorkspaceIds = entities
+      .map((entity) => entity.userWorkspaceId)
+      .filter(isDefined);
+
+    const userWorkspaces =
+      userWorkspaceIds.length > 0
+        ? await this.userWorkspaceRepository.find({
+            where: { id: In(userWorkspaceIds) },
+            select: ['id', 'userId'],
+          })
+        : [];
+
+    const userIdByUserWorkspaceId = new Map(
+      userWorkspaces.map((userWorkspace) => [
+        userWorkspace.id,
+        userWorkspace.userId,
+      ]),
+    );
+
+    const uniqueUserIds = [
+      ...new Set(userWorkspaces.map((userWorkspace) => userWorkspace.userId)),
+    ];
+
+    const workspaceMemberRepository =
+      await this.globalWorkspaceOrmManager.getRepository<WorkspaceMemberWorkspaceEntity>(
+        workspaceId,
+        'workspaceMember',
+      );
+
+    const workspaceMembers =
+      uniqueUserIds.length > 0
+        ? await workspaceMemberRepository.find({
+            where: { userId: In(uniqueUserIds) },
+          })
+        : [];
+
+    const workspaceMemberIdByUserId = new Map(
+      workspaceMembers.map((workspaceMember) => [
+        workspaceMember.userId,
+        workspaceMember.id,
+      ]),
+    );
+
+    return entities.map((entity) => {
+      const userId = entity.userWorkspaceId
+        ? userIdByUserWorkspaceId.get(entity.userWorkspaceId)
+        : undefined;
+
+      const accountOwnerId = userId
+        ? workspaceMemberIdByUserId.get(userId)
+        : undefined;
+
+      const handleAliases = Array.isArray(entity.handleAliases)
+        ? entity.handleAliases.join(',')
+        : (entity.handleAliases ?? '');
+
+      return {
+        ...entity,
+        handleAliases,
+        accountOwnerId: accountOwnerId ?? null,
+      } as unknown as ConnectedAccountWorkspaceEntity;
+    });
+  }
+
+  async getWorkspaceRepository(workspaceId: string) {
+    return this.globalWorkspaceOrmManager.getRepository<ConnectedAccountWorkspaceEntity>(
+      workspaceId,
+      'connectedAccount',
+    );
+  }
+
+  async findOne(
+    workspaceId: string,
+    options: FindOneOptions<ConnectedAccountWorkspaceEntity>,
+  ): Promise<ConnectedAccountWorkspaceEntity | null> {
+    if (await this.isMigrated(workspaceId)) {
+      const where = options.where as Record<string, unknown>;
+      const coreWhere = Array.isArray(where)
+        ? await Promise.all(
+            where.map((whereItem: Record<string, unknown>) =>
+              this.toCoreWhere(workspaceId, whereItem),
+            ),
+          )
+        : await this.toCoreWhere(workspaceId, where);
+
+      const coreResult = await this.coreRepository.findOne({
+        ...options,
+        where: coreWhere,
+      } as FindOneOptions<ConnectedAccountEntity>);
+
+      if (!coreResult) {
+        return null;
+      }
+
+      const [transformed] = await this.fromCoreEntities(workspaceId, [
+        coreResult,
+      ]);
+
+      return transformed ?? null;
+    }
+
+    const workspaceRepository = await this.getWorkspaceRepository(workspaceId);
+
+    return workspaceRepository.findOne(options);
+  }
+
+  async find(
+    workspaceId: string,
+    where?: FindOptionsWhere<ConnectedAccountWorkspaceEntity>,
+  ): Promise<ConnectedAccountWorkspaceEntity[]> {
+    if (await this.isMigrated(workspaceId)) {
+      const coreWhere = where
+        ? await this.toCoreWhere(workspaceId, where as Record<string, unknown>)
+        : { workspaceId };
+
+      const coreResults = await this.coreRepository.find({
+        where: coreWhere,
+      });
+
+      return this.fromCoreEntities(workspaceId, coreResults);
+    }
+
+    const workspaceRepository = await this.getWorkspaceRepository(workspaceId);
+
+    return workspaceRepository.find({ where });
+  }
+
+  async save(
+    workspaceId: string,
+    data: Partial<ConnectedAccountWorkspaceEntity>,
+    manager?: WorkspaceEntityManager,
+  ): Promise<void> {
+    const workspaceRepository = await this.getWorkspaceRepository(workspaceId);
+
+    await workspaceRepository.save(data, {}, manager);
+
+    if (await this.isMigrated(workspaceId)) {
+      try {
+        const coreData = await this.toCore(workspaceId, data);
+
+        await this.coreRepository.save({
+          ...coreData,
+          workspaceId,
+        } as ConnectedAccountEntity);
+      } catch (error) {
+        this.logger.error(
+          `Failed to dual-write connectedAccount to core: ${error}`,
+        );
+        throw error;
+      }
+    }
+  }
+
+  async update(
+    workspaceId: string,
+    where: FindOptionsWhere<ConnectedAccountWorkspaceEntity>,
+    data: Partial<ConnectedAccountWorkspaceEntity>,
+  ): Promise<void> {
+    const workspaceRepository = await this.getWorkspaceRepository(workspaceId);
+
+    await workspaceRepository.update(where, data);
+
+    if (await this.isMigrated(workspaceId)) {
+      try {
+        const coreData = await this.toCore(workspaceId, data);
+        const coreWhere = await this.toCoreWhere(
+          workspaceId,
+          where as Record<string, unknown>,
+        );
+
+        await this.coreRepository.update(
+          coreWhere,
+          coreData as Record<string, unknown>,
+        );
+      } catch (error) {
+        this.logger.error(
+          `Failed to dual-write connectedAccount update to core: ${error}`,
+        );
+        throw error;
+      }
+    }
+  }
+
+  async delete(
+    workspaceId: string,
+    where: FindOptionsWhere<ConnectedAccountWorkspaceEntity>,
+  ): Promise<void> {
+    const workspaceRepository = await this.getWorkspaceRepository(workspaceId);
+
+    await workspaceRepository.delete(where);
+
+    if (await this.isMigrated(workspaceId)) {
+      try {
+        const coreWhere = await this.toCoreWhere(
+          workspaceId,
+          where as Record<string, unknown>,
+        );
+
+        await this.coreRepository.delete(coreWhere);
+      } catch (error) {
+        this.logger.error(
+          `Failed to dual-write connectedAccount delete to core: ${error}`,
+        );
+        throw error;
+      }
+    }
+  }
+}

packages/twenty-server/src/engine/metadata-modules/connected-account/dtos/connected-account.dto.ts

@@ -0,0 +1,90 @@
+import { Field, HideField, ObjectType } from '@nestjs/graphql';
+
+import {
+  IsArray,
+  IsDateString,
+  IsNotEmpty,
+  IsOptional,
+  IsString,
+  IsUUID,
+} from 'class-validator';
+import GraphQLJSON from 'graphql-type-json';
+
+import { UUIDScalarType } from 'src/engine/api/graphql/workspace-schema-builder/graphql-types/scalars';
+
+@ObjectType('ConnectedAccountDTO')
+export class ConnectedAccountDTO {
+  @IsUUID()
+  @IsNotEmpty()
+  @Field(() => UUIDScalarType)
+  id: string;
+
+  @IsString()
+  @IsNotEmpty()
+  @Field()
+  handle: string;
+
+  @IsString()
+  @IsNotEmpty()
+  @Field()
+  provider: string;
+
+  @IsString()
+  @IsOptional()
+  @Field(() => String, { nullable: true })
+  accessToken: string | null;
+
+  @IsString()
+  @IsOptional()
+  @Field(() => String, { nullable: true })
+  refreshToken: string | null;
+
+  @IsDateString()
+  @IsOptional()
+  @Field(() => Date, { nullable: true })
+  lastCredentialsRefreshedAt: Date | null;
+
+  @IsDateString()
+  @IsOptional()
+  @Field(() => Date, { nullable: true })
+  authFailedAt: Date | null;
+
+  @IsArray()
+  @IsOptional()
+  @Field(() => [String], { nullable: true })
+  handleAliases: string[] | null;
+
+  @IsArray()
+  @IsOptional()
+  @Field(() => [String], { nullable: true })
+  scopes: string[] | null;
+
+  @IsOptional()
+  @Field(() => GraphQLJSON, { nullable: true })
+  connectionParameters: Record<string, unknown> | null;
+
+  @IsDateString()
+  @IsOptional()
+  @Field(() => Date, { nullable: true })
+  lastSignedInAt: Date | null;
+
+  @IsOptional()
+  @Field(() => GraphQLJSON, { nullable: true })
+  oidcTokenClaims: Record<string, unknown> | null;
+
+  @IsUUID()
+  @IsNotEmpty()
+  @Field(() => UUIDScalarType)
+  userWorkspaceId: string;
+
+  @HideField()
+  workspaceId: string;
+
+  @IsDateString()
+  @Field()
+  createdAt: Date;
+
+  @IsDateString()
+  @Field()
+  updatedAt: Date;
+}

packages/twenty-server/src/engine/metadata-modules/connected-account/dtos/create-connected-account.input.ts

@@ -0,0 +1,49 @@
+import { Field, InputType } from '@nestjs/graphql';
+
+import {
+  IsArray,
+  IsNotEmpty,
+  IsOptional,
+  IsString,
+  IsUUID,
+} from 'class-validator';
+
+import { UUIDScalarType } from 'src/engine/api/graphql/workspace-schema-builder/graphql-types/scalars';
+
+@InputType()
+export class CreateConnectedAccountInput {
+  @IsUUID()
+  @IsOptional()
+  @Field(() => UUIDScalarType, { nullable: true })
+  id?: string;
+
+  @IsString()
+  @IsNotEmpty()
+  @Field()
+  handle: string;
+
+  @IsString()
+  @IsNotEmpty()
+  @Field()
+  provider: string;
+
+  @IsString()
+  @IsOptional()
+  @Field({ nullable: true })
+  accessToken?: string;
+
+  @IsString()
+  @IsOptional()
+  @Field({ nullable: true })
+  refreshToken?: string;
+
+  @IsArray()
+  @IsOptional()
+  @Field(() => [String], { nullable: true })
+  scopes?: string[];
+
+  @IsUUID()
+  @IsNotEmpty()
+  @Field(() => UUIDScalarType)
+  userWorkspaceId: string;
+}

packages/twenty-server/src/engine/metadata-modules/connected-account/dtos/update-connected-account.input.ts

@@ -0,0 +1,49 @@
+import { Field, InputType } from '@nestjs/graphql';
+
+import { Type } from 'class-transformer';
+import {
+  IsArray,
+  IsNotEmpty,
+  IsOptional,
+  IsString,
+  IsUUID,
+  ValidateNested,
+} from 'class-validator';
+
+import { UUIDScalarType } from 'src/engine/api/graphql/workspace-schema-builder/graphql-types/scalars';
+
+@InputType()
+export class UpdateConnectedAccountInputUpdates {
+  @IsOptional()
+  @IsString()
+  @Field({ nullable: true })
+  accessToken?: string;
+
+  @IsOptional()
+  @IsString()
+  @Field({ nullable: true })
+  refreshToken?: string;
+
+  @IsOptional()
+  @IsArray()
+  @Field(() => [String], { nullable: true })
+  handleAliases?: string[];
+
+  @IsOptional()
+  @IsArray()
+  @Field(() => [String], { nullable: true })
+  scopes?: string[];
+}
+
+@InputType()
+export class UpdateConnectedAccountInput {
+  @IsUUID()
+  @IsNotEmpty()
+  @Field(() => UUIDScalarType)
+  id: string;
+
+  @Type(() => UpdateConnectedAccountInputUpdates)
+  @ValidateNested()
+  @Field(() => UpdateConnectedAccountInputUpdates)
+  update: UpdateConnectedAccountInputUpdates;
+}

packages/twenty-server/src/engine/metadata-modules/connected-account/entities/connected-account.entity.ts

@@ -0,0 +1,74 @@
+import {
+  Column,
+  CreateDateColumn,
+  Entity,
+  OneToMany,
+  PrimaryGeneratedColumn,
+  type Relation,
+  UpdateDateColumn,
+} from 'typeorm';
+
+import { type CalendarChannelEntity } from 'src/engine/metadata-modules/calendar-channel/entities/calendar-channel.entity';
+import { type MessageChannelEntity } from 'src/engine/metadata-modules/message-channel/entities/message-channel.entity';
+import { WorkspaceRelatedEntity } from 'src/engine/workspace-manager/types/workspace-related-entity';
+
+@Entity({ name: 'connectedAccount', schema: 'core' })
+export class ConnectedAccountEntity extends WorkspaceRelatedEntity {
+  @PrimaryGeneratedColumn('uuid')
+  id: string;
+
+  @Column({ type: 'varchar', nullable: false })
+  handle: string;
+
+  @Column({ type: 'varchar', nullable: false })
+  provider: string;
+
+  @Column({ type: 'varchar', nullable: true })
+  accessToken: string | null;
+
+  @Column({ type: 'varchar', nullable: true })
+  refreshToken: string | null;
+
+  @Column({ type: 'timestamptz', nullable: true })
+  lastCredentialsRefreshedAt: Date | null;
+
+  @Column({ type: 'timestamptz', nullable: true })
+  authFailedAt: Date | null;
+
+  @Column({ type: 'varchar', array: true, nullable: true })
+  handleAliases: string[] | null;
+
+  @Column({ type: 'varchar', array: true, nullable: true })
+  scopes: string[] | null;
+
+  @Column({ type: 'jsonb', nullable: true })
+  connectionParameters: Record<string, unknown> | null;
+
+  @Column({ type: 'timestamptz', nullable: true })
+  lastSignedInAt: Date | null;
+
+  @Column({ type: 'jsonb', nullable: true })
+  oidcTokenClaims: Record<string, unknown> | null;
+
+  @Column({ type: 'uuid', nullable: false })
+  userWorkspaceId: string;
+
+  @OneToMany(
+    'MessageChannelEntity',
+    (messageChannel: MessageChannelEntity) => messageChannel.connectedAccount,
+  )
+  messageChannels: Relation<MessageChannelEntity[]>;
+
+  @OneToMany(
+    'CalendarChannelEntity',
+    (calendarChannel: CalendarChannelEntity) =>
+      calendarChannel.connectedAccount,
+  )
+  calendarChannels: Relation<CalendarChannelEntity[]>;
+
+  @CreateDateColumn({ type: 'timestamptz' })
+  createdAt: Date;
+
+  @UpdateDateColumn({ type: 'timestamptz' })
+  updatedAt: Date;
+}

packages/twenty-server/src/engine/metadata-modules/connected-account/interceptors/connected-account-graphql-api-exception.interceptor.ts

@@ -0,0 +1,24 @@
+import {
+  type CallHandler,
+  type ExecutionContext,
+  Injectable,
+  type NestInterceptor,
+} from '@nestjs/common';
+
+import { type Observable, catchError } from 'rxjs';
+
+import { connectedAccountGraphqlApiExceptionHandler } from 'src/engine/metadata-modules/connected-account/utils/connected-account-graphql-api-exception-handler.util';
+
+@Injectable()
+export class ConnectedAccountGraphqlApiExceptionInterceptor
+  implements NestInterceptor
+{
+  intercept(
+    _context: ExecutionContext,
+    next: CallHandler,
+  ): Observable<unknown> {
+    return next
+      .handle()
+      .pipe(catchError(connectedAccountGraphqlApiExceptionHandler));
+  }
+}

packages/twenty-server/src/engine/metadata-modules/connected-account/resolvers/connected-account.resolver.ts

@@ -0,0 +1,86 @@
+import { UseGuards, UseInterceptors } from '@nestjs/common';
+import { Args, Mutation, Query } from '@nestjs/graphql';
+
+import { PermissionFlagType } from 'twenty-shared/constants';
+import { FeatureFlagKey } from 'twenty-shared/types';
+
+import { UUIDScalarType } from 'src/engine/api/graphql/workspace-schema-builder/graphql-types/scalars';
+import { MetadataResolver } from 'src/engine/api/graphql/graphql-config/decorators/metadata-resolver.decorator';
+import { WorkspaceEntity } from 'src/engine/core-modules/workspace/workspace.entity';
+import { AuthWorkspace } from 'src/engine/decorators/auth/auth-workspace.decorator';
+import {
+  FeatureFlagGuard,
+  RequireFeatureFlag,
+} from 'src/engine/guards/feature-flag.guard';
+import { SettingsPermissionGuard } from 'src/engine/guards/settings-permission.guard';
+import { WorkspaceAuthGuard } from 'src/engine/guards/workspace-auth.guard';
+import { ConnectedAccountMetadataService } from 'src/engine/metadata-modules/connected-account/connected-account-metadata.service';
+import { ConnectedAccountDTO } from 'src/engine/metadata-modules/connected-account/dtos/connected-account.dto';
+import { CreateConnectedAccountInput } from 'src/engine/metadata-modules/connected-account/dtos/create-connected-account.input';
+import { UpdateConnectedAccountInput } from 'src/engine/metadata-modules/connected-account/dtos/update-connected-account.input';
+import { ConnectedAccountGraphqlApiExceptionInterceptor } from 'src/engine/metadata-modules/connected-account/interceptors/connected-account-graphql-api-exception.interceptor';
+
+@UseGuards(WorkspaceAuthGuard, FeatureFlagGuard)
+@UseInterceptors(ConnectedAccountGraphqlApiExceptionInterceptor)
+@MetadataResolver(() => ConnectedAccountDTO)
+export class ConnectedAccountResolver {
+  constructor(
+    private readonly connectedAccountMetadataService: ConnectedAccountMetadataService,
+  ) {}
+
+  @Query(() => [ConnectedAccountDTO])
+  @UseGuards(SettingsPermissionGuard(PermissionFlagType.CONNECTED_ACCOUNTS))
+  @RequireFeatureFlag(FeatureFlagKey.IS_CONNECTED_ACCOUNT_MIGRATED)
+  async connectedAccounts(
+    @AuthWorkspace() workspace: WorkspaceEntity,
+  ): Promise<ConnectedAccountDTO[]> {
+    return this.connectedAccountMetadataService.findAll(workspace.id);
+  }
+
+  @Query(() => ConnectedAccountDTO, { nullable: true })
+  @UseGuards(SettingsPermissionGuard(PermissionFlagType.CONNECTED_ACCOUNTS))
+  @RequireFeatureFlag(FeatureFlagKey.IS_CONNECTED_ACCOUNT_MIGRATED)
+  async connectedAccount(
+    @Args('id', { type: () => UUIDScalarType }) id: string,
+    @AuthWorkspace() workspace: WorkspaceEntity,
+  ): Promise<ConnectedAccountDTO | null> {
+    return this.connectedAccountMetadataService.findById(id, workspace.id);
+  }
+
+  @Mutation(() => ConnectedAccountDTO)
+  @UseGuards(SettingsPermissionGuard(PermissionFlagType.CONNECTED_ACCOUNTS))
+  @RequireFeatureFlag(FeatureFlagKey.IS_CONNECTED_ACCOUNT_MIGRATED)
+  async createConnectedAccount(
+    @Args('input') input: CreateConnectedAccountInput,
+    @AuthWorkspace() workspace: WorkspaceEntity,
+  ): Promise<ConnectedAccountDTO> {
+    return this.connectedAccountMetadataService.create({
+      ...input,
+      workspaceId: workspace.id,
+    });
+  }
+
+  @Mutation(() => ConnectedAccountDTO)
+  @UseGuards(SettingsPermissionGuard(PermissionFlagType.CONNECTED_ACCOUNTS))
+  @RequireFeatureFlag(FeatureFlagKey.IS_CONNECTED_ACCOUNT_MIGRATED)
+  async updateConnectedAccount(
+    @Args('input') input: UpdateConnectedAccountInput,
+    @AuthWorkspace() workspace: WorkspaceEntity,
+  ): Promise<ConnectedAccountDTO> {
+    return this.connectedAccountMetadataService.update(
+      input.id,
+      workspace.id,
+      input.update,
+    );
+  }
+
+  @Mutation(() => ConnectedAccountDTO)
+  @UseGuards(SettingsPermissionGuard(PermissionFlagType.CONNECTED_ACCOUNTS))
+  @RequireFeatureFlag(FeatureFlagKey.IS_CONNECTED_ACCOUNT_MIGRATED)
+  async deleteConnectedAccount(
+    @Args('id', { type: () => UUIDScalarType }) id: string,
+    @AuthWorkspace() workspace: WorkspaceEntity,
+  ): Promise<ConnectedAccountDTO> {
+    return this.connectedAccountMetadataService.delete(id, workspace.id);
+  }
+}

packages/twenty-server/src/engine/metadata-modules/connected-account/utils/connected-account-graphql-api-exception-handler.util.ts

@@ -0,0 +1,26 @@
+import { assertUnreachable } from 'twenty-shared/utils';
+
+import {
+  NotFoundError,
+  UserInputError,
+} from 'src/engine/core-modules/graphql/utils/graphql-errors.util';
+import {
+  ConnectedAccountException,
+  ConnectedAccountExceptionCode,
+} from 'src/engine/metadata-modules/connected-account/connected-account.exception';
+
+export const connectedAccountGraphqlApiExceptionHandler = (error: Error) => {
+  if (error instanceof ConnectedAccountException) {
+    switch (error.code) {
+      case ConnectedAccountExceptionCode.CONNECTED_ACCOUNT_NOT_FOUND:
+        throw new NotFoundError(error);
+      case ConnectedAccountExceptionCode.INVALID_CONNECTED_ACCOUNT_INPUT:
+        throw new UserInputError(error);
+      default: {
+        return assertUnreachable(error.code);
+      }
+    }
+  }
+
+  throw error;
+};

packages/twenty-server/src/engine/metadata-modules/message-channel/data-access/message-channel-data-access.module.ts

@@ -0,0 +1,18 @@
+import { Module } from '@nestjs/common';
+import { TypeOrmModule } from '@nestjs/typeorm';
+
+import { FeatureFlagModule } from 'src/engine/core-modules/feature-flag/feature-flag.module';
+import { ConnectedAccountDataAccessModule } from 'src/engine/metadata-modules/connected-account/data-access/connected-account-data-access.module';
+import { MessageChannelDataAccessService } from 'src/engine/metadata-modules/message-channel/data-access/services/message-channel-data-access.service';
+import { MessageChannelEntity } from 'src/engine/metadata-modules/message-channel/entities/message-channel.entity';
+
+@Module({
+  imports: [
+    TypeOrmModule.forFeature([MessageChannelEntity]),
+    FeatureFlagModule,
+    ConnectedAccountDataAccessModule,
+  ],
+  providers: [MessageChannelDataAccessService],
+  exports: [MessageChannelDataAccessService],
+})
+export class MessageChannelDataAccessModule {}

packages/twenty-server/src/engine/metadata-modules/message-channel/data-access/services/message-channel-data-access.service.ts

@@ -0,0 +1,280 @@
+import { Injectable, Logger } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+
+import { FeatureFlagKey } from 'twenty-shared/types';
+import {
+  type FindManyOptions,
+  type FindOneOptions,
+  type FindOptionsWhere,
+  Repository,
+} from 'typeorm';
+
+import { FeatureFlagService } from 'src/engine/core-modules/feature-flag/services/feature-flag.service';
+import { ConnectedAccountDataAccessService } from 'src/engine/metadata-modules/connected-account/data-access/services/connected-account-data-access.service';
+import { MessageChannelEntity } from 'src/engine/metadata-modules/message-channel/entities/message-channel.entity';
+import { type WorkspaceEntityManager } from 'src/engine/twenty-orm/entity-manager/workspace-entity-manager';
+import { GlobalWorkspaceOrmManager } from 'src/engine/twenty-orm/global-workspace-datasource/global-workspace-orm.manager';
+import { type MessageChannelWorkspaceEntity } from 'src/modules/messaging/common/standard-objects/message-channel.workspace-entity';
+
+@Injectable()
+export class MessageChannelDataAccessService {
+  private readonly logger = new Logger(MessageChannelDataAccessService.name);
+
+  constructor(
+    @InjectRepository(MessageChannelEntity)
+    private readonly coreRepository: Repository<MessageChannelEntity>,
+    private readonly featureFlagService: FeatureFlagService,
+    private readonly globalWorkspaceOrmManager: GlobalWorkspaceOrmManager,
+    private readonly connectedAccountDataAccessService: ConnectedAccountDataAccessService,
+  ) {}
+
+  private async isMigrated(workspaceId: string): Promise<boolean> {
+    return this.featureFlagService.isFeatureEnabled(
+      FeatureFlagKey.IS_CONNECTED_ACCOUNT_MIGRATED,
+      workspaceId,
+    );
+  }
+
+  private async toCoreWhere(
+    workspaceId: string,
+    where: Record<string, unknown>,
+  ): Promise<Record<string, unknown>> {
+    const coreWhere: Record<string, unknown> = { ...where, workspaceId };
+
+    if (
+      coreWhere.connectedAccount &&
+      typeof coreWhere.connectedAccount === 'object'
+    ) {
+      const connectedAccountWhere = {
+        ...(coreWhere.connectedAccount as Record<string, unknown>),
+      };
+
+      if ('accountOwnerId' in connectedAccountWhere) {
+        const { accountOwnerId, ...restConnectedAccount } =
+          connectedAccountWhere;
+
+        const resolvedConnectedAccounts =
+          await this.connectedAccountDataAccessService.find(workspaceId, {
+            accountOwnerId,
+          } as never);
+
+        if (resolvedConnectedAccounts.length > 0) {
+          coreWhere.connectedAccountId = resolvedConnectedAccounts[0].id;
+        } else {
+          coreWhere.connectedAccountId = '00000000-0000-0000-0000-000000000000';
+        }
+
+        if (Object.keys(restConnectedAccount).length > 0) {
+          coreWhere.connectedAccount = restConnectedAccount;
+        } else {
+          delete coreWhere.connectedAccount;
+        }
+      }
+    }
+
+    return coreWhere;
+  }
+
+  async getWorkspaceRepository(workspaceId: string) {
+    return this.globalWorkspaceOrmManager.getRepository<MessageChannelWorkspaceEntity>(
+      workspaceId,
+      'messageChannel',
+    );
+  }
+
+  async findOne(
+    workspaceId: string,
+    options: FindOneOptions<MessageChannelWorkspaceEntity>,
+  ): Promise<MessageChannelWorkspaceEntity | null> {
+    if (await this.isMigrated(workspaceId)) {
+      const where = options.where as Record<string, unknown>;
+      const coreWhere = Array.isArray(where)
+        ? await Promise.all(
+            where.map((whereItem: Record<string, unknown>) =>
+              this.toCoreWhere(workspaceId, whereItem),
+            ),
+          )
+        : await this.toCoreWhere(workspaceId, where);
+
+      return this.coreRepository.findOne({
+        ...options,
+        where: coreWhere,
+      } as FindOneOptions<MessageChannelEntity>) as unknown as Promise<MessageChannelWorkspaceEntity | null>;
+    }
+
+    const workspaceRepository = await this.getWorkspaceRepository(workspaceId);
+
+    return workspaceRepository.findOne(options);
+  }
+
+  async find(
+    workspaceId: string,
+    where?: FindOptionsWhere<MessageChannelWorkspaceEntity>,
+  ): Promise<MessageChannelWorkspaceEntity[]> {
+    if (await this.isMigrated(workspaceId)) {
+      return this.coreRepository.find({
+        where: {
+          ...(where as Record<string, unknown>),
+          workspaceId,
+        } as FindOptionsWhere<MessageChannelEntity>,
+      }) as unknown as Promise<MessageChannelWorkspaceEntity[]>;
+    }
+
+    const workspaceRepository = await this.getWorkspaceRepository(workspaceId);
+
+    return workspaceRepository.find({ where });
+  }
+
+  async findMany(
+    workspaceId: string,
+    options: FindManyOptions<MessageChannelWorkspaceEntity>,
+  ): Promise<MessageChannelWorkspaceEntity[]> {
+    if (await this.isMigrated(workspaceId)) {
+      const baseWhere = options.where;
+
+      if (!baseWhere) {
+        return this.coreRepository.find({
+          ...options,
+          where: { workspaceId },
+        } as FindManyOptions<MessageChannelEntity>) as unknown as Promise<
+          MessageChannelWorkspaceEntity[]
+        >;
+      }
+
+      if (Array.isArray(baseWhere)) {
+        const coreWhereArray = await Promise.all(
+          baseWhere.map((whereItem) =>
+            this.toCoreWhere(workspaceId, whereItem as Record<string, unknown>),
+          ),
+        );
+
+        return this.coreRepository.find({
+          ...options,
+          where: coreWhereArray,
+        } as FindManyOptions<MessageChannelEntity>) as unknown as Promise<
+          MessageChannelWorkspaceEntity[]
+        >;
+      }
+
+      const coreWhere = await this.toCoreWhere(
+        workspaceId,
+        baseWhere as Record<string, unknown>,
+      );
+
+      return this.coreRepository.find({
+        ...options,
+        where: coreWhere,
+      } as FindManyOptions<MessageChannelEntity>) as unknown as Promise<
+        MessageChannelWorkspaceEntity[]
+      >;
+    }
+
+    const workspaceRepository = await this.getWorkspaceRepository(workspaceId);
+
+    return workspaceRepository.find(options);
+  }
+
+  async save(
+    workspaceId: string,
+    data: Partial<MessageChannelWorkspaceEntity>,
+    manager?: WorkspaceEntityManager,
+  ): Promise<void> {
+    const workspaceRepository = await this.getWorkspaceRepository(workspaceId);
+
+    await workspaceRepository.save(data, {}, manager);
+
+    if (await this.isMigrated(workspaceId)) {
+      try {
+        await this.coreRepository.save({
+          ...data,
+          workspaceId,
+        } as unknown as MessageChannelEntity);
+      } catch (error) {
+        this.logger.error(
+          `Failed to dual-write messageChannel to core: ${error}`,
+        );
+        throw error;
+      }
+    }
+  }
+
+  async update(
+    workspaceId: string,
+    where: FindOptionsWhere<MessageChannelWorkspaceEntity>,
+    data: Partial<MessageChannelWorkspaceEntity>,
+    manager?: WorkspaceEntityManager,
+  ): Promise<void> {
+    const workspaceRepository = await this.getWorkspaceRepository(workspaceId);
+
+    await workspaceRepository.update(where, data, manager);
+
+    if (await this.isMigrated(workspaceId)) {
+      try {
+        await this.coreRepository.update(
+          { ...where, workspaceId } as FindOptionsWhere<MessageChannelEntity>,
+          data as never,
+        );
+      } catch (error) {
+        this.logger.error(
+          `Failed to dual-write messageChannel update to core: ${error}`,
+        );
+        throw error;
+      }
+    }
+  }
+
+  async increment(
+    workspaceId: string,
+    where: FindOptionsWhere<MessageChannelWorkspaceEntity>,
+    propertyPath: string,
+    value: number,
+  ): Promise<void> {
+    const workspaceRepository = await this.getWorkspaceRepository(workspaceId);
+
+    await workspaceRepository.increment(where, propertyPath, value, undefined, [
+      propertyPath,
+      'id',
+    ]);
+
+    if (await this.isMigrated(workspaceId)) {
+      try {
+        await this.coreRepository.increment(
+          {
+            ...where,
+            workspaceId,
+          } as FindOptionsWhere<MessageChannelEntity>,
+          propertyPath,
+          value,
+        );
+      } catch (error) {
+        this.logger.error(
+          `Failed to dual-write messageChannel increment to core: ${error}`,
+        );
+        throw error;
+      }
+    }
+  }
+
+  async delete(
+    workspaceId: string,
+    where: FindOptionsWhere<MessageChannelWorkspaceEntity>,
+  ): Promise<void> {
+    const workspaceRepository = await this.getWorkspaceRepository(workspaceId);
+
+    await workspaceRepository.delete(where);
+
+    if (await this.isMigrated(workspaceId)) {
+      try {
+        await this.coreRepository.delete({
+          ...where,
+          workspaceId,
+        } as FindOptionsWhere<MessageChannelEntity>);
+      } catch (error) {
+        this.logger.error(
+          `Failed to dual-write messageChannel delete to core: ${error}`,
+        );
+        throw error;
+      }
+    }
+  }
+}

packages/twenty-server/src/engine/metadata-modules/message-channel/dtos/create-message-channel.input.ts

@@ -0,0 +1,88 @@
+import { Field, InputType } from '@nestjs/graphql';
+
+import {
+  IsBoolean,
+  IsEnum,
+  IsNotEmpty,
+  IsOptional,
+  IsString,
+  IsUUID,
+} from 'class-validator';
+import {
+  MessageChannelContactAutoCreationPolicy,
+  MessageChannelPendingGroupEmailsAction,
+  MessageChannelSyncStage,
+  MessageChannelType,
+  MessageChannelVisibility,
+  MessageFolderImportPolicy,
+} from 'twenty-shared/types';
+
+import { UUIDScalarType } from 'src/engine/api/graphql/workspace-schema-builder/graphql-types/scalars';
+
+@InputType()
+export class CreateMessageChannelInput {
+  @IsUUID()
+  @IsOptional()
+  @Field(() => UUIDScalarType, { nullable: true })
+  id?: string;
+
+  @IsString()
+  @IsNotEmpty()
+  @Field()
+  handle: string;
+
+  @IsEnum(MessageChannelVisibility)
+  @IsNotEmpty()
+  @Field(() => MessageChannelVisibility)
+  visibility: MessageChannelVisibility;
+
+  @IsEnum(MessageChannelType)
+  @IsNotEmpty()
+  @Field(() => MessageChannelType)
+  type: MessageChannelType;
+
+  @IsEnum(MessageChannelSyncStage)
+  @IsNotEmpty()
+  @Field(() => MessageChannelSyncStage)
+  syncStage: MessageChannelSyncStage;
+
+  @IsUUID()
+  @IsNotEmpty()
+  @Field(() => UUIDScalarType)
+  connectedAccountId: string;
+
+  @IsBoolean()
+  @IsNotEmpty()
+  @Field()
+  isContactAutoCreationEnabled: boolean;
+
+  @IsEnum(MessageChannelContactAutoCreationPolicy)
+  @IsNotEmpty()
+  @Field(() => MessageChannelContactAutoCreationPolicy)
+  contactAutoCreationPolicy: MessageChannelContactAutoCreationPolicy;
+
+  @IsEnum(MessageFolderImportPolicy)
+  @IsNotEmpty()
+  @Field(() => MessageFolderImportPolicy)
+  messageFolderImportPolicy: MessageFolderImportPolicy;
+
+  @IsBoolean()
+  @IsNotEmpty()
+  @Field()
+  excludeNonProfessionalEmails: boolean;
+
+  @IsBoolean()
+  @IsNotEmpty()
+  @Field()
+  excludeGroupEmails: boolean;
+
+  @IsEnum(MessageChannelPendingGroupEmailsAction)
+  @IsNotEmpty()
+  @Field(() => MessageChannelPendingGroupEmailsAction)
+  pendingGroupEmailsAction: MessageChannelPendingGroupEmailsAction;
+
+  @IsBoolean()
+  @IsNotEmpty()
+  @Field()
+  isSyncEnabled: boolean;
+}

packages/twenty-server/src/engine/metadata-modules/message-channel/dtos/message-channel.dto.ts

@@ -0,0 +1,127 @@
+import { Field, HideField, ObjectType } from '@nestjs/graphql';
+
+import {
+  IsBoolean,
+  IsDateString,
+  IsEnum,
+  IsInt,
+  IsNotEmpty,
+  IsOptional,
+  IsString,
+  IsUUID,
+} from 'class-validator';
+import {
+  MessageChannelContactAutoCreationPolicy,
+  MessageChannelPendingGroupEmailsAction,
+  MessageChannelSyncStage,
+  MessageChannelSyncStatus,
+  MessageChannelType,
+  MessageChannelVisibility,
+  MessageFolderImportPolicy,
+} from 'twenty-shared/types';
+
+import { UUIDScalarType } from 'src/engine/api/graphql/workspace-schema-builder/graphql-types/scalars';
+
+@ObjectType('MessageChannel')
+export class MessageChannelDTO {
+  @IsUUID()
+  @IsNotEmpty()
+  @Field(() => UUIDScalarType)
+  id: string;
+
+  @IsEnum(MessageChannelVisibility)
+  @IsNotEmpty()
+  @Field(() => MessageChannelVisibility)
+  visibility: MessageChannelVisibility;
+
+  @IsString()
+  @IsNotEmpty()
+  @Field()
+  handle: string;
+
+  @IsEnum(MessageChannelType)
+  @IsNotEmpty()
+  @Field(() => MessageChannelType)
+  type: MessageChannelType;
+
+  @IsBoolean()
+  @Field()
+  isContactAutoCreationEnabled: boolean;
+
+  @IsEnum(MessageChannelContactAutoCreationPolicy)
+  @IsNotEmpty()
+  @Field(() => MessageChannelContactAutoCreationPolicy)
+  contactAutoCreationPolicy: MessageChannelContactAutoCreationPolicy;
+
+  @IsEnum(MessageFolderImportPolicy)
+  @IsNotEmpty()
+  @Field(() => MessageFolderImportPolicy)
+  messageFolderImportPolicy: MessageFolderImportPolicy;
+
+  @IsBoolean()
+  @Field()
+  excludeNonProfessionalEmails: boolean;
+
+  @IsBoolean()
+  @Field()
+  excludeGroupEmails: boolean;
+
+  @IsEnum(MessageChannelPendingGroupEmailsAction)
+  @IsNotEmpty()
+  @Field(() => MessageChannelPendingGroupEmailsAction)
+  pendingGroupEmailsAction: MessageChannelPendingGroupEmailsAction;
+
+  @IsBoolean()
+  @Field()
+  isSyncEnabled: boolean;
+
+  @IsString()
+  @IsOptional()
+  @Field(() => String, { nullable: true })
+  syncCursor: string | null;
+
+  @IsDateString()
+  @IsOptional()
+  @Field(() => Date, { nullable: true })
+  syncedAt: Date | null;
+
+  @IsEnum(MessageChannelSyncStatus)
+  @IsNotEmpty()
+  @Field(() => MessageChannelSyncStatus)
+  syncStatus: MessageChannelSyncStatus;
+
+  @IsEnum(MessageChannelSyncStage)
+  @IsNotEmpty()
+  @Field(() => MessageChannelSyncStage)
+  syncStage: MessageChannelSyncStage;
+
+  @IsDateString()
+  @IsOptional()
+  @Field(() => Date, { nullable: true })
+  syncStageStartedAt: Date | null;
+
+  @IsInt()
+  @Field()
+  throttleFailureCount: number;
+
+  @IsDateString()
+  @IsOptional()
+  @Field(() => Date, { nullable: true })
+  throttleRetryAfter: Date | null;
+
+  @IsUUID()
+  @IsNotEmpty()
+  @Field(() => UUIDScalarType)
+  connectedAccountId: string;
+
+  @HideField()
+  workspaceId: string;
+
+  @IsDateString()
+  @Field()
+  createdAt: Date;
+
+  @IsDateString()
+  @Field()
+  updatedAt: Date;
+}

packages/twenty-server/src/engine/metadata-modules/message-channel/dtos/update-message-channel.input.ts

@@ -0,0 +1,69 @@
+import { Field, InputType } from '@nestjs/graphql';
+
+import { Type } from 'class-transformer';
+import {
+  IsBoolean,
+  IsEnum,
+  IsNotEmpty,
+  IsOptional,
+  IsUUID,
+  ValidateNested,
+} from 'class-validator';
+import {
+  MessageChannelContactAutoCreationPolicy,
+  MessageChannelVisibility,
+  MessageFolderImportPolicy,
+} from 'twenty-shared/types';
+
+import { UUIDScalarType } from 'src/engine/api/graphql/workspace-schema-builder/graphql-types/scalars';
+
+@InputType()
+export class UpdateMessageChannelInputUpdates {
+  @IsOptional()
+  @IsEnum(MessageChannelVisibility)
+  @Field(() => MessageChannelVisibility, { nullable: true })
+  visibility?: MessageChannelVisibility;
+
+  @IsOptional()
+  @IsBoolean()
+  @Field({ nullable: true })
+  isContactAutoCreationEnabled?: boolean;
+
+  @IsOptional()
+  @IsEnum(MessageChannelContactAutoCreationPolicy)
+  @Field(() => MessageChannelContactAutoCreationPolicy, { nullable: true })
+  contactAutoCreationPolicy?: MessageChannelContactAutoCreationPolicy;
+
+  @IsOptional()
+  @IsEnum(MessageFolderImportPolicy)
+  @Field(() => MessageFolderImportPolicy, { nullable: true })
+  messageFolderImportPolicy?: MessageFolderImportPolicy;
+
+  @IsOptional()
+  @IsBoolean()
+  @Field({ nullable: true })
+  isSyncEnabled?: boolean;
+
+  @IsOptional()
+  @IsBoolean()
+  @Field({ nullable: true })
+  excludeNonProfessionalEmails?: boolean;
+
+  @IsOptional()
+  @IsBoolean()
+  @Field({ nullable: true })
+  excludeGroupEmails?: boolean;
+}
+
+@InputType()
+export class UpdateMessageChannelInput {
+  @IsUUID()
+  @IsNotEmpty()
+  @Field(() => UUIDScalarType)
+  id: string;
+
+  @Type(() => UpdateMessageChannelInputUpdates)
+  @ValidateNested()
+  @Field(() => UpdateMessageChannelInputUpdates)
+  update: UpdateMessageChannelInputUpdates;
+}

packages/twenty-server/src/engine/metadata-modules/message-channel/entities/message-channel.entity.ts

@@ -0,0 +1,134 @@
+import {
+  Column,
+  CreateDateColumn,
+  Entity,
+  JoinColumn,
+  ManyToOne,
+  OneToMany,
+  PrimaryGeneratedColumn,
+  type Relation,
+  UpdateDateColumn,
+} from 'typeorm';
+
+import {
+  MessageChannelContactAutoCreationPolicy,
+  MessageChannelPendingGroupEmailsAction,
+  MessageChannelSyncStage,
+  MessageChannelSyncStatus,
+  MessageChannelType,
+  MessageChannelVisibility,
+  MessageFolderImportPolicy,
+} from 'twenty-shared/types';
+
+import { ConnectedAccountEntity } from 'src/engine/metadata-modules/connected-account/entities/connected-account.entity';
+import { type MessageFolderEntity } from 'src/engine/metadata-modules/message-folder/entities/message-folder.entity';
+import { WorkspaceRelatedEntity } from 'src/engine/workspace-manager/types/workspace-related-entity';
+
+@Entity({ name: 'messageChannel', schema: 'core' })
+export class MessageChannelEntity extends WorkspaceRelatedEntity {
+  @PrimaryGeneratedColumn('uuid')
+  id: string;
+
+  @Column({
+    type: 'enum',
+    enum: MessageChannelVisibility,
+    nullable: false,
+  })
+  visibility: MessageChannelVisibility;
+
+  @Column({ type: 'varchar', nullable: false })
+  handle: string;
+
+  @Column({
+    type: 'enum',
+    enum: MessageChannelType,
+    nullable: false,
+  })
+  type: MessageChannelType;
+
+  @Column({ type: 'boolean', nullable: false })
+  isContactAutoCreationEnabled: boolean;
+
+  @Column({
+    type: 'enum',
+    enum: MessageChannelContactAutoCreationPolicy,
+    nullable: false,
+  })
+  contactAutoCreationPolicy: MessageChannelContactAutoCreationPolicy;
+
+  @Column({
+    type: 'enum',
+    enum: MessageFolderImportPolicy,
+    nullable: false,
+  })
+  messageFolderImportPolicy: MessageFolderImportPolicy;
+
+  @Column({ type: 'boolean', nullable: false })
+  excludeNonProfessionalEmails: boolean;
+
+  @Column({ type: 'boolean', nullable: false })
+  excludeGroupEmails: boolean;
+
+  @Column({
+    type: 'enum',
+    enum: MessageChannelPendingGroupEmailsAction,
+    nullable: false,
+  })
+  pendingGroupEmailsAction: MessageChannelPendingGroupEmailsAction;
+
+  @Column({ type: 'boolean', nullable: false })
+  isSyncEnabled: boolean;
+
+  @Column({ type: 'varchar', nullable: true })
+  syncCursor: string | null;
+
+  @Column({ type: 'timestamptz', nullable: true })
+  syncedAt: Date | null;
+
+  @Column({
+    type: 'enum',
+    enum: MessageChannelSyncStatus,
+    nullable: false,
+    default: MessageChannelSyncStatus.NOT_SYNCED,
+  })
+  syncStatus: MessageChannelSyncStatus;
+
+  @Column({
+    type: 'enum',
+    enum: MessageChannelSyncStage,
+    nullable: false,
+  })
+  syncStage: MessageChannelSyncStage;
+
+  @Column({ type: 'timestamptz', nullable: true })
+  syncStageStartedAt: Date | null;
+
+  @Column({ type: 'integer', nullable: false, default: 0 })
+  throttleFailureCount: number;
+
+  @Column({ type: 'timestamptz', nullable: true })
+  throttleRetryAfter: Date | null;
+
+  @Column({ type: 'uuid', nullable: false })
+  connectedAccountId: string;
+
+  @ManyToOne(
+    () => ConnectedAccountEntity,
+    (connectedAccount) => connectedAccount.messageChannels,
+    { onDelete: 'CASCADE' },
+  )
+  @JoinColumn({ name: 'connectedAccountId' })
+  connectedAccount: Relation<ConnectedAccountEntity>;
+
+  @OneToMany(
+    'MessageFolderEntity',
+    (messageFolder: MessageFolderEntity) => messageFolder.messageChannel,
+  )
+  messageFolders: Relation<MessageFolderEntity[]>;
+
+  @CreateDateColumn({ type: 'timestamptz' })
+  createdAt: Date;
+
+  @UpdateDateColumn({ type: 'timestamptz' })
+  updatedAt: Date;
+}

packages/twenty-server/src/engine/metadata-modules/message-channel/interceptors/message-channel-graphql-api-exception.interceptor.ts

@@ -0,0 +1,24 @@
+import {
+  type CallHandler,
+  type ExecutionContext,
+  Injectable,
+  type NestInterceptor,
+} from '@nestjs/common';
+
+import { type Observable, catchError } from 'rxjs';
+
+import { messageChannelGraphqlApiExceptionHandler } from 'src/engine/metadata-modules/message-channel/utils/message-channel-graphql-api-exception-handler.util';
+
+@Injectable()
+export class MessageChannelGraphqlApiExceptionInterceptor
+  implements NestInterceptor
+{
+  intercept(
+    _context: ExecutionContext,
+    next: CallHandler,
+  ): Observable<unknown> {
+    return next
+      .handle()
+      .pipe(catchError(messageChannelGraphqlApiExceptionHandler));
+  }
+}

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

@@ -0,0 +1,26 @@
+import { Module } from '@nestjs/common';
+import { TypeOrmModule } from '@nestjs/typeorm';
+
+import { AuthModule } from 'src/engine/core-modules/auth/auth.module';
+import { FeatureFlagModule } from 'src/engine/core-modules/feature-flag/feature-flag.module';
+import { MessageChannelEntity } from 'src/engine/metadata-modules/message-channel/entities/message-channel.entity';
+import { MessageChannelGraphqlApiExceptionInterceptor } from 'src/engine/metadata-modules/message-channel/interceptors/message-channel-graphql-api-exception.interceptor';
+import { MessageChannelMetadataService } from 'src/engine/metadata-modules/message-channel/message-channel-metadata.service';
+import { MessageChannelResolver } from 'src/engine/metadata-modules/message-channel/resolvers/message-channel.resolver';
+import { PermissionsModule } from 'src/engine/metadata-modules/permissions/permissions.module';
+
+@Module({
+  imports: [
+    TypeOrmModule.forFeature([MessageChannelEntity]),
+    AuthModule,
+    PermissionsModule,
+    FeatureFlagModule,
+  ],
+  providers: [
+    MessageChannelMetadataService,
+    MessageChannelResolver,
+    MessageChannelGraphqlApiExceptionInterceptor,
+  ],
+  exports: [MessageChannelMetadataService],
+})
+export class MessageChannelMetadataModule {}

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

@@ -0,0 +1,79 @@
+import { Injectable } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+
+import { Repository } from 'typeorm';
+
+import {
+  MessageChannelSyncStage,
+  MessageChannelType,
+  MessageChannelVisibility,
+} from 'twenty-shared/types';
+
+import { MessageChannelDTO } from 'src/engine/metadata-modules/message-channel/dtos/message-channel.dto';
+import { MessageChannelEntity } from 'src/engine/metadata-modules/message-channel/entities/message-channel.entity';
+
+@Injectable()
+export class MessageChannelMetadataService {
+  constructor(
+    @InjectRepository(MessageChannelEntity)
+    private readonly repository: Repository<MessageChannelEntity>,
+  ) {}
+
+  async findAll(workspaceId: string): Promise<MessageChannelDTO[]> {
+    return this.repository.find({ where: { workspaceId } });
+  }
+
+  async findByConnectedAccountId(
+    connectedAccountId: string,
+    workspaceId: string,
+  ): Promise<MessageChannelDTO[]> {
+    return this.repository.find({
+      where: { connectedAccountId, workspaceId },
+    });
+  }
+
+  async findById(
+    id: string,
+    workspaceId: string,
+  ): Promise<MessageChannelDTO | null> {
+    return this.repository.findOne({ where: { id, workspaceId } });
+  }
+
+  async create(
+    data: Partial<MessageChannelEntity> & {
+      workspaceId: string;
+      handle: string;
+      connectedAccountId: string;
+      visibility: MessageChannelVisibility;
+      type: MessageChannelType;
+      syncStage: MessageChannelSyncStage;
+    },
+  ): Promise<MessageChannelDTO> {
+    const entity = this.repository.create(data);
+
+    return this.repository.save(entity);
+  }
+
+  async update(
+    id: string,
+    workspaceId: string,
+    data: Partial<MessageChannelEntity>,
+  ): Promise<MessageChannelDTO> {
+    await this.repository.update(
+      { id, workspaceId },
+      data as Record<string, unknown>,
+    );
+
+    return this.repository.findOneOrFail({ where: { id, workspaceId } });
+  }
+
+  async delete(id: string, workspaceId: string): Promise<MessageChannelDTO> {
+    const entity = await this.repository.findOneOrFail({
+      where: { id, workspaceId },
+    });
+
+    await this.repository.delete({ id, workspaceId });
+
+    return entity;
+  }
+}

packages/twenty-server/src/engine/metadata-modules/message-channel/message-channel.exception.ts

@@ -0,0 +1,37 @@
+import { type MessageDescriptor } from '@lingui/core';
+import { msg } from '@lingui/core/macro';
+import { assertUnreachable } from 'twenty-shared/utils';
+
+import { CustomException } from 'src/utils/custom-exception';
+
+export enum MessageChannelExceptionCode {
+  MESSAGE_CHANNEL_NOT_FOUND = 'MESSAGE_CHANNEL_NOT_FOUND',
+  INVALID_MESSAGE_CHANNEL_INPUT = 'INVALID_MESSAGE_CHANNEL_INPUT',
+}
+
+const getMessageChannelExceptionUserFriendlyMessage = (
+  code: MessageChannelExceptionCode,
+) => {
+  switch (code) {
+    case MessageChannelExceptionCode.MESSAGE_CHANNEL_NOT_FOUND:
+      return msg`Message channel not found.`;
+    case MessageChannelExceptionCode.INVALID_MESSAGE_CHANNEL_INPUT:
+      return msg`Invalid message channel input.`;
+    default:
+      assertUnreachable(code);
+  }
+};
+
+export class MessageChannelException extends CustomException<MessageChannelExceptionCode> {
+  constructor(
+    message: string,
+    code: MessageChannelExceptionCode,
+    { userFriendlyMessage }: { userFriendlyMessage?: MessageDescriptor } = {},
+  ) {
+    super(message, code, {
+      userFriendlyMessage:
+        userFriendlyMessage ??
+        getMessageChannelExceptionUserFriendlyMessage(code),
+    });
+  }
+}

packages/twenty-server/src/engine/metadata-modules/message-channel/resolvers/message-channel.resolver.ts

@@ -0,0 +1,98 @@
+import { UseGuards, UseInterceptors } from '@nestjs/common';
+import { Args, Mutation, Query } from '@nestjs/graphql';
+
+import { PermissionFlagType } from 'twenty-shared/constants';
+import { FeatureFlagKey } from 'twenty-shared/types';
+
+import { UUIDScalarType } from 'src/engine/api/graphql/workspace-schema-builder/graphql-types/scalars';
+import { MetadataResolver } from 'src/engine/api/graphql/graphql-config/decorators/metadata-resolver.decorator';
+import { WorkspaceEntity } from 'src/engine/core-modules/workspace/workspace.entity';
+import { AuthWorkspace } from 'src/engine/decorators/auth/auth-workspace.decorator';
+import {
+  FeatureFlagGuard,
+  RequireFeatureFlag,
+} from 'src/engine/guards/feature-flag.guard';
+import { SettingsPermissionGuard } from 'src/engine/guards/settings-permission.guard';
+import { WorkspaceAuthGuard } from 'src/engine/guards/workspace-auth.guard';
+import { CreateMessageChannelInput } from 'src/engine/metadata-modules/message-channel/dtos/create-message-channel.input';
+import { MessageChannelDTO } from 'src/engine/metadata-modules/message-channel/dtos/message-channel.dto';
+import { UpdateMessageChannelInput } from 'src/engine/metadata-modules/message-channel/dtos/update-message-channel.input';
+import { MessageChannelGraphqlApiExceptionInterceptor } from 'src/engine/metadata-modules/message-channel/interceptors/message-channel-graphql-api-exception.interceptor';
+import { MessageChannelMetadataService } from 'src/engine/metadata-modules/message-channel/message-channel-metadata.service';
+
+@UseGuards(WorkspaceAuthGuard, FeatureFlagGuard)
+@UseInterceptors(MessageChannelGraphqlApiExceptionInterceptor)
+@MetadataResolver(() => MessageChannelDTO)
+export class MessageChannelResolver {
+  constructor(
+    private readonly messageChannelMetadataService: MessageChannelMetadataService,
+  ) {}
+
+  @Query(() => [MessageChannelDTO])
+  @UseGuards(SettingsPermissionGuard(PermissionFlagType.CONNECTED_ACCOUNTS))
+  @RequireFeatureFlag(FeatureFlagKey.IS_CONNECTED_ACCOUNT_MIGRATED)
+  async messageChannels(
+    @AuthWorkspace() workspace: WorkspaceEntity,
+    @Args('connectedAccountId', {
+      type: () => UUIDScalarType,
+      nullable: true,
+    })
+    connectedAccountId?: string,
+  ): Promise<MessageChannelDTO[]> {
+    if (connectedAccountId) {
+      return this.messageChannelMetadataService.findByConnectedAccountId(
+        connectedAccountId,
+        workspace.id,
+      );
+    }
+
+    return this.messageChannelMetadataService.findAll(workspace.id);
+  }
+
+  @Query(() => MessageChannelDTO, { nullable: true })
+  @UseGuards(SettingsPermissionGuard(PermissionFlagType.CONNECTED_ACCOUNTS))
+  @RequireFeatureFlag(FeatureFlagKey.IS_CONNECTED_ACCOUNT_MIGRATED)
+  async messageChannel(
+    @Args('id', { type: () => UUIDScalarType }) id: string,
+    @AuthWorkspace() workspace: WorkspaceEntity,
+  ): Promise<MessageChannelDTO | null> {
+    return this.messageChannelMetadataService.findById(id, workspace.id);
+  }
+
+  @Mutation(() => MessageChannelDTO)
+  @UseGuards(SettingsPermissionGuard(PermissionFlagType.CONNECTED_ACCOUNTS))
+  @RequireFeatureFlag(FeatureFlagKey.IS_CONNECTED_ACCOUNT_MIGRATED)
+  async createMessageChannel(
+    @Args('input') input: CreateMessageChannelInput,
+    @AuthWorkspace() workspace: WorkspaceEntity,
+  ): Promise<MessageChannelDTO> {
+    return this.messageChannelMetadataService.create({
+      ...input,
+      workspaceId: workspace.id,
+    });
+  }
+
+  @Mutation(() => MessageChannelDTO)
+  @UseGuards(SettingsPermissionGuard(PermissionFlagType.CONNECTED_ACCOUNTS))
+  @RequireFeatureFlag(FeatureFlagKey.IS_CONNECTED_ACCOUNT_MIGRATED)
+  async updateMessageChannel(
+    @Args('input') input: UpdateMessageChannelInput,
+    @AuthWorkspace() workspace: WorkspaceEntity,
+  ): Promise<MessageChannelDTO> {
+    return this.messageChannelMetadataService.update(
+      input.id,
+      workspace.id,
+      input.update,
+    );
+  }
+
+  @Mutation(() => MessageChannelDTO)
+  @UseGuards(SettingsPermissionGuard(PermissionFlagType.CONNECTED_ACCOUNTS))
+  @RequireFeatureFlag(FeatureFlagKey.IS_CONNECTED_ACCOUNT_MIGRATED)
+  async deleteMessageChannel(
+    @Args('id', { type: () => UUIDScalarType }) id: string,
+    @AuthWorkspace() workspace: WorkspaceEntity,
+  ): Promise<MessageChannelDTO> {
+    return this.messageChannelMetadataService.delete(id, workspace.id);
+  }
+}

packages/twenty-server/src/engine/metadata-modules/message-channel/utils/message-channel-graphql-api-exception-handler.util.ts

@@ -0,0 +1,26 @@
+import { assertUnreachable } from 'twenty-shared/utils';
+
+import {
+  NotFoundError,
+  UserInputError,
+} from 'src/engine/core-modules/graphql/utils/graphql-errors.util';
+import {
+  MessageChannelException,
+  MessageChannelExceptionCode,
+} from 'src/engine/metadata-modules/message-channel/message-channel.exception';
+
+export const messageChannelGraphqlApiExceptionHandler = (error: Error) => {
+  if (error instanceof MessageChannelException) {
+    switch (error.code) {
+      case MessageChannelExceptionCode.MESSAGE_CHANNEL_NOT_FOUND:
+        throw new NotFoundError(error);
+      case MessageChannelExceptionCode.INVALID_MESSAGE_CHANNEL_INPUT:
+        throw new UserInputError(error);
+      default: {
+        return assertUnreachable(error.code);
+      }
+    }
+  }
+
+  throw error;
+};

packages/twenty-server/src/engine/metadata-modules/message-folder/data-access/message-folder-data-access.module.ts

@@ -0,0 +1,13 @@
+import { Module } from '@nestjs/common';
+import { TypeOrmModule } from '@nestjs/typeorm';
+
+import { FeatureFlagModule } from 'src/engine/core-modules/feature-flag/feature-flag.module';
+import { MessageFolderDataAccessService } from 'src/engine/metadata-modules/message-folder/data-access/services/message-folder-data-access.service';
+import { MessageFolderEntity } from 'src/engine/metadata-modules/message-folder/entities/message-folder.entity';
+
+@Module({
+  imports: [TypeOrmModule.forFeature([MessageFolderEntity]), FeatureFlagModule],
+  providers: [MessageFolderDataAccessService],
+  exports: [MessageFolderDataAccessService],
+})
+export class MessageFolderDataAccessModule {}

packages/twenty-server/src/engine/metadata-modules/message-folder/data-access/services/message-folder-data-access.service.ts

@@ -0,0 +1,157 @@
+import { Injectable, Logger } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+
+import { FeatureFlagKey } from 'twenty-shared/types';
+import {
+  type FindOneOptions,
+  type FindOptionsWhere,
+  Repository,
+} from 'typeorm';
+
+import { FeatureFlagService } from 'src/engine/core-modules/feature-flag/services/feature-flag.service';
+import { MessageFolderEntity } from 'src/engine/metadata-modules/message-folder/entities/message-folder.entity';
+import { type WorkspaceEntityManager } from 'src/engine/twenty-orm/entity-manager/workspace-entity-manager';
+import { GlobalWorkspaceOrmManager } from 'src/engine/twenty-orm/global-workspace-datasource/global-workspace-orm.manager';
+import { type MessageFolderWorkspaceEntity } from 'src/modules/messaging/common/standard-objects/message-folder.workspace-entity';
+
+@Injectable()
+export class MessageFolderDataAccessService {
+  private readonly logger = new Logger(MessageFolderDataAccessService.name);
+
+  constructor(
+    @InjectRepository(MessageFolderEntity)
+    private readonly coreRepository: Repository<MessageFolderEntity>,
+    private readonly featureFlagService: FeatureFlagService,
+    private readonly globalWorkspaceOrmManager: GlobalWorkspaceOrmManager,
+  ) {}
+
+  private async isMigrated(workspaceId: string): Promise<boolean> {
+    return this.featureFlagService.isFeatureEnabled(
+      FeatureFlagKey.IS_CONNECTED_ACCOUNT_MIGRATED,
+      workspaceId,
+    );
+  }
+
+  async getWorkspaceRepository(workspaceId: string) {
+    return this.globalWorkspaceOrmManager.getRepository<MessageFolderWorkspaceEntity>(
+      workspaceId,
+      'messageFolder',
+    );
+  }
+
+  async findOne(
+    workspaceId: string,
+    options: FindOneOptions<MessageFolderWorkspaceEntity>,
+  ): Promise<MessageFolderWorkspaceEntity | null> {
+    if (await this.isMigrated(workspaceId)) {
+      const where = options.where as Record<string, unknown>;
+      const coreWhere = Array.isArray(where)
+        ? where.map((whereItem) => ({
+            ...(whereItem as Record<string, unknown>),
+            workspaceId,
+          }))
+        : {
+            ...(where as Record<string, unknown>),
+            workspaceId,
+          };
+
+      return this.coreRepository.findOne({
+        ...options,
+        where: coreWhere,
+      } as FindOneOptions<MessageFolderEntity>) as unknown as Promise<MessageFolderWorkspaceEntity | null>;
+    }
+
+    const workspaceRepository = await this.getWorkspaceRepository(workspaceId);
+
+    return workspaceRepository.findOne(options);
+  }
+
+  async find(
+    workspaceId: string,
+    where?: FindOptionsWhere<MessageFolderWorkspaceEntity>,
+  ): Promise<MessageFolderWorkspaceEntity[]> {
+    if (await this.isMigrated(workspaceId)) {
+      return this.coreRepository.find({
+        where: {
+          ...(where as Record<string, unknown>),
+          workspaceId,
+        } as FindOptionsWhere<MessageFolderEntity>,
+      }) as unknown as Promise<MessageFolderWorkspaceEntity[]>;
+    }
+
+    const workspaceRepository = await this.getWorkspaceRepository(workspaceId);
+
+    return workspaceRepository.find({ where });
+  }
+
+  async save(
+    workspaceId: string,
+    data: Partial<MessageFolderWorkspaceEntity>,
+  ): Promise<void> {
+    const workspaceRepository = await this.getWorkspaceRepository(workspaceId);
+
+    await workspaceRepository.save(data);
+
+    if (await this.isMigrated(workspaceId)) {
+      try {
+        await this.coreRepository.save({
+          ...data,
+          workspaceId,
+        } as unknown as MessageFolderEntity);
+      } catch (error) {
+        this.logger.error(
+          `Failed to dual-write messageFolder to core: ${error}`,
+        );
+        throw error;
+      }
+    }
+  }
+
+  async update(
+    workspaceId: string,
+    where: FindOptionsWhere<MessageFolderWorkspaceEntity>,
+    data: Partial<MessageFolderWorkspaceEntity>,
+    manager?: WorkspaceEntityManager,
+  ): Promise<void> {
+    const workspaceRepository = await this.getWorkspaceRepository(workspaceId);
+
+    await workspaceRepository.update(where, data, manager);
+
+    if (await this.isMigrated(workspaceId)) {
+      try {
+        await this.coreRepository.update(
+          { ...where, workspaceId } as FindOptionsWhere<MessageFolderEntity>,
+          data as Record<string, unknown>,
+        );
+      } catch (error) {
+        this.logger.error(
+          `Failed to dual-write messageFolder update to core: ${error}`,
+        );
+        throw error;
+      }
+    }
+  }
+
+  async delete(
+    workspaceId: string,
+    where: FindOptionsWhere<MessageFolderWorkspaceEntity>,
+  ): Promise<void> {
+    const workspaceRepository = await this.getWorkspaceRepository(workspaceId);
+
+    await workspaceRepository.delete(where);
+
+    if (await this.isMigrated(workspaceId)) {
+      try {
+        await this.coreRepository.delete({
+          ...where,
+          workspaceId,
+        } as FindOptionsWhere<MessageFolderEntity>);
+      } catch (error) {
+        this.logger.error(
+          `Failed to dual-write messageFolder delete to core: ${error}`,
+        );
+        throw error;
+      }
+    }
+  }
+}

packages/twenty-server/src/engine/metadata-modules/message-folder/dtos/create-message-folder.input.ts

@@ -0,0 +1,56 @@
+import { Field, InputType } from '@nestjs/graphql';
+
+import {
+  IsBoolean,
+  IsEnum,
+  IsNotEmpty,
+  IsOptional,
+  IsString,
+  IsUUID,
+} from 'class-validator';
+import { MessageFolderPendingSyncAction } from 'twenty-shared/types';
+
+import { UUIDScalarType } from 'src/engine/api/graphql/workspace-schema-builder/graphql-types/scalars';
+
+@InputType()
+export class CreateMessageFolderInput {
+  @IsUUID()
+  @IsOptional()
+  @Field(() => UUIDScalarType, { nullable: true })
+  id?: string;
+
+  @IsString()
+  @IsOptional()
+  @Field({ nullable: true })
+  name?: string;
+
+  @IsBoolean()
+  @IsNotEmpty()
+  @Field()
+  isSentFolder: boolean;
+
+  @IsBoolean()
+  @IsNotEmpty()
+  @Field()
+  isSynced: boolean;
+
+  @IsString()
+  @IsOptional()
+  @Field({ nullable: true })
+  externalId?: string;
+
+  @IsEnum(MessageFolderPendingSyncAction)
+  @IsNotEmpty()
+  @Field(() => MessageFolderPendingSyncAction)
+  pendingSyncAction: MessageFolderPendingSyncAction;
+
+  @IsUUID()
+  @IsNotEmpty()
+  @Field(() => UUIDScalarType)
+  messageChannelId: string;
+
+  @IsUUID()
+  @IsOptional()
+  @Field(() => UUIDScalarType, { nullable: true })
+  parentFolderId?: string;
+}

packages/twenty-server/src/engine/metadata-modules/message-folder/dtos/message-folder.dto.ts

@@ -0,0 +1,71 @@
+import { Field, HideField, ObjectType } from '@nestjs/graphql';
+
+import {
+  IsBoolean,
+  IsDateString,
+  IsEnum,
+  IsNotEmpty,
+  IsOptional,
+  IsString,
+  IsUUID,
+} from 'class-validator';
+import { MessageFolderPendingSyncAction } from 'twenty-shared/types';
+
+import { UUIDScalarType } from 'src/engine/api/graphql/workspace-schema-builder/graphql-types/scalars';
+
+@ObjectType('MessageFolder')
+export class MessageFolderDTO {
+  @IsUUID()
+  @IsNotEmpty()
+  @Field(() => UUIDScalarType)
+  id: string;
+
+  @IsString()
+  @IsOptional()
+  @Field(() => String, { nullable: true })
+  name: string | null;
+
+  @IsString()
+  @IsOptional()
+  @Field(() => String, { nullable: true })
+  syncCursor: string | null;
+
+  @IsBoolean()
+  @Field()
+  isSentFolder: boolean;
+
+  @IsBoolean()
+  @Field()
+  isSynced: boolean;
+
+  @IsUUID()
+  @IsOptional()
+  @Field(() => UUIDScalarType, { nullable: true })
+  parentFolderId: string | null;
+
+  @IsString()
+  @IsOptional()
+  @Field(() => String, { nullable: true })
+  externalId: string | null;
+
+  @IsEnum(MessageFolderPendingSyncAction)
+  @IsNotEmpty()
+  @Field(() => MessageFolderPendingSyncAction)
+  pendingSyncAction: MessageFolderPendingSyncAction;
+
+  @IsUUID()
+  @IsNotEmpty()
+  @Field(() => UUIDScalarType)
+  messageChannelId: string;
+
+  @HideField()
+  workspaceId: string;
+
+  @IsDateString()
+  @Field()
+  createdAt: Date;
+
+  @IsDateString()
+  @Field()
+  updatedAt: Date;
+}

packages/twenty-server/src/engine/metadata-modules/message-folder/dtos/update-message-folder.input.ts

@@ -0,0 +1,51 @@
+import { Field, InputType } from '@nestjs/graphql';
+
+import { Type } from 'class-transformer';
+import {
+  IsBoolean,
+  IsEnum,
+  IsNotEmpty,
+  IsOptional,
+  IsString,
+  IsUUID,
+  ValidateNested,
+} from 'class-validator';
+import { MessageFolderPendingSyncAction } from 'twenty-shared/types';
+
+import { UUIDScalarType } from 'src/engine/api/graphql/workspace-schema-builder/graphql-types/scalars';
+
+@InputType()
+export class UpdateMessageFolderInputUpdates {
+  @IsOptional()
+  @IsString()
+  @Field({ nullable: true })
+  name?: string;
+
+  @IsOptional()
+  @IsString()
+  @Field({ nullable: true })
+  syncCursor?: string;
+
+  @IsOptional()
+  @IsBoolean()
+  @Field({ nullable: true })
+  isSynced?: boolean;
+
+  @IsOptional()
+  @IsEnum(MessageFolderPendingSyncAction)
+  @Field(() => MessageFolderPendingSyncAction, { nullable: true })
+  pendingSyncAction?: MessageFolderPendingSyncAction;
+}
+
+@InputType()
+export class UpdateMessageFolderInput {
+  @IsUUID()
+  @IsNotEmpty()
+  @Field(() => UUIDScalarType)
+  id: string;
+
+  @Type(() => UpdateMessageFolderInputUpdates)
+  @ValidateNested()
+  @Field(() => UpdateMessageFolderInputUpdates)
+  update: UpdateMessageFolderInputUpdates;
+}

packages/twenty-server/src/engine/metadata-modules/message-folder/entities/message-folder.entity.ts

@@ -0,0 +1,63 @@
+import {
+  Column,
+  CreateDateColumn,
+  Entity,
+  JoinColumn,
+  ManyToOne,
+  PrimaryGeneratedColumn,
+  type Relation,
+  UpdateDateColumn,
+} from 'typeorm';
+
+import { MessageFolderPendingSyncAction } from 'twenty-shared/types';
+
+import { MessageChannelEntity } from 'src/engine/metadata-modules/message-channel/entities/message-channel.entity';
+import { WorkspaceRelatedEntity } from 'src/engine/workspace-manager/types/workspace-related-entity';
+
+@Entity({ name: 'messageFolder', schema: 'core' })
+export class MessageFolderEntity extends WorkspaceRelatedEntity {
+  @PrimaryGeneratedColumn('uuid')
+  id: string;
+
+  @Column({ type: 'varchar', nullable: true })
+  name: string | null;
+
+  @Column({ type: 'varchar', nullable: true })
+  syncCursor: string | null;
+
+  @Column({ type: 'boolean', nullable: false })
+  isSentFolder: boolean;
+
+  @Column({ type: 'boolean', nullable: false })
+  isSynced: boolean;
+
+  @Column({ type: 'uuid', nullable: true })
+  parentFolderId: string | null;
+
+  @Column({ type: 'varchar', nullable: true })
+  externalId: string | null;
+
+  @Column({
+    type: 'enum',
+    enum: MessageFolderPendingSyncAction,
+    nullable: false,
+  })
+  pendingSyncAction: MessageFolderPendingSyncAction;
+
+  @Column({ type: 'uuid', nullable: false })
+  messageChannelId: string;
+
+  @ManyToOne(
+    () => MessageChannelEntity,
+    (messageChannel) => messageChannel.messageFolders,
+    { onDelete: 'CASCADE' },
+  )
+  @JoinColumn({ name: 'messageChannelId' })
+  messageChannel: Relation<MessageChannelEntity>;
+
+  @CreateDateColumn({ type: 'timestamptz' })
+  createdAt: Date;
+
+  @UpdateDateColumn({ type: 'timestamptz' })
+  updatedAt: Date;
+}

packages/twenty-server/src/engine/metadata-modules/message-folder/interceptors/message-folder-graphql-api-exception.interceptor.ts

@@ -0,0 +1,24 @@
+import {
+  type CallHandler,
+  type ExecutionContext,
+  Injectable,
+  type NestInterceptor,
+} from '@nestjs/common';
+
+import { type Observable, catchError } from 'rxjs';
+
+import { messageFolderGraphqlApiExceptionHandler } from 'src/engine/metadata-modules/message-folder/utils/message-folder-graphql-api-exception-handler.util';
+
+@Injectable()
+export class MessageFolderGraphqlApiExceptionInterceptor
+  implements NestInterceptor
+{
+  intercept(
+    _context: ExecutionContext,
+    next: CallHandler,
+  ): Observable<unknown> {
+    return next
+      .handle()
+      .pipe(catchError(messageFolderGraphqlApiExceptionHandler));
+  }
+}

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

@@ -0,0 +1,26 @@
+import { Module } from '@nestjs/common';
+import { TypeOrmModule } from '@nestjs/typeorm';
+
+import { AuthModule } from 'src/engine/core-modules/auth/auth.module';
+import { FeatureFlagModule } from 'src/engine/core-modules/feature-flag/feature-flag.module';
+import { MessageFolderEntity } from 'src/engine/metadata-modules/message-folder/entities/message-folder.entity';
+import { MessageFolderGraphqlApiExceptionInterceptor } from 'src/engine/metadata-modules/message-folder/interceptors/message-folder-graphql-api-exception.interceptor';
+import { MessageFolderMetadataService } from 'src/engine/metadata-modules/message-folder/message-folder-metadata.service';
+import { MessageFolderResolver } from 'src/engine/metadata-modules/message-folder/resolvers/message-folder.resolver';
+import { PermissionsModule } from 'src/engine/metadata-modules/permissions/permissions.module';
+
+@Module({
+  imports: [
+    TypeOrmModule.forFeature([MessageFolderEntity]),
+    AuthModule,
+    PermissionsModule,
+    FeatureFlagModule,
+  ],
+  providers: [
+    MessageFolderMetadataService,
+    MessageFolderResolver,
+    MessageFolderGraphqlApiExceptionInterceptor,
+  ],
+  exports: [MessageFolderMetadataService],
+})
+export class MessageFolderMetadataModule {}

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

@@ -0,0 +1,72 @@
+import { Injectable } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+
+import { Repository } from 'typeorm';
+
+import { MessageFolderPendingSyncAction } from 'twenty-shared/types';
+
+import { MessageFolderDTO } from 'src/engine/metadata-modules/message-folder/dtos/message-folder.dto';
+import { MessageFolderEntity } from 'src/engine/metadata-modules/message-folder/entities/message-folder.entity';
+
+@Injectable()
+export class MessageFolderMetadataService {
+  constructor(
+    @InjectRepository(MessageFolderEntity)
+    private readonly repository: Repository<MessageFolderEntity>,
+  ) {}
+
+  async findAll(workspaceId: string): Promise<MessageFolderDTO[]> {
+    return this.repository.find({ where: { workspaceId } });
+  }
+
+  async findByMessageChannelId(
+    messageChannelId: string,
+    workspaceId: string,
+  ): Promise<MessageFolderDTO[]> {
+    return this.repository.find({
+      where: { messageChannelId, workspaceId },
+    });
+  }
+
+  async findById(
+    id: string,
+    workspaceId: string,
+  ): Promise<MessageFolderDTO | null> {
+    return this.repository.findOne({ where: { id, workspaceId } });
+  }
+
+  async create(
+    data: Partial<MessageFolderEntity> & {
+      workspaceId: string;
+      messageChannelId: string;
+      pendingSyncAction: MessageFolderPendingSyncAction;
+    },
+  ): Promise<MessageFolderDTO> {
+    const entity = this.repository.create(data);
+
+    return this.repository.save(entity);
+  }
+
+  async update(
+    id: string,
+    workspaceId: string,
+    data: Partial<MessageFolderEntity>,
+  ): Promise<MessageFolderDTO> {
+    await this.repository.update(
+      { id, workspaceId },
+      data as Record<string, unknown>,
+    );
+
+    return this.repository.findOneOrFail({ where: { id, workspaceId } });
+  }
+
+  async delete(id: string, workspaceId: string): Promise<MessageFolderDTO> {
+    const entity = await this.repository.findOneOrFail({
+      where: { id, workspaceId },
+    });
+
+    await this.repository.delete({ id, workspaceId });
+
+    return entity;
+  }
+}

packages/twenty-server/src/engine/metadata-modules/message-folder/message-folder.exception.ts

@@ -0,0 +1,37 @@
+import { type MessageDescriptor } from '@lingui/core';
+import { msg } from '@lingui/core/macro';
+import { assertUnreachable } from 'twenty-shared/utils';
+
+import { CustomException } from 'src/utils/custom-exception';
+
+export enum MessageFolderExceptionCode {
+  MESSAGE_FOLDER_NOT_FOUND = 'MESSAGE_FOLDER_NOT_FOUND',
+  INVALID_MESSAGE_FOLDER_INPUT = 'INVALID_MESSAGE_FOLDER_INPUT',
+}
+
+const getMessageFolderExceptionUserFriendlyMessage = (
+  code: MessageFolderExceptionCode,
+) => {
+  switch (code) {
+    case MessageFolderExceptionCode.MESSAGE_FOLDER_NOT_FOUND:
+      return msg`Message folder not found.`;
+    case MessageFolderExceptionCode.INVALID_MESSAGE_FOLDER_INPUT:
+      return msg`Invalid message folder input.`;
+    default:
+      assertUnreachable(code);
+  }
+};
+
+export class MessageFolderException extends CustomException<MessageFolderExceptionCode> {
+  constructor(
+    message: string,
+    code: MessageFolderExceptionCode,
+    { userFriendlyMessage }: { userFriendlyMessage?: MessageDescriptor } = {},
+  ) {
+    super(message, code, {
+      userFriendlyMessage:
+        userFriendlyMessage ??
+        getMessageFolderExceptionUserFriendlyMessage(code),
+    });
+  }
+}

packages/twenty-server/src/engine/metadata-modules/message-folder/resolvers/message-folder.resolver.ts

@@ -0,0 +1,98 @@
+import { UseGuards, UseInterceptors } from '@nestjs/common';
+import { Args, Mutation, Query } from '@nestjs/graphql';
+
+import { PermissionFlagType } from 'twenty-shared/constants';
+import { FeatureFlagKey } from 'twenty-shared/types';
+
+import { UUIDScalarType } from 'src/engine/api/graphql/workspace-schema-builder/graphql-types/scalars';
+import { MetadataResolver } from 'src/engine/api/graphql/graphql-config/decorators/metadata-resolver.decorator';
+import { WorkspaceEntity } from 'src/engine/core-modules/workspace/workspace.entity';
+import { AuthWorkspace } from 'src/engine/decorators/auth/auth-workspace.decorator';
+import {
+  FeatureFlagGuard,
+  RequireFeatureFlag,
+} from 'src/engine/guards/feature-flag.guard';
+import { SettingsPermissionGuard } from 'src/engine/guards/settings-permission.guard';
+import { WorkspaceAuthGuard } from 'src/engine/guards/workspace-auth.guard';
+import { CreateMessageFolderInput } from 'src/engine/metadata-modules/message-folder/dtos/create-message-folder.input';
+import { MessageFolderDTO } from 'src/engine/metadata-modules/message-folder/dtos/message-folder.dto';
+import { UpdateMessageFolderInput } from 'src/engine/metadata-modules/message-folder/dtos/update-message-folder.input';
+import { MessageFolderGraphqlApiExceptionInterceptor } from 'src/engine/metadata-modules/message-folder/interceptors/message-folder-graphql-api-exception.interceptor';
+import { MessageFolderMetadataService } from 'src/engine/metadata-modules/message-folder/message-folder-metadata.service';
+
+@UseGuards(WorkspaceAuthGuard, FeatureFlagGuard)
+@UseInterceptors(MessageFolderGraphqlApiExceptionInterceptor)
+@MetadataResolver(() => MessageFolderDTO)
+export class MessageFolderResolver {
+  constructor(
+    private readonly messageFolderMetadataService: MessageFolderMetadataService,
+  ) {}
+
+  @Query(() => [MessageFolderDTO])
+  @UseGuards(SettingsPermissionGuard(PermissionFlagType.CONNECTED_ACCOUNTS))
+  @RequireFeatureFlag(FeatureFlagKey.IS_CONNECTED_ACCOUNT_MIGRATED)
+  async messageFolders(
+    @AuthWorkspace() workspace: WorkspaceEntity,
+    @Args('messageChannelId', {
+      type: () => UUIDScalarType,
+      nullable: true,
+    })
+    messageChannelId?: string,
+  ): Promise<MessageFolderDTO[]> {
+    if (messageChannelId) {
+      return this.messageFolderMetadataService.findByMessageChannelId(
+        messageChannelId,
+        workspace.id,
+      );
+    }
+
+    return this.messageFolderMetadataService.findAll(workspace.id);
+  }
+
+  @Query(() => MessageFolderDTO, { nullable: true })
+  @UseGuards(SettingsPermissionGuard(PermissionFlagType.CONNECTED_ACCOUNTS))
+  @RequireFeatureFlag(FeatureFlagKey.IS_CONNECTED_ACCOUNT_MIGRATED)
+  async messageFolder(
+    @Args('id', { type: () => UUIDScalarType }) id: string,
+    @AuthWorkspace() workspace: WorkspaceEntity,
+  ): Promise<MessageFolderDTO | null> {
+    return this.messageFolderMetadataService.findById(id, workspace.id);
+  }
+
+  @Mutation(() => MessageFolderDTO)
+  @UseGuards(SettingsPermissionGuard(PermissionFlagType.CONNECTED_ACCOUNTS))
+  @RequireFeatureFlag(FeatureFlagKey.IS_CONNECTED_ACCOUNT_MIGRATED)
+  async createMessageFolder(
+    @Args('input') input: CreateMessageFolderInput,
+    @AuthWorkspace() workspace: WorkspaceEntity,
+  ): Promise<MessageFolderDTO> {
+    return this.messageFolderMetadataService.create({
+      ...input,
+      workspaceId: workspace.id,
+    });
+  }
+
+  @Mutation(() => MessageFolderDTO)
+  @UseGuards(SettingsPermissionGuard(PermissionFlagType.CONNECTED_ACCOUNTS))
+  @RequireFeatureFlag(FeatureFlagKey.IS_CONNECTED_ACCOUNT_MIGRATED)
+  async updateMessageFolder(
+    @Args('input') input: UpdateMessageFolderInput,
+    @AuthWorkspace() workspace: WorkspaceEntity,
+  ): Promise<MessageFolderDTO> {
+    return this.messageFolderMetadataService.update(
+      input.id,
+      workspace.id,
+      input.update,
+    );
+  }
+
+  @Mutation(() => MessageFolderDTO)
+  @UseGuards(SettingsPermissionGuard(PermissionFlagType.CONNECTED_ACCOUNTS))
+  @RequireFeatureFlag(FeatureFlagKey.IS_CONNECTED_ACCOUNT_MIGRATED)
+  async deleteMessageFolder(
+    @Args('id', { type: () => UUIDScalarType }) id: string,
+    @AuthWorkspace() workspace: WorkspaceEntity,
+  ): Promise<MessageFolderDTO> {
+    return this.messageFolderMetadataService.delete(id, workspace.id);
+  }
+}

packages/twenty-server/src/engine/metadata-modules/message-folder/utils/message-folder-graphql-api-exception-handler.util.ts

@@ -0,0 +1,26 @@
+import { assertUnreachable } from 'twenty-shared/utils';
+
+import {
+  NotFoundError,
+  UserInputError,
+} from 'src/engine/core-modules/graphql/utils/graphql-errors.util';
+import {
+  MessageFolderException,
+  MessageFolderExceptionCode,
+} from 'src/engine/metadata-modules/message-folder/message-folder.exception';
+
+export const messageFolderGraphqlApiExceptionHandler = (error: Error) => {
+  if (error instanceof MessageFolderException) {
+    switch (error.code) {
+      case MessageFolderExceptionCode.MESSAGE_FOLDER_NOT_FOUND:
+        throw new NotFoundError(error);
+      case MessageFolderExceptionCode.INVALID_MESSAGE_FOLDER_INPUT:
+        throw new UserInputError(error);
+      default: {
+        return assertUnreachable(error.code);
+      }
+    }
+  }
+
+  throw error;
+};

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

@@ -5,6 +5,8 @@ import { AiAgentMonitorModule } from 'src/engine/metadata-modules/ai/ai-agent-mo
 import { AiAgentModule } from 'src/engine/metadata-modules/ai/ai-agent/ai-agent.module';
 import { AiChatModule } from 'src/engine/metadata-modules/ai/ai-chat/ai-chat.module';
 import { AiGenerateTextModule } from 'src/engine/metadata-modules/ai/ai-generate-text/ai-generate-text.module';
+import { CalendarChannelMetadataModule } from 'src/engine/metadata-modules/calendar-channel/calendar-channel-metadata.module';
+import { ConnectedAccountMetadataModule } from 'src/engine/metadata-modules/connected-account/connected-account-metadata.module';
 import { CommandMenuItemModule } from 'src/engine/metadata-modules/command-menu-item/command-menu-item.module';
 import { DataSourceModule } from 'src/engine/metadata-modules/data-source/data-source.module';
 import { FieldMetadataModule } from 'src/engine/metadata-modules/field-metadata/field-metadata.module';
@@ -12,6 +14,8 @@ import { FlatEntityMapsGraphqlApiExceptionFilter } from 'src/engine/metadata-mod
 import { FrontComponentModule } from 'src/engine/metadata-modules/front-component/front-component.module';
 import { LogicFunctionLayerModule } from 'src/engine/metadata-modules/logic-function-layer/logic-function-layer.module';
 import { LogicFunctionModule } from 'src/engine/metadata-modules/logic-function/logic-function.module';
+import { MessageChannelMetadataModule } from 'src/engine/metadata-modules/message-channel/message-channel-metadata.module';
+import { MessageFolderMetadataModule } from 'src/engine/metadata-modules/message-folder/message-folder-metadata.module';
 import { NavigationMenuItemModule } from 'src/engine/metadata-modules/navigation-menu-item/navigation-menu-item.module';
 import { ObjectMetadataModule } from 'src/engine/metadata-modules/object-metadata/object-metadata.module';
 import { PermissionsModule } from 'src/engine/metadata-modules/permissions/permissions.module';
@@ -47,6 +51,10 @@ import { WorkspaceMetadataVersionModule } from 'src/engine/metadata-modules/work
     PermissionsModule,
     RouteTriggerModule,
     WebhookModule,
+    ConnectedAccountMetadataModule,
+    MessageChannelMetadataModule,
+    CalendarChannelMetadataModule,
+    MessageFolderMetadataModule,
   ],
   providers: [
     {
@@ -71,6 +79,10 @@ import { WorkspaceMetadataVersionModule } from 'src/engine/metadata-modules/work
     RoleModule,
     PermissionsModule,
     WebhookModule,
+    ConnectedAccountMetadataModule,
+    MessageChannelMetadataModule,
+    CalendarChannelMetadataModule,
+    MessageFolderMetadataModule,
   ],
 })
 export class MetadataEngineModule {}

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

@@ -250,6 +250,7 @@ describe('WorkspaceEntityManager', () => {
         IS_DATE_TIME_WHOLE_DAY_FILTER_ENABLED: false,
         IS_DRAFT_EMAIL_ENABLED: false,
         IS_RICH_TEXT_V1_MIGRATED: false,
+        IS_CONNECTED_ACCOUNT_MIGRATED: false,
       },
       userWorkspaceRoleMap: {},
       eventEmitterService: {