feat(storage): add backblaze b2 storage module

- 【feat】introduce a complete nestjs module for backblaze b2 storage
- 【feat】implement service to generate presigned urls for secure uploads
- 【feat】create controller with endpoints for upload and deletion
- 【feat】organize files into folders based on type (e.g., images, videos)
- 【chore】add required environment variables to .env.example
- 【chore】integrate the new module into the main application module

.env.example

@@ -4,6 +4,11 @@
 # Copy this file to .env and fill in your values
 # cp .env.example .env
 
+# Application
+APP_URL="http://localhost:3000"
+PORT=3000
+NODE_ENV="development"
+
 # Database (PostgreSQL)
 DATABASE_URL="postgresql://username:password@localhost:5432/database_name?schema=public"
 
@@ -48,3 +53,11 @@ SUPABASE_S3_URL="https://your-project.storage.supabase.co/storage/v1/s3"
 SUPABASE_S3_ACCESS_KEY="your-access-key"
 SUPABASE_S3_SECRET_KEY="your-secret-key"
 SUPABASE_BUCKET="Streamflix"
+
+# Backblaze B2 Storage Credentials
+B2_BUCKET_NAME="StreamflixAkshar"
+B2_REGION="us-west-004"
+B2_S3_ENDPOINT="https://s3.us-west-004.backblazeb2.com"
+B2_ACCESS_KEY_ID="your-access-key-id"
+B2_SECRET_ACCESS_KEY="your-secret-access-key"
+B2_CDN_URL="https://cdn.aksharbhesaniya.dev"

src/app.module.ts

@@ -10,6 +10,7 @@ import { BaseQueryCoreModule } from './core/base-query-core/base-query-core.modu
 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 { AppController } from './app.controller';
 
 @Module({
@@ -30,6 +31,7 @@ import { AppController } from './app.controller';
     ImagekitioModule,
     CloudinaryModule,
     SupabaseStorageModule,
+    BackblazeStorageModule,
     UserModule,
     SuperAdminModule,
   ],

src/shared/modules/backblaze-storage/backblaze-storage.config.ts

@@ -0,0 +1,10 @@
+import { registerAs } from '@nestjs/config';
+
+export default registerAs('backblazeStorage', () => ({
+  endpoint: process.env.B2_S3_ENDPOINT,
+  region: process.env.B2_REGION || 'us-west-004',
+  accessKeyId: process.env.B2_ACCESS_KEY_ID,
+  secretAccessKey: process.env.B2_SECRET_ACCESS_KEY,
+  bucket: process.env.B2_BUCKET_NAME || 'StreamflixAkshar',
+  cdnUrl: process.env.B2_CDN_URL || 'https://cdn.aksharbhesaniya.dev',
+}));

src/shared/modules/backblaze-storage/backblaze-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 { BackblazeStorageService } from './backblaze-storage.service';
+import { FileType } from './enums/file-type.enum';
+
+@ApiTags('Backblaze B2 Storage')
+@Controller('backblaze')
+export class BackblazeStorageController {
+  constructor(
+    private readonly backblazeStorageService: BackblazeStorageService,
+  ) {}
+
+  @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.backblazeStorageService.getPresignedUploadUrl(
+      fileName,
+      fileType,
+    );
+  }
+
+  @Delete('by-url')
+  @HttpCode(HttpStatus.OK)
+  @ApiOperation({ summary: 'Delete file by CDN URL' })
+  async deleteFileByUrl(@Query('url') url: string) {
+    const result = await this.backblazeStorageService.deleteFileByUrl(url);
+    return {
+      message: 'File deleted successfully',
+      ...result,
+    };
+  }
+}

src/shared/modules/backblaze-storage/backblaze-storage.module.ts

@@ -0,0 +1,13 @@
+import { Module } from '@nestjs/common';
+import { ConfigModule } from '@nestjs/config';
+import { BackblazeStorageController } from './backblaze-storage.controller';
+import { BackblazeStorageService } from './backblaze-storage.service';
+import backblazeStorageConfig from './backblaze-storage.config';
+
+@Module({
+  imports: [ConfigModule.forFeature(backblazeStorageConfig)],
+  controllers: [BackblazeStorageController],
+  providers: [BackblazeStorageService],
+  exports: [BackblazeStorageService],
+})
+export class BackblazeStorageModule {}

src/shared/modules/backblaze-storage/backblaze-storage.service.ts

