Migrate to a monorepo structure (#2909)

packages/twenty-server/src/integrations/file-storage/drivers/interfaces/storage-driver.interface.ts

@@ -0,0 +1,11 @@
+import { Readable } from 'stream';
+
+export interface StorageDriver {
+  read(params: { folderPath: string; filename: string }): Promise<Readable>;
+  write(params: {
+    file: Buffer | Uint8Array | string;
+    name: string;
+    folder: string;
+    mimeType: string | undefined;
+  }): Promise<void>;
+}

packages/twenty-server/src/integrations/file-storage/drivers/local.driver.ts

@@ -0,0 +1,57 @@
+import * as fs from 'fs/promises';
+import { createReadStream, existsSync } from 'fs';
+import { join, dirname } from 'path';
+import { Readable } from 'stream';
+
+import { StorageDriver } from './interfaces/storage-driver.interface';
+
+export interface LocalDriverOptions {
+  storagePath: string;
+}
+
+export class LocalDriver implements StorageDriver {
+  private options: LocalDriverOptions;
+
+  constructor(options: LocalDriverOptions) {
+    this.options = options;
+  }
+
+  async createFolder(path: string) {
+    if (existsSync(path)) {
+      return;
+    }
+
+    return fs.mkdir(path, { recursive: true });
+  }
+
+  async write(params: {
+    file: Buffer | Uint8Array | string;
+    name: string;
+    folder: string;
+    mimeType: string | undefined;
+  }): Promise<void> {
+    const filePath = join(
+      `${this.options.storagePath}/`,
+      params.folder,
+      params.name,
+    );
+    const folderPath = dirname(filePath);
+
+    await this.createFolder(folderPath);
+
+    await fs.writeFile(filePath, params.file);
+  }
+
+  async read(params: {
+    folderPath: string;
+    filename: string;
+  }): Promise<Readable> {
+    const filePath = join(
+      `${this.options.storagePath}/`,
+      params.folderPath,
+      params.filename,
+    );
+
+    return createReadStream(filePath);
+  }
+}

packages/twenty-server/src/integrations/file-storage/drivers/s3.driver.ts

@@ -0,0 +1,98 @@
+import { Readable } from 'stream';
+
+import {
+  CreateBucketCommandInput,
+  GetObjectCommand,
+  HeadBucketCommandInput,
+  NotFound,
+  PutObjectCommand,
+  S3,
+  S3ClientConfig,
+} from '@aws-sdk/client-s3';
+
+import { StorageDriver } from './interfaces/storage-driver.interface';
+
+export interface S3DriverOptions extends S3ClientConfig {
+  bucketName: string;
+  endpoint?: string;
+  region: string;
+}
+
+export class S3Driver implements StorageDriver {
+  private s3Client: S3;
+  private bucketName: string;
+
+  constructor(options: S3DriverOptions) {
+    const { bucketName, region, endpoint, ...s3Options } = options;
+
+    if (!bucketName || !region) {
+      return;
+    }
+
+    this.s3Client = new S3({ ...s3Options, region, endpoint });
+    this.bucketName = bucketName;
+  }
+
+  public get client(): S3 {
+    return this.s3Client;
+  }
+
+  async write(params: {
+    file: Buffer | Uint8Array | string;
+    name: string;
+    folder: string;
+    mimeType: string | undefined;
+  }): Promise<void> {
+    const command = new PutObjectCommand({
+      Key: `${params.folder}/${params.name}`,
+      Body: params.file,
+      ContentType: params.mimeType,
+      Bucket: this.bucketName,
+    });
+
+    await this.s3Client.send(command);
+  }
+
+  async read(params: {
+    folderPath: string;
+    filename: string;
+  }): Promise<Readable> {
+    const command = new GetObjectCommand({
+      Key: `${params.folderPath}/${params.filename}`,
+      Bucket: this.bucketName,
+    });
+    const file = await this.s3Client.send(command);
+
+    if (!file || !file.Body || !(file.Body instanceof Readable)) {
+      throw new Error('Unable to get file stream');
+    }
+
+    return Readable.from(file.Body);
+  }
+
+  async checkBucketExists(args: HeadBucketCommandInput) {
+    try {
+      await this.s3Client.headBucket(args);
+
+      return true;
+    } catch (error) {
+      if (error instanceof NotFound) {
+        return false;
+      }
+
+      throw error;
+    }
+  }
+
+  async createBucket(args: CreateBucketCommandInput) {
+    const exist = await this.checkBucketExists({
+      Bucket: args.Bucket,
+    });
+
+    if (exist) {
+      return;
+    }
+
+    return this.s3Client.createBucket(args);
+  }
+}

packages/twenty-server/src/integrations/file-storage/file-storage.constants.ts

@@ -0,0 +1 @@
+export const STORAGE_DRIVER = Symbol('STORAGE_DRIVER');

packages/twenty-server/src/integrations/file-storage/file-storage.module-definition.ts

@@ -0,0 +1,14 @@
+import { ConfigurableModuleBuilder } from '@nestjs/common';
+
+import { FileStorageModuleOptions } from './interfaces';
+
+export const {
+  ConfigurableModuleClass,
+  MODULE_OPTIONS_TOKEN,
+  OPTIONS_TYPE,
+  ASYNC_OPTIONS_TYPE,
+} = new ConfigurableModuleBuilder<FileStorageModuleOptions>({
+  moduleName: 'FileStorage',
+})
+  .setClassMethodName('forRoot')
+  .build();

packages/twenty-server/src/integrations/file-storage/file-storage.module-factory.ts

@@ -0,0 +1,53 @@
+import { fromNodeProviderChain } from '@aws-sdk/credential-providers';
+
+import { EnvironmentService } from 'src/integrations/environment/environment.service';
+import {
+  FileStorageModuleOptions,
+  StorageDriverType,
+} from 'src/integrations/file-storage/interfaces';
+
+/**
+ * FileStorage Module factory
+ * @param environment
+ * @returns FileStorageModuleOptions
+ */
+export const fileStorageModuleFactory = async (
+  environmentService: EnvironmentService,
+): Promise<FileStorageModuleOptions> => {
+  const driverType = environmentService.getStorageDriverType();
+
+  switch (driverType) {
+    case StorageDriverType.Local: {
+      const storagePath = environmentService.getStorageLocalPath();
+
+      return {
+        type: StorageDriverType.Local,
+        options: {
+          storagePath: process.cwd() + '/' + storagePath,
+        },
+      };
+    }
+    case StorageDriverType.S3: {
+      const bucketName = environmentService.getStorageS3Name();
+      const endpoint = environmentService.getStorageS3Endpoint();
+      const region = environmentService.getStorageS3Region();
+
+      return {
+        type: StorageDriverType.S3,
+        options: {
+          bucketName: bucketName ?? '',
+          endpoint: endpoint,
+          credentials: fromNodeProviderChain({
+            clientConfig: { region },
+          }),
+          forcePathStyle: true,
+          region: region ?? '',
+        },
+      };
+    }
+    default:
+      throw new Error(
+        `Invalid storage driver type (${driverType}), check your .env file`,
+      );
+  }
+};

packages/twenty-server/src/integrations/file-storage/file-storage.module.ts

@@ -0,0 +1,51 @@
+import { DynamicModule, Global } from '@nestjs/common';
+
+import { FileStorageService } from './file-storage.service';
+import {
+  FileStorageModuleAsyncOptions,
+  FileStorageModuleOptions,
+} from './interfaces';
+import { STORAGE_DRIVER } from './file-storage.constants';
+
+import { LocalDriver } from './drivers/local.driver';
+import { S3Driver } from './drivers/s3.driver';
+
+@Global()
+export class FileStorageModule {
+  static forRoot(options: FileStorageModuleOptions): DynamicModule {
+    const provider = {
+      provide: STORAGE_DRIVER,
+      useValue:
+        options.type === 's3'
+          ? new S3Driver(options.options)
+          : new LocalDriver(options.options),
+    };
+
+    return {
+      module: FileStorageModule,
+      providers: [FileStorageService, provider],
+      exports: [FileStorageService],
+    };
+  }
+
+  static forRootAsync(options: FileStorageModuleAsyncOptions): DynamicModule {
+    const provider = {
+      provide: STORAGE_DRIVER,
+      useFactory: async (...args: any[]) => {
+        const config = await options.useFactory(...args);
+
+        return config?.type === 's3'
+          ? new S3Driver(config.options)
+          : new LocalDriver(config.options);
+      },
+      inject: options.inject || [],
+    };
+
+    return {
+      module: FileStorageModule,
+      imports: options.imports || [],
+      providers: [FileStorageService, provider],
+      exports: [FileStorageService],
+    };
+  }
+}

packages/twenty-server/src/integrations/file-storage/file-storage.service.spec.ts

@@ -0,0 +1,26 @@
+import { Test, TestingModule } from '@nestjs/testing';
+
+import { FileStorageService } from './file-storage.service';
+import { STORAGE_DRIVER } from './file-storage.constants';
+
+describe('FileStorageService', () => {
+  let service: FileStorageService;
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      providers: [
+        FileStorageService,
+        {
+          provide: STORAGE_DRIVER,
+          useValue: {},
+        },
+      ],
+    }).compile();
+
+    service = module.get<FileStorageService>(FileStorageService);
+  });
+
+  it('should be defined', () => {
+    expect(service).toBeDefined();
+  });
+});

