@ackplus/nest-file-storage 1.0.1 → 1.1.1

package/{dist/lib/interceptor/file-storage.interceptor.js → src/lib/interceptor/file-storage.interceptor.ts}

@@ -1,32 +1,55 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
+import { NestInterceptor, ExecutionContext, CallHandler } from '@nestjs/common';
+import { Request } from 'express';
+import multer from 'multer';
+import { Observable } from 'rxjs';
+
+import { FileStorageService } from '../file-storage.service';
+import { StorageFactory } from '../storage.factory';
+import { FileStorageEnum, StorageOptions, FileStorageConfigOptions, UploadedFile } from '../types';
+
+
+export type FileUploadConfig = {
+    type: 'single' | 'array' | 'fields';
+    fieldName?: string;
+    maxCount?: number;
+    fields?: { name: string; maxCount?: number }[];
 };
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FileStorageInterceptor = FileStorageInterceptor;
-const multer_1 = __importDefault(require("multer"));
-const file_storage_service_1 = require("../file-storage.service");
-const storage_factory_1 = require("../storage.factory");
-const types_1 = require("../types");
+
+export type FileStorageInterceptorOptions = {
+    fileName?: (file: any, req?: Request) => string;
+    fileDist?: (file: any, req?: Request) => string;
+    prefix?: string;
+    storageType?: FileStorageEnum;
+    storageOptions?: StorageOptions;
+
+    // File mapping callback - user defines what to return (defaults to file.key)
+    mapToRequestBody?: (file: any, fieldName: string, req?: Request) => any;
+};
+
 // Helper function to map file object
-function mapFileObject(file) {
+function mapFileObject(file: any) {
     return {
         fieldName: file.fieldname,
         originalName: file.originalname,
         fileName: file.filename,
         mimetype: file.mimetype,
         size: file.size,
-        key: file.key,
-        path: file.path,
-        url: file.url,
+        key: (file as any).key,
+        path: (file as any).path,
+        url: (file as any).url,
         encoding: file.encoding,
-        fullPath: file.fullPath
-    };
+        fullPath: (file as any).fullPath
+    } as unknown as UploadedFile;
 }
+
 // Helper function to apply file mapping with callback
