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

package/cjs/services/upload.service.js

@@ -10,6 +10,7 @@ Object.defineProperty(exports, "UploadService", {
 });
 const _common = require("@nestjs/common");
 const _config = require("../config");
+const _filelocationenum = require("../enums/file-location.enum");
 const _storagefactoryservice = require("../providers/storage-factory.service");
 const _storageproviderconfigservice = require("./storage-provider-config.service");
 function _define_property(obj, key, value) {
@@ -55,19 +56,14 @@ let UploadService = class UploadService {
         }
     }
     /**
-   * Get storage provider based on storage config ID
+   * Get storage provider and config info based on storage config ID
    * Validates company ownership when company feature is enabled
-   */ async getStorageProvider(storageConfigId, user) {
+   */ async getStorageProviderWithConfig(storageConfigId, user) {
         let storageConfig;
-        // Get storage config from database (scoped to user's company/branch)
+        // Get storage config from database
         if (storageConfigId) {
-            // Pass user for company-scoped filtering
-            const config = await this.storageProviderConfigService.findById(storageConfigId, user ?? null, [
-                'name',
-                'storage',
-                'config',
-                'companyId'
-            ]);
+            // Use direct lookup (bypasses company filtering, returns null instead of throwing)
+            const config = await this.storageProviderConfigService.findByIdDirect(storageConfigId);
             if (!config) {
                 throw new _common.NotFoundException('Storage configuration not found');
             }
@@ -93,17 +89,98 @@ let UploadService = class UploadService {
             config: storageConfig.config
         };
         // Get or create provider instance
-        return await this.storageFactory.createProvider(providerConfig);
+        const provider = await this.storageFactory.createProvider(providerConfig);
+        return {
+            provider,
+            location: storageConfig.storage,
+            configId: storageConfig.id
+        };
+    }
+    /**
+   * Get storage provider based on storage config ID (convenience method)
+   */ async getStorageProvider(storageConfigId, user) {
+        const { provider } = await this.getStorageProviderWithConfig(storageConfigId, user);
+        return provider;
+    }
+    /**
+   * Get storage provider for delete operations with fallback
+   * If the original storage config doesn't exist, falls back based on locationHint
+   * This ensures files can still be deleted even if storage config was removed
+   * @param storageConfigId - The storage config ID to look up
+   * @param user - User context for company filtering
+   * @param locationHint - The file's original location type (used for fallback)
+   */ async getStorageProviderForDelete(storageConfigId, user, locationHint) {
+        // If storageConfigId provided, try to find it
+        if (storageConfigId) {
+            const config = await this.storageProviderConfigService.findByIdDirect(storageConfigId);
+            if (config) {
+                const providerConfig = {
+                    provider: config.storage,
+                    config: config.config
+                };
+                return await this.storageFactory.createProvider(providerConfig);
+            }
+            // Config not found, log warning and try fallback
+            this.logger.warn(`Storage config ${storageConfigId} not found, trying fallback for delete`);
+        }
+        // Fallback: Use locationHint to find a matching config or create provider
+        if (locationHint) {
+            // Try to find a config matching the file's original location type
+            const matchingConfigs = await this.storageProviderConfigService.getConfigByType(locationHint, user);
+            if (matchingConfigs.length > 0) {
+                const providerConfig = {
+                    provider: matchingConfigs[0].storage,
+                    config: matchingConfigs[0].config
+                };
+                this.logger.debug(`Using matching ${locationHint} config for delete fallback`);
+                return await this.storageFactory.createProvider(providerConfig);
+            }
+            // No matching config found, create a basic provider based on locationHint
+            if (locationHint === _filelocationenum.FileLocationEnum.LOCAL) {
+                this.logger.warn('No local config found, using fallback local provider for delete');
+                const localProviderConfig = {
+                    provider: _filelocationenum.FileLocationEnum.LOCAL,
+                    config: {
+                        basePath: this.storageConfigService.getDefaultLocalStoragePath()
+                    }
+                };
+                return await this.storageFactory.createProvider(localProviderConfig);
+            }
+        }
+        // Last resort: Try default config (might be different provider type)
+        const defaultConfig = await this.storageProviderConfigService.getDefaultConfig(user);
+        if (defaultConfig) {
+            const providerConfig = {
+                provider: defaultConfig.storage,
+                config: defaultConfig.config
+            };
+            return await this.storageFactory.createProvider(providerConfig);
+        }
+        // Final fallback: Create a basic local provider
+        this.logger.warn('No storage config found, using fallback local provider for delete');
+        const localProviderConfig = {
+            provider: _filelocationenum.FileLocationEnum.LOCAL,
+            config: {
+                basePath: this.storageConfigService.getDefaultLocalStoragePath()
+            }
+        };
+        return await this.storageFactory.createProvider(localProviderConfig);
     }
     async uploadSingleFile(file, options, user) {
         try {
             // Validate file before upload
             this.validateFile(file);
-            const provider = await this.getStorageProvider(options.storageConfigId, user);
-            return await provider.uploadFile(file, options);
+            const { provider, location, configId } = await this.getStorageProviderWithConfig(options.storageConfigId, user);
+            const result = await provider.uploadFile(file, options);
+            // Enrich result with storage info
+            return {
+                ...result,
+                location,
+                storageConfigId: configId
+            };
         } catch (err) {
             this.logger.error('Single file upload failed', err);
-            throw new _common.InternalServerErrorException(err.message);
+            throw new _common.InternalServerErrorException(err?.message || 'Single file upload failed');
         }
     }
     async uploadMultipleFiles(files, options, user) {
@@ -112,39 +189,73 @@ let UploadService = class UploadService {
             for (const file of files){
                 this.validateFile(file);
             }
-            const provider = await this.getStorageProvider(options.storageConfigId, user);
-            return await provider.uploadMultipleFiles(files, options);
+            const { provider, location, configId } = await this.getStorageProviderWithConfig(options.storageConfigId, user);
+            const results = await provider.uploadMultipleFiles(files, options);
+            // Enrich results with storage info
+            return results.map((result)=>({
+                    ...result,
+                    location,
+                    storageConfigId: configId
+                }));
         } catch (err) {
             this.logger.error('Multiple files upload failed', err);
-            throw new _common.InternalServerErrorException(err.message);
+            throw new _common.InternalServerErrorException(err?.message || 'Multiple files upload failed');
         }
     }
-    async deleteSingleFile(key, storageConfigId, user) {
+    async deleteSingleFile(key, storageConfigId, user, locationHint) {
         try {
             if (!key) throw new Error('No file path provided');
-            const provider = await this.getStorageProvider(storageConfigId, user);
+            const provider = await this.getStorageProviderForDelete(storageConfigId, user, locationHint);
             await provider.deleteFile(key);
             return true;
         } catch (err) {
             this.logger.error('Delete single file failed', err);
-            throw new _common.InternalServerErrorException(err.message);
+            throw new _common.InternalServerErrorException(err?.message || 'Delete single file failed');
         }
     }
-    async deleteMultipleFile(keys, storageConfigId, user) {
+    async deleteMultipleFile(keys, storageConfigId, user, locationHint) {
         try {
             if (!keys || !keys.length) throw new Error('No file paths provided');
-            const provider = await this.getStorageProvider(storageConfigId, user);
+            const provider = await this.getStorageProviderForDelete(storageConfigId, user, locationHint);
             await provider.deleteMultipleFiles(keys);
             return true;
         } catch (err) {
             this.logger.error('Delete multiple files failed', err);
-            throw new _common.InternalServerErrorException(err.message);
+            throw new _common.InternalServerErrorException(err?.message || 'Delete multiple files failed');
         }
     }
     bytesToKb(bytes) {
         return Number((bytes * 0.001).toFixed(2));
     }
     /**
+   * Get local storage basePath from DB config
+   * Initializes local provider if not cached, ensuring basePath is from DB
+   */ async getLocalStorageBasePath() {
+        try {
+            // First check if already cached
+            const cachedPath = this.storageFactory.getLocalProviderBasePath();
+            if (cachedPath) {
+                return cachedPath;
+            }
+            // Get local config from DB (without user context for public access)
+            const localConfigs = await this.storageProviderConfigService.getConfigByType(_filelocationenum.FileLocationEnum.LOCAL);
+            if (localConfigs.length > 0) {
+                const localConfig = localConfigs[0];
+                // Initialize provider to cache it
+                await this.storageFactory.createProvider({
+                    provider: _filelocationenum.FileLocationEnum.LOCAL,
+                    config: localConfig.config
+                });
+                // Now get the cached basePath
+                return this.storageFactory.getLocalProviderBasePath();
+            }
+            return null;
+        } catch (error) {
+            this.logger.warn(`Failed to get local storage basePath: ${error.message}`);
+            return null;
+        }
+    }
+    /**
    * Generate a URL for accessing a file
    * For S3/Azure: generates presigned URL
    * For Local/SFTP: returns direct path
@@ -159,7 +270,7 @@ let UploadService = class UploadService {
             return key;
         } catch (err) {
             this.logger.error('Generate file URL failed', err);
-            throw new _common.InternalServerErrorException(err.message);
+            throw new _common.InternalServerErrorException(err?.message || 'Generate file URL failed');
         }
     }
     // NOTE: @Inject() required for bundled code - type metadata may be lost during esbuild

package/cjs/utils/image-compressor.util.js

@@ -8,12 +8,50 @@ Object.defineProperty(exports, "ImageCompressor", {
         return ImageCompressor;
     }
 });
-const _sharp = /*#__PURE__*/ _interop_require_default(require("sharp"));
-function _interop_require_default(obj) {
-    return obj && obj.__esModule ? obj : {
-        default: obj
+const _sharp = /*#__PURE__*/ _interop_require_wildcard(require("sharp"));
+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;
 }
+// Handle ESM/CJS interop - sharp exports differently in each module system
+const sharp = _sharp.default || _sharp;
 let ImageCompressor = class ImageCompressor {
     /**
    * Dynamically compresses an image based on its format and provided options.
@@ -29,7 +67,7 @@ let ImageCompressor = class ImageCompressor {
             };
         }
         // Initialize sharp with improved error handling
-        const image = (0, _sharp.default)(buffer, {
+        const image = sharp(buffer, {
             failOnError: false,
             density: 300
         });

package/config/storage-config.service.d.ts

@@ -17,4 +17,6 @@ export declare class StorageConfigService {
     };
     getDefaultDatabaseConfig(): import("@flusys/nestjs-core").IDatabaseConfig;
     getOptions(): StorageModuleOptions;
+    getDefaultLocalStoragePath(): string;
+    getAppUrl(): string;
 }

package/controllers/file-manager.controller.d.ts

@@ -1,5 +1,5 @@
-import { ILoggedUserInfo } from '@flusys/nestjs-shared/interfaces';
 import { SingleResponseDto } from '@flusys/nestjs-shared/dtos';
+import { ILoggedUserInfo } from '@flusys/nestjs-shared/interfaces';
 import { CreateFileManagerDto, FileManagerResponseDto, FilesResponseDto, GetFilesRequestDto, UpdateFileManagerDto } from '../dtos';
 import { Request } from 'express';
 import { FileManagerService } from '../services/file-manager.service';

package/controllers/upload.controller.d.ts

@@ -1,15 +1,16 @@
 import { SingleResponseDto } from '@flusys/nestjs-shared/dtos';
 import { ILoggedUserInfo } from '@flusys/nestjs-shared/interfaces';
 import { DeleteMultipleFileDto, DeleteSingleFileDto, FileUploadResponsePayloadDto, UploadOptionsDto } from '../dtos';
-import { Response } from 'express';
 import { UploadService } from '../services/upload.service';
+import { StorageConfigService } from '../config';
+import { StorageFactoryService } from '../providers/storage-factory.service';
 export declare class UploadController {
     private uploadService;
-    private logger;
-    constructor(uploadService: UploadService);
+    private storageConfigService;
+    private storageFactoryService;
+    constructor(uploadService: UploadService, storageConfigService: StorageConfigService, storageFactoryService: StorageFactoryService);
     uploadSingleFile(file: Express.Multer.File, options: UploadOptionsDto, user: ILoggedUserInfo): Promise<SingleResponseDto<FileUploadResponsePayloadDto>>;
     uploadMultipleFiles(files: Express.Multer.File[], options: UploadOptionsDto, user: ILoggedUserInfo): Promise<SingleResponseDto<FileUploadResponsePayloadDto[]>>;
     deleteSingleFile(dto: DeleteSingleFileDto, user: ILoggedUserInfo): Promise<SingleResponseDto<boolean>>;
     deleteMultipleFile(dto: DeleteMultipleFileDto, user: ILoggedUserInfo): Promise<SingleResponseDto<boolean>>;
-    seeUploadedFile(filePath: string | string[], res: Response): Promise<void>;
 }

package/dtos/file-manager.dto.d.ts

@@ -16,6 +16,7 @@ export declare class UpdateFileManagerDto extends UpdateFileManagerDto_base impl
     id: string;
 }
 export declare class FileManagerResponseDto extends UpdateFileManagerDto {
+    providerName?: string;
 }
 export declare class GetFilesRequestDto {
     id: string;
@@ -25,5 +26,8 @@ export declare class FilesResponseDto {
     name: string;
     contentType: string;
     url: string;
+    location?: string;
+    storageConfigId?: string;
+    providerName?: string;
 }
 export {};

package/dtos/upload.dto.d.ts

@@ -26,4 +26,6 @@ export declare class FileUploadResponsePayloadDto {
     contentType: string;
     size: number;
     key: string;
+    location: string;
+    storageConfigId: string;
 }

package/fesm/config/storage-config.service.js

@@ -106,6 +106,37 @@ export class StorageConfigService {
    */ getOptions() {
         return this.options;
     }
+    /**
+   * Get default local storage base path
+   * Used for serving local files without database lookup
+   * Falls back to './uploads' if not configured
+   */ getDefaultLocalStoragePath() {
+        // Check if localStoragePath is configured in module options
+        const configuredPath = this.options.config?.localStoragePath;
+        if (configuredPath) {
+            return configuredPath;
+        }
+        // Default to ./uploads in the project root
+        return './uploads';
+    }
+    /**
+   * Get application base URL for generating file URLs
+   * - First tries module config
+   * - Falls back to APP_URL env var
+   * - Finally constructs from PORT env var
+   */ getAppUrl() {
+        // Try from module config first
+        if (this.options.config?.appUrl) {
+            return this.options.config.appUrl;
+        }
+        // Fallback: read directly from environment
+        if (process.env.APP_URL) {
+            return process.env.APP_URL;
+        }
+        // Last resort: construct from PORT
+        const port = process.env.PORT || '3000';
+        return `http://localhost:${port}`;
+    }
     constructor(options){
         _define_property(this, "options", void 0);
         this.options = options;

package/fesm/controllers/file-manager.controller.js

@@ -26,22 +26,24 @@ function _ts_param(paramIndex, decorator) {
     };
 }
 import { BadRequestException, Body, Controller, HttpCode, Inject, Post, Req, UseGuards } from '@nestjs/common';
-import { JwtAuthGuard } from '@flusys/nestjs-shared/guards';
 import { createApiController } from '@flusys/nestjs-shared/classes';
 import { CurrentUser } from '@flusys/nestjs-shared/decorators';
-import { ILoggedUserInfo } from '@flusys/nestjs-shared/interfaces';
 import { SingleResponseDto } from '@flusys/nestjs-shared/dtos';
+import { JwtAuthGuard } from '@flusys/nestjs-shared/guards';
+import { ILoggedUserInfo } from '@flusys/nestjs-shared/interfaces';
 import { CreateFileManagerDto, FileManagerResponseDto, GetFilesRequestDto, UpdateFileManagerDto } from '../dtos';
 import { ApiBearerAuth, ApiBody, ApiOperation, ApiResponse, ApiTags } from '@nestjs/swagger';
 import { Request } from 'express';
 import { FileManagerService } from '../services/file-manager.service';
-export class FileManagerController extends createApiController(CreateFileManagerDto, UpdateFileManagerDto, FileManagerResponseDto) {
+export class FileManagerController extends createApiController(CreateFileManagerDto, UpdateFileManagerDto, FileManagerResponseDto, {
+    security: 'jwt'
+}) {
     async getFiles(dto, req, user) {
         if (!dto || !dto.length) {
             throw new BadRequestException('No files provided');
         }
         // Fetch files from service
-        const files = await this.fileService.getFiles(dto, req.protocol, req.host, user);
+        const files = await this.fileService.getFiles(dto, req.protocol, req.get('host') || req.hostname, user);
         return {
             success: true,
             message: 'Files retrieved successfully',
@@ -54,6 +56,8 @@ export class FileManagerController extends createApiController(CreateFileManager
 }
 _ts_decorate([
     Post('get-files'),
+    UseGuards(JwtAuthGuard),
+    ApiBearerAuth(),
     HttpCode(200),
     ApiBody({
         type: GetFilesRequestDto,
@@ -80,9 +84,7 @@ _ts_decorate([
 ], FileManagerController.prototype, "getFiles", null);
 FileManagerController = _ts_decorate([
     ApiTags('Files'),
-    ApiBearerAuth(),
     Controller('storage/file-manager'),
-    UseGuards(JwtAuthGuard),
     _ts_param(0, Inject(FileManagerService)),
     _ts_metadata("design:type", Function),
     _ts_metadata("design:paramtypes", [

package/fesm/controllers/folder.controller.js

@@ -25,22 +25,21 @@ function _ts_param(paramIndex, decorator) {
         decorator(target, key, paramIndex);
     };
 }
-import { JwtAuthGuard } from '@flusys/nestjs-shared/guards';
 import { createApiController } from '@flusys/nestjs-shared/classes';
 import { CreateFolderDto, FolderResponseDto, UpdateFolderDto } from '../dtos';
-import { Controller, Inject, UseGuards } from '@nestjs/common';
-import { ApiBearerAuth, ApiTags } from '@nestjs/swagger';
+import { Controller, Inject } from '@nestjs/common';
+import { ApiTags } from '@nestjs/swagger';
 import { FolderService } from '../services/folder.service';
-export class FolderController extends createApiController(CreateFolderDto, UpdateFolderDto, FolderResponseDto) {
+export class FolderController extends createApiController(CreateFolderDto, UpdateFolderDto, FolderResponseDto, {
+    security: 'jwt'
+}) {
     constructor(folderService){
         super(folderService), _define_property(this, "folderService", void 0), this.folderService = folderService;
     }
 }
 FolderController = _ts_decorate([
     ApiTags('Folders'),
-    ApiBearerAuth(),
     Controller('storage/folder'),
-    UseGuards(JwtAuthGuard),
     _ts_param(0, Inject(FolderService)),
     _ts_metadata("design:type", Function),
     _ts_metadata("design:paramtypes", [

package/fesm/controllers/storage-config.controller.js

@@ -25,22 +25,21 @@ function _ts_param(paramIndex, decorator) {
         decorator(target, key, paramIndex);
     };
 }
-import { JwtAuthGuard } from '@flusys/nestjs-shared/guards';
 import { createApiController } from '@flusys/nestjs-shared/classes';
 import { CreateStorageConfigDto, StorageConfigResponseDto, UpdateStorageConfigDto } from '../dtos';
-import { Controller, Inject, UseGuards } from '@nestjs/common';
-import { ApiBearerAuth, ApiTags } from '@nestjs/swagger';
+import { Controller, Inject } from '@nestjs/common';
+import { ApiTags } from '@nestjs/swagger';
 import { StorageProviderConfigService } from '../services/storage-provider-config.service';
-export class StorageConfigController extends createApiController(CreateStorageConfigDto, UpdateStorageConfigDto, StorageConfigResponseDto) {
+export class StorageConfigController extends createApiController(CreateStorageConfigDto, UpdateStorageConfigDto, StorageConfigResponseDto, {
+    security: 'jwt'
+}) {
     constructor(storageConfigService){
         super(storageConfigService), _define_property(this, "storageConfigService", void 0), this.storageConfigService = storageConfigService;
     }
 }
 StorageConfigController = _ts_decorate([
     ApiTags('Storage Config'),
-    ApiBearerAuth(),
     Controller('storage/storage-config'),
-    UseGuards(JwtAuthGuard),
     _ts_param(0, Inject(StorageProviderConfigService)),
     _ts_metadata("design:type", Function),
     _ts_metadata("design:paramtypes", [