@ackplus/nest-file-storage 1.1.2 → 1.1.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ackplus/nest-file-storage",
-  "version": "1.1.2",
+  "version": "1.1.6",
   "type": "commonjs",
   "main": "./src/index.js",
   "types": "./src/index.d.ts",

package/src/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./lib/nest-file-storage.module"), exports);
+tslib_1.__exportStar(require("./lib/file-storage.service"), exports);
+tslib_1.__exportStar(require("./lib/interceptor/file-storage.interceptor"), exports);
+tslib_1.__exportStar(require("./lib/types"), exports);

package/src/lib/constants.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FILE_STORAGE_OPTIONS = void 0;
+exports.FILE_STORAGE_OPTIONS = 'FileStorageOptions';

package/src/lib/file-storage.service.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileStorageService = void 0;
+const storage_factory_1 = require("./storage.factory");
+class FileStorageService {
+    static setOptions(options) {
+        FileStorageService.options = options;
+    }
+    static getOptions() {
+        return FileStorageService.options;
+    }
+    static async getStorage(storageType) {
+        const options = this.getOptions();
+        // Check if it's a class factory approach
+        if ('storageFactory' in options) {
+            const classOptions = options;
+            const StorageClass = await classOptions.storageFactory();
+            return new StorageClass(classOptions.options);
+        }
+        // Configuration-based approach
+        const configOptions = options;
+        if (!storageType) {
+            storageType = configOptions.storage;
+        }
+        const config = configOptions[`Config`];
+        return await storage_factory_1.StorageFactory.createStorage(storageType, config);
+    }
+}
+exports.FileStorageService = FileStorageService;

package/src/lib/index.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./nest-file-storage.module"), exports);
+tslib_1.__exportStar(require("./types"), exports);
+tslib_1.__exportStar(require("./storage.factory"), exports);
+tslib_1.__exportStar(require("./interceptor/file-storage.interceptor"), exports);
+tslib_1.__exportStar(require("./file-storage.service"), exports);

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