-function applyFileKeyMapping(request, fileConfig, interceptorOptions) {
+function applyFileKeyMapping(
+    request: Request,
+    fileConfig: FileUploadConfig,
+    interceptorOptions?: FileStorageInterceptorOptions
+): void {
     // Default callback returns the file key
-    const mapCallback = interceptorOptions?.mapToRequestBody || ((file) => {
+    const mapCallback = interceptorOptions?.mapToRequestBody || ((file: any) => {
         // For arrays, return array of keys
         if (Array.isArray(file)) {
             return file.map(f => f.key);
@@ -34,6 +57,7 @@ function applyFileKeyMapping(request, fileConfig, interceptorOptions) {
         // For single file, return the key
         return file.key;
     });
+
     if (fileConfig.type === 'single') {
         const file = request.file;
         if (file) {
@@ -41,17 +65,15 @@ function applyFileKeyMapping(request, fileConfig, interceptorOptions) {
             const mappedFile = mapFileObject(file);
             request.body[fieldName] = mapCallback(mappedFile, fieldName, request);
         }
-    }
-    else if (fileConfig.type === 'array') {
-        const files = request.files;
+    } else if (fileConfig.type === 'array') {
+        const files = request.files as Express.Multer.File[];
         if (files && files.length > 0) {
             const fieldName = fileConfig.fieldName || 'files';
             const mappedFiles = files.map(file => mapFileObject(file));
             request.body[fieldName] = mapCallback(mappedFiles, fieldName, request);
         }
-    }
-    else if (fileConfig.type === 'fields') {
-        const files = request.files;
+    } else if (fileConfig.type === 'fields') {
+        const files = request.files as { [fieldname: string]: Express.Multer.File[] };
         if (files) {
             Object.keys(files).forEach(fieldName => {
                 const mappedFiles = files[fieldName].map(file => mapFileObject(file));
@@ -60,40 +82,47 @@ function applyFileKeyMapping(request, fileConfig, interceptorOptions) {
         }
     }
 }
+
 /**
  * Function-based interceptor that accepts storage options dynamically.
  */
-function FileStorageInterceptor(fileConfig, interceptorOptions) {
+export function FileStorageInterceptor(
+    fileConfig: FileUploadConfig | string,
+    interceptorOptions?: FileStorageInterceptorOptions,
+): NestInterceptor {
     if (typeof fileConfig === 'string') {
         fileConfig = {
             type: 'single',
             fieldName: fileConfig,
         };
     }
+
     return {
-        async intercept(context, next) {
-            const options = file_storage_service_1.FileStorageService.getOptions();
+        async intercept(context: ExecutionContext, next: CallHandler): Promise<Observable<any>> {
+            const options = FileStorageService.getOptions();
             const request = context.switchToHttp().getRequest();
             const response = context.switchToHttp().getResponse();
+
             // Determine storage type - handle both config approaches
-            let storageType;
-            let storageConfig;
+            let storageType: FileStorageEnum;
+            let storageConfig: any;
+
             if ('storage' in options) {
                 // Configuration-based approach
-                const configOptions = options;
+                const configOptions = options as FileStorageConfigOptions;
                 storageType = interceptorOptions?.storageType ?? configOptions.storage;
-                storageConfig = configOptions[`${storageType}Config`];
-            }
-            else {
+                storageConfig = (configOptions as any)[`Config`];
+            } else {
                 // Class factory approach - default to LOCAL
-                storageType = interceptorOptions?.storageType ?? types_1.FileStorageEnum.LOCAL;
+                storageType = interceptorOptions?.storageType ?? FileStorageEnum.LOCAL;
                 storageConfig = {};
             }
+
             const storageOptions = {
                 ...storageConfig,
                 ...(interceptorOptions?.storageOptions || {}),
                 fileName: interceptorOptions?.fileName || storageConfig?.fileName,
-                fileDist: (file, req) => {
+                fileDist: (file: any, req: any) => {
                     if (interceptorOptions?.fileDist) {
                         return interceptorOptions.fileDist(file, req);
                     }
@@ -101,9 +130,11 @@ function FileStorageInterceptor(fileConfig, interceptorOptions) {
                 },
                 prefix: interceptorOptions?.prefix || storageConfig?.prefix,
             };
+
             // Create storage instance dynamically
-            const storage = await storage_factory_1.StorageFactory.createStorage(storageType, storageOptions);
-            const multerInstance = (0, multer_1.default)({ storage });
+            const storage = await StorageFactory.createStorage(storageType, storageOptions);
+            const multerInstance = multer({ storage });
+
             // Multer setup based on fileConfig
             let multerMiddleware;
             switch (fileConfig.type) {
@@ -128,14 +159,16 @@ function FileStorageInterceptor(fileConfig, interceptorOptions) {
                 default:
                     throw new Error('Invalid file upload type. Use "single", "array", or "fields".');
             }
+
             // Execute Multer middleware
             await new Promise((resolve, reject) => {
                 multerMiddleware(request, response, (err) => (err ? reject(err) : resolve(true)));
             });
+
             // Apply file key mapping after multer processing
             applyFileKeyMapping(request, fileConfig, interceptorOptions);
+
             return next.handle();
         }
     };
 }
-//# sourceMappingURL=file-storage.interceptor.js.map

package/src/lib/nest-file-storage.module.ts

@@ -0,0 +1,78 @@
+import { Module, DynamicModule, Provider } from '@nestjs/common';
+
+import { FILE_STORAGE_OPTIONS } from './constants';
+import { FileStorageService } from './file-storage.service';
+import { FileStorageAsyncOptions, FileStorageModuleOptions, FileStorageOptionsFactory } from './types';
+
+
+@Module({})
+export class NestFileStorageModule {
+
+    static forRoot(options: FileStorageModuleOptions): DynamicModule {
+        return {
+            module: NestFileStorageModule,
+            providers: [
+                {
+                    provide: FILE_STORAGE_OPTIONS,
+                    useFactory: async () => {
+                        FileStorageService.setOptions(options); // ✅ Store globally
+                        return options;
+                    },
+                    inject: [],
+                },
+                FileStorageService,
+            ],
+            exports: [],
+        };
+    }
+
+    static forRootAsync(options: FileStorageAsyncOptions): DynamicModule {
+        const asyncProviders: Provider[] = this.createAsyncProviders(options);
+
+        return {
+            module: NestFileStorageModule,
+            imports: options.imports || [],
+            providers: [...asyncProviders, FileStorageService],
+            exports: [],
+        };
+    }
+
+    private static createAsyncProviders(options: FileStorageAsyncOptions): Provider[] {
+        if (options.useExisting || options.useFactory) {
+            return [this.createAsyncOptionsProvider(options)];
+        }
+
+        return [
+            this.createAsyncOptionsProvider(options),
+            {
+                provide: options.useClass!,
+                useClass: options.useClass!,
+            },
+        ];
+    }
+
+    private static createAsyncOptionsProvider(options: FileStorageAsyncOptions): Provider {
+        if (options.useFactory) {
+            return {
+                provide: FILE_STORAGE_OPTIONS,
+                useFactory: async (...args: any[]) => {
+                    const fileStorageOptions = await options.useFactory!(...args);
+                    FileStorageService.setOptions(fileStorageOptions);
+                    return fileStorageOptions;
+                },
+                inject: options.inject || [],
+            };
+        }
+
+        return {
+            provide: FILE_STORAGE_OPTIONS,
+            useFactory: async (optionsFactory: FileStorageOptionsFactory) => {
+                const fileStorageOptions = await optionsFactory.createFileStorageOptions();
+                FileStorageService.setOptions(fileStorageOptions);
+                return fileStorageOptions;
+            },
+            inject: [options.useExisting || options.useClass!],
+        };
+    }
+
+}

package/src/lib/storage/azure.storage.ts

@@ -0,0 +1,214 @@
+import {
+    BlobSASPermissions,
+    BlobSASSignatureValues,
+    BlobServiceClient,
+    generateBlobSASQueryParameters,
+    SASProtocol,
+    StorageSharedKeyCredential,
+} from '@azure/storage-blob';
+import concat from 'concat-stream';
+import moment from 'moment';
+import { StorageEngine } from 'multer';
+import path, { basename, join } from 'path';
+import { v4 as uuidv4 } from 'uuid';
+
+import { AzureStorageOptions, Storage, UploadedFile } from '../types';
+
+
+export class AzureStorage implements StorageEngine, Storage {
+
+    private blobServiceClient: BlobServiceClient;
+
+    private fileNameFunction: (file: Express.Multer.File, req?: any) => string | Promise<string>;
+    private fileDistFunction: (file: Express.Multer.File, req?: any) => string | Promise<string>;
+
+
+    constructor(private options: AzureStorageOptions) {
+        this.fileNameFunction = options.fileName || ((file, _req) => {
+            return `${uuidv4()}-${file.originalname}`;
+        });
+
+        this.fileDistFunction = options.fileDist || ((_file, _req) => {
+            return path.join('uploads', moment().format('YYYY'), moment().format('MM'), moment().format('DD'));
+        });
+
+        const sharedKeyCredential = new StorageSharedKeyCredential(
+            options.account,
+            options.accountKey,
+        );
+
+        this.blobServiceClient = new BlobServiceClient(
+            `https://${options.account}.blob.core.windows.net`,
+            sharedKeyCredential,
+        );
+    }
+
+    async _handleFile(
+        req: any,
+        file: any,
+        cb: (error?: any, info?: any) => void,
+    ): Promise<void> {
+        try {
+            const dist = await this.fileDistFunction(file, req);
+            const key = await this.fileNameFunction(file, req);
+            const filePath = join(dist, key);
+
+            file.stream.pipe(concat({ encoding: 'buffer' }, async (buffer) => {
+                const uploadedFile = await this.putFile(buffer, filePath);
+
+                const fileInfo: UploadedFile = {
+                    ...uploadedFile,
+                    fieldName: file.fieldname,
+                    originalName: file.originalname,
+                    mimetype: file.mimetype,
+                };
+                let transformData = fileInfo;
+
+                if (this.options?.transformUploadedFileObject) {
+                    transformData = await this.options.transformUploadedFileObject(fileInfo);
+                }
+                cb(null, transformData);
+            }));
+        } catch (error) {
+            cb(error);
+        }
+
+        file.stream.on('error', (err: any) => cb(err));
+    }
+
+    async _removeFile(
+        _req: any,
+        file: any,
+        cb: (error: Error | null) => void,
+    ): Promise<void> {
+        try {
+            const blobClient = this.blobServiceClient
+                .getContainerClient(this.options.container)
+                .getBlobClient(file.key);
+
+            await blobClient.delete();
+            cb(null);
+        } catch (error) {
+            cb(error);
+        }
+    }
+
+    getUrl(key: string): string {
+        return `https://${this.options.account}.blob.core.windows.net/${this.options.container}/${key}`;
+    }
+
+
+    getSignedUrl(key: string, signatureValues: Partial<Omit<BlobSASSignatureValues, 'containerName'>> = {}): string {
+        if (!key) return '';
+
+        const cloudFrontDomain = process.env['AZURE_CDN_DOMAIN_NAME'];
+
+        if (cloudFrontDomain) {
+            return `${cloudFrontDomain}/${key}`;
+        }
+
+        const containerClient = this.blobServiceClient.getContainerClient(this.options.container);
+        const blobClient = containerClient.getBlobClient(key);
+
+        const sharedKeyCredential = new StorageSharedKeyCredential(
+            this.options.account,
+            this.options.accountKey,
+        );
+
+        // Set the SAS token options
+        const expiresOn = new Date();
+        expiresOn.setHours(expiresOn.getHours() + 1); // Set expiration time to 1 hour from now
+
+        const sasToken = generateBlobSASQueryParameters(
+            {
+                containerName: this.options.container,
+                blobName: key,
+                permissions: BlobSASPermissions.parse('r'), // Read permissions
+                protocol: SASProtocol.Https, // HTTPS only
+                startsOn: new Date(), // Start time (now)
+                expiresOn, // Expiration time
+                ...signatureValues,
+            },
+            sharedKeyCredential,
+        ).toString();
+
+        return `${blobClient.url}?${sasToken}`;
+    }
+
+    async getFile(key: string): Promise<Buffer> {
+        const containerClient = this.blobServiceClient.getContainerClient(this.options.container);
+        const blobClient = containerClient.getBlobClient(key);
+        const downloadResponse = await blobClient.download();
+        const stream = downloadResponse.readableStreamBody;
+
+        return new Promise((resolve, reject) => {
+            const chunks: Buffer[] = [];
+            stream?.on('data', (chunk) => chunks.push(chunk));
+            stream?.on('end', () => resolve(Buffer.concat(chunks)));
+            stream?.on('error', reject);
+        });
+    }
+
+    async putFile(buffer: Buffer, key: string): Promise<UploadedFile> {
+        try {
+            const containerClient = this.blobServiceClient.getContainerClient(this.options.container);
+            const blockBlobClient = containerClient.getBlockBlobClient(key);
+
+            await blockBlobClient.uploadData(buffer);
+
+            const fileInfo: UploadedFile = {
+                originalName: basename(key),
+                fileName: basename(key),
+                size: buffer.length,
+                buffer,
+                key,
+                fullPath: key,
+                url: this.getUrl(key),
+            };
+
+            return fileInfo;
+        } catch (error) {
+            console.error(`Error uploading file "${key}":`, error);
+            throw error;
+        }
+    }
+
+    async deleteFile(key: string) {
+        try {
+            const blobClient = this.blobServiceClient
+                .getContainerClient(this.options.container)
+                .getBlobClient(key);
+
+            await blobClient.delete();
+        } catch (error) {
+            console.error(`Error deleting blob "${key}":`, error);
+        }
+    }
+
+    async copyFile(oldKey: string, newKey: string): Promise<UploadedFile> {
+        try {
+            const containerClient = this.blobServiceClient.getContainerClient(this.options.container);
+            const sourceBlobClient = containerClient.getBlobClient(oldKey);
+            const destinationBlobClient = containerClient.getBlobClient(newKey);
+
+            const copyPoller = await destinationBlobClient.beginCopyFromURL(sourceBlobClient.url);
+            await copyPoller.pollUntilDone();
+
+            const properties = await destinationBlobClient.getProperties();
+
+            return {
+                originalName: basename(newKey),
+                size: properties.contentLength || 0,
+                fileName: basename(newKey),
+                key: newKey,
+                fullPath: newKey,
+                url: this.getUrl(newKey),
+            };
+        } catch (error) {
+            console.error('Error copying file in Azure Blob Storage:', error);
+            throw error;
+        }
+    }
+
+
+}