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

package/fesm/controllers/upload.controller.js

@@ -26,28 +26,28 @@ function _ts_param(paramIndex, decorator) {
     };
 }
 import { JwtAuthGuard } from '@flusys/nestjs-shared/guards';
-import { ApiResponseDto, CurrentUser, Public } from '@flusys/nestjs-shared/decorators';
+import { ApiResponseDto, CurrentUser } from '@flusys/nestjs-shared/decorators';
 import { ILoggedUserInfo } from '@flusys/nestjs-shared/interfaces';
 import { DeleteMultipleFileDto, DeleteSingleFileDto, FileUploadResponsePayloadDto, UploadOptionsDto } from '../dtos';
-import { Body, Controller, Get, Inject, Logger, NotFoundException, Param, Post, Query, Res, UploadedFile, UploadedFiles, UseGuards, UseInterceptors } from '@nestjs/common';
+import { Body, Controller, Inject, Post, Query, UploadedFile, UploadedFiles, UseGuards, UseInterceptors } from '@nestjs/common';
 import { FileInterceptor, FilesInterceptor } from '@nestjs/platform-express';
-import { ApiBearerAuth, ApiBody, ApiConsumes, ApiOperation, ApiParam, ApiProduces, ApiQuery, ApiResponse, ApiTags } from '@nestjs/swagger';
-import { Response } from 'express';
-import { createReadStream, existsSync, statSync } from 'fs';
-import * as mime from 'mime-types';
-import { join } from 'path';
+import { ApiBearerAuth, ApiBody, ApiConsumes, ApiOperation, ApiQuery, ApiTags } from '@nestjs/swagger';
 import { UploadService } from '../services/upload.service';
+import { StorageConfigService } from '../config';
+import { StorageFactoryService } from '../providers/storage-factory.service';
 export class UploadController {
     async uploadSingleFile(file, options, user) {
-        const url = await this.uploadService.uploadSingleFile(file, options, user);
+        const result = await this.uploadService.uploadSingleFile(file, options, user);
         return {
             success: true,
             message: 'File uploaded successfully',
             data: {
-                size: this.uploadService.bytesToKb(url.size),
-                name: url.name,
-                key: url.key,
-                contentType: url.contentType
+                size: this.uploadService.bytesToKb(result.size),
+                name: result.name,
+                key: result.key,
+                contentType: result.contentType,
+                location: result.location || 'local',
+                storageConfigId: result.storageConfigId || ''
             }
         };
     }
@@ -57,7 +57,9 @@ export class UploadController {
                 size: this.uploadService.bytesToKb(file.size),
                 name: file.name,
                 key: file.key,
-                contentType: file.contentType
+                contentType: file.contentType,
+                location: file.location || 'local',
+                storageConfigId: file.storageConfigId || ''
             }));
         return {
             success: true,
@@ -81,82 +83,13 @@ export class UploadController {
             data
         };
     }
-    async seeUploadedFile(filePath, res) {
-        try {
-            const uploadDir = join(process.cwd(), 'uploads');
-            const normalizedPath = Array.isArray(filePath) ? filePath.join('/') : filePath;
-            const fullPath = join(uploadDir, normalizedPath);
-            this.logger.debug(`Attempting to serve file from: ${fullPath}`);
-            // Validate path is inside uploads directory
-            if (!fullPath.startsWith(uploadDir)) {
-                throw new NotFoundException('Invalid file path');
-            }
-            // Check if file exists
-            if (!existsSync(fullPath)) {
-                throw new NotFoundException(`File not found: ${normalizedPath}`);
-            }
-            const stats = statSync(fullPath);
-            if (!stats.isFile()) {
-                throw new NotFoundException(`Not a file: ${normalizedPath}`);
-            }
-            // Enhanced MIME type detection
-            let mimeType = mime.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
-            // Inline: PDFs, images, videos, audio, text files
-            // Download: Office docs, archives, executables, etc.
-            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 optimized for different file types
-            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 = createReadStream(fullPath);
-            stream.pipe(res);
-            return new Promise((resolve, reject)=>{
-                stream.on('end', ()=>{
-                    res.end();
-                    resolve();
-                });
-                stream.on('error', (err)=>{
-                    this.logger.error('File stream error', err);
-                    reject(new NotFoundException(`Failed to serve file: ${normalizedPath}`));
-                });
-                // Handle client disconnection
-                res.on('close', ()=>{
-                    stream.destroy();
-                });
-            });
-        } catch (error) {
-            this.logger.error('File retrieval error:', error);
-            throw new NotFoundException(`File not found: ${filePath}`);
-        }
-    }
-    constructor(uploadService){
+    constructor(uploadService, storageConfigService, storageFactoryService){
         _define_property(this, "uploadService", void 0);
-        _define_property(this, "logger", void 0);
+        _define_property(this, "storageConfigService", void 0);
+        _define_property(this, "storageFactoryService", void 0);
         this.uploadService = uploadService;
-        this.logger = new Logger(UploadController.name);
+        this.storageConfigService = storageConfigService;
+        this.storageFactoryService = storageFactoryService;
     }
 }
 _ts_decorate([
@@ -278,57 +211,18 @@ _ts_decorate([
     ]),
     _ts_metadata("design:returntype", Promise)
 ], UploadController.prototype, "deleteMultipleFile", null);
