refactor(files): use s3 service

Author: ycdzj

src/files/files.module.ts

@@ -3,9 +3,10 @@ import { FilesService } from './files.service';
 import { ConfigModule } from '@nestjs/config';
 import { TypeOrmModule } from '@nestjs/typeorm';
 import { File } from './entities/file.entity';
+import { S3Module } from 'omniboxd/s3/s3.module';
 
 @Module({
-  imports: [ConfigModule, TypeOrmModule.forFeature([File])],
+  imports: [ConfigModule, TypeOrmModule.forFeature([File]), S3Module],
   providers: [FilesService],
   exports: [FilesService],
 })

src/files/files.service.ts

@@ -5,17 +5,14 @@ import { File } from './entities/file.entity';
 import { InjectRepository } from '@nestjs/typeorm';
 import { AppException } from 'omniboxd/common/exceptions/app.exception';
 import { I18nService } from 'nestjs-i18n';
-import { S3Client, GetObjectCommand } from '@aws-sdk/client-s3';
-import { createPresignedPost, PresignedPost } from '@aws-sdk/s3-presigned-post';
-import { getSignedUrl } from '@aws-sdk/s3-request-presigner';
+import { PresignedPost } from '@aws-sdk/s3-presigned-post';
 import { formatFileSize } from '../utils/format-file-size';
