feat(new-minio-storage): add new minio vesrion s3 storage module for file management

- Add NewMinioStorageModule with S3Client integration for MinIO compatibility
- Create MinioStorageService with presigned URL generation and file deletion capabilities
- Implement MinioStorageController with endpoints for presigned uploads and file deletion
- Add FileType enum to categorize files (IMAGE, DOCUMENT, VIDEO) with folder organization
- Create minioStorageConfig for environment-based configuration management
- Add MinIO credentials to .env.example (endpoint, access key, secret key, bucket, region)
- Register NewMinioStorageModule in AppModule for application-wide availability
- Support file organization by type with automatic folder path generation
- Enable presigned URL generation for secure client-side uploads
- Provide file deletion by URL with proper error handling and logging

.env.example

@@ -69,3 +69,11 @@ CLOUDFLARE_API_TOKEN="your-api-token"
 # Filestack Credentials
 FILESTACK_API_KEY_DEV="your-filestack-api-key"
 FILESTACK_APP_SECRET_DEV="your-filestack-app-secret"
+
+# NewMinio Storage Credentials
+NEWMINIO_PROJECT_URL="https://your-minio-instance.com"
+NEWMINIO_S3_ENDPOINT="https://your-minio-instance.com"
+NEWMINIO_S3_ACCESS_KEY="your-access-key"
+NEWMINIO_S3_SECRET_KEY="your-secret-key"
+NEWMINIO_BUCKET="streamflix"
+NEWMINIO_REGION="us-east-1"

src/app.module.ts

@@ -11,6 +11,7 @@ import { ImagekitioModule } from './shared/modules/imagekitio/imagekitio.module'
 import { CloudinaryModule } from './shared/modules/cloudinary/cloudinary.module';
 import { SupabaseStorageModule } from './shared/modules/supabase-storage/supabase-storage.module';
 import { BackblazeStorageModule } from './shared/modules/backblaze-storage/backblaze-storage.module';
+import { NewMinioStorageModule } from './shared/modules/new-minio-storage/new-minio-storage.module';
 import { FilestackModule } from './shared/modules/filestack/filestack.module';
 import { AppController } from './app.controller';
 
@@ -33,6 +34,7 @@ import { AppController } from './app.controller';
     CloudinaryModule,
     SupabaseStorageModule,
     BackblazeStorageModule,
+    NewMinioStorageModule,
     FilestackModule,
     UserModule,
     SuperAdminModule,

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

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

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

@@ -0,0 +1,10 @@
+import { registerAs } from '@nestjs/config';
+
+export default registerAs('minioStorage', () => ({
+  endpoint: process.env.NEWMINIO_S3_ENDPOINT,
+  region: process.env.NEWMINIO_REGION || 'us-east-1',
+  accessKeyId: process.env.NEWMINIO_S3_ACCESS_KEY,
+  secretAccessKey: process.env.NEWMINIO_S3_SECRET_KEY,
+  bucket: process.env.NEWMINIO_BUCKET || 'streamflix',
+  projectUrl: process.env.NEWMINIO_PROJECT_URL,
+}));

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

@@ -0,0 +1,39 @@
+import {
+  Controller,
+  Get,
+  Delete,
+  Query,
+  HttpCode,
+  HttpStatus,
+} from '@nestjs/common';
+import { ApiTags, ApiOperation, ApiQuery } from '@nestjs/swagger';
+import { MinioStorageService } from './new-minio-storage.service';
+import { FileType } from './enums/file-type.enum';
+
+@ApiTags('NewMinio Storage')
+@Controller('newminio')
+export class MinioStorageController {
+  constructor(private readonly minioStorageService: MinioStorageService) {}
+
+  @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.minioStorageService.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.minioStorageService.deleteFileByUrl(url);
+    return {
+      message: 'File deleted successfully',
+      ...result,
+    };
+  }
+}

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

@@ -0,0 +1,13 @@
+import { Module } from '@nestjs/common';
+import { ConfigModule } from '@nestjs/config';
+import { MinioStorageController } from './new-minio-storage.controller';
+import { MinioStorageService } from './new-minio-storage.service';
+import minioStorageConfig from './new-minio-storage.config';
+
+@Module({
+  imports: [ConfigModule.forFeature(minioStorageConfig)],
+  controllers: [MinioStorageController],
+  providers: [MinioStorageService],
+  exports: [MinioStorageService],
+})
+export class NewMinioStorageModule {}

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

@@ -0,0 +1,171 @@
+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 MinioStorageService {
+  private readonly logger = new Logger(MinioStorageService.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>('minioStorage.endpoint')!;
+    this.region = this.configService.get<string>('minioStorage.region')!;
+    this.bucket = this.configService.get<string>('minioStorage.bucket')!;
+    this.projectUrl = this.configService.get<string>('minioStorage.projectUrl')!;
+
+    const accessKeyId = this.configService.get<string>(
+      'minioStorage.accessKeyId',
+    )!;
+    const secretAccessKey = this.configService.get<string>(
+      'minioStorage.secretAccessKey',
+    )!;
+
+    this.s3Client = new S3Client({
+      region: this.region,
+      endpoint: this.endpoint,
+      credentials: {
+        accessKeyId,
+        secretAccessKey,
+      },
+      forcePathStyle: true, // Required for MinIO
+    });
+
+    this.logger.log('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 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 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 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 MinIO Storage URL
+   * @param url - The MinIO Storage URL
+   * @returns File path
+   */
+  private extractFilePathFromUrl(url: string): string | null {
+    try {
+      // URL format: https://lucifer925-minio-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;
+    }
+  }
+}