feat(seaweedfs-storage): add seaweedfs module for file management

- Add SeaweedFS storage module with file upload and deletion capabilities
- Create seaweedfs-storage service with S3-compatible API integration
- Implement seaweedfs-storage controller with upload and delete endpoints
- Add FileType enum for categorizing uploaded files (IMAGE, DOCUMENT, VIDEO)
- Create seaweedfs-storage configuration with environment variables
- Migrate old-minio-storage module to unified upload namespace structure
- Add SeaweedFS credentials to .env.example configuration
- Register SeaweedfsStorageModule in upload module exports
- Provides distributed file storage alternative with S3-compatible interface

.env.example

@@ -85,3 +85,9 @@ OLDMINIO_S3_ACCESS_KEY="your-access-key"
 OLDMINIO_S3_SECRET_KEY="your-secret-key"
 OLDMINIO_BUCKET="streamflix"
 OLDMINIO_REGION="us-east-1"
+
+# SeaweedFS Storage Credentials
+SEAWEEDFS_FILER_ENDPOINT="https://your-seaweedfs-instance.com/filer/buckets/your-bucket"
+SEAWEEDFS_PUBLIC_URL="https://your-seaweedfs-instance.com/your-bucket"
+SEAWEEDFS_ACCESS_KEY="your-access-key"
+SEAWEEDFS_SECRET_KEY="your-secret-key"

src/shared/modules/upload/seaweedfs-storage/enums/file-type.enum.ts

@@ -0,0 +1,5 @@
+export enum FileType {
+  IMAGE = 'IMAGE',
+  DOCUMENT = 'DOCUMENT',
+  VIDEO = 'VIDEO',
+}

src/shared/modules/upload/seaweedfs-storage/seaweedfs-storage.config.ts

@@ -0,0 +1,8 @@
+import { registerAs } from '@nestjs/config';
+
+export default registerAs('seaweedfsStorage', () => ({
+  filerEndpoint: process.env.SEAWEEDFS_FILER_ENDPOINT,
+  publicUrl: process.env.SEAWEEDFS_PUBLIC_URL,
+  accessKey: process.env.SEAWEEDFS_ACCESS_KEY,
+  secretKey: process.env.SEAWEEDFS_SECRET_KEY,
+}));

src/shared/modules/upload/seaweedfs-storage/seaweedfs-storage.controller.ts

@@ -0,0 +1,62 @@
+import {
+  Controller,
+  Post,
+  Delete,
+  Query,
+  HttpCode,
+  HttpStatus,
+  UseInterceptors,
+  UploadedFile,
+} from '@nestjs/common';
+import { FileInterceptor } from '@nestjs/platform-express';
+import {
+  ApiTags,
+  ApiOperation,
+  ApiQuery,
+  ApiConsumes,
+  ApiBody,
+} from '@nestjs/swagger';
+import { SeaweedfsStorageService } from './seaweedfs-storage.service';
+import { FileType } from './enums/file-type.enum';
+
+@ApiTags('SeaweedFS Storage')
+@Controller('seaweedfs')
+export class SeaweedfsStorageController {
+  constructor(
+    private readonly seaweedfsStorageService: SeaweedfsStorageService,
+  ) {}
+
+  @Post('upload')
+  @ApiOperation({ summary: 'Upload file to SeaweedFS' })
+  @ApiConsumes('multipart/form-data')
+  @ApiQuery({ name: 'fileType', enum: FileType, required: false })
+  @ApiBody({
+    schema: {
+      type: 'object',
+      properties: { file: { type: 'string', format: 'binary' } },
+    },
+  })
+  @UseInterceptors(FileInterceptor('file'))
+  async uploadFile(
+    @UploadedFile() file: any,
+    @Query('fileType') fileType?: FileType,
+  ) {
+    return this.seaweedfsStorageService.uploadFile(
+      file.originalname,
+      file.buffer,
+      file.mimetype,
+      fileType,
+    );
+  }
+
+  @Delete('by-url')
+  @HttpCode(HttpStatus.OK)
+  @ApiOperation({ summary: 'Delete file by URL' })
+  async deleteFileByUrl(@Query('url') url: string) {
+    const result = await this.seaweedfsStorageService.deleteFileByUrl(url);
+    return {
+      message: 'File deleted successfully',
+      ...result,
+    };
+  }
+}

