Refactor storage services: remove deprecated FileStorageService and ImageStorageService, introduce new S3StorageProvider, FileMetadataService, and BucketConfigService for improved file handling and metadata management. Add exception handling for storage operations and integrate AWS SDK for S3 request presigning. Update pnpm-lock.yaml to include new dependencies.

Author: Rykuno

apps/api/package.json

@@ -27,6 +27,7 @@
   },
   "dependencies": {
     "@aws-sdk/client-s3": "^3.940.0",
+    "@aws-sdk/s3-request-presigner": "^3.940.0",
     "@itgorillaz/configify": "^4.0.1",
     "@keyv/redis": "^5.1.4",
     "@keyv/valkey": "^1.0.11",

apps/api/src/storage/exceptions/storage.exception.ts

@@ -0,0 +1,23 @@
+import { HttpException, HttpStatus } from '@nestjs/common';
+
+export class StorageException extends HttpException {
+  constructor(message: string, statusCode: HttpStatus = HttpStatus.INTERNAL_SERVER_ERROR) {
+    super(message, statusCode);
+  }
+}
+
+export class FileNotFoundException extends StorageException {
+  constructor(key: string) {
+    super(`File not found: ${key}`, HttpStatus.NOT_FOUND);
+  }
+}
+
+export class StorageOperationException extends StorageException {
+  constructor(operation: string, cause?: Error) {
+    super(
+      `Storage operation failed: ${operation}${cause ? ` - ${cause.message}` : ''}`,
+      HttpStatus.INTERNAL_SERVER_ERROR,
+    );
+  }
+}
+

apps/api/src/storage/file-storage.service.ts

@@ -0,0 +1,152 @@
+import { Injectable } from '@nestjs/common';
+import {
+  S3Client,
+  PutObjectCommand,
+  GetObjectCommand,
+  DeleteObjectCommand,
+  HeadObjectCommand,
+} from '@aws-sdk/client-s3';
+import { getSignedUrl } from '@aws-sdk/s3-request-presigner';
+import { Readable } from 'stream';
+import { StorageConfig } from 'src/common/config/storage.config';
+
+export interface UploadParams {
+  key: string;
+  body: Buffer | Readable;
+  contentType?: string;
+  metadata?: Record<string, string>;
+}
+
+export interface UploadResult {
+  key: string;
+  url?: string;
+  etag?: string;
+}
+
+export interface UrlOptions {
+  expiresIn?: number; // seconds
+}
+
+@Injectable()
+export class S3StorageProvider {
+  private readonly client: S3Client;
+  private readonly bucket: string;
+
+  constructor(private readonly storageConfig: StorageConfig) {
+    this.bucket = 'public'; // Could be configurable
+    this.client = new S3Client({
+      endpoint: this.storageConfig.url,
+      region: this.storageConfig.region,
+      credentials: {
+        accessKeyId: this.storageConfig.accessKey,
+        secretAccessKey: this.storageConfig.secretKey,
+      },
+      forcePathStyle: true, // Required for LocalStack and S3-compatible services
+    });
+  }
+
+  async upload(params: UploadParams): Promise<UploadResult> {
+    const command = new PutObjectCommand({
+      Bucket: this.bucket,
+      Key: params.key,
+      Body: params.body,
+      ContentType: params.contentType,
+      Metadata: params.metadata,
+    });
+
+    const result = await this.client.send(command);
+
+    // Generate URL for the uploaded file
+    const url = await this.getUrl(params.key);
+
+    return {
+      key: params.key,
+      url,
+      etag: result.ETag,
+    };
+  }
+
+  async download(key: string): Promise<Buffer> {
+    const command = new GetObjectCommand({
+      Bucket: this.bucket,
+      Key: key,
+    });
+
+    const response = await this.client.send(command);
+
+    if (!response.Body) {
+      throw new Error(`File not found: ${key}`);
+    }
+
+    // Convert stream to buffer
+    const chunks: Uint8Array[] = [];
+    const stream = response.Body as Readable;
+
+    return new Promise((resolve, reject) => {
+      stream.on('data', (chunk) => chunks.push(chunk));
+      stream.on('end', () => resolve(Buffer.concat(chunks)));
+      stream.on('error', reject);
+    });
+  }
+
+  async delete(key: string): Promise<void> {
+    const command = new DeleteObjectCommand({
+      Bucket: this.bucket,
+      Key: key,
+    });
+
+    await this.client.send(command);
+  }
+
+  async exists(key: string): Promise<boolean> {
+    try {
+      const command = new HeadObjectCommand({
+        Bucket: this.bucket,
+        Key: key,
+      });
+
+      await this.client.send(command);
+      return true;
+    } catch (error: any) {
+      if (error.name === 'NotFound' || error.$metadata?.httpStatusCode === 404) {
+        return false;
+      }
+      throw error;
+    }
+  }
+
+  async getUrl(key: string, options?: UrlOptions): Promise<string> {
+    const command = new GetObjectCommand({
+      Bucket: this.bucket,
+      Key: key,
+    });
+
+    // Generate presigned URL if expiration is specified, otherwise public URL
+    if (options?.expiresIn) {
+      return getSignedUrl(this.client, command, {
+        expiresIn: options.expiresIn,
+      });
+    }
+
+    // For public buckets, return direct URL
+    // Format: http://endpoint/bucket/key
+    const endpoint = this.storageConfig.url.replace(/\/$/, '');
+    return `${endpoint}/${this.bucket}/${key}`;
+  }
+
+  async stream(key: string): Promise<Readable> {
+    const command = new GetObjectCommand({
+      Bucket: this.bucket,
+      Key: key,
+    });
+
+    const response = await this.client.send(command);
+
+    if (!response.Body) {
+      throw new Error(`File not found: ${key}`);
+    }
+
+    return response.Body as Readable;
+  }
+}
+

apps/api/src/storage/image-storage.service.ts

@@ -0,0 +1,96 @@
+import { Injectable, OnModuleInit, Logger } from '@nestjs/common';
+import {
+  S3Client,
+  CreateBucketCommand,
+  HeadBucketCommand,
+  PutBucketPolicyCommand,
+} from '@aws-sdk/client-s3';
+import { StorageConfig } from 'src/common/config/storage.config';
+
+@Injectable()
+export class BucketConfigService implements OnModuleInit {
+  private readonly logger = new Logger(BucketConfigService.name);
+  private readonly client: S3Client;
+  private readonly bucket = 'public';
+
+  constructor(private readonly storageConfig: StorageConfig) {
+    this.client = new S3Client({
+      endpoint: this.storageConfig.url,
+      region: this.storageConfig.region,
+      credentials: {
+        accessKeyId: this.storageConfig.accessKey,
+        secretAccessKey: this.storageConfig.secretKey,
+      },
+      forcePathStyle: true,
+    });
+  }
+
+  async onModuleInit() {
+    await this.ensureBucketExists();
+    await this.ensureBucketPolicy();
+  }
+
+  private async ensureBucketExists() {
+    try {
+      // Check if bucket exists
+      await this.client.send(new HeadBucketCommand({ Bucket: this.bucket }));
+      this.logger.log(`Bucket "${this.bucket}" already exists`);
+    } catch (error: any) {
+      // Bucket doesn't exist, create it
+      if (
+        error.name === 'NotFound' ||
+        error.$metadata?.httpStatusCode === 404
+      ) {
+        try {
+          await this.client.send(
+            new CreateBucketCommand({ Bucket: this.bucket }),
+          );
+          this.logger.log(`Created bucket "${this.bucket}"`);
+        } catch (createError) {
+          this.logger.error(
+            `Failed to create bucket "${this.bucket}":`,
+            createError,
+          );
+          throw createError;
+        }
+      } else {
+        this.logger.error(`Failed to check bucket "${this.bucket}":`, error);
+        throw error;
+      }
+    }
+  }
+
+  private async ensureBucketPolicy() {
+    try {
+      const policy = {
+        Version: '2012-10-17',
+        Statement: [
+          {
+            Sid: 'PublicReadGetObject',
+            Effect: 'Allow',
+            Principal: '*',
+            Action: ['s3:GetObject'],
+            Resource: [`arn:aws:s3:::${this.bucket}/*`],
+          },
+        ],
+      };
+
+      await this.client.send(
+        new PutBucketPolicyCommand({
+          Bucket: this.bucket,
+          Policy: JSON.stringify(policy),
+        }),
+      );
+
+      this.logger.log(
+        `Bucket policy set for "${this.bucket}" (public read access)`,
+      );
+    } catch (error) {
+      this.logger.warn(
+        `Failed to set bucket policy for "${this.bucket}":`,
+        error,
+      );
+      // Don't throw - policy setting is not critical for basic functionality
+    }
+  }
+}