@@ -0,0 +1,178 @@
+import { Injectable, Logger, NotFoundException } 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';
+
+@Injectable()
+export class BackblazeStorageService {
+  private readonly logger = new Logger(BackblazeStorageService.name);
+  private s3Client: S3Client;
+  private bucket: string;
+  private region: string;
+  private endpoint: string;
+  private cdnUrl: string;
+
+  constructor(private configService: ConfigService) {
+    this.endpoint =
+      this.configService.get<string>('backblazeStorage.endpoint') || '';
+    this.region =
+      this.configService.get<string>('backblazeStorage.region') ||
+      'us-west-004';
+    const accessKeyId =
+      this.configService.get<string>('backblazeStorage.accessKeyId') || '';
+    const secretAccessKey =
+      this.configService.get<string>('backblazeStorage.secretAccessKey') || '';
+    this.bucket =
+      this.configService.get<string>('backblazeStorage.bucket') ||
+      'StreamflixAkshar';
+    this.cdnUrl =
+      this.configService.get<string>('backblazeStorage.cdnUrl') ||
+      'https://cdn.aksharbhesaniya.dev';
+
+    this.s3Client = new S3Client({
+      region: this.region,
+      endpoint: this.endpoint,
+      credentials: {
+        accessKeyId,
+        secretAccessKey,
+      },
+    });
+  }
+
+  /**
+   * 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 {
+    const folderMap: Record<string, string> = {
+      IMAGE: 'images',
+      DOCUMENT: 'documents',
+      VIDEO: 'videos',
+    };
+    return folderMap[fileType.toUpperCase()] || 'others';
+  }
+
+  /**
+   * Generate presigned upload URL using S3
+   * @param fileName - The file name
+   * @param fileType - The file type (IMAGE, DOCUMENT, VIDEO)
+   * @returns Presigned upload URL and CDN file URL
+   */
+  async getPresignedUploadUrl(fileName: string, fileType?: string) {
+    try {
+      // Determine folder based on file type
+      const folder = fileType ? this.getFolderPath(fileType) : 'others';
+
+      // Create full file path: folder/timestamp-filename
+      const timestamp = Date.now();
+      const filePath = `${folder}/${timestamp}-${fileName}`;
+
+      // Create PutObject command
+      const command = new PutObjectCommand({
+        Bucket: this.bucket,
+        Key: filePath,
+      });
+
+      // Generate presigned URL (valid for 1 hour)
+      const uploadUrl = await getSignedUrl(this.s3Client, command, {
+        expiresIn: 3600,
+      });
+
+      // Construct the permanent public URL through Cloudflare CDN
+      const fileUrl = `${this.cdnUrl}/${filePath}`;
+
+      this.logger.log(
+        `Generated presigned upload URL for: ${filePath}${fileType ? ` (type: ${fileType})` : ''}`,
+      );
+
+      return {
+        uploadUrl,
+        fileUrl, // Permanent CDN URL (use this for access/delete)
+        filePath,
+        expiresIn: 3600, // 1 hour in seconds
+        ...(fileType && { fileType }),
+      };
+    } catch (error) {
+      this.logger.error('Failed to generate presigned upload URL', error);
+      throw error;
+    }
+  }
+
+  /**
+   * Delete a file from Backblaze B2 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,
+      });
+
+      const result = await this.s3Client.send(command);
+
+      this.logger.log(`Successfully deleted file: ${filePath}`);
+      return {
+        success: true,
+        deletedPath: filePath,
+        result,
+      };
+    } catch (error) {
+      this.logger.error(`Failed to delete file: ${filePath}`, error);
+      throw new NotFoundException('File not found or already deleted');
+    }
+  }
+
+  /**
+   * Delete a file by CDN URL
+   * @param url - The CDN URL (e.g., https://cdn.aksharbhesaniya.dev/images/1234567890-file.jpg)
+   * @returns Deletion result
+   */
+  async deleteFileByUrl(url: string): Promise<any> {
+    try {
+      // Extract file path from URL
+      const filePath = this.extractFilePathFromUrl(url);
+
+      if (!filePath) {
+        throw new NotFoundException('Could not extract file path from URL');
+      }
+
+      const result = await this.deleteFile(filePath);
+
+      this.logger.log(`Successfully deleted file from URL: ${url}`);
+
+      return {
+        ...result,
+        deletedUrl: url,
+      };
+    } catch (error) {
+      if (error instanceof NotFoundException) {
+        throw error;
+      }
+      this.logger.error(`Failed to delete file by URL: ${url}`, error);
+      throw new NotFoundException('File not found or already deleted');
+    }
+  }
+
+  /**
+   * Extract file path from CDN URL
+   * @param url - The CDN URL (e.g., https://cdn.aksharbhesaniya.dev/images/1234567890-file.jpg)
+   * @returns File path (e.g., images/1234567890-file.jpg)
+   */
+  private extractFilePathFromUrl(url: string): string | null {
+    try {
+      // Match pattern: https://cdn.aksharbhesaniya.dev/{path}
+      // Extract everything after the domain
+      const match = url.match(/^https?:\/\/[^/]+\/(.+)$/);
+      return match ? match[1] : null;
+    } catch {
+      return null;
+    }
+  }
+}

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

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