@flusys/nestjs-storage 0.1.0-beta.2 → 1.0.0-beta

package/cjs/middlewares/file-serve.middleware.js

@@ -0,0 +1,204 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "FileServeMiddleware", {
+    enumerable: true,
+    get: function() {
+        return FileServeMiddleware;
+    }
+});
+const _common = require("@nestjs/common");
+const _fs = require("fs");
+const _path = require("path");
+const _mimetypes = /*#__PURE__*/ _interop_require_wildcard(require("mime-types"));
+const _uploadservice = require("../services/upload.service");
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+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(k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+let FileServeMiddleware = class FileServeMiddleware {
+    async use(req, res, next) {
+        try {
+            const uploadDir = process.cwd();
+            // Extract path after /storage/upload/file/
+            const urlPath = req.path || req.url;
+            const match = urlPath.match(/\/storage\/upload\/file\/(.+)/);
+            const normalizedPath = match ? match[1] : '';
+            if (!normalizedPath) {
+                throw new _common.NotFoundException('File path is required');
+            }
+            this.logger.debug(`Attempting to serve file, normalizedPath: ${normalizedPath}`);
+            // Get the local storage basePath for fallback lookups
+            const basePath = await this.uploadService.getLocalStorageBasePath();
+            const normalizedBasePath = basePath ? basePath.replace(/^\.\//, '').replace(/\/$/, '') : null;
+            // Strategy 1: Try path relative to CWD (new format: key includes basePath)
+            let fullPath = (0, _path.join)(uploadDir, normalizedPath);
+            let resolvedPath = (0, _path.resolve)(fullPath);
+            this.logger.debug(`Strategy 1 - CWD relative: ${fullPath}`);
+            // Validate path is inside the project directory (prevent path traversal)
+            if (!resolvedPath.startsWith(uploadDir)) {
+                throw new _common.NotFoundException('Invalid file path');
+            }
+            // Check if file exists
+            if (!(0, _fs.existsSync)(fullPath)) {
+                // Strategy 2: If key already starts with basePath, try using basePath directly
+                if (basePath && normalizedBasePath) {
+                    const pathStartsWithBase = normalizedPath.startsWith(normalizedBasePath + '/') || normalizedPath.startsWith(normalizedBasePath);
+                    if (pathStartsWithBase) {
+                        const remainingPath = normalizedPath.substring(normalizedBasePath.length).replace(/^\//, '');
+                        const fallbackPath = (0, _path.join)(basePath, remainingPath);
+                        this.logger.debug(`Strategy 2 - basePath + remaining: ${fallbackPath}`);
+                        if ((0, _fs.existsSync)(fallbackPath)) {
+                            fullPath = fallbackPath;
+                            resolvedPath = (0, _path.resolve)(fullPath);
+                        }
+                    } else {
+                        // Old format: key doesn't include basePath, prepend it
+                        const fallbackPath = (0, _path.join)(basePath, normalizedPath);
+                        this.logger.debug(`Strategy 3 - basePath + full key (old format): ${fallbackPath}`);
+                        if ((0, _fs.existsSync)(fallbackPath)) {
+                            fullPath = fallbackPath;
+                            resolvedPath = (0, _path.resolve)(fullPath);
+                        }
+                    }
+                }
+                // Final check if file was found
+                if (!(0, _fs.existsSync)(fullPath)) {
+                    throw new _common.NotFoundException(`File not found: ${normalizedPath}`);
+                }
+            }
+            const stats = (0, _fs.statSync)(fullPath);
+            if (!stats.isFile()) {
+                throw new _common.NotFoundException(`Not a file: ${normalizedPath}`);
+            }
+            // Enhanced MIME type detection
+            let mimeType = _mimetypes.lookup(fullPath) || 'application/octet-stream';
+            // Special handling for SVG files
+            if (fullPath.toLowerCase().endsWith('.svg')) {
+                mimeType = 'image/svg+xml';
+            }
+            // Determine if file should be displayed inline or downloaded
+            const viewableTypes = [
+                'image/',
+                'video/',
+                'audio/',
+                'text/',
+                'application/pdf',
+                'application/json',
+                'application/xml'
+            ];
+            const isViewable = viewableTypes.some((type)=>mimeType.startsWith(type));
+            const contentDisposition = isViewable ? 'inline' : `attachment; filename="${encodeURIComponent(normalizedPath.split('/').pop() || 'download')}"`;
+            // Set headers
+            res.set({
+                'Content-Type': mimeType,
+                'Content-Length': stats.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 the file
+            const stream = (0, _fs.createReadStream)(fullPath);
+            stream.pipe(res);
+            stream.on('error', (err)=>{
+                this.logger.error('File stream error', err);
+                if (!res.headersSent) {
+                    res.status(404).json({
+                        message: `Failed to serve file: ${normalizedPath}`,
+                        error: 'Not Found',
+                        statusCode: 404
+                    });
+                }
+            });
+            // Handle client disconnection
+            res.on('close', ()=>{
+                stream.destroy();
+            });
+        } catch (error) {
+            this.logger.error('File retrieval error:', error);
+            if (!res.headersSent) {
+                res.status(404).json({
+                    message: error instanceof _common.NotFoundException ? error.message : `File not found`,
+                    error: 'Not Found',
+                    statusCode: 404
+                });
+            }
+        }
+    }
+    constructor(uploadService){
+        _define_property(this, "uploadService", void 0);
+        _define_property(this, "logger", void 0);
+        this.uploadService = uploadService;
+        this.logger = new _common.Logger(FileServeMiddleware.name);
+    }
+};
+FileServeMiddleware = _ts_decorate([
+    (0, _common.Injectable)(),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof _uploadservice.UploadService === "undefined" ? Object : _uploadservice.UploadService
+    ])
+], FileServeMiddleware);

package/cjs/middlewares/index.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+_export_star(require("./file-serve.middleware"), exports);
+function _export_star(from, to) {
+    Object.keys(from).forEach(function(k) {
+        if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) {
+            Object.defineProperty(to, k, {
+                enumerable: true,
+                get: function() {
+                    return from[k];
+                }
+            });
+        }
+    });
+    return from;
+}

package/cjs/modules/storage.module.js

@@ -10,10 +10,13 @@ Object.defineProperty(exports, "StorageModule", {
 });
 const _modules = require("@flusys/nestjs-shared/modules");
 const _common = require("@nestjs/common");
+const _middlewares = require("../middlewares");
 const _config = require("../config");
 const _storageconstants = require("../config/storage.constants");
 const _controllers = require("../controllers");
+const _filelocationenum = require("../enums/file-location.enum");
 const _providers = require("../providers");
+const _localprovider = require("../providers/local-provider");
 const _services = require("../services");
 const _storageproviderconfigservice = require("../services/storage-provider-config.service");
 function _ts_decorate(decorators, target, key, desc) {
@@ -22,8 +25,44 @@ function _ts_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;
 }
+// Auto-register built-in storage providers
+const logger = new _common.Logger('StorageModule');
+// Register LocalProvider (always available - uses Node.js built-in fs)
+_providers.StorageProviderRegistry.register(_filelocationenum.FileLocationEnum.LOCAL, _localprovider.LocalProvider);
+logger.log('Registered LocalProvider');
+// Try to register optional providers (only if dependencies are installed)
+try {
+    const { S3Provider } = require('../providers/s3-provider.optional');
+    _providers.StorageProviderRegistry.register(_filelocationenum.FileLocationEnum.AWS, S3Provider);
+    logger.log('Registered S3Provider');
+} catch  {
+    logger.debug('S3Provider not available (install @aws-sdk/client-s3 to enable)');
+}
+try {
+    const { AzureProvider } = require('../providers/azure-provider.optional');
+    _providers.StorageProviderRegistry.register(_filelocationenum.FileLocationEnum.AZURE, AzureProvider);
+    logger.log('Registered AzureProvider');
+} catch  {
+    logger.debug('AzureProvider not available (install @azure/storage-blob to enable)');
+}
+try {
+    const { SftpProvider } = require('../providers/sftp-provider.optional');
+    _providers.StorageProviderRegistry.register(_filelocationenum.FileLocationEnum.SFTP, SftpProvider);
+    logger.log('Registered SftpProvider');
+} catch  {
+    logger.debug('SftpProvider not available (install ssh2-sftp-client to enable)');
+}
 let StorageModule = class StorageModule {
     /**
+   * Configure middleware for file serving
+   * This bypasses path-to-regexp issues with wildcard routes
+   */ configure(consumer) {
+        consumer.apply(_middlewares.FileServeMiddleware).forRoutes({
+            path: 'storage/upload/file/*',
+            method: _common.RequestMethod.GET
+        });
+    }
+    /**
    * Register StorageModule synchronously
    */ static forRoot(options) {
         const controllers = this.getControllers(options);
@@ -62,9 +101,10 @@ let StorageModule = class StorageModule {
                 _modules.UtilsModule
             ],
             controllers: options.includeController !== false ? controllers : [],
+            // Pass false to exclude STORAGE_MODULE_OPTIONS - it's already in asyncProviders
             providers: [
                 ...asyncProviders,
-                ...this.getProviders(options)
+                ...this.getProviders(options, false)
             ],
             exports: [
                 _config.StorageConfigService,
@@ -77,10 +117,8 @@ let StorageModule = class StorageModule {
             ]
         };
     }
-    // ==================== Private Helper Methods ====================
-    /**
-   * Get controllers (all controllers always loaded)
-   */ static getControllers(options) {
+    // Private Helper Methods
+    /** Get controllers (all controllers always loaded) */ static getControllers(options) {
         return [
             _controllers.FileManagerController,
             _controllers.FolderController,
@@ -93,22 +131,28 @@ let StorageModule = class StorageModule {
    * This ensures dynamic entity loading based on runtime configuration
    */ /**
    * Get providers (all providers always loaded)
-   */ static getProviders(options) {
-        const enableCompanyFeature = options.bootstrapAppConfig?.enableCompanyFeature ?? false;
-        const optionsProvider = {
-            provide: _storageconstants.STORAGE_MODULE_OPTIONS,
-            useValue: options
-        };
-        return [
-            optionsProvider,
+   * @param options Module options
+   * @param includeOptionsProvider Whether to include the STORAGE_MODULE_OPTIONS provider (false for async registration)
+   */ static getProviders(options, includeOptionsProvider = true) {
+        const providers = [
             _config.StorageConfigService,
             _services.StorageDataSourceProvider,
             _services.FileManagerService,
             _services.FolderService,
             _storageproviderconfigservice.StorageProviderConfigService,
             _services.UploadService,
-            _providers.StorageFactoryService
+            _providers.StorageFactoryService,
+            _middlewares.FileServeMiddleware
         ];
+        // Only include options provider for sync registration
+        // For async registration, createAsyncProviders handles it
+        if (includeOptionsProvider) {
+            providers.unshift({
+                provide: _storageconstants.STORAGE_MODULE_OPTIONS,
+                useValue: options
+            });
+        }
+        return providers;
     }
     /**
    * Create async providers for forRootAsync

package/cjs/providers/azure-provider.optional.js

@@ -101,7 +101,7 @@ let AzureProvider = class AzureProvider {
             // Ensure container exists
             await this.containerClient.createIfNotExists();
             this.logger.log(`Azure Provider initialized: account=${config.accountName}, container=${config.containerName}`);
-        } catch (error) {
+        } catch (_error) {
             this.logger.error('Failed to initialize AzureProvider. Make sure @azure/storage-blob is installed.');
             throw new Error('Azure Storage SDK not found. Install it with: npm install @azure/storage-blob');
         }
@@ -129,7 +129,6 @@ let AzureProvider = class AzureProvider {
                 blobContentType: contentType
             }
         });
-        const url = blockBlobClient.url;
         return {
             name: fileName,
             key: blobName,

package/cjs/providers/local-provider.js

@@ -81,14 +81,19 @@ function _interop_require_wildcard(obj, nodeInterop) {
 let LocalProvider = class LocalProvider {
     /**
    * 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) {
-        this.basePath = _path.resolve(config.basePath);
-        this.baseUrl = config.baseUrl || '';
+        // Store original relative path for key generation
+        this.relativeBasePath = config?.basePath || './uploads';
+        // Resolve to absolute path for file operations
+        this.basePath = _path.resolve(this.relativeBasePath);
+        this.baseUrl = config?.baseUrl || '';
         // Ensure base directory exists
         await _promises.mkdir(this.basePath, {
             recursive: true
         });
-        this.logger.log(`Local Provider initialized: ${this.basePath}`);
+        this.logger.log(`Local Provider initialized: ${this.basePath} (relative: ${this.relativeBasePath})`);
     }
     async uploadFile(file, options) {
         let processedBuffer = file.buffer;
@@ -114,8 +119,9 @@ let LocalProvider = class LocalProvider {
         });
         // Write file to disk
         await _promises.writeFile(filePath, processedBuffer);
-        // Generate relative key (for URL generation and deletion)
-        const relativeKey = _path.relative(this.basePath, filePath);
+        // Generate key that includes the base path (relative to cwd)
+        // This makes the key self-contained for serving files
+        const relativeKey = _path.join(this.relativeBasePath, options.folderPath || '', fileName).replace(/\\/g, '/'); // Normalize path separators
         this.logger.log(`Uploaded file to local storage: ${relativeKey}`);
         return {
             name: fileName,
@@ -129,7 +135,24 @@ let LocalProvider = class LocalProvider {
     }
     async deleteFile(key) {
         try {
-            const filePath = _path.join(this.basePath, key);
+            // Key now includes the basePath, resolve from cwd
+            let filePath = _path.resolve(key);
+            // Check if file exists at the resolved path
+            try {
+                await _promises.access(filePath);
+            } catch  {
+                // Fallback: try with basePath prefix (for old keys without basePath)
+                const fallbackPath = _path.join(this.basePath, key);
+                try {
+                    await _promises.access(fallbackPath);
+                    filePath = fallbackPath;
+                    this.logger.debug(`Using fallback path for delete: ${fallbackPath}`);
+                } catch  {
+                    // File doesn't exist at either location
+                    this.logger.warn(`File not found for deletion: ${key}`);
+                    return;
+                }
+            }
             await _promises.unlink(filePath);
             this.logger.log(`Deleted file from local storage: ${key}`);
         } catch (_error) {
@@ -143,8 +166,13 @@ let LocalProvider = class LocalProvider {
     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, otherwise return relative path
-        return this.baseUrl ? `${this.baseUrl}/${key}` : `/${key}`;
+        // 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 {
@@ -156,14 +184,16 @@ let LocalProvider = class LocalProvider {
     }
     /**
    * Get the absolute path for a file key
+   * Key now includes basePath, so resolve from cwd
    */ getAbsolutePath(key) {
-        return _path.join(this.basePath, key);
+        return _path.resolve(key);
     }
     /**
    * Check if a file exists
    */ async fileExists(key) {
         try {
-            const filePath = _path.join(this.basePath, key);
+            // Key now includes basePath, resolve from cwd
+            const filePath = _path.resolve(key);
             await _promises.access(filePath);
             return true;
         } catch  {
@@ -173,7 +203,8 @@ let LocalProvider = class LocalProvider {
     /**
    * Get file stats
    */ async getFileStats(key) {
-        const filePath = _path.join(this.basePath, key);
+        // Key now includes basePath, resolve from cwd
+        const filePath = _path.resolve(key);
         const stats = await _promises.stat(filePath);
         return {
             size: stats.size,
@@ -185,5 +216,6 @@ let LocalProvider = class LocalProvider {
         _define_property(this, "logger", new _common.Logger(LocalProvider.name));
         _define_property(this, "basePath", '');
         _define_property(this, "baseUrl", '');
+        _define_property(this, "relativeBasePath", ''); // Path relative to cwd for key generation
     }
 };

package/cjs/providers/storage-factory.service.js

@@ -11,6 +11,7 @@ Object.defineProperty(exports, "StorageFactoryService", {
 const _storageproviderregistry = require("./storage-provider.registry");
 const _common = require("@nestjs/common");
 const _crypto = /*#__PURE__*/ _interop_require_wildcard(require("crypto"));
+const _config = require("../config");
 function _define_property(obj, key, value) {
     if (key in obj) {
         Object.defineProperty(obj, key, {
@@ -71,6 +72,14 @@ function _ts_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(k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+function _ts_param(paramIndex, decorator) {
+    return function(target, key) {
+        decorator(target, key, paramIndex);
+    };
+}
 let StorageFactoryService = class StorageFactoryService {
     /**
    * Generate a stable cache key for provider configuration
@@ -100,7 +109,19 @@ let StorageFactoryService = class StorageFactoryService {
             const instance = new ProviderClass();
             // Initialize if method exists
             if ('initialize' in instance && typeof instance.initialize === 'function') {
-                await instance.initialize(config.config);
+                // For local provider, inject appUrl as fallback for baseUrl
+                let initConfig = config.config;
+                if (config.provider === 'local' && !config.config?.baseUrl) {
+                    const appUrl = this.storageConfigService.getAppUrl();
+                    if (appUrl) {
+                        initConfig = {
+                            ...config.config,
+                            baseUrl: appUrl
+                        };
+                        this.logger.debug(`Using appUrl from config as baseUrl: ${appUrl}`);
+                    }
+                }
+                await instance.initialize(initConfig);
             }
             // Cache the instance
             this.providerCache.set(providerKey, instance);
@@ -142,6 +163,20 @@ let StorageFactoryService = class StorageFactoryService {
         return _storageproviderregistry.StorageProviderRegistry.getAll();
     }
     /**
+   * Get the basePath from cached local provider
+   * Returns null if no local provider is cached
+   */ getLocalProviderBasePath() {
+        // Find cached local provider
+        const localKey = Array.from(this.providerCache.keys()).find((key)=>key.startsWith('local'));
+        if (localKey) {
+            const provider = this.providerCache.get(localKey);
+            if (provider && 'basePath' in provider) {
+                return provider.basePath;
+            }
+        }
+        return null;
+    }
+    /**
    * Cleanup all cached provider connections on module destroy
    * Ensures SFTP connections and other resources are properly released
    */ async onModuleDestroy() {
@@ -157,11 +192,20 @@ let StorageFactoryService = class StorageFactoryService {
         this.providerCache.clear();
         this.logger.log('Storage provider cleanup complete');
     }
-    constructor(){
-        _define_property(this, "logger", new _common.Logger(StorageFactoryService.name));
-        _define_property(this, "providerCache", new Map());
+    constructor(storageConfigService){
+        _define_property(this, "storageConfigService", void 0);
+        _define_property(this, "logger", void 0);
+        _define_property(this, "providerCache", void 0);
+        this.storageConfigService = storageConfigService;
+        this.logger = new _common.Logger(StorageFactoryService.name);
+        this.providerCache = new Map();
     }
 };
 StorageFactoryService = _ts_decorate([
-    (0, _common.Injectable)()
+    (0, _common.Injectable)(),
+    _ts_param(0, (0, _common.Inject)(_config.StorageConfigService)),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof _config.StorageConfigService === "undefined" ? Object : _config.StorageConfigService
+    ])
 ], StorageFactoryService);