packages/twenty-server/src/integrations/file-storage/file-storage.service.ts

@@ -0,0 +1,25 @@
+import { Inject, Injectable } from '@nestjs/common';
+
+import { Readable } from 'stream';
+
+import { STORAGE_DRIVER } from './file-storage.constants';
+
+import { StorageDriver } from './drivers/interfaces/storage-driver.interface';
+
+@Injectable()
+export class FileStorageService implements StorageDriver {
+  constructor(@Inject(STORAGE_DRIVER) private driver: StorageDriver) {}
+
+  write(params: {
+    file: string | Buffer | Uint8Array;
+    name: string;
+    folder: string;
+    mimeType: string | undefined;
+  }): Promise<void> {
+    return this.driver.write(params);
+  }
+
+  read(params: { folderPath: string; filename: string }): Promise<Readable> {
+    return this.driver.read(params);
+  }
+}

packages/twenty-server/src/integrations/file-storage/interfaces/file-storage.interface.ts

@@ -0,0 +1,30 @@
+import { FactoryProvider, ModuleMetadata } from '@nestjs/common';
+
+import { S3DriverOptions } from 'src/integrations/file-storage/drivers/s3.driver';
+import { LocalDriverOptions } from 'src/integrations/file-storage/drivers/local.driver';
+
+export enum StorageDriverType {
+  S3 = 's3',
+  Local = 'local',
+}
+
+export interface S3DriverFactoryOptions {
+  type: StorageDriverType.S3;
+  options: S3DriverOptions;
+}
+
+export interface LocalDriverFactoryOptions {
+  type: StorageDriverType.Local;
+  options: LocalDriverOptions;
+}
+
+export type FileStorageModuleOptions =
+  | S3DriverFactoryOptions
+  | LocalDriverFactoryOptions;
+
+export type FileStorageModuleAsyncOptions = {
+  useFactory: (
+    ...args: any[]
+  ) => FileStorageModuleOptions | Promise<FileStorageModuleOptions>;
+} & Pick<ModuleMetadata, 'imports'> &
+  Pick<FactoryProvider, 'inject'>;

packages/twenty-server/src/integrations/file-storage/interfaces/index.ts

@@ -0,0 +1 @@
+export * from './file-storage.interface';