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
2026-03-20 00:34:58 +01:00
parent cd594ce8bd
commit cee4cf6452
149 changed files with 7338 additions and 1699 deletions
@@ -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 {}
@@ -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;
+      }
+    }
+  }
+}
@@ -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;
+}
@@ -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;
+}
@@ -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;
+}
@@ -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;
+}
@@ -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));
+  }
+}
@@ -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 {}
@@ -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;
+  }
+}
@@ -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),
+    });
+  }
+}
@@ -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);
+  }
+}
@@ -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;
+};