@flusys/nestjs-storage 3.0.1 → 4.0.0-rc

package/fesm/services/upload.service.js

@@ -25,9 +25,13 @@ function _ts_param(paramIndex, decorator) {
         decorator(target, key, paramIndex);
     };
 }
-import { ErrorHandler, validateCompanyOwnership } from '@flusys/nestjs-shared/utils';
-import { BadRequestException, Inject, Injectable, Logger, NotFoundException, Scope } from '@nestjs/common';
+import { LogAction } from '@flusys/nestjs-shared';
+import { UPLOAD_MESSAGES } from '../config';
+import { ILoggedUserInfo } from '@flusys/nestjs-shared/interfaces';
+import { validateCompanyOwnership } from '@flusys/nestjs-shared/utils';
+import { BadRequestException, Inject, Injectable, NotFoundException, Scope } from '@nestjs/common';
 import { StorageConfigService } from './storage-config.service';
+import { UploadOptionsDto } from '../dtos/upload.dto';
 import { FileLocationEnum } from '../enums/file-location.enum';
 import { StorageFactoryService } from '../providers/storage-factory.service';
 import { StorageProviderConfigService } from './storage-provider-config.service';
@@ -40,23 +44,28 @@ export class UploadService {
         // Validate file size
         const sizeValidation = this.storageConfigService.validateFileSize(file.size);
         if (!sizeValidation.valid) {
-            throw new BadRequestException(sizeValidation.message);
+            throw new BadRequestException({
+                message: sizeValidation.message,
+                messageKey: UPLOAD_MESSAGES.FILE_TOO_LARGE
+            });
         }
         // Validate declared file type (MIME)
         const typeValidation = this.storageConfigService.validateFileType(file.mimetype);
         if (!typeValidation.valid) {
-            throw new BadRequestException(typeValidation.message);
+            throw new BadRequestException({
+                message: typeValidation.message,
+                messageKey: UPLOAD_MESSAGES.INVALID_TYPE
+            });
         }
         // Validate file content matches declared type (magic bytes check)
         // This prevents MIME type spoofing attacks
         const allowedTypes = this.storageConfigService.getAllowedFileTypes();
         const contentValidation = FileValidator.validateFileContent(file.buffer, file.mimetype, allowedTypes);
         if (!contentValidation.valid) {
-            this.logger.warn(`File content validation failed: ${contentValidation.message}`, {
-                declaredType: file.mimetype,
-                detectedType: contentValidation.detectedType
+            throw new BadRequestException({
+                message: contentValidation.message || 'File content validation failed',
+                messageKey: UPLOAD_MESSAGES.INVALID_TYPE
             });
-            throw new BadRequestException(contentValidation.message || 'File content validation failed');
         }
         // Sanitize filename to prevent path traversal attacks
         file.originalname = FileValidator.sanitizeFilename(file.originalname);
@@ -72,7 +81,6 @@ export class UploadService {
     /**
    * Create fallback local provider
    */ async createFallbackLocalProvider() {
-        this.logger.warn('No storage config found, using fallback local provider');
         return this.storageFactory.createProvider({
             provider: FileLocationEnum.LOCAL,
             config: {
@@ -90,7 +98,10 @@ export class UploadService {
             // Use direct lookup (bypasses company filtering, returns null instead of throwing)
             const config = await this.storageProviderConfigService.findByIdDirect(storageConfigId);
             if (!config) {
-                throw new NotFoundException('Storage configuration not found');
+                throw new NotFoundException({
+                    message: 'Storage configuration not found',
+                    messageKey: UPLOAD_MESSAGES.CONFIG_NOT_FOUND
+                });
             }
             // Validate company ownership using shared utility
             validateCompanyOwnership(config, user, this.storageConfigService.isCompanyFeatureEnabled(), 'Storage configuration');
@@ -99,7 +110,10 @@ export class UploadService {
             // Use default config (scoped to user's company/branch)
             const defaultConfig = await this.storageProviderConfigService.getDefaultConfig(user);
             if (!defaultConfig) {
-                throw new NotFoundException('No default storage configuration found for your company/branch. Please create one.');
+                throw new NotFoundException({
+                    message: 'No default storage configuration found for your company/branch. Please create one.',
+                    messageKey: UPLOAD_MESSAGES.CONFIG_NOT_FOUND
+                });
             }
             storageConfig = defaultConfig;
         }
@@ -120,7 +134,6 @@ export class UploadService {
             if (config) {
                 return this.createProviderFromConfig(config);
             }
-            this.logger.warn(`Storage config ${storageConfigId} not found, trying fallback`);
         }
         // Fallback: Use locationHint to find a matching config
         if (locationHint) {
@@ -140,62 +153,44 @@ export class UploadService {
         return this.createFallbackLocalProvider();
     }
     async uploadSingleFile(file, options, user) {
-        try {
-            // Validate file before upload
+        this.validateFile(file);
+        const { provider, location, configId } = await this.getStorageProviderWithConfig(options.storageConfigId, user);
+        const result = await provider.uploadFile(file, options);
+        return {
+            ...result,
+            location,
+            storageConfigId: configId
+        };
+    }
+    async uploadMultipleFiles(files, options, user) {
+        for (const file of files){
             this.validateFile(file);
-            const { provider, location, configId } = await this.getStorageProviderWithConfig(options.storageConfigId, user);
-            const result = await provider.uploadFile(file, options);
-            // Enrich result with storage info
-            return {
+        }
+        const { provider, location, configId } = await this.getStorageProviderWithConfig(options.storageConfigId, user);
+        const results = await provider.uploadMultipleFiles(files, options);
+        return results.map((result)=>({
                 ...result,
                 location,
                 storageConfigId: configId
-            };
-        } catch (error) {
-            ErrorHandler.logError(this.logger, error, 'uploadSingleFile');
-            ErrorHandler.rethrowError(error);
-        }
-    }
-    async uploadMultipleFiles(files, options, user) {
-        try {
-            // Validate each file before upload
-            for (const file of files){
-                this.validateFile(file);
-            }
-            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 (error) {
-            ErrorHandler.logError(this.logger, error, 'uploadMultipleFiles');
-            ErrorHandler.rethrowError(error);
-        }
+            }));
     }
     async deleteSingleFile(key, storageConfigId, user, locationHint) {
-        try {
-            if (!key) throw new BadRequestException('No file path provided');
-            const provider = await this.getStorageProviderForDelete(storageConfigId, user, locationHint);
-            await provider.deleteFile(key);
-            return true;
-        } catch (error) {
-            ErrorHandler.logError(this.logger, error, 'deleteSingleFile');
-            ErrorHandler.rethrowError(error);
-        }
+        if (!key) throw new BadRequestException({
+            message: 'No file path provided',
+            messageKey: UPLOAD_MESSAGES.NO_FILE_PATH
+        });
+        const provider = await this.getStorageProviderForDelete(storageConfigId, user, locationHint);
+        await provider.deleteFile(key);
+        return true;
     }
     async deleteMultipleFile(keys, storageConfigId, user, locationHint) {
-        try {
-            if (!keys || !keys.length) throw new BadRequestException('No file paths provided');
-            const provider = await this.getStorageProviderForDelete(storageConfigId, user, locationHint);
-            await provider.deleteMultipleFiles(keys);
-            return true;
-        } catch (error) {
-            ErrorHandler.logError(this.logger, error, 'deleteMultipleFiles');
-            ErrorHandler.rethrowError(error);
-        }
+        if (!keys || !keys.length) throw new BadRequestException({
+            message: 'No file paths provided',
+            messageKey: UPLOAD_MESSAGES.NO_FILE_PATH
+        });
+        const provider = await this.getStorageProviderForDelete(storageConfigId, user, locationHint);
+        await provider.deleteMultipleFiles(keys);
+        return true;
     }
     bytesToKb(bytes) {
         return Number((bytes * 0.001).toFixed(2));
@@ -223,42 +218,97 @@ export class UploadService {
                 return this.storageFactory.getLocalProviderBasePath();
             }
             return null;
-        } catch (error) {
-            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
-            this.logger.warn(`Failed to get local storage basePath: ${errorMessage}`);
+        } catch  {
             return null;
         }
     }
-    /**
-   * Generate a URL for accessing a file
-   * For S3/Azure: generates presigned URL
-   * For Local/SFTP: returns direct path
-   */ async makeFileUrl(key, storageConfigId, expiresIn = 3600, user) {
-        try {
-            const { provider } = await this.getStorageProviderWithConfig(storageConfigId, user);
-            // Check if provider supports presigned URLs
-            if (provider.generatePresignedUrl) {
-                return await provider.generatePresignedUrl(key, expiresIn);
-            }
-            // For SFTP or other providers without presigned URLs
-            return key;
-        } catch (error) {
-            ErrorHandler.logError(this.logger, error, 'makeFileUrl');
-            ErrorHandler.rethrowError(error);
+    async makeFileUrl(key, storageConfigId, expiresIn = 3600, user) {
+        const { provider } = await this.getStorageProviderWithConfig(storageConfigId, user);
+        // Check if provider supports presigned URLs
+        if (provider.generatePresignedUrl) {
+            return await provider.generatePresignedUrl(key, expiresIn);
         }
+        // For SFTP or other providers without presigned URLs
+        return key;
     }
     // NOTE: @Inject() required for bundled code - type metadata may be lost during esbuild
     constructor(storageFactory, storageConfigService, storageProviderConfigService){
         _define_property(this, "storageFactory", void 0);
         _define_property(this, "storageConfigService", void 0);
         _define_property(this, "storageProviderConfigService", void 0);
-        _define_property(this, "logger", void 0);
         this.storageFactory = storageFactory;
         this.storageConfigService = storageConfigService;
         this.storageProviderConfigService = storageProviderConfigService;
-        this.logger = new Logger(UploadService.name);
     }
 }
+_ts_decorate([
+    LogAction({
+        action: 'storage.uploadSingle',
+        module: 'storage'
+    }),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof Express === "undefined" || typeof Express.Multer === "undefined" || typeof Express.Multer.File === "undefined" ? Object : Express.Multer.File,
+        typeof UploadOptionsDto === "undefined" ? Object : UploadOptionsDto,
+        typeof ILoggedUserInfo === "undefined" ? Object : ILoggedUserInfo
+    ]),
+    _ts_metadata("design:returntype", Promise)
+], UploadService.prototype, "uploadSingleFile", null);
+_ts_decorate([
+    LogAction({
+        action: 'storage.uploadMultiple',
+        module: 'storage'
+    }),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        Array,
+        typeof UploadOptionsDto === "undefined" ? Object : UploadOptionsDto,
+        typeof ILoggedUserInfo === "undefined" ? Object : ILoggedUserInfo
+    ]),
+    _ts_metadata("design:returntype", Promise)
+], UploadService.prototype, "uploadMultipleFiles", null);
+_ts_decorate([
+    LogAction({
+        action: 'storage.deleteSingle',
+        module: 'storage'
+    }),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        String,
+        String,
+        typeof ILoggedUserInfo === "undefined" ? Object : ILoggedUserInfo,
+        String
+    ]),
+    _ts_metadata("design:returntype", Promise)
+], UploadService.prototype, "deleteSingleFile", null);
+_ts_decorate([
+    LogAction({
+        action: 'storage.deleteMultiple',
+        module: 'storage'
+    }),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        Array,
+        String,
+        typeof ILoggedUserInfo === "undefined" ? Object : ILoggedUserInfo,
+        String
+    ]),
+    _ts_metadata("design:returntype", Promise)
+], UploadService.prototype, "deleteMultipleFile", null);
+_ts_decorate([
+    LogAction({
+        action: 'storage.makeFileUrl',
+        module: 'storage'
+    }),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        String,
+        String,
+        Number,
+        typeof ILoggedUserInfo === "undefined" ? Object : ILoggedUserInfo
+    ]),
+    _ts_metadata("design:returntype", Promise)
+], UploadService.prototype, "makeFileUrl", null);
 UploadService = _ts_decorate([
     Injectable({
         scope: Scope.REQUEST

package/fesm/utils/file-validator.util.js

@@ -1,18 +1,6 @@
-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;
-}
-import { Logger } from '@nestjs/common';
 /**
+ * Result of file content validation.
+ */ /**
  * Magic byte signatures for common file types.
  * Each entry maps a hex signature pattern to its MIME type.
  */ const MAGIC_BYTES = [
@@ -401,7 +389,6 @@ import { Logger } from '@nestjs/common';
             }
             // Verify detected type matches declared type
             if (!this.mimeTypesMatch(detectedType, declaredMimeType)) {
-                this.logger.warn(`MIME type mismatch: declared=${declaredMimeType}, detected=${detectedType}`);
                 return this.failureResult(`File content does not match declared type. Detected: ${detectedType}, Declared: ${declaredMimeType}`, detectedType, declaredMimeType);
             }
             // Verify type is in allowed list
@@ -409,8 +396,7 @@ import { Logger } from '@nestjs/common';
                 return this.failureResult(`File type "${detectedType}" is not allowed`, detectedType, declaredMimeType);
             }
             return this.successResult(detectedType, declaredMimeType);
-        } catch (error) {
-            this.logger.error('File validation error:', error);
+        } catch  {
             return this.failureResult('File validation failed');
         }
     }
@@ -421,10 +407,8 @@ import { Logger } from '@nestjs/common';
         if (this.isDangerousTextType(declaredMimeType)) {
             const explicitlyAllowed = allowedTypes.some((t)=>t === declaredMimeType && t !== '*/*' && !t.endsWith('/*'));
             if (!explicitlyAllowed) {
-                this.logger.warn(`Blocked dangerous file type: ${declaredMimeType} - requires explicit allowlisting`);
                 return this.failureResult(`File type "${declaredMimeType}" is potentially dangerous and not explicitly allowed`, declaredMimeType, declaredMimeType);
             }
-            this.logger.warn(`Allowing explicitly permitted dangerous file type: ${declaredMimeType}`);
         }
         // Safe text-based files don't have magic bytes, trust declared type
         if (this.isTextBasedType(declaredMimeType)) {
@@ -432,7 +416,6 @@ import { Logger } from '@nestjs/common';
             return isAllowed ? this.successResult(declaredMimeType, declaredMimeType) : this.failureResult(`File type "${declaredMimeType}" is not allowed`, declaredMimeType, declaredMimeType);
         }
         // Binary files without recognized signatures - be cautious
-        this.logger.warn(`Unable to detect file type for declared type: ${declaredMimeType}`);
         return this.failureResult('Unable to verify file type. File may be corrupted or unsupported.', undefined, declaredMimeType);
     }
     /**
@@ -448,4 +431,3 @@ import { Logger } from '@nestjs/common';
         .substring(0, 255);
     }
 }
-_define_property(FileValidator, "logger", new Logger(FileValidator.name));

package/middlewares/file-serve.middleware.d.ts

@@ -3,7 +3,6 @@ import { Request, Response, NextFunction } from 'express';
 import { UploadService } from '../services/upload.service';
 export declare class FileServeMiddleware implements NestMiddleware {
     private uploadService;
-    private readonly logger;
     private readonly uploadDir;
     constructor(uploadService: UploadService);
     use(req: Request, res: Response, next: NextFunction): Promise<void>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@flusys/nestjs-storage",
-  "version": "3.0.1",
+  "version": "4.0.0-rc",
   "description": "Modular storage package with optional AWS S3, Azure Blob, and SFTP providers",
   "main": "cjs/index.js",
   "module": "fesm/index.js",
@@ -128,7 +128,7 @@
     }
   },
   "dependencies": {
-    "@flusys/nestjs-core": "3.0.1",
-    "@flusys/nestjs-shared": "3.0.1"
+    "@flusys/nestjs-core": "4.0.0-rc",
+    "@flusys/nestjs-shared": "4.0.0-rc"
   }
 }

package/providers/azure-provider.optional.d.ts

@@ -7,7 +7,6 @@ interface AzureConfig {
     connectionString?: string;
 }
 export declare class AzureProvider implements IStorageProvider {
-    private logger;
     private blobServiceClient;
     private containerClient;
     private containerName;

package/providers/local-provider.d.ts

@@ -1,7 +1,6 @@
 import { UploadOptionsDto } from '../dtos/upload.dto';
 import { IStorageProvider, IUploadedFileInfo } from '../interfaces/storage-provider.interface';
 export declare class LocalProvider implements IStorageProvider {
-    private logger;
     private basePath;
     private baseUrl;
     private relativeBasePath;

package/providers/s3-provider.optional.d.ts

@@ -8,7 +8,6 @@ interface S3Config {
     endpoint?: string;
 }
 export declare class S3Provider implements IStorageProvider {
-    private logger;
     private s3;
     private bucketName;
     private region;

package/providers/sftp-provider.optional.d.ts

@@ -1,7 +1,6 @@
 import { UploadOptionsDto } from '../dtos';
 import { IStorageProvider, IUploadedFileInfo } from '../interfaces';
 export declare class SftpProvider implements IStorageProvider {
-    private logger;
     private sftp;
     private config;
     private connected;

package/providers/storage-factory.service.d.ts

@@ -3,7 +3,6 @@ import { IStorageProvider, IStorageProviderConfig } from '../interfaces/storage-
 import { StorageConfigService } from '../services';
 export declare class StorageFactoryService implements OnModuleDestroy {
     private readonly configService;
-    private readonly logger;
     private readonly cache;
     constructor(configService: StorageConfigService);
     createProvider(config: IStorageProviderConfig): Promise<IStorageProvider>;

package/services/file-manager.service.d.ts

@@ -23,7 +23,7 @@ export declare class FileManagerService extends RequestScopedApiService<CreateFi
         query: SelectQueryBuilder<FileManager>;
         isRaw: boolean;
     }>;
-    protected getFilterQuery(query: SelectQueryBuilder<FileManagerBase>, filter: Record<string, any>, _user: ILoggedUserInfo | null): Promise<{
+    protected getFilterQuery(query: SelectQueryBuilder<FileManagerBase>, filter: Record<string, unknown>, _user: ILoggedUserInfo | null): Promise<{
         query: SelectQueryBuilder<FileManagerBase>;
         isRaw: boolean;
     }>;
@@ -38,8 +38,8 @@ export declare class FileManagerService extends RequestScopedApiService<CreateFi
         providerName?: string;
     })[]>;
     getFiles(dtos: GetFilesRequestDto[], protocol: string, host: string, user?: ILoggedUserInfo): Promise<FilesResponseDto[]>;
-    private getStorageConfigRepository;
     private buildWhereWithCompany;
+    private getStorageConfigRepository;
     private getStorageConfigBasePath;
     private validateFolder;
     private resolveStorageLocation;

package/services/storage-datasource.provider.d.ts

@@ -1,12 +1,10 @@
 import { MultiTenantDataSourceService } from '@flusys/nestjs-shared/modules';
 import { IDatabaseConfig, ITenantDatabaseConfig } from '@flusys/nestjs-core';
-import { Logger } from '@nestjs/common';
 import { Request } from 'express';
 import { DataSource } from 'typeorm';
 import { StorageConfigService } from './storage-config.service';
 export declare class StorageDataSourceProvider extends MultiTenantDataSourceService {
     private readonly configService;
-    protected readonly logger: Logger;
     protected static readonly tenantConnections: Map<string, DataSource>;
     protected static singleDataSource: DataSource | null;
     protected static readonly tenantsRegistry: Map<string, ITenantDatabaseConfig>;

package/services/upload.service.d.ts

@@ -8,7 +8,6 @@ export declare class UploadService {
     private readonly storageFactory;
     private readonly storageConfigService;
     private readonly storageProviderConfigService;
-    private logger;
     constructor(storageFactory: StorageFactoryService, storageConfigService: StorageConfigService, storageProviderConfigService: StorageProviderConfigService);
     private validateFile;
     private createProviderFromConfig;

package/utils/file-validator.util.d.ts

@@ -5,7 +5,6 @@ export interface FileValidationResult {
     message?: string;
 }
 export declare class FileValidator {
-    private static logger;
     private static failureResult;
     private static successResult;
     static detectFileType(buffer: Buffer): string | null;