-_ts_decorate([
-    Public(),
-    Get('file/*filePath'),
-    ApiOperation({
-        summary: 'Serve uploaded file by relative path (Public endpoint)',
-        description: `
-This endpoint returns a stored file from the server.
-
-- The \`filePath\` is a **wildcard path parameter** that supports nested folders.
-- Example:
-  \`GET /uploads/file/profile/user123/avatar.png\`
-  → Will serve the file from \`./profile/user123/avatar.png\`
-
-**Use case:**
-Access uploaded files publicly through a structured path.
-
-**Note:** This endpoint is public and does not require authentication.
-    `
-    }),
-    ApiParam({
-        name: 'filePath',
-        required: true,
-        description: 'Relative path to the uploaded file (supports nested directories, e.g. "profile/user123/avatar.png")',
-        example: 'profile/user123/avatar.png'
-    }),
-    ApiProduces('image/jpeg'),
-    ApiResponse({
-        status: 200,
-        description: 'Uploaded file successfully returned',
-        schema: {
-            type: 'string',
-            format: 'binary'
-        }
-    }),
-    _ts_param(0, Param('filePath')),
-    _ts_param(1, Res()),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        Object,
-        typeof Response === "undefined" ? Object : Response
-    ]),
-    _ts_metadata("design:returntype", Promise)
-], UploadController.prototype, "seeUploadedFile", null);
 UploadController = _ts_decorate([
     ApiTags('Upload'),
     ApiBearerAuth(),
     Controller('storage/upload'),
     UseGuards(JwtAuthGuard),
     _ts_param(0, Inject(UploadService)),
+    _ts_param(1, Inject(StorageConfigService)),
+    _ts_param(2, Inject(StorageFactoryService)),
     _ts_metadata("design:type", Function),
     _ts_metadata("design:paramtypes", [
-        typeof UploadService === "undefined" ? Object : UploadService
+        typeof UploadService === "undefined" ? Object : UploadService,
+        typeof StorageConfigService === "undefined" ? Object : StorageConfigService,
+        typeof StorageFactoryService === "undefined" ? Object : StorageFactoryService
     ])
 ], UploadController);

package/fesm/dtos/file-manager.dto.js

@@ -122,7 +122,17 @@ _ts_decorate([
     _ts_metadata("design:type", String)
 ], UpdateFileManagerDto.prototype, "id", void 0);
 export class FileManagerResponseDto extends UpdateFileManagerDto {
+    constructor(...args){
+        super(...args), _define_property(this, "providerName", void 0);
+    }
 }
