feat(old-minio-storage): add old minio version s3 storage module for file management

- Add FileType enum with IMAGE, DOCUMENT, and VIDEO types
- Create OldMinioStorageConfig for environment variable configuration
- Implement OldMinioStorageService with presigned URL generation and file deletion
- Add OldMinioStorageController with endpoints for upload URLs and file deletion
- Create OldMinioStorageModule to integrate the storage provider
- Update .env.example with OldMinio storage credentials and configuration
- Register OldMinioStorageModule in the upload module
- Support S3-compatible MinIO API with presigned URL generation for secure uploads
- Enable file organization by type (images, documents, videos) with automatic folder routing

.env.example

@@ -77,3 +77,11 @@ NEWMINIO_S3_ACCESS_KEY="your-access-key"
 NEWMINIO_S3_SECRET_KEY="your-secret-key"
 NEWMINIO_BUCKET="streamflix"
 NEWMINIO_REGION="us-east-1"
+
+# OldMinio Storage Credentials
+OLDMINIO_PROJECT_URL="https://your-old-minio-instance.com"
+OLDMINIO_S3_ENDPOINT="https://your-old-minio-instance.com"
+OLDMINIO_S3_ACCESS_KEY="your-access-key"
+OLDMINIO_S3_SECRET_KEY="your-secret-key"
+OLDMINIO_BUCKET="streamflix"
+OLDMINIO_REGION="us-east-1"

src/shared/modules/old-minio-storage/enums/file-type.enum.ts

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

src/shared/modules/old-minio-storage/old-minio-storage.config.ts

@@ -0,0 +1,10 @@
+import { registerAs } from '@nestjs/config';
+
+export default registerAs('oldMinioStorage', () => ({
+  endpoint: process.env.OLDMINIO_S3_ENDPOINT,
+  region: process.env.OLDMINIO_REGION || 'us-east-1',
+  accessKeyId: process.env.OLDMINIO_S3_ACCESS_KEY,
+  secretAccessKey: process.env.OLDMINIO_S3_SECRET_KEY,
+  bucket: process.env.OLDMINIO_BUCKET || 'streamflix',
+  projectUrl: process.env.OLDMINIO_PROJECT_URL,
+}));

src/shared/modules/old-minio-storage/old-minio-storage.controller.ts

@@ -0,0 +1,44 @@
+import {
+  Controller,
+  Get,
+  Delete,
+  Query,
+  HttpCode,
+  HttpStatus,
+} from '@nestjs/common';
+import { ApiTags, ApiOperation, ApiQuery } from '@nestjs/swagger';
+import { OldMinioStorageService } from './old-minio-storage.service';
+import { FileType } from './enums/file-type.enum';
+
+@ApiTags('OldMinio Storage')
+@Controller('oldminio')
+export class OldMinioStorageController {
+  constructor(
+    private readonly oldMinioStorageService: OldMinioStorageService,
+  ) {}
+
+  @Get('presigned-upload')
+  @ApiOperation({ summary: 'Get presigned upload URL' })
+  @ApiQuery({ name: 'fileName', required: true })
+  @ApiQuery({ name: 'fileType', enum: FileType, required: false })
+  async getPresignedUploadUrl(
+    @Query('fileName') fileName: string,
+    @Query('fileType') fileType?: FileType,
+  ) {
+    return this.oldMinioStorageService.getPresignedUploadUrl(
+      fileName,
+      fileType,
+    );
+  }
+
+  @Delete('by-url')
+  @HttpCode(HttpStatus.OK)
+  @ApiOperation({ summary: 'Delete file by URL' })
+  async deleteFileByUrl(@Query('url') url: string) {
+    const result = await this.oldMinioStorageService.deleteFileByUrl(url);
+    return {
+      message: 'File deleted successfully',
+      ...result,
+    };
+  }
+}

src/shared/modules/old-minio-storage/old-minio-storage.module.ts

@@ -0,0 +1,13 @@
+import { Module } from '@nestjs/common';
+import { ConfigModule } from '@nestjs/config';
+import { OldMinioStorageController } from './old-minio-storage.controller';
+import { OldMinioStorageService } from './old-minio-storage.service';
+import oldMinioStorageConfig from './old-minio-storage.config';
+
+@Module({
+  imports: [ConfigModule.forFeature(oldMinioStorageConfig)],
+  controllers: [OldMinioStorageController],
+  providers: [OldMinioStorageService],
+  exports: [OldMinioStorageService],
+})
+export class OldMinioStorageModule {}

src/shared/modules/old-minio-storage/old-minio-storage.service.ts

