@ackplus/nest-file-storage 0.1.51 → 1.1.0

package/src/lib/interceptor/file-storage.interceptor.ts

@@ -0,0 +1,174 @@
+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 }[];
+};
+
+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: any) {
+    return {
+        fieldName: file.fieldname,
+        originalName: file.originalname,
+        fileName: file.filename,
+        mimetype: file.mimetype,
+        size: file.size,
+        key: (file as any).key,
+        path: (file as any).path,
+        url: (file as any).url,
+        encoding: file.encoding,
+        fullPath: (file as any).fullPath
+    } as unknown as UploadedFile;
+}
+
+// Helper function to apply file mapping with callback
+function applyFileKeyMapping(
+    request: Request,
+    fileConfig: FileUploadConfig,
+    interceptorOptions?: FileStorageInterceptorOptions
+): void {
+    // Default callback returns the file key
+    const mapCallback = interceptorOptions?.mapToRequestBody || ((file: any) => {
+        // For arrays, return array of keys
+        if (Array.isArray(file)) {
+            return file.map(f => f.key);
+        }
+        // For single file, return the key
+        return file.key;
+    });
+
+    if (fileConfig.type === 'single') {
+        const file = request.file;
+        if (file) {
+            const fieldName = fileConfig.fieldName || 'file';
+            const mappedFile = mapFileObject(file);
+            request.body[fieldName] = mapCallback(mappedFile, fieldName, request);
+        }
+    } 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 as { [fieldname: string]: Express.Multer.File[] };
+        if (files) {
+            Object.keys(files).forEach(fieldName => {
+                const mappedFiles = files[fieldName].map(file => mapFileObject(file));
+                request.body[fieldName] = mapCallback(mappedFiles, fieldName, request);
+            });
+        }
+    }
+}
+
+/**
+ * Function-based interceptor that accepts storage options dynamically.
+ */
+export function FileStorageInterceptor(
+    fileConfig: FileUploadConfig | string,
+    interceptorOptions?: FileStorageInterceptorOptions,
+): NestInterceptor {
+    if (typeof fileConfig === 'string') {
+        fileConfig = {
+            type: 'single',
+            fieldName: fileConfig,
+        };
+    }
+
+    return {
+        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: FileStorageEnum;
+            let storageConfig: any;
+
+            if ('storage' in options) {
+                // Configuration-based approach
+                const configOptions = options as FileStorageConfigOptions;
+                storageType = interceptorOptions?.storageType ?? configOptions.storage;
+                storageConfig = (configOptions as any)[`Config`];
+            } else {
+                // Class factory approach - default to LOCAL
+                storageType = interceptorOptions?.storageType ?? FileStorageEnum.LOCAL;
+                storageConfig = {};
+            }
+
+            const storageOptions = {
+                ...storageConfig,
+                ...(interceptorOptions?.storageOptions || {}),
+                fileName: interceptorOptions?.fileName || storageConfig?.fileName,
+                fileDist: (file: any, req: any) => {
+                    if (interceptorOptions?.fileDist) {
+                        return interceptorOptions.fileDist(file, req);
+                    }
+                    return storageConfig?.fileDist?.(file, req);
+                },
+                prefix: interceptorOptions?.prefix || storageConfig?.prefix,
+            };
+
+            // Create storage instance dynamically
+            const storage = await StorageFactory.createStorage(storageType, storageOptions);
+            const multerInstance = multer({ storage });
+
+            // Multer setup based on fileConfig
+            let multerMiddleware;
+            switch (fileConfig.type) {
+                case 'single':
+                    if (!fileConfig.fieldName) {
+                        throw new Error('fieldName is required for single file upload.');
+                    }
+                    multerMiddleware = multerInstance.single(fileConfig.fieldName);
+                    break;
+                case 'array':
+                    if (!fileConfig.fieldName) {
+                        throw new Error('fieldName is required for multiple file upload.');
+                    }
+                    multerMiddleware = multerInstance.array(fileConfig.fieldName, fileConfig.maxCount);
+                    break;
+                case 'fields':
+                    if (!fileConfig.fields || !Array.isArray(fileConfig.fields)) {
+                        throw new Error('fields array is required for multiple fields file upload.');
+                    }
+                    multerMiddleware = multerInstance.fields(fileConfig.fields);
+                    break;
+                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();
+        }
+    };
+}

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;
+        }
+    }
+
+
+}