+import { S3Service } from 'omniboxd/s3/s3.service';
+
+const s3Prefix = 'uploaded-files';
 
 @Injectable()
 export class FilesService {
-  private readonly s3Client: S3Client;
-  private readonly s3InternalClient: S3Client;
-  private readonly s3Bucket: string;
-  private readonly s3Prefix: string;
   private readonly s3MaxFileSize: number;
 
   constructor(
@@ -24,65 +21,12 @@ export class FilesService {
     @InjectRepository(File)
     private readonly fileRepo: Repository<File>,
     private readonly i18n: I18nService,
+    private readonly s3Service: S3Service,
   ) {
-    const accessKeyId = configService.get<string>('OBB_S3_ACCESS_KEY_ID');
-    const secretAccessKey = configService.get<string>(
-      'OBB_S3_SECRET_ACCESS_KEY',
-    );
-    if (!accessKeyId || !secretAccessKey) {
-      throw new Error('S3 credentials not set');
-    }
-
-    const s3Endpoint = configService.get<string>('OBB_S3_ENDPOINT');
-    if (!s3Endpoint) {
-      throw new Error('S3 endpoint not set');
-    }
-
-    const s3InternalEndpoint = configService.get<string>(
-      'OBB_S3_INTERNAL_ENDPOINT',
-    );
-
-    const s3Bucket = configService.get<string>('OBB_S3_BUCKET');
-    if (!s3Bucket) {
-      throw new Error('S3 bucket not set');
-    }
-
-    const s3Prefix = configService.get<string>('OBB_S3_PREFIX');
-    if (!s3Prefix) {
-      throw new Error('S3 prefix not set');
-    }
-
-    const s3Region = configService.get<string>('OBB_S3_REGION', 'us-east-1');
-
     this.s3MaxFileSize = configService.get<number>(
       'OBB_S3_MAX_FILE_SIZE',
       20 * 1024 * 1024,
     );
-
-    this.s3Client = new S3Client({
-      region: s3Region,
-      credentials: {
-        accessKeyId,
-        secretAccessKey,
-      },
-      endpoint: s3Endpoint,
-    });
-
-    if (s3InternalEndpoint && s3InternalEndpoint != s3Endpoint) {
-      this.s3InternalClient = new S3Client({
-        region: s3Region,
-        credentials: {
-          accessKeyId,
-          secretAccessKey,
-        },
-        endpoint: s3InternalEndpoint,
-      });
-    } else {
-      this.s3InternalClient = this.s3Client;
-    }
-
-    this.s3Bucket = s3Bucket;
-    this.s3Prefix = s3Prefix;
   }
 
   async createFile(
@@ -121,53 +65,45 @@ export class FilesService {
       throw new AppException(message, 'FILE_TOO_LARGE', HttpStatus.BAD_REQUEST);
     }
     const disposition = `attachment; filename*=UTF-8''${encodeURIComponent(filename)}`;
-    return await createPresignedPost(this.s3Client, {
-      Bucket: this.s3Bucket,
-      Key: `${this.s3Prefix}/${fileId}`,
-      Conditions: [
-        ['content-length-range', 0, this.s3MaxFileSize],
-        { 'content-type': mimetype },
-        { 'content-disposition': disposition },
-      ],
-      Fields: {
-        'content-type': mimetype,
-        'content-disposition': disposition,
-      },
-      Expires: 900, // 900 seconds
-    });
+    return await this.s3Service.generateUploadForm(
+      `${s3Prefix}/${fileId}`,
+      true,
+      mimetype,
+      disposition,
+      this.s3MaxFileSize,
+    );
   }
 
   private async generateDownloadUrl(
     namespaceId: string,
     fileId: string,
-    s3Client: S3Client,
+    isPublic: boolean,
   ): Promise<string> {
     const file = await this.getFile(namespaceId, fileId);
     if (!file) {
       const message = this.i18n.t('resource.errors.fileNotFound');
       throw new AppException(message, 'FILE_NOT_FOUND', HttpStatus.NOT_FOUND);
     }
 
-    const command = new GetObjectCommand({
-      Bucket: this.s3Bucket,
-      Key: `${this.s3Prefix}/${fileId}`,
-      ResponseContentDisposition: `attachment; filename*=UTF-8''${encodeURIComponent(file.name)}`,
-    });
-
-    return await getSignedUrl(s3Client, command, { expiresIn: 900 });
+    const disposition = `attachment; filename*=UTF-8''${encodeURIComponent(file.name)}`;
+    return await this.s3Service.generateDownloadUrl(
+      `${s3Prefix}/${fileId}`,
+      isPublic,
+      disposition,
+    );
   }
 
   async generatePublicDownloadUrl(
     namespaceId: string,
     fileId: string,
   ): Promise<string> {
-    return this.generateDownloadUrl(namespaceId, fileId, this.s3Client);
+    return this.generateDownloadUrl(namespaceId, fileId, true);
   }
 
   async generateInternalDownloadUrl(
     namespaceId: string,
     fileId: string,
   ): Promise<string> {
-    return this.generateDownloadUrl(namespaceId, fileId, this.s3InternalClient);
+    return this.generateDownloadUrl(namespaceId, fileId, false);
   }
 }

src/s3/s3.service.ts

@@ -14,6 +14,9 @@ import {
 import { Readable } from 'stream';
 import generateId from 'omniboxd/utils/generate-id';
 import { getOriginalFileName } from 'omniboxd/utils/encode-filename';
+import { createPresignedPost, PresignedPost } from '@aws-sdk/s3-presigned-post';
+import { Conditions } from '@aws-sdk/s3-presigned-post/dist-types/types';
+import { getSignedUrl } from '@aws-sdk/s3-request-presigner';
 
 export class ObjectMeta {
   constructor(
@@ -38,6 +41,7 @@ export class ObjectMeta {
 @Injectable()
 export class S3Service implements OnModuleInit {
   private readonly s3Client: S3Client;
+  private readonly s3PublicClient: S3Client;
   private readonly bucket: string;
 
   constructor(configService: ConfigService) {
@@ -50,6 +54,9 @@ export class S3Service implements OnModuleInit {
     }
 
     const s3Endpoint = configService.get<string>('OBB_S3_ENDPOINT');
+    const s3PublicEndpoint = configService.get<string>(
+      'OBB_S3_PUBLIC_ENDPOINT',
+    );
     if (!s3Endpoint) {
       throw new Error('S3 endpoint not set');
     }
@@ -72,7 +79,19 @@ export class S3Service implements OnModuleInit {
       endpoint: s3Endpoint,
       forcePathStyle,
     });
-
+    if (s3PublicEndpoint && s3PublicEndpoint != s3Endpoint) {
+      this.s3PublicClient = new S3Client({
+        region: s3Region,
+        credentials: {
+          accessKeyId,
+          secretAccessKey,
+        },
+        endpoint: s3PublicEndpoint,
+        forcePathStyle,
+      });
+    } else {
+      this.s3PublicClient = this.s3Client;
+    }
     this.bucket = s3Bucket;
   }
 
@@ -188,4 +207,48 @@ export class S3Service implements OnModuleInit {
     });
     return await this.s3Client.send(command);
   }
+
+  async generateUploadForm(
+    key: string,
+    isPublic: boolean,
+    contentType?: string,
+    contentDisposition?: string,
+    maxSize?: number,
+  ): Promise<PresignedPost> {
+    const s3Client = isPublic ? this.s3PublicClient : this.s3Client;
+    const conditions: Conditions[] = [];
+    const fields: Record<string, string> = {};
+    if (contentType) {
+      conditions.push({ 'content-type': contentType });
+      fields['content-type'] = contentType;
+    }
+    if (contentDisposition) {
+      conditions.push({ 'content-disposition': contentDisposition });
+      fields['content-disposition'] = contentDisposition;
+    }
+    if (maxSize) {
+      conditions.push(['content-length-range', 0, maxSize]);
+    }
+    return await createPresignedPost(s3Client, {
+      Bucket: this.bucket,
+      Key: key,
+      Conditions: conditions,
+      Fields: fields,
+      Expires: 900, // 900 seconds
+    });
+  }
+
+  async generateDownloadUrl(
+    key: string,
+    isPublic: boolean,
+    contentDisposition?: string,
+  ): Promise<string> {
+    const s3Client = isPublic ? this.s3PublicClient : this.s3Client;
+    const command = new GetObjectCommand({
+      Bucket: this.bucket,
+      Key: key,
+      ResponseContentDisposition: contentDisposition,
+    });
+    return await getSignedUrl(s3Client, command, { expiresIn: 900 });
+  }
 }