@flusys/nestjs-storage 7.1.0 → 8.0.0

package/fesm/562.js

@@ -0,0 +1,786 @@
+import * as __rspack_external_sharp from "sharp";
+import * as __rspack_external_path from "path";
+import * as __rspack_external_uuid from "uuid";
+import * as __rspack_external_fs from "fs";
+import * as __rspack_external_mime_types_1e2a4730 from "mime-types";
+import * as __rspack_external_passport from "passport";
+import * as __rspack_external_fs_promises_e1851c9c from "fs/promises";
+export const __rspack_esm_id = 562;
+export const __rspack_esm_ids = [562];
+export const __webpack_modules__ = {
+969(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+  u: () => (/* reexport */ FileServeMiddleware)
+});
+
+// EXTERNAL MODULE: external "@nestjs/common"
+var common_ = __webpack_require__(157);
+;// CONCATENATED MODULE: external "fs"
+
+// EXTERNAL MODULE: external "path"
+var external_path_ = __webpack_require__(521);
+;// CONCATENATED MODULE: external "mime-types"
+
+;// CONCATENATED MODULE: external "passport"
+
+// EXTERNAL MODULE: external "@flusys/nestjs-shared/constants"
+var constants_ = __webpack_require__(140);
+// EXTERNAL MODULE: ./projects/nestjs-storage/src/config/message-keys.ts
+var message_keys = __webpack_require__(450);
+// EXTERNAL MODULE: ./projects/nestjs-storage/src/services/upload.service.ts + 1 modules
+var upload_service = __webpack_require__(18);
+;// CONCATENATED MODULE: ./projects/nestjs-storage/src/middlewares/file-serve.middleware.ts
+function _ts_decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") {
+        r = Reflect.decorate(decorators, target, key, desc);
+    } else {
+        for(var i = decorators.length - 1; i >= 0; i--){
+            if (d = decorators[i]) {
+                r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+            }
+        }
+    }
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+function _ts_metadata(metadataKey, metadataValue) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") {
+        return Reflect.metadata(metadataKey, metadataValue);
+    }
+}
+function _ts_param(paramIndex, decorator) {
+    return function(target, key) {
+        decorator(target, key, paramIndex);
+    };
+}
+
+
+
+
+
+
+
+
+/** MIME type prefixes that can be displayed inline in browser */ const VIEWABLE_TYPE_PREFIXES = [
+    'image/',
+    'video/',
+    'audio/',
+    'text/',
+    'application/pdf',
+    'application/json',
+    'application/xml'
+];
+class FileServeMiddleware {
+    uploadService;
+    uploadDir = process.cwd();
+    constructor(uploadService){
+        this.uploadService = uploadService;
+    }
+    async use(req, res, next) {
+        await new Promise((resolvePromise)=>{
+            __rspack_external_passport["default"].authenticate('jwt', {
+                session: false
+            }, (err, user)=>{
+                if (err || !user) {
+                    this.sendErrorResponse(res, new common_.UnauthorizedException({
+                        message: 'Authentication required',
+                        messageKey: constants_.AUTH_MESSAGES.TOKEN_INVALID
+                    }));
+                    resolvePromise();
+                    return;
+                }
+                req.user = user;
+                this.serveFile(req, res).finally(resolvePromise);
+            })(req, res, next);
+        });
+    }
+    async serveFile(req, res) {
+        try {
+            const normalizedPath = this.extractFilePath(req);
+            const fullPath = await this.resolveFilePath(normalizedPath);
+            const stats = (0,__rspack_external_fs.statSync)(fullPath);
+            if (!stats.isFile()) {
+                throw new common_.NotFoundException({
+                    message: `Not a file: ${normalizedPath}`,
+                    messageKey: message_keys/* .FILE_MESSAGES.NOT_FOUND */.uA.NOT_FOUND,
+                    messageVariables: {
+                        path: normalizedPath
+                    }
+                });
+            }
+            const mimeType = this.getMimeType(fullPath);
+            this.setResponseHeaders(res, stats.size, mimeType, normalizedPath);
+            this.streamFile(res, fullPath, normalizedPath);
+        } catch (error) {
+            this.sendErrorResponse(res, error);
+        }
+    }
+    /** Extract and validate file path from request URL */ extractFilePath(req) {
+        const urlPath = req.path || req.url;
+        const match = urlPath.match(/\/storage\/upload\/file\/(.+)/);
+        const normalizedPath = match ? match[1] : '';
+        if (!normalizedPath) {
+            throw new common_.BadRequestException({
+                message: 'File path is required',
+                messageKey: message_keys/* .UPLOAD_MESSAGES.NO_FILE_PATH */.dS.NO_FILE_PATH
+            });
+        }
+        return normalizedPath;
+    }
+    /** Resolve file path using multiple fallback strategies */ async resolveFilePath(normalizedPath) {
+        // Strategy 1: Path relative to CWD (new format: key includes basePath)
+        let fullPath = (0,external_path_.join)(this.uploadDir, normalizedPath);
+        const resolvedPath = (0,external_path_.resolve)(fullPath);
+        // Prevent path traversal attacks (boundary-safe: avoids matching sibling dirs like uploadDir + '-evil')
+        if (resolvedPath !== this.uploadDir && !resolvedPath.startsWith(this.uploadDir + external_path_.sep)) {
+            throw new common_.BadRequestException({
+                message: 'Invalid file path',
+                messageKey: message_keys/* .UPLOAD_MESSAGES.INVALID_FILE_PATH */.dS.INVALID_FILE_PATH
+            });
+        }
+        if ((0,__rspack_external_fs.existsSync)(fullPath)) {
+            return fullPath;
+        }
+        // Try fallback strategies with basePath
+        const basePath = await this.uploadService.getLocalStorageBasePath();
+        if (basePath) {
+            const fallbackPath = this.tryFallbackPaths(normalizedPath, basePath);
+            if (fallbackPath) {
+                return fallbackPath;
+            }
+        }
+        throw new common_.NotFoundException({
+            message: `File not found: ${normalizedPath}`,
+            messageKey: message_keys/* .FILE_MESSAGES.NOT_FOUND */.uA.NOT_FOUND,
+            messageVariables: {
+                path: normalizedPath
+            }
+        });
+    }
+    /** Try basePath-based fallback strategies */ tryFallbackPaths(normalizedPath, basePath) {
+        const normalizedBasePath = basePath.replace(/^\.\//, '').replace(/\/$/, '');
+        const pathStartsWithBase = normalizedPath.startsWith(normalizedBasePath + '/') || normalizedPath.startsWith(normalizedBasePath);
+        if (pathStartsWithBase) {
+            // Strategy 2: basePath + remaining path
+            const remainingPath = normalizedPath.substring(normalizedBasePath.length).replace(/^\//, '');
+            const fallbackPath = (0,external_path_.join)(basePath, remainingPath);
+            if ((0,__rspack_external_fs.existsSync)(fallbackPath)) return fallbackPath;
+        } else {
+            // Strategy 3: Old format - prepend basePath
+            const fallbackPath = (0,external_path_.join)(basePath, normalizedPath);
+            if ((0,__rspack_external_fs.existsSync)(fallbackPath)) return fallbackPath;
+        }
+        return null;
+    }
+    /** Get MIME type with SVG special handling */ getMimeType(fullPath) {
+        if (fullPath.toLowerCase().endsWith('.svg')) {
+            return 'image/svg+xml';
+        }
+        return __rspack_external_mime_types_1e2a4730.lookup(fullPath) || 'application/octet-stream';
+    }
+    /** Set response headers for file serving */ setResponseHeaders(res, size, mimeType, normalizedPath) {
+        const isViewable = VIEWABLE_TYPE_PREFIXES.some((type)=>mimeType.startsWith(type));
+        const filename = normalizedPath.split('/').pop() || 'download';
+        const contentDisposition = isViewable ? 'inline' : `attachment; filename="${encodeURIComponent(filename)}"`;
+        res.set({
+            'Content-Type': mimeType,
+            'Content-Length': size,
+            'Content-Disposition': contentDisposition,
+            'Cache-Control': 'public, max-age=3600',
+            'Accept-Ranges': 'bytes',
+            'Cross-Origin-Resource-Policy': 'cross-origin',
+            'Access-Control-Allow-Origin': '*',
+            'X-Content-Type-Options': 'nosniff'
+        });
+    }
+    /** Stream file to response with error handling */ streamFile(res, fullPath, normalizedPath) {
+        const stream = (0,__rspack_external_fs.createReadStream)(fullPath);
+        stream.pipe(res);
+        stream.on('error', ()=>{
+            if (!res.headersSent) {
+                this.sendErrorResponse(res, new common_.NotFoundException({
+                    message: `Failed to serve file: ${normalizedPath}`,
+                    messageKey: message_keys/* .FILE_MESSAGES.NOT_FOUND */.uA.NOT_FOUND,
+                    messageVariables: {
+                        path: normalizedPath
+                    }
+                }));
+            }
+        });
+        res.on('close', ()=>stream.destroy());
+    }
+    /** Send consistent error response */ sendErrorResponse(res, error) {
+        if (res.headersSent) {
+            return;
+        }
+        const isHttpException = error instanceof common_.NotFoundException || error instanceof common_.BadRequestException || error instanceof common_.UnauthorizedException;
+        const response = isHttpException ? error.getResponse() : null;
+        const statusCode = isHttpException ? error.getStatus() : 404;
+        const message = response?.message ?? 'File not found';
+        const messageKey = response?.messageKey ?? message_keys/* .FILE_MESSAGES.NOT_FOUND */.uA.NOT_FOUND;
+        const messageVariables = response?.messageVariables;
+        res.status(statusCode).json({
+            success: false,
+            message,
+            messageKey,
+            messageVariables,
+            error: statusCode === 401 ? 'Unauthorized' : statusCode === 400 ? 'Bad Request' : 'Not Found',
+            statusCode
+        });
+    }
+}
+FileServeMiddleware = _ts_decorate([
+    (0,common_.Injectable)(),
+    _ts_param(0, (0,common_.Inject)(upload_service/* .UploadService */.B)),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof upload_service/* .UploadService */.B === "undefined" ? Object : upload_service/* .UploadService */.B
+    ])
+], FileServeMiddleware);
+
+;// CONCATENATED MODULE: ./projects/nestjs-storage/src/middlewares/index.ts
+
+
+
+},
+329(module, __webpack_exports__, __webpack_require__) {
+__webpack_require__.a(module, async function (__rspack_load_async_deps, __rspack_async_done) { try {
+/* import */ var _storage_module_js__rspack_import_0 = __webpack_require__(624);
+var __rspack_async_deps = __rspack_load_async_deps([_storage_module_js__rspack_import_0]);
+_storage_module_js__rspack_import_0 = (__rspack_async_deps.then ? (await __rspack_async_deps)() : __rspack_async_deps)[0];
+
+__webpack_require__.d(__webpack_exports__, {
+  k: () => (/* reexport safe */ _storage_module_js__rspack_import_0.k)
+});
+
+__rspack_async_done();
+} catch(e) { __rspack_async_done(e); } });
+
+},
+624(module, __webpack_exports__, __webpack_require__) {
+__webpack_require__.a(module, async function (__rspack_load_async_deps, __rspack_async_done) { try {
+/* import */ var _flusys_nestjs_shared_modules__rspack_import_0 = __webpack_require__(236);
+/* import */ var _nestjs_common__rspack_import_1 = __webpack_require__(157);
+/* import */ var _middlewares_index_js__rspack_import_2 = __webpack_require__(969);
+/* import */ var _services_index_js__rspack_import_3 = __webpack_require__(148);
+/* import */ var _config_storage_constants_js__rspack_import_9 = __webpack_require__(188);
+/* import */ var _controllers_index_js__rspack_import_4 = __webpack_require__(488);
+/* import */ var _enums_file_location_enum_js__rspack_import_8 = __webpack_require__(733);
+/* import */ var _providers_index_js__rspack_import_5 = __webpack_require__(922);
+/* import */ var _providers_local_provider_js__rspack_import_6 = __webpack_require__(632);
+/* import */ var _services_storage_provider_config_service_js__rspack_import_7 = __webpack_require__(623);
+function _ts_decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") {
+        r = Reflect.decorate(decorators, target, key, desc);
+    } else {
+        for(var i = decorators.length - 1; i >= 0; i--){
+            if (d = decorators[i]) {
+                r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+            }
+        }
+    }
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+
+
+
+
+
+
+
+
+
+
+
+const logger = new _nestjs_common__rspack_import_1.Logger('StorageModule');
+const CONTROLLERS = [
+    _controllers_index_js__rspack_import_4/* .FileManagerController */.AE,
+    _controllers_index_js__rspack_import_4/* .FolderController */.X$,
+    _controllers_index_js__rspack_import_4/* .StorageConfigController */.Iz,
+    _controllers_index_js__rspack_import_4/* .UploadController */.I7
+];
+const EXPORTED_SERVICES = [
+    _services_index_js__rspack_import_3/* .StorageConfigService */.tP,
+    _services_index_js__rspack_import_3/* .StorageDataSourceProvider */.M0,
+    _services_index_js__rspack_import_3/* .FileManagerService */.DL,
+    _services_index_js__rspack_import_3/* .FolderService */.kh,
+    _services_storage_provider_config_service_js__rspack_import_7/* .StorageProviderConfigService */.o,
+    _services_index_js__rspack_import_3/* .UploadService */.BB,
+    _providers_index_js__rspack_import_5/* .StorageFactoryService */.Lk
+];
+// Register built-in provider
+_providers_index_js__rspack_import_5/* .StorageProviderRegistry.register */.CG.register(_enums_file_location_enum_js__rspack_import_8/* .FileLocationEnum.LOCAL */.N.LOCAL, _providers_local_provider_js__rspack_import_6/* .LocalProvider */.T);
+logger.log('Registered LocalProvider');
+// Register optional providers (skip if dependencies not installed).
+// Each `import()` below MUST stay a literal string, not a variable — a computed
+// specifier can't be statically resolved by Rspack/Webpack ("the request of a
+// dependency is an expression"), which silently drops the dynamic import instead
+// of bundling it, even when the underlying package is installed.
+async function registerOptionalProvider(location, name, dep, loader) {
+    try {
+        const providerModule = await loader();
+        _providers_index_js__rspack_import_5/* .StorageProviderRegistry.register */.CG.register(location, providerModule[name]);
+        logger.log(`Registered ${name}`);
+    } catch  {
+        logger.debug(`${name} not available (install ${dep} to enable)`);
+    }
+}
+await registerOptionalProvider(_enums_file_location_enum_js__rspack_import_8/* .FileLocationEnum.AWS */.N.AWS, 'S3Provider', '@aws-sdk/client-s3', ()=>__webpack_require__.e(/* import() */ 591).then(__webpack_require__.bind(__webpack_require__, 970)));
+await registerOptionalProvider(_enums_file_location_enum_js__rspack_import_8/* .FileLocationEnum.AZURE */.N.AZURE, 'AzureProvider', '@azure/storage-blob', ()=>__webpack_require__.e(/* import() */ 190).then(__webpack_require__.bind(__webpack_require__, 269)));
+await registerOptionalProvider(_enums_file_location_enum_js__rspack_import_8/* .FileLocationEnum.SFTP */.N.SFTP, 'SftpProvider', 'ssh2-sftp-client', ()=>__webpack_require__.e(/* import() */ 918).then(__webpack_require__.bind(__webpack_require__, 5)));
+class StorageModule {
+    configure(consumer) {
+        consumer.apply(_middlewares_index_js__rspack_import_2/* .FileServeMiddleware */.u).forRoutes({
+            path: 'storage/upload/file/*',
+            method: _nestjs_common__rspack_import_1.RequestMethod.GET
+        });
+    }
+    static forRoot(options) {
+        return {
+            module: StorageModule,
+            global: options.global ?? false,
+            imports: [
+                _flusys_nestjs_shared_modules__rspack_import_0.CacheModule,
+                _flusys_nestjs_shared_modules__rspack_import_0.UtilsModule
+            ],
+            controllers: options.includeController !== false ? CONTROLLERS : [],
+            providers: this.buildProviders(options),
+            exports: EXPORTED_SERVICES
+        };
+    }
+    static forRootAsync(options) {
+        return {
+            module: StorageModule,
+            global: options.global ?? false,
+            imports: [
+                ...options.imports || [],
+                _flusys_nestjs_shared_modules__rspack_import_0.CacheModule,
+                _flusys_nestjs_shared_modules__rspack_import_0.UtilsModule
+            ],
+            controllers: options.includeController !== false ? CONTROLLERS : [],
+            providers: [
+                ...this.createAsyncProviders(options),
+                ...this.buildProviders()
+            ],
+            exports: EXPORTED_SERVICES
+        };
+    }
+    // ─── Private Helpers ──────────────────────────────────────────────────────────
+    static buildProviders(options) {
+        const providers = [
+            ...EXPORTED_SERVICES,
+            _middlewares_index_js__rspack_import_2/* .FileServeMiddleware */.u
+        ];
+        if (options) {
+            providers.unshift({
+                provide: _config_storage_constants_js__rspack_import_9/* .STORAGE_MODULE_OPTIONS */.k0,
+                useValue: options
+            });
+        }
+        providers.push((0,_flusys_nestjs_shared_modules__rspack_import_0.createModuleEventsProvider)('storage', _config_storage_constants_js__rspack_import_9/* .STORAGE_MODULE_OPTIONS */.k0));
+        return providers;
+    }
+    static createAsyncProviders(options) {
+        if (options.useFactory) {
+            return [
+                {
+                    provide: _config_storage_constants_js__rspack_import_9/* .STORAGE_MODULE_OPTIONS */.k0,
+                    useFactory: async (...args)=>({
+                            ...options,
+                            config: await options.useFactory(...args)
+                        }),
+                    inject: options.inject || []
+                }
+            ];
+        }
+        const factoryClass = options.useClass || options.useExisting;
+        if (!factoryClass) return [];
+        const providers = [
+            {
+                provide: _config_storage_constants_js__rspack_import_9/* .STORAGE_MODULE_OPTIONS */.k0,
+                useFactory: async (factory)=>({
+                        ...options,
+                        config: await factory.createStorageOptions()
+                    }),
+                inject: [
+                    factoryClass
+                ]
+            }
+        ];
+        if (options.useClass) {
+            providers.push({
+                provide: options.useClass,
+                useClass: options.useClass
+            });
+        }
+        return providers;
+    }
+}
+StorageModule = _ts_decorate([
+    (0,_nestjs_common__rspack_import_1.Module)({})
+], StorageModule);
+
+__webpack_require__.d(__webpack_exports__, {
+  k: () => (StorageModule)
+});
+
+__rspack_async_done();
+} catch(e) { __rspack_async_done(e); } }, 1);
+
+},
+922(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+/* import */ var _storage_factory_service_js__rspack_import_0 = __webpack_require__(192);
+/* import */ var _storage_provider_registry_js__rspack_import_1 = __webpack_require__(264);
+/* import */ var _local_provider_js__rspack_import_2 = __webpack_require__(632);
+// Core exports
+
+
+// Built-in provider (no external dependencies)
+ // Note: Optional storage providers are loaded dynamically
+ // Import them directly from their files when needed:
+ // - import { S3Provider } from '@flusys/nestjs-storage/providers/s3-provider.optional';
+ // - import { AzureProvider } from '@flusys/nestjs-storage/providers/azure-provider.optional';
+ // - import { SftpProvider } from '@flusys/nestjs-storage/providers/sftp-provider.optional';
+
+__webpack_require__.d(__webpack_exports__, {
+  CG: () => (/* reexport safe */ _storage_provider_registry_js__rspack_import_1.C),
+  Lk: () => (/* reexport safe */ _storage_factory_service_js__rspack_import_0.L),
+  TZ: () => (/* reexport safe */ _local_provider_js__rspack_import_2.T)
+});
+
+
+},
+632(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+  T: () => (/* binding */ LocalProvider)
+});
+
+// EXTERNAL MODULE: external "@nestjs/common"
+var common_ = __webpack_require__(157);
+// EXTERNAL MODULE: external "@flusys/nestjs-shared/constants"
+var constants_ = __webpack_require__(140);
+// EXTERNAL MODULE: ./projects/nestjs-storage/src/utils/image-compressor.util.ts + 1 modules
+var image_compressor_util = __webpack_require__(872);
+;// CONCATENATED MODULE: external "fs/promises"
+
+// EXTERNAL MODULE: external "path"
+var external_path_ = __webpack_require__(521);
+// EXTERNAL MODULE: external "uuid"
+var external_uuid_ = __webpack_require__(37);
+;// CONCATENATED MODULE: ./projects/nestjs-storage/src/providers/local-provider.ts
+/**
+ * LOCAL File System Provider
+ *
+ * This provider uses Node.js built-in 'fs' module - NO external dependencies required!
+ * Perfect for same-server storage scenarios.
+ *
+ * Usage:
+ * import { LocalProvider } from '@flusys/nestjs-storage/providers/local-provider';
+ * import { StorageProviderRegistry, FileLocationEnum } from '@flusys/nestjs-storage';
+ *
+ * StorageProviderRegistry.register(FileLocationEnum.LOCAL, LocalProvider);
+ */ 
+
+
+
+
+
+/**
+ * Local File System Storage Provider
+ * Uses Node.js built-in fs module - no external dependencies
+ */ class LocalProvider {
+    basePath = '';
+    baseUrl = '';
+    relativeBasePath = '';
+    /**
+   * SECURITY: Validates that a target path does not escape the base directory
+   * Prevents path traversal attacks using ../ sequences
+   * @throws Error if path traversal is detected
+   */ validatePathWithinBase(targetPath) {
+        const normalizedBasePath = external_path_.resolve(this.basePath);
+        const normalizedTargetPath = external_path_.resolve(targetPath);
+        if (!normalizedTargetPath.startsWith(normalizedBasePath + external_path_.sep) && normalizedTargetPath !== normalizedBasePath) {
+            throw new common_.BadRequestException({
+                message: 'Invalid path: Path traversal attempt detected',
+                messageKey: constants_.SYSTEM_MESSAGES.PATH_TRAVERSAL_DETECTED
+            });
+        }
+    }
+    /**
+   * SECURITY: Validates file key format to prevent malicious input
+   * @throws Error if key contains suspicious patterns
+   */ validateKeyFormat(key) {
+        if (!key || typeof key !== 'string' || key.trim().length === 0) {
+            throw new common_.BadRequestException({
+                message: 'Invalid file key: empty or invalid',
+                messageKey: constants_.SYSTEM_MESSAGES.INVALID_FILE_KEY
+            });
+        }
+        if (key.includes('\0')) {
+            throw new common_.BadRequestException({
+                message: 'Invalid file key: contains null bytes',
+                messageKey: constants_.SYSTEM_MESSAGES.INVALID_FILE_KEY
+            });
+        }
+    }
+    /**
+   * Initialize Local File System provider with configuration
+   * @param config.basePath - Base path for file storage (default: './uploads')
+   * @param config.baseUrl - Optional base URL for generating file URLs
+   */ async initialize(config) {
+        // Store original relative path for key generation
+        this.relativeBasePath = config?.basePath || './uploads';
+        // Resolve to absolute path for file operations
+        this.basePath = external_path_.resolve(this.relativeBasePath);
+        this.baseUrl = config?.baseUrl || '';
+        // Ensure base directory exists
+        await __rspack_external_fs_promises_e1851c9c.mkdir(this.basePath, {
+            recursive: true
+        });
+    }
+    async uploadFile(file, options) {
+        let processedBuffer = file.buffer;
+        let contentType = file.mimetype;
+        const fileName = `${(0,external_uuid_.v4)()}-${file.originalname}`;
+        // Compress image if needed
+        if (options.compress && file.mimetype.startsWith('image/')) {
+            const result = await image_compressor_util/* .ImageCompressor.compress */.J.compress(file.buffer, file.mimetype, {
+                maxWidth: options.maxWidth,
+                maxHeight: options.maxHeight,
+                quality: options.quality,
+                format: options.format
+            });
+            processedBuffer = result.buffer;
+            contentType = result.format;
+        }
+        // Build file path
+        const folderPath = options.folderPath ? external_path_.join(this.basePath, options.folderPath) : this.basePath;
+        // SECURITY: Validate path does not escape base directory
+        this.validatePathWithinBase(folderPath);
+        const filePath = external_path_.join(folderPath, fileName);
+        // SECURITY: Double-check final file path
+        this.validatePathWithinBase(filePath);
+        // Ensure directory exists
+        await __rspack_external_fs_promises_e1851c9c.mkdir(folderPath, {
+            recursive: true
+        });
+        // Write file to disk
+        await __rspack_external_fs_promises_e1851c9c.writeFile(filePath, processedBuffer);
+        // Generate key that includes the base path (relative to cwd)
+        // This makes the key self-contained for serving files
+        const relativeKey = external_path_.join(this.relativeBasePath, options.folderPath || '', fileName).replace(/\\/g, '/'); // Normalize path separators
+        return {
+            name: fileName,
+            key: relativeKey,
+            size: processedBuffer.length,
+            contentType
+        };
+    }
+    async uploadMultipleFiles(files, options) {
+        return Promise.all(files.map((file)=>this.uploadFile(file, options)));
+    }
+    async deleteFile(key) {
+        try {
+            // SECURITY: Validate key format first
+            this.validateKeyFormat(key);
+            // Key now includes the basePath, resolve from cwd
+            let filePath = external_path_.resolve(key);
+            // SECURITY: Validate resolved path is within base directory
+            this.validatePathWithinBase(filePath);
+            // Check if file exists at the resolved path
+            try {
+                await __rspack_external_fs_promises_e1851c9c.access(filePath);
+            } catch  {
+                // Fallback: try with basePath prefix (for old keys without basePath)
+                const fallbackPath = external_path_.join(this.basePath, key);
+                // SECURITY: Validate fallback path as well
+                this.validatePathWithinBase(fallbackPath);
+                try {
+                    await __rspack_external_fs_promises_e1851c9c.access(fallbackPath);
+                    filePath = fallbackPath;
+                } catch  {
+                    // File doesn't exist at either location - silent return
+                    return;
+                }
+            }
+            await __rspack_external_fs_promises_e1851c9c.unlink(filePath);
+        } catch (error) {
+            // Re-throw security errors
+            if (error instanceof Error && error.message.includes('Invalid')) {
+                throw error;
+            }
+        // Silent failure for other errors
+        }
+    }
+    async deleteMultipleFiles(keys) {
+        await Promise.all(keys.map((key)=>this.deleteFile(key)));
+    }
+    async generatePresignedUrl(key, _expiresInSeconds) {
+        // Return public URL or relative path
+        // Note: Local storage doesn't support true presigned URLs
+        // If baseUrl is provided, return full URL with file serving endpoint, otherwise return relative path
+        if (this.baseUrl) {
+            // Construct URL with the file serving endpoint
+            const baseUrlWithoutTrailingSlash = this.baseUrl.replace(/\/$/, '');
+            return `${baseUrlWithoutTrailingSlash}/storage/upload/file/${key}`;
+        }
+        return `/storage/upload/file/${key}`;
+    }
+    async healthCheck() {
+        try {
+            await __rspack_external_fs_promises_e1851c9c.access(this.basePath);
+            return true;
+        } catch  {
+            return false;
+        }
+    }
+}
+
+
+},
+872(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+  J: () => (/* binding */ ImageCompressor)
+});
+
+;// CONCATENATED MODULE: external "sharp"
+
+;// CONCATENATED MODULE: ./projects/nestjs-storage/src/utils/image-compressor.util.ts
+
+// Handle ESM/CJS interop - sharp exports differently in each module system
+const sharp = __rspack_external_sharp["default"] || __rspack_external_sharp;
+/**
+ * Image Compression Utility
+ * Handles image compression and format conversion using sharp
+ */ class ImageCompressor {
+    /**
+   * Dynamically compresses an image based on its format and provided options.
+   * - Preserves original format if not overridden
+   * - Adjusts compression settings for each codec
+   */ static async compress(buffer, mimetype, options = {}) {
+        const { maxWidth = 1280, maxHeight = 1280, quality = 85, format = 'original' } = options;
+        // Skip processing for SVG
+        if (mimetype === 'image/svg+xml') {
+            return {
+                buffer,
+                format: mimetype
+            };
+        }
+        // Initialize sharp with improved error handling
+        const image = sharp(buffer, {
+            failOnError: false,
+            density: 300
+        });
+        // Apply initial resize
+        image.resize({
+            width: maxWidth,
+            height: maxHeight,
+            fit: 'inside',
+            withoutEnlargement: true
+        });
+        // Determine target format
+        let targetFormat = format !== 'original' ? format : mimetype.split('/')[1];
+        // Format-specific optimizations
+        switch(targetFormat.toLowerCase()){
+            case 'jpeg':
+            case 'jpg':
+                image.jpeg({
+                    quality,
+                    mozjpeg: true,
+                    chromaSubsampling: '4:4:4'
+                });
+                break;
+            case 'png':
+                image.png({
+                    compressionLevel: 9,
+                    adaptiveFiltering: true,
+                    palette: true,
+                    quality,
+                    colors: 256,
+                    dither: 1.0
+                });
+                break;
+            case 'webp':
+                image.webp({
+                    quality,
+                    smartSubsample: true,
+                    effort: 6,
+                    lossless: quality === 100
+                });
+                break;
+            case 'avif':
+                image.avif({
+                    quality,
+                    effort: 6,
+                    chromaSubsampling: '4:4:4'
+                });
+                break;
+            case 'tiff':
+                image.tiff({
+                    quality,
+                    compression: 'lzw',
+                    predictor: 'horizontal',
+                    pyramid: true
+                });
+                break;
+            case 'gif':
+                image.gif({
+                    colours: 256,
+                    effort: 10,
+                    dither: 1
+                });
+                break;
+            case 'jp2':
+                image.jp2({
+                    quality,
+                    lossless: quality === 100
+                });
+                break;
+            default:
+                // Fallback to WebP for best compression/quality ratio
+                targetFormat = 'webp';
+                image.webp({
+                    quality,
+                    smartSubsample: true,
+                    effort: 6
+                });
+                break;
+        }
+        try {
+            const compressedBuffer = await image.toBuffer();
+            return {
+                buffer: compressedBuffer,
+                format: `image/${targetFormat}`
+            };
+        } catch  {
+            return {
+                buffer,
+                format: mimetype
+            };
+        }
+    }
+}
+
+
+},
+521(module) {
+
+module.exports = __rspack_external_path;
+
+
+},
+37(module) {
+
+module.exports = __rspack_external_uuid;
+
+
+},
+
+};