+_ts_decorate([
+    ApiPropertyOptional({
+        example: 'My S3 Storage',
+        description: 'Name of the storage configuration/provider'
+    }),
+    _ts_metadata("design:type", String)
+], FileManagerResponseDto.prototype, "providerName", void 0);
 export class GetFilesRequestDto {
     constructor(){
         _define_property(this, "id", void 0);
@@ -140,6 +150,9 @@ export class FilesResponseDto {
         _define_property(this, "name", void 0);
         _define_property(this, "contentType", void 0);
         _define_property(this, "url", void 0);
+        _define_property(this, "location", void 0);
+        _define_property(this, "storageConfigId", void 0);
+        _define_property(this, "providerName", void 0);
     }
 }
 _ts_decorate([
@@ -156,13 +169,34 @@ _ts_decorate([
 ], FilesResponseDto.prototype, "name", void 0);
 _ts_decorate([
     ApiProperty({
-        example: 'file123.jpg'
+        example: 'image/jpeg'
     }),
     _ts_metadata("design:type", String)
 ], FilesResponseDto.prototype, "contentType", void 0);
 _ts_decorate([
     ApiProperty({
-        example: 'file123.jpg'
+        example: 'https://example.com/file123.jpg'
     }),
     _ts_metadata("design:type", String)
 ], FilesResponseDto.prototype, "url", void 0);
+_ts_decorate([
+    ApiPropertyOptional({
+        example: 'local',
+        description: 'Storage provider type (local, aws, azure, sftp)'
+    }),
+    _ts_metadata("design:type", String)
+], FilesResponseDto.prototype, "location", void 0);
+_ts_decorate([
+    ApiPropertyOptional({
+        example: '123e4567-e89b-12d3-a456-426614174000',
+        description: 'Storage configuration ID'
+    }),
+    _ts_metadata("design:type", String)
+], FilesResponseDto.prototype, "storageConfigId", void 0);
+_ts_decorate([
+    ApiPropertyOptional({
+        example: 'My S3 Storage',
+        description: 'Name of the storage configuration/provider'
+    }),
+    _ts_metadata("design:type", String)
+], FilesResponseDto.prototype, "providerName", void 0);

package/fesm/dtos/upload.dto.js

@@ -184,6 +184,8 @@ export class FileUploadResponsePayloadDto {
         _define_property(this, "contentType", void 0);
         _define_property(this, "size", void 0);
         _define_property(this, "key", void 0);
+        _define_property(this, "location", void 0);
+        _define_property(this, "storageConfigId", void 0);
     }
 }
 _ts_decorate([
@@ -210,3 +212,17 @@ _ts_decorate([
     }),
     _ts_metadata("design:type", String)
 ], FileUploadResponsePayloadDto.prototype, "key", void 0);
+_ts_decorate([
+    ApiProperty({
+        example: 'local',
+        description: 'Storage provider type (local, aws, azure, sftp)'
+    }),
+    _ts_metadata("design:type", String)
+], FileUploadResponsePayloadDto.prototype, "location", void 0);
+_ts_decorate([
+    ApiProperty({
+        example: '123e4567-e89b-12d3-a456-426614174000',
+        description: 'Storage configuration ID used for this upload'
+    }),
+    _ts_metadata("design:type", String)
+], FileUploadResponsePayloadDto.prototype, "storageConfigId", void 0);

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

@@ -0,0 +1,153 @@
+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 _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);
+}
+import { Injectable, Logger, NotFoundException } from '@nestjs/common';
+import { createReadStream, existsSync, statSync } from 'fs';
+import { join, resolve } from 'path';
+import * as mime from 'mime-types';
+import { UploadService } from '../services/upload.service';
+export 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 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 = join(uploadDir, normalizedPath);
+            let resolvedPath = 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 NotFoundException('Invalid file path');
+            }
+            // Check if file exists
+            if (!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 = join(basePath, remainingPath);
+                        this.logger.debug(`Strategy 2 - basePath + remaining: ${fallbackPath}`);
+                        if (existsSync(fallbackPath)) {
+                            fullPath = fallbackPath;
+                            resolvedPath = resolve(fullPath);
+                        }
+                    } else {
+                        // Old format: key doesn't include basePath, prepend it
+                        const fallbackPath = join(basePath, normalizedPath);
+                        this.logger.debug(`Strategy 3 - basePath + full key (old format): ${fallbackPath}`);
+                        if (existsSync(fallbackPath)) {
+                            fullPath = fallbackPath;
+                            resolvedPath = resolve(fullPath);
+                        }
+                    }
+                }
+                // Final check if file was found
+                if (!existsSync(fullPath)) {
+                    throw new NotFoundException(`File not found: ${normalizedPath}`);
+                }
+            }
+            const stats = statSync(fullPath);
+            if (!stats.isFile()) {
+                throw new NotFoundException(`Not a file: ${normalizedPath}`);
+            }
+            // Enhanced MIME type detection
+            let mimeType = mime.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 = 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 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 Logger(FileServeMiddleware.name);
+    }
+}
+FileServeMiddleware = _ts_decorate([
+    Injectable(),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof UploadService === "undefined" ? Object : UploadService
+    ])
+], FileServeMiddleware);