package/src/lib/storage/local.storage.ts

@@ -0,0 +1,233 @@
+import concat from 'concat-stream';
+import * as fs from 'fs';
+import moment from 'moment';
+import { StorageEngine } from 'multer';
+import * as path from 'path';
+import { basename, dirname, join, normalize, sep } from 'path';
+import { join as posixJoin } from 'path/posix';
+import { v4 as uuidv4 } from 'uuid';
+
+import { LocalStorageOptions, Storage, UploadedFile } from '../types';
+
+
+export class LocalStorage implements StorageEngine, Storage {
+
+    private rootPath: string;
+    private fileNameFunction: (file: Express.Multer.File, req?: any) => string | Promise<string>;
+    private fileDistFunction: (file: Express.Multer.File, req?: any) => string | Promise<string>;
+
+    /**
+     * Convert OS-specific file path to URL-friendly key
+     * This ensures keys are consistent across all platforms
+     * Windows: C:\uploads\2024\01\file.jpg -> 2024/01/file.jpg
+     * Unix: /uploads/2024/01/file.jpg -> 2024/01/file.jpg
+     */
+    private pathToUrl(filePath: string): string {
+        if (!filePath) return '';
+
+        // Remove rootPath if present
+        let relativePath = filePath;
+        if (filePath.startsWith(this.rootPath)) {
+            relativePath = filePath.substring(this.rootPath.length);
+        }
+
+        // Convert backslashes to forward slashes and remove leading slash
+        return relativePath.replace(/\\/g, '/').replace(/^\/+/, '');
+    }
+
+    /**
+     * Convert URL-friendly key to OS-specific file path
+     * This converts stored keys back to valid file system paths
+     * 2024/01/file.jpg -> Windows: 2024\01\file.jpg, Unix: 2024/01/file.jpg
+     */
+    private urlToPath(urlKey: string): string {
+        if (!urlKey) return '';
+
+        // Split by forward slashes and rejoin with OS-specific separator
+        const parts = urlKey.split('/').filter(part => part.length > 0);
+        return parts.join(sep);
+    }
+
+    /**
+     * Get full file system path from URL-friendly key
+     */
+    private getFullPath(urlKey: string): string {
+        const osPath = this.urlToPath(urlKey);
+        return join(this.rootPath, osPath);
+    }
+
+    constructor(private options: LocalStorageOptions) {
+        // Normalize path for the current OS
+        this.rootPath = normalize(options.rootPath || join(process.cwd(), 'public'));
+
+        this.fileNameFunction = options.fileName || ((file, _req) => {
+            return `${uuidv4()}-${file.originalname}`;
+        });
+
+        this.fileDistFunction = options.fileDist || ((_file, _req) => {
+            return join(this.rootPath, moment().format('YYYY'), moment().format('MM'), moment().format('DD'));
+        });
+
+
+        // Ensure the rootPath directory exists
+        if (!fs.existsSync(this.rootPath)) {
+            fs.mkdirSync(this.rootPath, { recursive: true });
+        }
+    }
+
+    async _handleFile(
+        req: any,
+        file: Express.Multer.File,
+        cb: (error?: any, info?: any) => void,
+    ) {
+        try {
+            const dist = await this.fileDistFunction(file, req);
+            const fileName = await this.fileNameFunction(file, req);
+
+            const filePath = join(dist, fileName);
+            // Convert to URL-friendly key for storage
+            const urlKey = this.pathToUrl(filePath);
+
+            file.stream.pipe(concat({ encoding: 'buffer' }, async (buffer) => {
+                const uploadedFile = await this.putFile(buffer, urlKey);
+
+                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) {
+            console.error('error', error);
+            cb(error);
+        }
+    }
+
+    _removeFile(
+        _req: any,
+        file: any,
+        cb: (error: Error | null) => void,
+    ) {
+        const filePath = file.path;
+
+        fs.unlink(filePath, (err) => {
+            if (err) {
+                cb(err);
+            } else {
+                cb(null);
+            }
+        });
+    }
+
+    getUrl(urlKey: string): string {
+        if (urlKey && urlKey.startsWith('http')) {
+            return urlKey;
+        }
+        if (!urlKey) {
+            return '';
+        }
+
+        // Key is already in URL format (forward slashes)
+        // Ensure baseUrl doesn't end with slash and key doesn't start with slash
+        const baseUrl = this.options.baseUrl.replace(/\/$/, '');
+        const cleanKey = urlKey.replace(/^\//, '');
+
+        return `${baseUrl}/${cleanKey}`;
+    }
+
+    async getFile(urlKey: string): Promise<Buffer> {
+        // Convert URL key to OS-specific path
+        const fullPath = this.getFullPath(urlKey);
+        return fs.promises.readFile(fullPath);
+    }
+
+    async deleteFile(urlKey: string): Promise<void> {
+        // Convert URL key to OS-specific path
+        const fullPath = this.getFullPath(urlKey);
+        return fs.promises.unlink(fullPath);
+    }
+
+    async putFile(
+        fileContent: Buffer,
+        urlKey: string,
+    ): Promise<UploadedFile> {
+        return new Promise((putFileResolve, reject) => {
+            // Convert URL key to OS-specific path
+            const filePath = this.getFullPath(urlKey);
+
+            const directoryPath = dirname(filePath);
+
+            // Create the directory if it doesn't exist
+            fs.mkdirSync(directoryPath, { recursive: true });
+
+            fs.writeFile(filePath, fileContent, (err) => {
+                if (err) {
+                    reject(err);
+                    return;
+                }
+
+                const stats = fs.statSync(filePath);
+                const fileName = urlKey.split('/').pop() || urlKey;
+
+                const fileInfo: UploadedFile = {
+                    originalName: fileName,
+                    size: stats.size,
+                    fileName: fileName,
+                    key: urlKey,
+                    url: this.getUrl(urlKey),
+                    fullPath: filePath,
+                };
+                putFileResolve(fileInfo);
+            });
+        });
+    }
+
+
+    path(urlKey: string): string {
+        if (!urlKey) {
+            return '';
+        }
+        // Convert URL key to full OS-specific path
+        return this.getFullPath(urlKey);
+    }
+
+    async copyFile(oldUrlKey: string, newUrlKey: string): Promise<UploadedFile> {
+        return new Promise((resolve, reject) => {
+            // Convert URL keys to OS-specific paths
+            const oldPath = this.getFullPath(oldUrlKey);
+            const newPath = this.getFullPath(newUrlKey);
+
+            const directoryPath = dirname(newPath);
+            fs.mkdirSync(directoryPath, { recursive: true });
+
+            fs.copyFile(oldPath, newPath, (err) => {
+                if (err) {
+                    reject(err);
+                    return;
+                }
+
+                const stats = fs.statSync(newPath);
+                const fileName = newUrlKey.split('/').pop() || newUrlKey;
+
+                const fileInfo: UploadedFile = {
+                    originalName: fileName,
+                    size: stats.size,
+                    fileName: fileName,
+                    key: newUrlKey,
+                    fullPath: newPath,
+                    url: this.getUrl(newUrlKey),
+                };
+                resolve(fileInfo);
+            });
+        });
+    }
+
+
+}