refactor(attachments): use putObject

Author: ycdzj

src/attachments/attachments.service.ts

@@ -88,18 +88,23 @@ export class AttachmentsService {
       ResourcePermission.CAN_EDIT,
     );
 
-    const id = await this.s3Service.put(filename, buffer, mimetype, {
-      folder: 'attachments',
-    });
+    const { key, objectName } = await this.s3Service.generateObjectKey(
+      'attachments',
+      filename,
+    );
+    const metadata = {
+      filename: encodeFileName(filename),
+    };
+    await this.s3Service.putObject(key, buffer, mimetype, metadata);
 
     // Create the resource-attachment relation
     await this.resourceAttachmentsService.addAttachmentToResource(
       namespaceId,
       resourceId,
-      id,
+      objectName,
     );
 
-    return id;
+    return objectName;
   }
 
   async uploadAttachments(

src/s3/s3.service.ts

@@ -4,9 +4,12 @@ import {
   S3Client,
   PutObjectCommand,
   GetObjectCommand,
+  GetObjectCommandOutput,
   DeleteObjectCommand,
   HeadBucketCommand,
   CreateBucketCommand,
+  HeadObjectCommand,
+  HeadObjectCommandOutput,
 } from '@aws-sdk/client-s3';
 import { Readable } from 'stream';
 import generateId from 'omniboxd/utils/generate-id';
@@ -21,11 +24,24 @@ export interface PutOptions {
   folder?: string;
 }
 
-export interface ObjectMeta {
-  contentType?: string;
-  contentLength?: number;
-  metadata?: Record<string, string>;
-  lastModified?: Date;
+export class ObjectMeta {
+  constructor(
+    public contentType?: string,
+    public contentLength?: number,
+    public metadata?: Record<string, string>,
+    public lastModified?: Date,
+  ) {}
+
+  static fromResponse(
+    response: GetObjectCommandOutput | HeadObjectCommandOutput,
+  ): ObjectMeta {
+    return new ObjectMeta(
+      response.ContentType,
+      response.ContentLength,
+      response.Metadata,
+      response.LastModified,
+    );
+  }
 }
 
 @Injectable()
@@ -73,7 +89,24 @@ export class S3Service implements OnModuleInit {
     await this.ensureBucket();
   }
 
-  private generateId(filename: string, length: number = 32): string {
+  private async ensureBucket(): Promise<void> {
+    try {
+      await this.s3Client.send(new HeadBucketCommand({ Bucket: this.bucket }));
+    } catch (error: any) {
+      if (
+        error.name === 'NotFound' ||
+        error.$metadata?.httpStatusCode === 404
+      ) {
+        await this.s3Client.send(
+          new CreateBucketCommand({ Bucket: this.bucket }),
+        );
+      } else {
+        throw error;
+      }
+    }
+  }
+
+  private generateId(filename?: string, length: number = 32): string {
     const uuid = generateId(length);
     // Get the original filename to extract the proper extension
     const originalFilename = getOriginalFileName(filename);
@@ -88,21 +121,23 @@ export class S3Service implements OnModuleInit {
     return `${uuid}${ext}`;
   }
 
-  private async ensureBucket(): Promise<void> {
-    try {
-      await this.s3Client.send(new HeadBucketCommand({ Bucket: this.bucket }));
-    } catch (error: any) {
-      if (
-        error.name === 'NotFound' ||
-        error.$metadata?.httpStatusCode === 404
-      ) {
-        await this.s3Client.send(
-          new CreateBucketCommand({ Bucket: this.bucket }),
-        );
-      } else {
-        throw error;
+  // There might still be race conditions but the probability should be low enough
+  async generateObjectKey(
+    prefix: string,
+    filename?: string,
+    length: number = 32,
+  ): Promise<{ key: string; objectName: string }> {
+    if (!prefix.endsWith('/')) {
+      prefix += '/';
+    }
+    for (let i = 0; i < 5; i++) {
+      const objectName = this.generateId(filename, length);
+      const key = `${prefix}${objectName}`;
+      if ((await this.headObject(key)) === null) {
+        return { key, objectName };
       }
     }
+    throw new Error('Unable to generate unique S3 key');
   }
 
   async putObject(
@@ -131,15 +166,30 @@ export class S3Service implements OnModuleInit {
     const response = await this.s3Client.send(command);
     return {
       stream: response.Body as Readable,
-      meta: {
-        contentType: response.ContentType,
-        contentLength: response.ContentLength,
-        metadata: response.Metadata,
-        lastModified: response.LastModified,
-      },
+      meta: ObjectMeta.fromResponse(response),
     };
   }
 
+  async headObject(key: string): Promise<ObjectMeta | null> {
+    const command = new HeadObjectCommand({
+      Bucket: this.bucket,
+      Key: key,
+    });
+
+    try {
+      const response = await this.s3Client.send(command);
+      return ObjectMeta.fromResponse(response);
+    } catch (error: any) {
+      if (
+        error?.name === 'NotFound' ||
+        error?.$metadata?.httpStatusCode === 404
+      ) {
+        return null;
+      }
+      throw error;
+    }
+  }
+
   async deleteObject(key: string) {
     const command = new DeleteObjectCommand({
       Bucket: this.bucket,