@@ -0,0 +1,138 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileStorageInterceptor = FileStorageInterceptor;
+const tslib_1 = require("tslib");
+const multer_1 = tslib_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");
+// Helper function to map file object
+function mapFileObject(file) {
+    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,
+        encoding: file.encoding,
+        fullPath: file.fullPath
+    };
+}
+// Helper function to apply file mapping with callback
+function applyFileKeyMapping(request, fileConfig, interceptorOptions) {
+    // Default callback returns the file key
+    const mapCallback = interceptorOptions?.mapToRequestBody || ((file) => {
+        // 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;
+        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;
+        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.
+ */
+function FileStorageInterceptor(fileConfig, interceptorOptions) {
+    if (typeof fileConfig === 'string') {
+        fileConfig = {
+            type: 'single',
+            fieldName: fileConfig,
+        };
+    }
+    return {
+        async intercept(context, next) {
+            const options = file_storage_service_1.FileStorageService.getOptions();
+            const request = context.switchToHttp().getRequest();
+            const response = context.switchToHttp().getResponse();
+            // Determine storage type - handle both config approaches
+            let storageType;
+            let storageConfig;
+            if ('storage' in options) {
+                // Configuration-based approach
+                const configOptions = options;
+                storageType = interceptorOptions?.storageType ?? configOptions.storage;
+                storageConfig = configOptions[`${storageType}Config`];
+            }
+            else {
+                // Class factory approach - default to LOCAL
+                storageType = interceptorOptions?.storageType ?? types_1.FileStorageEnum.LOCAL;
+                storageConfig = {};
+            }
+            const storageOptions = {
+                ...storageConfig,
+                ...(interceptorOptions?.storageOptions || {}),
+                fileName: interceptorOptions?.fileName || storageConfig?.fileName,
+                fileDist: (file, req) => {
+                    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 storage_factory_1.StorageFactory.createStorage(storageType, storageOptions);
+            const multerInstance = (0, multer_1.default)({ 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.js

@@ -0,0 +1,74 @@
+"use strict";
+var NestFileStorageModule_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NestFileStorageModule = void 0;
+const tslib_1 = require("tslib");
+const common_1 = require("@nestjs/common");
+const constants_1 = require("./constants");
+const file_storage_service_1 = require("./file-storage.service");
+let NestFileStorageModule = NestFileStorageModule_1 = class NestFileStorageModule {
+    static forRoot(options) {
+        return {
+            module: NestFileStorageModule_1,
+            providers: [
+                {
+                    provide: constants_1.FILE_STORAGE_OPTIONS,
+                    useFactory: async () => {
+                        file_storage_service_1.FileStorageService.setOptions(options); // ✅ Store globally
+                        return options;
+                    },
+                    inject: [],
+                },
+                file_storage_service_1.FileStorageService,
+            ],
+            exports: [],
+        };
+    }
+    static forRootAsync(options) {
+        const asyncProviders = this.createAsyncProviders(options);
+        return {
+            module: NestFileStorageModule_1,
+            imports: options.imports || [],
+            providers: [...asyncProviders, file_storage_service_1.FileStorageService],
+            exports: [],
+        };
+    }
+    static createAsyncProviders(options) {
+        if (options.useExisting || options.useFactory) {
+            return [this.createAsyncOptionsProvider(options)];
+        }
+        return [
+            this.createAsyncOptionsProvider(options),
+            {
+                provide: options.useClass,
+                useClass: options.useClass,
+            },
+        ];
+    }
+    static createAsyncOptionsProvider(options) {
+        if (options.useFactory) {
+            return {
+                provide: constants_1.FILE_STORAGE_OPTIONS,
+                useFactory: async (...args) => {
+                    const fileStorageOptions = await options.useFactory(...args);
+                    file_storage_service_1.FileStorageService.setOptions(fileStorageOptions);
+                    return fileStorageOptions;
+                },
+                inject: options.inject || [],
+            };
+        }
+        return {
+            provide: constants_1.FILE_STORAGE_OPTIONS,
+            useFactory: async (optionsFactory) => {
+                const fileStorageOptions = await optionsFactory.createFileStorageOptions();
+                file_storage_service_1.FileStorageService.setOptions(fileStorageOptions);
+                return fileStorageOptions;
+            },
+            inject: [options.useExisting || options.useClass],
+        };
+    }
+};
+exports.NestFileStorageModule = NestFileStorageModule;
+exports.NestFileStorageModule = NestFileStorageModule = NestFileStorageModule_1 = tslib_1.__decorate([
+    (0, common_1.Module)({})
+], NestFileStorageModule);

package/src/lib/storage/azure.storage.js

@@ -0,0 +1,153 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AzureStorage = void 0;
+const tslib_1 = require("tslib");
+const storage_blob_1 = require("@azure/storage-blob");
+const concat_stream_1 = tslib_1.__importDefault(require("concat-stream"));
+const moment_1 = tslib_1.__importDefault(require("moment"));
+const path_1 = tslib_1.__importStar(require("path"));
+const uuid_1 = require("uuid");
+class AzureStorage {
+    constructor(options) {
+        this.options = options;
+        this.fileNameFunction = options.fileName || ((file, _req) => {
+            return `${(0, uuid_1.v4)()}-${file.originalname}`;
+        });
+        this.fileDistFunction = options.fileDist || ((_file, _req) => {
+            return path_1.default.join('uploads', (0, moment_1.default)().format('YYYY'), (0, moment_1.default)().format('MM'), (0, moment_1.default)().format('DD'));
+        });
+        const sharedKeyCredential = new storage_blob_1.StorageSharedKeyCredential(options.account, options.accountKey);
+        this.blobServiceClient = new storage_blob_1.BlobServiceClient(`https://${options.account}.blob.core.windows.net`, sharedKeyCredential);
+    }
+    async _handleFile(req, file, cb) {
+        try {
+            const dist = await this.fileDistFunction(file, req);
+            const key = await this.fileNameFunction(file, req);
+            const filePath = (0, path_1.join)(dist, key);
+            file.stream.pipe((0, concat_stream_1.default)({ encoding: 'buffer' }, async (buffer) => {
+                const uploadedFile = await this.putFile(buffer, filePath);
+                const fileInfo = {
+                    ...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) => cb(err));
+    }
+    async _removeFile(_req, file, cb) {
+        try {
+            const blobClient = this.blobServiceClient
+                .getContainerClient(this.options.container)
+                .getBlobClient(file.key);
+            await blobClient.delete();
+            cb(null);
+        }
+        catch (error) {
+            cb(error);
+        }
+    }
+    getUrl(key) {
+        return `https://${this.options.account}.blob.core.windows.net/${this.options.container}/${key}`;
+    }
+    getSignedUrl(key, signatureValues = {}) {
+        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 storage_blob_1.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 = (0, storage_blob_1.generateBlobSASQueryParameters)({
+            containerName: this.options.container,
+            blobName: key,
+            permissions: storage_blob_1.BlobSASPermissions.parse('r'), // Read permissions
+            protocol: storage_blob_1.SASProtocol.Https, // HTTPS only
+            startsOn: new Date(), // Start time (now)
+            expiresOn, // Expiration time
+            ...signatureValues,
+        }, sharedKeyCredential).toString();
+        return `${blobClient.url}?${sasToken}`;
+    }
+    async getFile(key) {
+        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 = [];
+            stream?.on('data', (chunk) => chunks.push(chunk));
+            stream?.on('end', () => resolve(Buffer.concat(chunks)));
+            stream?.on('error', reject);
+        });
+    }
+    async putFile(buffer, key) {
+        try {
+            const containerClient = this.blobServiceClient.getContainerClient(this.options.container);
+            const blockBlobClient = containerClient.getBlockBlobClient(key);
+            await blockBlobClient.uploadData(buffer);
+            const fileInfo = {
+                originalName: (0, path_1.basename)(key),
+                fileName: (0, path_1.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) {
+        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, newKey) {
+        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: (0, path_1.basename)(newKey),
+                size: properties.contentLength || 0,
+                fileName: (0, path_1.basename)(newKey),
+                key: newKey,
+                fullPath: newKey,
+                url: this.getUrl(newKey),
+            };
+        }
+        catch (error) {
+            console.error('Error copying file in Azure Blob Storage:', error);
+            throw error;
+        }
+    }
+}
+exports.AzureStorage = AzureStorage;

package/src/lib/storage/local.storage.js

@@ -0,0 +1,183 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LocalStorage = void 0;
+const tslib_1 = require("tslib");
+const concat_stream_1 = tslib_1.__importDefault(require("concat-stream"));
+const fs = tslib_1.__importStar(require("fs"));
+const moment_1 = tslib_1.__importDefault(require("moment"));
+const path_1 = require("path");
+const uuid_1 = require("uuid");
+class LocalStorage {
+    /**
+     * 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
+     */
+    pathToUrl(filePath) {
+        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
+     */
+    urlToPath(urlKey) {
+        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(path_1.sep);
+    }
+    /**
+     * Get full file system path from URL-friendly key
+     */
+    getFullPath(urlKey) {
+        const osPath = this.urlToPath(urlKey);
+        return (0, path_1.join)(this.rootPath, osPath);
+    }
+    constructor(options) {
+        this.options = options;
+        // Normalize path for the current OS
+        this.rootPath = (0, path_1.normalize)(options.rootPath || (0, path_1.join)(process.cwd(), 'public'));
+        this.fileNameFunction = options.fileName || ((file, _req) => {
+            return `${(0, uuid_1.v4)()}-${file.originalname}`;
+        });
+        this.fileDistFunction = options.fileDist || ((_file, _req) => {
+            return (0, path_1.join)(this.rootPath, (0, moment_1.default)().format('YYYY'), (0, moment_1.default)().format('MM'), (0, moment_1.default)().format('DD'));
+        });
+        // Ensure the rootPath directory exists
+        if (!fs.existsSync(this.rootPath)) {
+            fs.mkdirSync(this.rootPath, { recursive: true });
+        }
+    }
+    async _handleFile(req, file, cb) {
+        try {
+            const dist = await this.fileDistFunction(file, req);
+            const fileName = await this.fileNameFunction(file, req);
+            const filePath = (0, path_1.join)(dist, fileName);
+            // Convert to URL-friendly key for storage
+            const urlKey = this.pathToUrl(filePath);
+            file.stream.pipe((0, concat_stream_1.default)({ encoding: 'buffer' }, async (buffer) => {
+                const uploadedFile = await this.putFile(buffer, urlKey);
+                const fileInfo = {
+                    ...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, file, cb) {
+        const filePath = file.path;
+        fs.unlink(filePath, (err) => {
+            if (err) {
+                cb(err);
+            }
+            else {
+                cb(null);
+            }
+        });
+    }
+    getUrl(urlKey) {
+        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) {
+        // Convert URL key to OS-specific path
+        const fullPath = this.getFullPath(urlKey);
+        return fs.promises.readFile(fullPath);
+    }
+    async deleteFile(urlKey) {
+        // Convert URL key to OS-specific path
+        const fullPath = this.getFullPath(urlKey);
+        return fs.promises.unlink(fullPath);
+    }
+    async putFile(fileContent, urlKey) {
+        return new Promise((putFileResolve, reject) => {
+            // Convert URL key to OS-specific path
+            const filePath = this.getFullPath(urlKey);
+            const directoryPath = (0, path_1.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 = {
+                    originalName: fileName,
+                    size: stats.size,
+                    fileName: fileName,
+                    key: urlKey,
+                    url: this.getUrl(urlKey),
+                    fullPath: filePath,
+                };
+                putFileResolve(fileInfo);
+            });
+        });
+    }
+    path(urlKey) {
+        if (!urlKey) {
+            return '';
+        }
+        // Convert URL key to full OS-specific path
+        return this.getFullPath(urlKey);
+    }
+    async copyFile(oldUrlKey, newUrlKey) {
+        return new Promise((resolve, reject) => {
+            // Convert URL keys to OS-specific paths
+            const oldPath = this.getFullPath(oldUrlKey);
+            const newPath = this.getFullPath(newUrlKey);
+            const directoryPath = (0, path_1.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 = {
+                    originalName: fileName,
+                    size: stats.size,
+                    fileName: fileName,
+                    key: newUrlKey,
+                    fullPath: newPath,
+                    url: this.getUrl(newUrlKey),
+                };
+                resolve(fileInfo);
+            });
+        });
+    }
+}
+exports.LocalStorage = LocalStorage;

package/src/lib/storage/s3.storage.js

@@ -0,0 +1,195 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.S3Storage = void 0;
+const tslib_1 = require("tslib");
+const client_s3_1 = require("@aws-sdk/client-s3");
+const client_s3_2 = require("@aws-sdk/client-s3");
+const s3_request_presigner_1 = require("@aws-sdk/s3-request-presigner");
+const moment_1 = tslib_1.__importDefault(require("moment"));
+const path_1 = tslib_1.__importStar(require("path"));
+const stream_1 = require("stream");
+const uuid_1 = require("uuid");
+class S3Storage {
+    constructor(options) {
+        this.options = options;
+        this.fileNameFunction = options.fileName || ((file, _req) => {
+            return `${(0, uuid_1.v4)()}-${file.originalname}`;
+        });
+        this.fileDistFunction = options.fileDist || ((_file, _req) => {
+            return path_1.default.join('uploads', (0, moment_1.default)().format('YYYY'), (0, moment_1.default)().format('MM'), (0, moment_1.default)().format('DD'));
+        });
+        this.s3 = new client_s3_1.S3({
+            ...(this.options.endpoint ? { endpoint: this.options.endpoint } : {}),
+            region: this.options.region,
+            credentials: {
+                accessKeyId: this.options.accessKeyId,
+                secretAccessKey: this.options.secretAccessKey,
+            },
+        });
+    }
+    async _handleFile(req, file, cb) {
+        // Collect file chunks to determine size
+        const chunks = [];
+        file.stream.on('data', (chunk) => chunks.push(chunk));
+        file.stream.on('end', async () => {
+            const buffer = Buffer.concat(chunks);
+            try {
+                const dist = await this.fileDistFunction(file, req);
+                const key = await this.fileNameFunction(file, req);
+                const filePath = (0, path_1.join)(dist, key);
+                const uploadedFile = await this.putFile(buffer, filePath);
+                const fileInfo = {
+                    ...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 (err) {
+                cb(err);
+            }
+        });
+        file.stream.on('error', (err) => cb(err));
+    }
+    _removeFile(_req, file, cb) {
+        const params = {
+            Bucket: this.options.bucket,
+            Key: file.key,
+        };
+        this.s3
+            .deleteObject(params)
+            .then(() => cb(null))
+            .catch((err) => cb(err));
+    }
+    getUrl(key) {
+        if (this.options?.cloudFrontUrl) {
+            return `${this.options.cloudFrontUrl}/${key}`;
+        }
+        return `https://${this.options.bucket}.s3.amazonaws.com/${key}`;
+    }
+    async getSignedUrl(key, objectConfig) {
+        if (key) {
+            const url = await (0, s3_request_presigner_1.getSignedUrl)(this.s3, new client_s3_2.GetObjectCommand({
+                Bucket: this.options.bucket,
+                Key: key,
+                ...(objectConfig && { ...objectConfig }),
+            }));
+            return url;
+        }
+        return '';
+    }
+    async getFile(key) {
+        if (!key) {
+            throw new Error('Key is required to fetch the file from S3.');
+        }
+        try {
+            const command = new client_s3_2.GetObjectCommand({
+                Bucket: this.options.bucket,
+                Key: key,
+            });
+            const data = await this.s3.send(command);
+            if (!data.Body) {
+                throw new Error('Empty response received from S3.');
+            }
+            // Handle both Buffer and Readable Stream responses
+            if (data.Body instanceof stream_1.Readable) {
+                return await this.streamToBuffer(data.Body);
+            }
+            throw new Error('Unexpected data.Body type received from S3.');
+        }
+        catch (error) {
+            console.error(`Error fetching file (${key}) from S3:`, error);
+            throw error;
+        }
+    }
+    async putFile(fileContent, key) {
+        try {
+            const fileName = (0, path_1.basename)(key);
+            const fileKey = key || (Math.random() + 1).toString(36).substring(12);
+            // Upload the file
+            const putParams = {
+                Bucket: this.options.bucket,
+                Key: fileKey,
+                Body: fileContent,
+                ContentDisposition: `inline; ${fileName}`,
+            };
+            await this.s3.send(new client_s3_2.PutObjectCommand(putParams));
+            // Fetch file metadata to get size
+            const headParams = {
+                Bucket: this.options.bucket,
+                Key: fileKey,
+            };
+            const headObject = await this.s3.send(new client_s3_2.HeadObjectCommand(headParams));
+            const fileSize = headObject.ContentLength || 0;
+            // Construct response object
+            const fileData = {
+                originalName: fileName,
+                fileName: fileName,
+                size: fileSize,
+                buffer: fileContent,
+                fullPath: fileKey,
+                key: fileKey,
+                url: this.getUrl(fileKey),
+            };
+            return fileData;
+        }
+        catch (error) {
+            console.error('Error uploading file to S3:', error);
+            throw error;
+        }
+    }
+    async deleteFile(key) {
+        if (!key) {
+            throw new Error('File key is required for deletion.');
+        }
+        try {
+            const deleteParams = {
+                Bucket: this.options.bucket,
+                Key: key,
+            };
+            await this.s3.send(new client_s3_2.DeleteObjectCommand(deleteParams));
+        }
+        catch (error) {
+            console.error(`Error deleting file (${key}) from S3:`, error);
+            throw error;
+        }
+    }
+    async streamToBuffer(stream) {
+        const chunks = [];
+        for await (const chunk of stream) {
+            chunks.push(chunk);
+        }
+        return Buffer.concat(chunks);
+    }
+    async copyFile(oldKey, newKey) {
+        try {
+            await this.s3.send(new client_s3_1.CopyObjectCommand({
+                Bucket: this.options.bucket,
+                CopySource: `/${this.options.bucket}/${oldKey}`,
+                Key: newKey,
+            }));
+            const headObject = await this.s3.send(new client_s3_2.HeadObjectCommand({
+                Bucket: this.options.bucket,
+                Key: newKey,
+            }));
+            return {
+                originalName: (0, path_1.basename)(newKey),
+                size: headObject.ContentLength || 0,
+                fileName: (0, path_1.basename)(newKey),
+                key: newKey,
+                fullPath: newKey,
+                url: this.getUrl(newKey),
+            };
+        }
+        catch (error) {
+            console.error('Error copying file in S3:', error);
+            throw error;
+        }
+    }
+}
+exports.S3Storage = S3Storage;

package/src/lib/storage.factory.js

@@ -0,0 +1,81 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StorageFactory = void 0;
+const types_1 = require("./types");
+class StorageFactory {
+    static async createStorage(storageType, options) {
+        const cacheKey = `${storageType}-${JSON.stringify(options)}`;
+        // if (this.storageInstances.has(cacheKey)) {
+        //     return this.storageInstances.get(cacheKey)!;
+        // }
+        let storageInstance;
+        switch (storageType) {
+            case types_1.FileStorageEnum.LOCAL:
+                const { LocalStorage } = await Promise.resolve().then(() => __importStar(require('./storage/local.storage')));
+                storageInstance = new LocalStorage(options);
+                break;
+            case types_1.FileStorageEnum.AZURE:
+                try {
+                    const { AzureStorage } = await Promise.resolve().then(() => __importStar(require('./storage/azure.storage')));
+                    storageInstance = new AzureStorage(options);
+                }
+                catch (error) {
+                    throw new Error('Azure Storage SDK (@azure/storage-blob) is required when using AzureStorage. ' +
+                        'Please install it: npm install @azure/storage-blob');
+                }
+                break;
+            case types_1.FileStorageEnum.S3:
+                try {
+                    const { S3Storage } = await Promise.resolve().then(() => __importStar(require('./storage/s3.storage')));
+                    storageInstance = new S3Storage(options);
+                }
+                catch (error) {
+                    throw new Error('AWS SDK (@aws-sdk/client-s3 and @aws-sdk/s3-request-presigner) is required when using S3Storage. ' +
+                        'Please install them: npm install @aws-sdk/client-s3 @aws-sdk/s3-request-presigner');
+                }
+                break;
+            default:
+                throw new Error(`Unsupported storage type: ${storageType}`);
+        }
+        this.storageInstances.set(cacheKey, storageInstance);
+        return storageInstance;
+    }
+    static clearCache() {
+        this.storageInstances.clear();
+    }
+}
+exports.StorageFactory = StorageFactory;
+StorageFactory.storageInstances = new Map();

package/src/lib/types.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileStorageEnum = void 0;
+var FileStorageEnum;
+(function (FileStorageEnum) {
+    FileStorageEnum["LOCAL"] = "local";
+    FileStorageEnum["S3"] = "s3";
+    FileStorageEnum["AZURE"] = "azure";
+})(FileStorageEnum || (exports.FileStorageEnum = FileStorageEnum = {}));