@@ -0,0 +1,173 @@
+import { Injectable, Logger } from '@nestjs/common';
+import { ConfigService } from '@nestjs/config';
+import {
+  S3Client,
+  PutObjectCommand,
+  DeleteObjectCommand,
+} from '@aws-sdk/client-s3';
+import { getSignedUrl } from '@aws-sdk/s3-request-presigner';
+import { FileType } from './enums/file-type.enum';
+
+@Injectable()
+export class OldMinioStorageService {
+  private readonly logger = new Logger(OldMinioStorageService.name);
+  private s3Client: S3Client;
+  private bucket: string;
+  private region: string;
+  private endpoint: string;
+  private projectUrl: string;
+
+  constructor(private configService: ConfigService) {
+    this.endpoint = this.configService.get<string>('oldMinioStorage.endpoint')!;
+    this.region = this.configService.get<string>('oldMinioStorage.region')!;
+    this.bucket = this.configService.get<string>('oldMinioStorage.bucket')!;
+    this.projectUrl = this.configService.get<string>(
+      'oldMinioStorage.projectUrl',
+    )!;
+
+    const accessKeyId = this.configService.get<string>(
+      'oldMinioStorage.accessKeyId',
+    )!;
+    const secretAccessKey = this.configService.get<string>(
+      'oldMinioStorage.secretAccessKey',
+    )!;
+
+    this.s3Client = new S3Client({
+      region: this.region,
+      endpoint: this.endpoint,
+      credentials: {
+        accessKeyId,
+        secretAccessKey,
+      },
+      forcePathStyle: true, // Required for MinIO
+    });
+
+    this.logger.log('Old MinIO 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
+   */
+  private 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';
+    }
+  }
+
+  /**
+   * Generate presigned upload URL using S3
+   * @param fileName - The file name
+   * @param fileType - The file type (IMAGE, DOCUMENT, VIDEO)
+   * @returns Presigned upload URL and file path
+   */
+  async getPresignedUploadUrl(fileName: string, fileType?: string) {
+    try {
+      const folder = this.getFolderPath(fileType || '');
+      const timestamp = Date.now();
+      const sanitizedFileName = fileName.replace(/[^a-zA-Z0-9.-]/g, '_');
+      const key = `${folder}/${timestamp}-${sanitizedFileName}`;
+
+      const command = new PutObjectCommand({
+        Bucket: this.bucket,
+        Key: key,
+      });
+
+      const uploadUrl = await getSignedUrl(this.s3Client, command, {
+        expiresIn: 3600, // 1 hour
+      });
+
+      const fileUrl = `${this.projectUrl}/${this.bucket}/${key}`;
+
+      this.logger.log(`Generated presigned upload URL for: ${key}`);
+
+      return {
+        uploadUrl,
+        fileUrl,
+        key,
+        bucket: this.bucket,
+        expiresIn: 3600,
+      };
+    } catch (error) {
+      this.logger.error('Error generating presigned URL:', error);
+      throw error;
+    }
+  }
+
+  /**
+   * Delete a file from Old MinIO Storage using S3
+   * @param filePath - The file path in the bucket
+   * @returns Deletion result
+   */
+  async deleteFile(filePath: string): Promise<any> {
+    try {
+      const command = new DeleteObjectCommand({
+        Bucket: this.bucket,
+        Key: filePath,
+      });
+
+      await this.s3Client.send(command);
+
+      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 Old MinIO Storage file URL
+   * @returns Deletion result
+   */
+  async deleteFileByUrl(url: string): Promise<any> {
+    try {
+      const filePath = this.extractFilePathFromUrl(url);
+
+      if (!filePath) {
+        throw new Error('Invalid Old MinIO Storage URL');
+      }
+
+      return await this.deleteFile(filePath);
+    } catch (error) {
+      this.logger.error('Error deleting file by URL:', error);
+      throw error;
+    }
+  }
+
+  /**
+   * Extract file path from Old MinIO Storage URL
+   * @param url - The Old MinIO Storage URL
+   * @returns File path
+   */
+  private extractFilePathFromUrl(url: string): string | null {
+    try {
+      // URL format: https://lucifer925-minio-classic-oss-storage.hf.space/streamflix/images/1701234567890-avatar.jpg
+      const urlObj = new URL(url);
+      const pathParts = urlObj.pathname.split('/').filter(Boolean);
+
+      // Remove bucket name from path
+      if (pathParts[0] === this.bucket) {
+        pathParts.shift();
+      }
+
+      return pathParts.join('/');
+    } catch (error) {
+      this.logger.error('Error extracting file path from URL:', error);
+      return null;
+    }
+  }
+}

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

@@ -4,6 +4,7 @@ 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 { FilestackModule } from './filestack/filestack.module';
 
 @Module({
@@ -14,6 +15,7 @@ import { FilestackModule } from './filestack/filestack.module';
     BackblazeStorageModule,
     FilestackModule,
     NewMinioStorageModule,
+    OldMinioStorageModule,
   ],
 })
 export class UploadModule {}