package/fesm/middlewares/index.js

@@ -0,0 +1 @@
+export * from './file-serve.middleware';

package/fesm/modules/storage.module.js

@@ -5,15 +5,54 @@ function _ts_decorate(decorators, target, key, desc) {
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
 import { CacheModule, UtilsModule } from '@flusys/nestjs-shared/modules';
-import { Module } from '@nestjs/common';
+import { Module, Logger, RequestMethod } from '@nestjs/common';
+import { FileServeMiddleware } from '../middlewares';
 import { StorageConfigService } from '../config';
 import { STORAGE_MODULE_OPTIONS } from '../config/storage.constants';
 import { FileManagerController, FolderController, StorageConfigController, UploadController } from '../controllers';
-import { StorageFactoryService } from '../providers';
+import { FileLocationEnum } from '../enums/file-location.enum';
+import { StorageFactoryService, StorageProviderRegistry } from '../providers';
+import { LocalProvider } from '../providers/local-provider';
 import { FileManagerService, FolderService, StorageDataSourceProvider, UploadService } from '../services';
 import { StorageProviderConfigService } from '../services/storage-provider-config.service';
+// Auto-register built-in storage providers
+const logger = new Logger('StorageModule');
+// Register LocalProvider (always available - uses Node.js built-in fs)
+StorageProviderRegistry.register(FileLocationEnum.LOCAL, LocalProvider);
+logger.log('Registered LocalProvider');
+// Try to register optional providers (only if dependencies are installed)
+try {
+    const { S3Provider } = require('../providers/s3-provider.optional');
+    StorageProviderRegistry.register(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');
+    StorageProviderRegistry.register(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');
+    StorageProviderRegistry.register(FileLocationEnum.SFTP, SftpProvider);
+    logger.log('Registered SftpProvider');
+} catch  {
+    logger.debug('SftpProvider not available (install ssh2-sftp-client to enable)');
+}
 export class StorageModule {
     /**
+   * Configure middleware for file serving
+   * This bypasses path-to-regexp issues with wildcard routes
+   */ configure(consumer) {
+        consumer.apply(FileServeMiddleware).forRoutes({
+            path: 'storage/upload/file/*',
+            method: RequestMethod.GET
+        });
+    }
+    /**
    * Register StorageModule synchronously
    */ static forRoot(options) {
         const controllers = this.getControllers(options);
@@ -52,9 +91,10 @@ export class StorageModule {
                 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: [
                 StorageConfigService,
@@ -67,10 +107,8 @@ export 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 [
             FileManagerController,
             FolderController,
@@ -83,22 +121,28 @@ export 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: 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 = [
             StorageConfigService,
             StorageDataSourceProvider,
             FileManagerService,
             FolderService,
             StorageProviderConfigService,
             UploadService,
-            StorageFactoryService
+            StorageFactoryService,
+            FileServeMiddleware
         ];
+        // Only include options provider for sync registration
+        // For async registration, createAsyncProviders handles it
+        if (includeOptionsProvider) {
+            providers.unshift({
+                provide: STORAGE_MODULE_OPTIONS,
+                useValue: options
+            });
+        }
+        return providers;
     }
     /**
    * Create async providers for forRootAsync

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

@@ -53,7 +53,7 @@ import { v4 as uuidv4 } from 'uuid';
             // 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');
         }
@@ -81,7 +81,6 @@ import { v4 as uuidv4 } from 'uuid';
                 blobContentType: contentType
             }
         });
-        const url = blockBlobClient.url;
         return {
             name: fileName,
             key: blobName,