@flusys/nestjs-storage 1.0.0-rc → 1.0.1

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

@@ -1,18 +1,4 @@
-/**
- * OPTIONAL S3 Provider
- *
- * This provider requires @aws-sdk packages to be installed.
- * Only import this if you need AWS S3 storage.
- *
- * Installation:
- * npm install @aws-sdk/client-s3 @aws-sdk/lib-storage @aws-sdk/s3-request-presigner
- *
- * Usage:
- * import { S3Provider } from '@flusys/nestjs-storage/providers/s3-provider.optional';
- * import { StorageProviderRegistry, FileLocationEnum } from '@flusys/nestjs-storage';
- *
- * StorageProviderRegistry.register(FileLocationEnum.AWS, S3Provider);
- */ function _define_property(obj, key, value) {
+function _define_property(obj, key, value) {
     if (key in obj) {
         Object.defineProperty(obj, key, {
             value: value,
@@ -25,33 +11,29 @@
     }
     return obj;
 }
-import { ImageCompressor } from '../utils/image-compressor.util';
-import { Logger } from '@nestjs/common';
-import { v4 as uuidv4 } from 'uuid';
 /**
- * AWS S3 Storage Provider
- * Requires @aws-sdk packages to be installed
- */ export class S3Provider {
-    /**
-   * Initialize S3 provider with configuration
-   */ async initialize(config) {
+ * Optional AWS S3 Storage Provider
+ * Requires: npm install @aws-sdk/client-s3 @aws-sdk/lib-storage @aws-sdk/s3-request-presigner
+ */ import { Logger } from '@nestjs/common';
+import { v4 as uuidv4 } from 'uuid';
+import { ImageCompressor } from '../utils/image-compressor.util';
+export class S3Provider {
+    async initialize(config) {
         try {
-            // Dynamic import - only loads AWS SDK if this provider is used
             const { S3Client } = await import('@aws-sdk/client-s3');
             this.region = config.region;
             this.bucketName = config.bucket;
             this.s3 = new S3Client({
                 region: config.region,
+                endpoint: config.endpoint,
                 credentials: config.accessKeyId && config.secretAccessKey ? {
                     accessKeyId: config.accessKeyId,
                     secretAccessKey: config.secretAccessKey
-                } : undefined,
-                endpoint: config.endpoint
+                } : undefined
             });
             this.logger.log(`S3 Provider initialized: region=${config.region}, bucket=${config.bucket}`);
-        } catch (_error) {
-            this.logger.error('Failed to initialize S3Provider. Make sure @aws-sdk packages are installed.');
-            throw new Error('AWS SDK not found. Install it with: npm install @aws-sdk/client-s3 @aws-sdk/lib-storage @aws-sdk/s3-request-presigner');
+        } catch  {
+            throw new Error('AWS SDK not found. Install: npm install @aws-sdk/client-s3 @aws-sdk/lib-storage @aws-sdk/s3-request-presigner');
         }
     }
     async uploadFile(file, options) {
@@ -59,7 +41,6 @@ import { v4 as uuidv4 } from 'uuid';
         let processedBuffer = file.buffer;
         let contentType = file.mimetype;
         const fileName = `${uuidv4()}-${file.originalname}`;
-        // Compress image if needed
         if (options.compress && file.mimetype.startsWith('image/')) {
             const result = await ImageCompressor.compress(file.buffer, file.mimetype, {
                 maxWidth: options.maxWidth,
@@ -71,7 +52,7 @@ import { v4 as uuidv4 } from 'uuid';
             contentType = result.format;
         }
         const key = options.folderPath ? `${options.folderPath}/${fileName}` : fileName;
-        const upload = new Upload({
+        await new Upload({
             client: this.s3,
             params: {
                 Bucket: this.bucketName,
@@ -79,8 +60,7 @@ import { v4 as uuidv4 } from 'uuid';
                 Body: processedBuffer,
                 ContentType: contentType
             }
-        });
-        await upload.done();
+        }).done();
         return {
             name: fileName,
             key,
@@ -93,44 +73,40 @@ import { v4 as uuidv4 } from 'uuid';
     }
     async deleteFile(key) {
         const { DeleteObjectCommand } = await import('@aws-sdk/client-s3');
-        const command = new DeleteObjectCommand({
+        await this.s3.send(new DeleteObjectCommand({
             Bucket: this.bucketName,
             Key: key
-        });
-        await this.s3.send(command);
+        }));
         this.logger.log(`Deleted file from S3: ${key}`);
     }
     async deleteMultipleFiles(keys) {
         const { DeleteObjectsCommand } = await import('@aws-sdk/client-s3');
-        const command = new DeleteObjectsCommand({
+        await this.s3.send(new DeleteObjectsCommand({
             Bucket: this.bucketName,
             Delete: {
                 Objects: keys.map((key)=>({
                         Key: key
                     }))
             }
-        });
-        await this.s3.send(command);
+        }));
         this.logger.log(`Deleted ${keys.length} files from S3`);
     }
     async generatePresignedUrl(key, expiresInSeconds = 3600) {
         const { GetObjectCommand } = await import('@aws-sdk/client-s3');
         const { getSignedUrl } = await import('@aws-sdk/s3-request-presigner');
-        const command = new GetObjectCommand({
+        return getSignedUrl(this.s3, new GetObjectCommand({
             Bucket: this.bucketName,
             Key: key
-        });
-        return getSignedUrl(this.s3, command, {
+        }), {
             expiresIn: expiresInSeconds
         });
     }
     async healthCheck() {
         try {
             const { HeadBucketCommand } = await import('@aws-sdk/client-s3');
-            const command = new HeadBucketCommand({
+            await this.s3.send(new HeadBucketCommand({
                 Bucket: this.bucketName
-            });
-            await this.s3.send(command);
+            }));
             return true;
         } catch  {
             return false;
@@ -138,7 +114,7 @@ import { v4 as uuidv4 } from 'uuid';
     }
     constructor(){
         _define_property(this, "logger", new Logger(S3Provider.name));
-        _define_property(this, "s3", void 0); // S3Client - typed as any to avoid import
+        _define_property(this, "s3", void 0);
         _define_property(this, "bucketName", '');
         _define_property(this, "region", '');
     }

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

@@ -25,129 +25,84 @@ function _ts_param(paramIndex, decorator) {
         decorator(target, key, paramIndex);
     };
 }
-import { StorageProviderRegistry } from './storage-provider.registry';
 import { Inject, Injectable, Logger, NotFoundException } from '@nestjs/common';
 import * as crypto from 'crypto';
-import { StorageConfigService } from '../config';
+import { StorageConfigService } from '../services';
+import { StorageProviderRegistry } from './storage-provider.registry';
 export class StorageFactoryService {
-    /**
-   * Generate a stable cache key for provider configuration
-   * Uses SHA256 hash to handle complex config objects consistently
-   */ generateCacheKey(config) {
-        // Sort keys for consistent ordering, then hash
-        const configString = JSON.stringify(config.config, Object.keys(config.config || {}).sort());
-        const configHash = crypto.createHash('sha256').update(configString).digest('hex').substring(0, 16);
-        return `${config.provider}-${configHash}`;
-    }
-    /**
-   * Create a storage provider instance based on configuration
-   * Uses lazy loading - provider is only instantiated when requested
-   */ async createProvider(config) {
-        const providerKey = this.generateCacheKey(config);
-        // Check cache first
-        if (this.providerCache.has(providerKey)) {
-            return this.providerCache.get(providerKey);
-        }
-        // Get provider class from registry
+    async createProvider(config) {
+        const cacheKey = this.generateCacheKey(config);
+        const cached = this.cache.get(cacheKey);
+        if (cached) return cached;
         const ProviderClass = StorageProviderRegistry.get(config.provider);
         if (!ProviderClass) {
-            throw new NotFoundException(`Storage provider '${config.provider}' is not registered. ` + `Available providers: ${StorageProviderRegistry.getAll().join(', ')}`);
+            throw new NotFoundException(`Storage provider '${config.provider}' not registered. Available: ${StorageProviderRegistry.getAll().join(', ')}`);
         }
-        // Instantiate provider
         try {
             const instance = new ProviderClass();
-            // Initialize if method exists
-            if ('initialize' in instance && typeof instance.initialize === 'function') {
-                // 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);
-            this.logger.log(`Created storage provider: ${config.provider} (key: ${providerKey})`);
+            await this.initializeProvider(instance, config);
+            this.cache.set(cacheKey, instance);
+            this.logger.log(`Created provider: ${config.provider} (${cacheKey})`);
             return instance;
         } catch (error) {
-            this.logger.error(`Failed to create provider ${config.provider}:`, error);
-            // Preserve original error message for better debugging
-            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
-            throw new Error(`Failed to initialize storage provider '${config.provider}': ${errorMessage}`);
+            const message = error instanceof Error ? error.message : 'Unknown error';
+            throw new Error(`Failed to initialize '${config.provider}': ${message}`);
         }
     }
-    /**
-   * Get provider by name (creates with default config if not cached)
-   */ async getProvider(providerName) {
-        const cachedKey = Array.from(this.providerCache.keys()).find((key)=>key.startsWith(providerName));
-        if (cachedKey) {
-            return this.providerCache.get(cachedKey);
-        }
-        // Create with empty config
+    async getProvider(providerName) {
+        const cachedKey = Array.from(this.cache.keys()).find((k)=>k.startsWith(providerName));
+        if (cachedKey) return this.cache.get(cachedKey);
         return this.createProvider({
             provider: providerName,
             config: {}
         });
     }
-    /**
-   * Clear cached providers
-   */ clearCache() {
-        this.providerCache.clear();
+    getLocalProviderBasePath() {
+        const localKey = Array.from(this.cache.keys()).find((k)=>k.startsWith('local'));
+        const provider = localKey ? this.cache.get(localKey) : null;
+        return provider && 'basePath' in provider ? provider.basePath : null;
     }
-    /**
-   * Check if a provider is available
-   */ isProviderAvailable(providerName) {
-        return StorageProviderRegistry.has(providerName);
+    clearCache() {
+        this.cache.clear();
     }
-    /**
-   * Get list of available providers
-   */ getAvailableProviders() {
-        return StorageProviderRegistry.getAll();
+    async onModuleDestroy() {
+        this.logger.log('Cleaning up storage providers...');
+        const closePromises = Array.from(this.cache.entries()).filter(([, p])=>'close' in p && typeof p.close === 'function').map(([key, p])=>p.close().then(()=>this.logger.debug(`Closed: ${key}`)).catch((e)=>this.logger.warn(`Failed to close ${key}: ${e.message}`)));
+        await Promise.allSettled(closePromises);
+        this.cache.clear();
+        this.logger.log('Storage provider cleanup complete');
     }
-    /**
-   * 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;
+    // ─── Private Helpers ──────────────────────────────────────────────────────────
+    generateCacheKey(config) {
+        const sortedKeys = Object.keys(config.config || {}).sort();
+        const hash = crypto.createHash('sha256').update(JSON.stringify(config.config, sortedKeys)).digest('hex').substring(0, 16);
+        return `${config.provider}-${hash}`;
     }
-    /**
-   * Cleanup all cached provider connections on module destroy
-   * Ensures SFTP connections and other resources are properly released
-   */ async onModuleDestroy() {
-        this.logger.log('Cleaning up storage provider connections...');
-        const closePromises = [];
-        for (const [key, provider] of this.providerCache.entries()){
-            // Check if provider has a close method (e.g., SFTP)
-            if ('close' in provider && typeof provider.close === 'function') {
-                closePromises.push(provider.close().then(()=>this.logger.debug(`Closed provider: ${key}`)).catch((err)=>this.logger.warn(`Failed to close provider ${key}: ${err.message}`)));
+    async initializeProvider(instance, config) {
+        if (!('initialize' in instance) || typeof instance.initialize !== 'function') {
+            return;
+        }
+        let initConfig = config.config;
+        // Inject appUrl as baseUrl fallback for local provider
+        if (config.provider === 'local' && !config.config?.baseUrl) {
+            const appUrl = this.configService.getAppUrl();
+            if (appUrl) {
+                initConfig = {
+                    ...config.config,
+                    baseUrl: appUrl
+                };
+                this.logger.debug(`Using appUrl as baseUrl: ${appUrl}`);
             }
         }
-        await Promise.allSettled(closePromises);
-        this.providerCache.clear();
-        this.logger.log('Storage provider cleanup complete');
+        await instance.initialize(initConfig);
     }
-    constructor(storageConfigService){
-        _define_property(this, "storageConfigService", void 0);
+    constructor(configService){
+        _define_property(this, "configService", void 0);
         _define_property(this, "logger", void 0);
-        _define_property(this, "providerCache", void 0);
-        this.storageConfigService = storageConfigService;
+        _define_property(this, "cache", void 0);
+        this.configService = configService;
         this.logger = new Logger(StorageFactoryService.name);
-        this.providerCache = new Map();
+        this.cache = new Map();
     }
 }
 StorageFactoryService = _ts_decorate([

package/fesm/providers/storage-provider.registry.js

@@ -12,32 +12,22 @@ function _define_property(obj, key, value) {
     return obj;
 }
 /**
- * Registry for storage providers
- * Allows dynamic registration of providers at runtime
+ * Static registry for storage provider classes
+ * Allows dynamic registration at runtime
  */ export class StorageProviderRegistry {
-    /**
-   * Register a storage provider
-   */ static register(providerName, providerClass) {
-        this.providers.set(providerName.toLowerCase(), providerClass);
+    static register(name, providerClass) {
+        this.providers.set(name.toLowerCase(), providerClass);
     }
-    /**
-   * Get a registered provider class
-   */ static get(providerName) {
-        return this.providers.get(providerName.toLowerCase());
+    static get(name) {
+        return this.providers.get(name.toLowerCase());
     }
-    /**
-   * Check if a provider is registered
-   */ static has(providerName) {
-        return this.providers.has(providerName.toLowerCase());
+    static has(name) {
+        return this.providers.has(name.toLowerCase());
     }
-    /**
-   * Get all registered provider names
-   */ static getAll() {
+    static getAll() {
         return Array.from(this.providers.keys());
     }
-    /**
-   * Clear all providers (useful for testing)
-   */ static clear() {
+    static clear() {
         this.providers.clear();
     }
 }