src/shared/modules/upload/seaweedfs-storage/seaweedfs-storage.module.ts

@@ -0,0 +1,13 @@
+import { Module } from '@nestjs/common';
+import { ConfigModule } from '@nestjs/config';
+import { SeaweedfsStorageController } from './seaweedfs-storage.controller';
+import { SeaweedfsStorageService } from './seaweedfs-storage.service';
+import seaweedfsStorageConfig from './seaweedfs-storage.config';
+
+@Module({
+  imports: [ConfigModule.forFeature(seaweedfsStorageConfig)],
+  controllers: [SeaweedfsStorageController],
+  providers: [SeaweedfsStorageService],
+  exports: [SeaweedfsStorageService],
+})
+export class SeaweedfsStorageModule {}

src/shared/modules/upload/seaweedfs-storage/seaweedfs-storage.service.ts

@@ -0,0 +1,183 @@
+import { Injectable, Logger } from '@nestjs/common';
+import { ConfigService } from '@nestjs/config';
+import { FileType } from './enums/file-type.enum';
+
+@Injectable()
+export class SeaweedfsStorageService {
+  private readonly logger = new Logger(SeaweedfsStorageService.name);
+  private readonly filerEndpoint: string;
+  private readonly publicUrl: string;
+  private readonly authHeader: string;
+
+  constructor(private configService: ConfigService) {
+    this.filerEndpoint = this.configService.get<string>(
+      'seaweedfsStorage.filerEndpoint',
+    )!;
+    this.publicUrl = this.configService.get<string>(
+      'seaweedfsStorage.publicUrl',
+    )!;
+
+    const accessKey = this.configService.get<string>(
+      'seaweedfsStorage.accessKey',
+    )!;
+    const secretKey = this.configService.get<string>(
+      'seaweedfsStorage.secretKey',
+    )!;
+
+    // Pre-generate auth header
+    this.authHeader = `Basic ${Buffer.from(`${accessKey}:${secretKey}`).toString('base64')}`;
+
+    this.logger.log('SeaweedFS Storage Service initialized');
+  }
+
+  /**
+   * Get folder path based on file type
+   * @param fileType - The file type (IMAGE, DOCUMENT, VIDEO)
+   * @returns Folder path for the file type
+   */
+  getFolderPath(fileType: string): string {
+    switch (fileType?.toUpperCase()) {
+      case FileType.IMAGE:
+        return 'images';
+      case FileType.DOCUMENT:
+        return 'documents';
+      case FileType.VIDEO:
+        return 'videos';
+      default:
+        return 'files';
+    }
+  }
+
+  /**
+   * Upload file to SeaweedFS
+   * @param fileName - Original file name
+   * @param fileBuffer - The file buffer
+   * @param contentType - The content type
+   * @param fileType - The file type (IMAGE, DOCUMENT, VIDEO)
+   * @returns Upload result
+   */
+  async uploadFile(
+    fileName: string,
+    fileBuffer: Buffer,
+    contentType?: string,
+    fileType?: string,
+  ): Promise<any> {
+    const folder = this.getFolderPath(fileType || 'IMAGE');
+    const timestamp = Date.now();
+    const sanitizedFileName = fileName.replace(/[^a-zA-Z0-9.-]/g, '_');
+    const key = `${folder}/${timestamp}-${sanitizedFileName}`;
+
+    return this.uploadFileDirect(key, fileBuffer, contentType);
+  }
+
+  /**
+   * Upload file directly to SeaweedFS (internal method)
+   * @param key - The file key/path
+   * @param fileBuffer - The file buffer
+   * @param contentType - The content type
+   * @returns Upload result
+   */
+  private async uploadFileDirect(
+    key: string,
+    fileBuffer: Buffer,
+    contentType?: string,
+  ): Promise<any> {
+    try {
+      const uploadUrl = `${this.filerEndpoint}/${key}`;
+
+      const response = await fetch(uploadUrl, {
+        method: 'PUT',
+        body: fileBuffer as any,
+        headers: {
+          'Content-Type': contentType || 'application/octet-stream',
+          Authorization: this.authHeader,
+        },
+      });
+
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(`Upload failed: ${response.statusText} - ${errorText}`);
+      }
+
+      const fileUrl = `${this.publicUrl}/${key}`;
+
+      this.logger.log(`File uploaded successfully: ${key}`);
+
+      return {
+        success: true,
+        fileUrl,
+        key,
+      };
+    } catch (error) {
+      this.logger.error(`Error uploading file: ${key}`, error);
+      throw error;
+    }
+  }
+
+  /**
+   * Delete a file from SeaweedFS Storage using Filer API
+   * @param filePath - The file path in the bucket
+   * @returns Deletion result
+   */
+  async deleteFile(filePath: string): Promise<any> {
+    try {
+      const deleteUrl = `${this.filerEndpoint}/${filePath}`;
+
+      const response = await fetch(deleteUrl, {
+        method: 'DELETE',
+        headers: {
+          Authorization: this.authHeader,
+        },
+      });
+
+      if (!response.ok) {
+        throw new Error(`Delete failed: ${response.statusText}`);
+      }
+
+      this.logger.log(`File deleted successfully: ${filePath}`);
+
+      return {
+        success: true,
+        filePath,
+      };
+    } catch (error) {
+      this.logger.error(`Error deleting file: ${filePath}`, error);
+      throw error;
+    }
+  }
+
+  /**
+   * Delete a file by URL
+   * @param url - The SeaweedFS Storage file URL
+   * @returns Deletion result
+   */
+  async deleteFileByUrl(url: string): Promise<any> {
+    try {
+      const filePath = this.extractFilePathFromUrl(url);
+
+      if (!filePath) {
+        throw new Error('Invalid SeaweedFS Storage URL');
+      }
+
+      return await this.deleteFile(filePath);
+    } catch (error) {
+      this.logger.error('Error deleting file by URL:', error);
+      throw error;
+    }
+  }
+
+  /**
+   * Extract file path from SeaweedFS Storage URL
+   * @param url - The SeaweedFS Storage URL
+   * @returns File path
+   */
+  private extractFilePathFromUrl(url: string): string | null {
+    try {
+      // Extract path after public URL
+      return url.replace(this.publicUrl + '/', '');
+    } catch (error) {
+      this.logger.error('Error extracting file path from URL:', error);
+      return null;
+    }
+  }
+}

src/shared/modules/upload/upload.module.ts

@@ -4,7 +4,8 @@ import { CloudinaryModule } from './cloudinary/cloudinary.module';
 import { SupabaseStorageModule } from './supabase-storage/supabase-storage.module';
 import { BackblazeStorageModule } from './backblaze-storage/backblaze-storage.module';
 import { NewMinioStorageModule } from './new-minio-storage/new-minio-storage.module';
-import { OldMinioStorageModule } from '../old-minio-storage/old-minio-storage.module';
+import { OldMinioStorageModule } from './old-minio-storage/old-minio-storage.module';
+import { SeaweedfsStorageModule } from './seaweedfs-storage/seaweedfs-storage.module';
 import { FilestackModule } from './filestack/filestack.module';
 
 @Module({
@@ -13,9 +14,10 @@ import { FilestackModule } from './filestack/filestack.module';
     CloudinaryModule,
     SupabaseStorageModule,
     BackblazeStorageModule,
-    FilestackModule,
     NewMinioStorageModule,
     OldMinioStorageModule,
+    SeaweedfsStorageModule,
+    FilestackModule,
   ],
 })
 export class UploadModule {}