Add file support to agent chat (#13187)

https://github.com/user-attachments/assets/911d5d8d-cc2e-4c18-9f93-2663d84ff9ef

---------

Co-authored-by: Raphaël Bosi <71827178+bosiraphael@users.noreply.github.com>
Co-authored-by: neo773 <62795688+neo773@users.noreply.github.com>
Co-authored-by: greptile-apps[bot] <165735046+greptile-apps[bot]@users.noreply.github.com>
Co-authored-by: Félix Malfait <felix.malfait@gmail.com>
Co-authored-by: Félix Malfait <felix@twenty.com>
Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com>
Co-authored-by: github-actions <github-actions@twenty.com>
Co-authored-by: MD Readul Islam <99027968+readul-islam@users.noreply.github.com>
Co-authored-by: readul-islam <developer.readul@gamil.com>
Co-authored-by: Thomas des Francs <tdesfrancs@gmail.com>
Co-authored-by: Guillim <guillim@users.noreply.github.com>
Co-authored-by: Lucas Bordeau <bordeau.lucas@gmail.com>

packages/twenty-server/src/engine/core-modules/file/crons/commands/cleanup-orphaned-files.cron.command.ts

@@ -0,0 +1,32 @@
+import { Command, CommandRunner } from 'nest-commander';
+
+import {
+  CLEANUP_ORPHANED_FILES_CRON_PATTERN,
+  CleanupOrphanedFilesCronJob,
+} from 'src/engine/core-modules/file/crons/jobs/cleanup-orphaned-files.cron.job';
+import { InjectMessageQueue } from 'src/engine/core-modules/message-queue/decorators/message-queue.decorator';
+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';
+
+@Command({
+  name: 'cron:file:cleanup-orphaned-files',
+  description: 'Starts a cron job to clean up orphaned files (no messageId)',
+})
+export class CleanupOrphanedFilesCronCommand extends CommandRunner {
+  constructor(
+    @InjectMessageQueue(MessageQueue.cronQueue)
+    private readonly messageQueueService: MessageQueueService,
+  ) {
+    super();
+  }
+
+  async run(): Promise<void> {
+    await this.messageQueueService.addCron<undefined>({
+      jobName: CleanupOrphanedFilesCronJob.name,
+      data: undefined,
+      options: {
+        repeat: { pattern: CLEANUP_ORPHANED_FILES_CRON_PATTERN },
+      },
+    });
+  }
+}

packages/twenty-server/src/engine/core-modules/file/crons/jobs/cleanup-orphaned-files.cron.job.ts

@@ -0,0 +1,69 @@
+import { InjectRepository } from '@nestjs/typeorm';
+
+import { WorkspaceActivationStatus } from 'twenty-shared/workspace';
+import { IsNull, LessThan, Repository } from 'typeorm';
+
+import { SentryCronMonitor } from 'src/engine/core-modules/cron/sentry-cron-monitor.decorator';
+import { ExceptionHandlerService } from 'src/engine/core-modules/exception-handler/exception-handler.service';
+import { FileEntity } from 'src/engine/core-modules/file/entities/file.entity';
+import { FileMetadataService } from 'src/engine/core-modules/file/services/file-metadata.service';
+import { Process } from 'src/engine/core-modules/message-queue/decorators/process.decorator';
+import { Processor } from 'src/engine/core-modules/message-queue/decorators/processor.decorator';
+import { MessageQueue } from 'src/engine/core-modules/message-queue/message-queue.constants';
+import { Workspace } from 'src/engine/core-modules/workspace/workspace.entity';
+
+export const CLEANUP_ORPHANED_FILES_CRON_PATTERN = '0 2 * * *';
+
+@Processor(MessageQueue.cronQueue)
+export class CleanupOrphanedFilesCronJob {
+  constructor(
+    @InjectRepository(Workspace, 'core')
+    private readonly workspaceRepository: Repository<Workspace>,
+    @InjectRepository(FileEntity, 'core')
+    private readonly fileRepository: Repository<FileEntity>,
+    private readonly fileMetadataService: FileMetadataService,
+    private readonly exceptionHandlerService: ExceptionHandlerService,
+  ) {}
+
+  @Process(CleanupOrphanedFilesCronJob.name)
+  @SentryCronMonitor(
+    CleanupOrphanedFilesCronJob.name,
+    CLEANUP_ORPHANED_FILES_CRON_PATTERN,
+  )
+  async handle(): Promise<void> {
+    const activeWorkspaces = await this.workspaceRepository.find({
+      where: {
+        activationStatus: WorkspaceActivationStatus.ACTIVE,
+      },
+      select: ['id'],
+    });
+
+    if (activeWorkspaces.length === 0) {
+      return;
+    }
+
+    const oneHourAgo = new Date(Date.now() - 60 * 60 * 1000);
+
+    const orphanedFiles = await this.fileRepository.find({
+      select: ['id', 'workspaceId', 'fullPath'],
+      where: {
+        messageId: IsNull(),
+        createdAt: LessThan(oneHourAgo),
+      },
+    });
+
+    if (orphanedFiles.length === 0) {
+      return;
+    }
+
+    for (const file of orphanedFiles) {
+      await this.fileMetadataService
+        .deleteFileById(file.id, file.workspaceId)
+        .catch((error) => {
+          throw new Error(
+            `[${CleanupOrphanedFilesCronJob.name}] Cannot delete orphaned file - ${file.fullPath}: ${error.message}`,
+          );
+        });
+    }
+  }
+}

packages/twenty-server/src/engine/core-modules/file/dtos/file.dto.ts

@@ -0,0 +1,25 @@
+import { Field, ID, ObjectType } from '@nestjs/graphql';
+
+@ObjectType('File')
+export class FileDTO {
+  @Field(() => ID)
+  id: string;
+
+  @Field()
+  name: string;
+
+  @Field()
+  fullPath: string;
+
+  @Field()
+  size: number;
+
+  @Field()
+  type: string;
+
+  @Field(() => ID, { nullable: true })
+  messageId?: string;
+
+  @Field()
+  createdAt: Date;
+}

packages/twenty-server/src/engine/core-modules/file/entities/file.entity.ts

@@ -0,0 +1,53 @@
+import {
+  Column,
+  CreateDateColumn,
+  Entity,
+  Index,
+  JoinColumn,
+  ManyToOne,
+  PrimaryGeneratedColumn,
+  Relation,
+} from 'typeorm';
+
+import { Workspace } from 'src/engine/core-modules/workspace/workspace.entity';
+import { AgentChatMessageEntity } from 'src/engine/metadata-modules/agent/agent-chat-message.entity';
+
+@Entity('file')
+@Index('IDX_FILE_WORKSPACE_ID', ['workspaceId'])
+export class FileEntity {
+  @PrimaryGeneratedColumn('uuid')
+  id: string;
+
+  @Column({ nullable: false })
+  name: string;
+
+  @Column({ nullable: false })
+  fullPath: string;
+
+  @Column({ nullable: false, type: 'bigint' })
+  size: number;
+
+  @Column({ nullable: false })
+  type: string;
+
+  @Column({ nullable: false, type: 'uuid' })
+  workspaceId: string;
+
+  @ManyToOne(() => Workspace, {
+    onDelete: 'CASCADE',
+  })
+  @JoinColumn({ name: 'workspaceId' })
+  workspace: Relation<Workspace>;
+
+  @Column({ nullable: true, type: 'uuid' })
+  messageId: string;
+
+  @ManyToOne(() => AgentChatMessageEntity, {
+    onDelete: 'CASCADE',
+  })
+  @JoinColumn({ name: 'messageId' })
+  message: Relation<AgentChatMessageEntity>;
+
+  @CreateDateColumn({ type: 'timestamptz' })
+  createdAt: Date;
+}

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

@@ -1,4 +1,6 @@
+import { HttpModule } from '@nestjs/axios';
 import { Module } from '@nestjs/common';
+import { TypeOrmModule } from '@nestjs/typeorm';
 
 import { FilePathGuard } from 'src/engine/core-modules/file/guards/file-path-guard';
 import { FileDeletionJob } from 'src/engine/core-modules/file/jobs/file-deletion.job';
@@ -6,21 +8,37 @@ import { FileWorkspaceFolderDeletionJob } from 'src/engine/core-modules/file/job
 import { FileAttachmentListener } from 'src/engine/core-modules/file/listeners/file-attachment.listener';
 import { FileWorkspaceMemberListener } from 'src/engine/core-modules/file/listeners/file-workspace-member.listener';
 import { JwtModule } from 'src/engine/core-modules/jwt/jwt.module';
+import { Workspace } from 'src/engine/core-modules/workspace/workspace.entity';
 
 import { FileController } from './controllers/file.controller';
+import { CleanupOrphanedFilesCronCommand } from './crons/commands/cleanup-orphaned-files.cron.command';
+import { CleanupOrphanedFilesCronJob } from './crons/jobs/cleanup-orphaned-files.cron.job';
+import { FileEntity } from './entities/file.entity';
+import { FileUploadService } from './file-upload/services/file-upload.service';
+import { FileResolver } from './resolvers/file.resolver';
+import { FileMetadataService } from './services/file-metadata.service';
 import { FileService } from './services/file.service';
 
 @Module({
-  imports: [JwtModule],
+  imports: [
+    JwtModule,
+    TypeOrmModule.forFeature([FileEntity, Workspace], 'core'),
+    HttpModule,
+  ],
   providers: [
     FileService,
+    FileMetadataService,
+    FileResolver,
     FilePathGuard,
     FileAttachmentListener,
     FileWorkspaceMemberListener,
     FileWorkspaceFolderDeletionJob,
     FileDeletionJob,
+    CleanupOrphanedFilesCronJob,
+    CleanupOrphanedFilesCronCommand,
+    FileUploadService,
   ],
-  exports: [FileService],
+  exports: [FileService, FileMetadataService, CleanupOrphanedFilesCronCommand],
   controllers: [FileController],
 })
 export class FileModule {}

packages/twenty-server/src/engine/core-modules/file/interfaces/file-folder.interface.ts

@@ -8,6 +8,7 @@ export enum FileFolder {
   Attachment = 'attachment',
   PersonPicture = 'person-picture',
   ServerlessFunction = 'serverless-function',
+  File = 'file',
 }
 
 registerEnumType(FileFolder, {
@@ -34,6 +35,9 @@ export const fileFolderConfigs: Record<FileFolder, FileFolderConfig> = {
   [FileFolder.ServerlessFunction]: {
     ignoreExpirationToken: false,
   },
+  [FileFolder.File]: {
+    ignoreExpirationToken: false,
+  },
 };
 
 export type AllowedFolders = KebabCase<keyof typeof FileFolder>;

packages/twenty-server/src/engine/core-modules/file/jobs/file-deletion.job.ts

@@ -1,6 +1,7 @@
 import { UnrecoverableError } from 'bullmq';
 
 import { FileService } from 'src/engine/core-modules/file/services/file.service';
+import { extractFolderPathAndFilename } from 'src/engine/core-modules/file/utils/extract-folderpath-and-filename.utils';
 import { Process } from 'src/engine/core-modules/message-queue/decorators/process.decorator';
 import { Processor } from 'src/engine/core-modules/message-queue/decorators/processor.decorator';
 import { MessageQueue } from 'src/engine/core-modules/message-queue/message-queue.constants';
@@ -18,8 +19,7 @@ export class FileDeletionJob {
   async handle(data: FileDeletionJobData): Promise<void> {
     const { workspaceId, fullPath } = data;
 
-    const folderPath = fullPath.split('/').slice(0, -1).join('/');
-    const filename = fullPath.split('/').pop();
+    const { folderPath, filename } = extractFolderPathAndFilename(fullPath);
 
     if (!filename) {
       throw new UnrecoverableError(

packages/twenty-server/src/engine/core-modules/file/resolvers/file.resolver.ts

@@ -0,0 +1,55 @@
+import { UseFilters, UseGuards, UsePipes } from '@nestjs/common';
+import { Args, Mutation, Resolver } from '@nestjs/graphql';
+
+import { FileUpload, GraphQLUpload } from 'graphql-upload';
+
+import { FileDTO } from 'src/engine/core-modules/file/dtos/file.dto';
+import { FileMetadataService } from 'src/engine/core-modules/file/services/file-metadata.service';
+import { PreventNestToAutoLogGraphqlErrorsFilter } from 'src/engine/core-modules/graphql/filters/prevent-nest-to-auto-log-graphql-errors.filter';
+import { ResolverValidationPipe } from 'src/engine/core-modules/graphql/pipes/resolver-validation.pipe';
+import { Workspace } from 'src/engine/core-modules/workspace/workspace.entity';
+import { AuthWorkspace } from 'src/engine/decorators/auth/auth-workspace.decorator';
+import { WorkspaceAuthGuard } from 'src/engine/guards/workspace-auth.guard';
+import { streamToBuffer } from 'src/utils/stream-to-buffer';
+
+@UseGuards(WorkspaceAuthGuard)
+@UsePipes(ResolverValidationPipe)
+@UseFilters(PreventNestToAutoLogGraphqlErrorsFilter)
+@Resolver()
+export class FileResolver {
+  constructor(private readonly fileMetadataService: FileMetadataService) {}
+
+  @Mutation(() => FileDTO)
+  async createFile(
+    @AuthWorkspace() { id: workspaceId }: Workspace,
+    @Args({ name: 'file', type: () => GraphQLUpload })
+    { createReadStream, filename, mimetype }: FileUpload,
+  ): Promise<FileDTO> {
+    const stream = createReadStream();
+    const buffer = await streamToBuffer(stream);
+
+    return this.fileMetadataService.createFile({
+      file: buffer,
+      filename,
+      mimeType: mimetype,
+      workspaceId,
+    });
+  }
+
+  @Mutation(() => FileDTO)
+  async deleteFile(
+    @AuthWorkspace() { id: workspaceId }: Workspace,
+    @Args('fileId') fileId: string,
+  ): Promise<FileDTO> {
+    const deletedFile = await this.fileMetadataService.deleteFileById(
+      fileId,
+      workspaceId,
+    );
+
+    if (!deletedFile) {
+      throw new Error(`File with id ${fileId} not found`);
+    }
+
+    return deletedFile;
+  }
+}

packages/twenty-server/src/engine/core-modules/file/services/file-metadata.service.ts

@@ -0,0 +1,94 @@
+import { Injectable } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+
+import { Repository } from 'typeorm';
+
+import { FileFolder } from 'src/engine/core-modules/file/interfaces/file-folder.interface';
+
+import { FileStorageService } from 'src/engine/core-modules/file-storage/file-storage.service';
+import { FileDTO } from 'src/engine/core-modules/file/dtos/file.dto';
+import { FileEntity } from 'src/engine/core-modules/file/entities/file.entity';
+import { FileUploadService } from 'src/engine/core-modules/file/file-upload/services/file-upload.service';
+import { extractFolderPathAndFilename } from 'src/engine/core-modules/file/utils/extract-folderpath-and-filename.utils';
+
+import { FileService } from './file.service';
+
+@Injectable()
+export class FileMetadataService {
+  constructor(
+    @InjectRepository(FileEntity, 'core')
+    private readonly fileRepository: Repository<FileEntity>,
+    private readonly fileService: FileService,
+    private readonly fileStorageService: FileStorageService,
+    private readonly fileUploadService: FileUploadService,
+  ) {}
+
+  async createFile({
+    file,
+    filename,
+    mimeType,
+    workspaceId,
+  }: {
+    file: Buffer;
+    filename: string;
+    mimeType: string;
+    workspaceId: string;
+  }): Promise<FileDTO> {
+    const { files } = await this.fileUploadService.uploadFile({
+      file,
+      filename,
+      mimeType,
+      fileFolder: FileFolder.File,
+      workspaceId,
+    });
+
+    if (!files.length) {
+      throw new Error('Failed to upload file');
+    }
+
+    const createdFile = this.fileRepository.create({
+      name: filename,
+      fullPath: files[0].path,
+      size: file.length,
+      type: mimeType,
+      workspaceId,
+    });
+
+    const savedFile = await this.fileRepository.save(createdFile);
+
+    return savedFile;
+  }
+
+  async deleteFileById(
+    id: string,
+    workspaceId: string,
+  ): Promise<FileDTO | null> {
+    const file = await this.fileRepository.findOne({
+      where: { id, workspaceId },
+    });
+
+    if (!file) {
+      return null;
+    }
+
+    const { folderPath, filename } = extractFolderPathAndFilename(
+      file.fullPath,
+    );
+
+    try {
+      if (file.fullPath) {
+        await this.fileService.deleteFile({
+          folderPath,
+          filename,
+          workspaceId,
+        });
+      }
+
+      await this.fileRepository.delete(file.id);
+
+      return file;
+    } catch (error) {
+      throw new Error(`Failed to delete file ${id}: ${error.message}`);
+    }
+  }
+}

packages/twenty-server/src/engine/core-modules/file/services/file.service.ts

@@ -3,18 +3,18 @@ import { Injectable } from '@nestjs/common';
 import { basename, dirname, extname } from 'path';
 import { Stream } from 'stream';
 
-import { v4 as uuidV4 } from 'uuid';
-import { buildSignedPath } from 'twenty-shared/utils';
 import { isNonEmptyString } from '@sniptt/guards';
+import { buildSignedPath } from 'twenty-shared/utils';
+import { v4 as uuidV4 } from 'uuid';
 
-import { FileStorageService } from 'src/engine/core-modules/file-storage/file-storage.service';
-import { JwtWrapperService } from 'src/engine/core-modules/jwt/services/jwt-wrapper.service';
-import { TwentyConfigService } from 'src/engine/core-modules/twenty-config/twenty-config.service';
-import { extractFilenameFromPath } from 'src/engine/core-modules/file/utils/extract-file-id-from-path.utils';
 import {
   FileTokenJwtPayload,
   JwtTokenTypeEnum,
 } from 'src/engine/core-modules/auth/types/auth-context.type';
+import { FileStorageService } from 'src/engine/core-modules/file-storage/file-storage.service';
+import { extractFolderPathAndFilename } from 'src/engine/core-modules/file/utils/extract-folderpath-and-filename.utils';
+import { JwtWrapperService } from 'src/engine/core-modules/jwt/services/jwt-wrapper.service';
+import { TwentyConfigService } from 'src/engine/core-modules/twenty-config/twenty-config.service';
 
 @Injectable()
 export class FileService {
@@ -45,7 +45,7 @@ export class FileService {
     return buildSignedPath({
       path: url,
       token: this.encodeFileToken({
-        filename: extractFilenameFromPath(url),
+        filename: extractFolderPathAndFilename(url).filename,
         workspaceId,
       }),
     });

packages/twenty-server/src/engine/core-modules/file/utils/__tests__/extract-file-id-from-path.utils.spec.ts

@@ -1,37 +0,0 @@
-import { extractFilenameFromPath } from 'src/engine/core-modules/file/utils/extract-file-id-from-path.utils';
-
-describe('extractFileIdFromPath', () => {
-  it('should return the last segment of a normal path', () => {
-    const result = extractFilenameFromPath('uploads/files/1234.txt');
-
-    expect(result).toBe('1234.txt');
-  });
-
-  it('should return the last segment when there is no slash', () => {
-    const result = extractFilenameFromPath('file.txt');
-
-    expect(result).toBe('file.txt');
-  });
-
-  it('should throw when empty path', () => {
-    expect(() => extractFilenameFromPath('')).toThrow(
-      new Error('Cannot extract id from empty path'),
-    );
-  });
-
-  it('should throw when empty filename', () => {
-    const folderPath = 'uploads/files/';
-
-    expect(() => extractFilenameFromPath(folderPath)).toThrow(
-      new Error(`Cannot extract id from folder path '${folderPath}'`),
-    );
-  });
-
-  it('should throw when empty filename absolute path', () => {
-    const folderPath = '/a/b/c/';
-
-    expect(() => extractFilenameFromPath(folderPath)).toThrow(
-      new Error(`Cannot extract id from folder path '${folderPath}'`),
-    );
-  });
-});

packages/twenty-server/src/engine/core-modules/file/utils/extract-file-id-from-path.utils.ts

@@ -1,17 +0,0 @@
-import { basename } from 'path';
-
-import { isNonEmptyString } from '@sniptt/guards';
-
-export const extractFilenameFromPath = (path: string) => {
-  if (path.endsWith('/')) {
-    throw new Error(`Cannot extract id from folder path '${path}'`);
-  }
-
-  const fileId = basename(path);
-
-  if (!isNonEmptyString(fileId)) {
-    throw new Error(`Cannot extract id from empty path`);
-  }
-
-  return fileId;
-};

packages/twenty-server/src/engine/core-modules/file/utils/extract-folderpath-and-filename.utils.ts

@@ -0,0 +1,13 @@
+export function extractFolderPathAndFilename(fullPath: string): {
+  folderPath: string;
+  filename: string;
+} {
+  if (!fullPath || typeof fullPath !== 'string') {
+    throw new Error('Invalid fullPath provided');
+  }
+  const parts = fullPath.split('/');
+  const filename = parts.pop() || '';
+  const folderPath = parts.join('/');
+
+  return { folderPath, filename };
+}