@flusys/nestjs-storage 1.1.0-beta → 2.0.0

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 originalMessage = error?.message || 'Unknown error';
-            throw new Error(`Failed to initialize storage provider '${config.provider}': ${originalMessage}`);
+            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();
     }
 }