@flusys/nestjs-storage 7.1.0 → 8.0.0

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

@@ -1,175 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "StorageFactoryService", {
-    enumerable: true,
-    get: function() {
-        return StorageFactoryService;
-    }
-});
-const _constants = require("@flusys/nestjs-shared/constants");
-const _common = require("@nestjs/common");
-const _crypto = /*#__PURE__*/ _interop_require_wildcard(require("crypto"));
-const _services = require("../services");
-const _storageproviderregistry = require("./storage-provider.registry");
-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 _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;
-}
-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);
-}
-function _ts_param(paramIndex, decorator) {
-    return function(target, key) {
-        decorator(target, key, paramIndex);
-    };
-}
-let StorageFactoryService = class StorageFactoryService {
-    async createProvider(config) {
-        const cacheKey = this.generateCacheKey(config);
-        const cached = this.cache.get(cacheKey);
-        if (cached) return cached;
-        const ProviderClass = _storageproviderregistry.StorageProviderRegistry.get(config.provider);
-        if (!ProviderClass) {
-            throw new _common.NotFoundException({
-                message: `Storage provider '${config.provider}' not available. Available: ${_storageproviderregistry.StorageProviderRegistry.getAll().join(', ')}`,
-                messageKey: _constants.SYSTEM_MESSAGES.SERVICE_NOT_AVAILABLE,
-                messageVariables: {
-                    provider: config.provider,
-                    available: _storageproviderregistry.StorageProviderRegistry.getAll().join(', ')
-                }
-            });
-        }
-        try {
-            const instance = new ProviderClass();
-            await this.initializeProvider(instance, config);
-            this.cache.set(cacheKey, instance);
-            return instance;
-        } catch (error) {
-            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
-            throw new _common.InternalServerErrorException({
-                message: `Failed to initialize '${config.provider}': ${errorMessage}`,
-                messageKey: _constants.SYSTEM_MESSAGES.INTERNAL_ERROR,
-                messageVariables: {
-                    provider: config.provider,
-                    error: errorMessage
-                }
-            });
-        }
-    }
-    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: {}
-        });
-    }
-    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;
-    }
-    clearCache() {
-        this.cache.clear();
-    }
-    async onModuleDestroy() {
-        const closePromises = Array.from(this.cache.entries()).filter(([, p])=>'close' in p && typeof p.close === 'function').map(([, p])=>p.close().catch(()=>{}));
-        await Promise.allSettled(closePromises);
-        this.cache.clear();
-    }
-    // ─── 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}`;
-    }
-    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
-                };
-            }
-        }
-        await instance.initialize(initConfig);
-    }
-    constructor(configService){
-        _define_property(this, "configService", void 0);
-        _define_property(this, "cache", void 0);
-        this.configService = configService;
-        this.cache = new Map();
-    }
-};
-StorageFactoryService = _ts_decorate([
-    (0, _common.Injectable)(),
-    _ts_param(0, (0, _common.Inject)(_services.StorageConfigService)),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        typeof _services.StorageConfigService === "undefined" ? Object : _services.StorageConfigService
-    ])
-], StorageFactoryService);

package/cjs/providers/storage-factory.service.spec.js

@@ -1,253 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-const _common = require("@nestjs/common");
-const _storagefactoryservice = require("./storage-factory.service");
-const _storageproviderregistry = require("./storage-provider.registry");
-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;
-}
-let FakeProvider = class FakeProvider {
-    async initialize(config) {
-        this.initializeCalledWith = config;
-        this.basePath = config?.basePath;
-    }
-    async uploadFile() {
-        return {};
-    }
-    async uploadMultipleFiles() {
-        return [];
-    }
-    async deleteFile() {}
-    async deleteMultipleFiles() {}
-    async generatePresignedUrl() {
-        return '';
-    }
-    async healthCheck() {
-        return true;
-    }
-    constructor(){
-        _define_property(this, "initializeCalledWith", undefined);
-        _define_property(this, "basePath", void 0);
-        _define_property(this, "close", jest.fn().mockResolvedValue(undefined));
-    }
-};
-let NoInitProvider = class NoInitProvider {
-    async uploadFile() {
-        return {};
-    }
-    async uploadMultipleFiles() {
-        return [];
-    }
-    async deleteFile() {}
-    async deleteMultipleFiles() {}
-    async generatePresignedUrl() {
-        return '';
-    }
-    async healthCheck() {
-        return true;
-    }
-};
-describe('StorageFactoryService', ()=>{
-    let service;
-    let mockConfigService;
-    beforeEach(()=>{
-        _storageproviderregistry.StorageProviderRegistry.clear();
-        _storageproviderregistry.StorageProviderRegistry.register('fake', FakeProvider);
-        _storageproviderregistry.StorageProviderRegistry.register('local', FakeProvider);
-        _storageproviderregistry.StorageProviderRegistry.register('noinit', NoInitProvider);
-        mockConfigService = {
-            getAppUrl: jest.fn().mockReturnValue('http://localhost:2002')
-        };
-        service = new _storagefactoryservice.StorageFactoryService(mockConfigService);
-    });
-    afterEach(()=>{
-        _storageproviderregistry.StorageProviderRegistry.clear();
-    });
-    describe('createProvider', ()=>{
-        it('creates and initializes a provider instance from the registry', async ()=>{
-            const provider = await service.createProvider({
-                provider: 'fake',
-                config: {
-                    bucket: 'x'
-                }
-            });
-            expect(provider).toBeInstanceOf(FakeProvider);
-            expect(provider.initializeCalledWith).toEqual({
-                bucket: 'x'
-            });
-        });
-        it('caches providers by a hash of their config and reuses the cached instance', async ()=>{
-            const config = {
-                provider: 'fake',
-                config: {
-                    bucket: 'x'
-                }
-            };
-            const first = await service.createProvider(config);
-            const second = await service.createProvider(config);
-            expect(first).toBe(second);
-        });
-        it('creates distinct instances for different configs of the same provider', async ()=>{
-            const first = await service.createProvider({
-                provider: 'fake',
-                config: {
-                    bucket: 'a'
-                }
-            });
-            const second = await service.createProvider({
-                provider: 'fake',
-                config: {
-                    bucket: 'b'
-                }
-            });
-            expect(first).not.toBe(second);
-        });
-        it('throws NotFoundException when the requested provider is not registered', async ()=>{
-            await expect(service.createProvider({
-                provider: 'unregistered',
-                config: {}
-            })).rejects.toThrow(_common.NotFoundException);
-        });
-        it('skips calling initialize() when the provider does not implement it', async ()=>{
-            const provider = await service.createProvider({
-                provider: 'noinit',
-                config: {}
-            });
-            expect(provider).toBeInstanceOf(NoInitProvider);
-        });
-        it('wraps unexpected initialization errors in InternalServerErrorException', async ()=>{
-            let ThrowingProvider = class ThrowingProvider {
-                async initialize() {
-                    throw new Error('connection refused');
-                }
-                async uploadFile() {
-                    return {};
-                }
-                async uploadMultipleFiles() {
-                    return [];
-                }
-                async deleteFile() {}
-                async deleteMultipleFiles() {}
-                async generatePresignedUrl() {
-                    return '';
-                }
-                async healthCheck() {
-                    return true;
-                }
-            };
-            _storageproviderregistry.StorageProviderRegistry.register('throwing', ThrowingProvider);
-            await expect(service.createProvider({
-                provider: 'throwing',
-                config: {}
-            })).rejects.toThrow(_common.InternalServerErrorException);
-        });
-        it('injects appUrl as baseUrl fallback for the local provider when not explicitly configured', async ()=>{
-            const provider = await service.createProvider({
-                provider: 'local',
-                config: {
-                    basePath: './uploads'
-                }
-            });
-            expect(provider.initializeCalledWith).toEqual({
-                basePath: './uploads',
-                baseUrl: 'http://localhost:2002'
-            });
-        });
-        it('does not override an explicitly configured baseUrl for the local provider', async ()=>{
-            const provider = await service.createProvider({
-                provider: 'local',
-                config: {
-                    basePath: './uploads',
-                    baseUrl: 'https://cdn.example.com'
-                }
-            });
-            expect(provider.initializeCalledWith.baseUrl).toBe('https://cdn.example.com');
-        });
-    });
-    describe('getProvider', ()=>{
-        it('returns a cached provider whose cache key starts with the given name', async ()=>{
-            const created = await service.createProvider({
-                provider: 'fake',
-                config: {
-                    bucket: 'x'
-                }
-            });
-            const result = await service.getProvider('fake');
-            expect(result).toBe(created);
-        });
-        it('creates a new provider with empty config if none is cached yet', async ()=>{
-            const result = await service.getProvider('fake');
-            expect(result).toBeInstanceOf(FakeProvider);
-        });
-    });
-    describe('getLocalProviderBasePath', ()=>{
-        it('returns null when no local provider has been created yet', ()=>{
-            expect(service.getLocalProviderBasePath()).toBeNull();
-        });
-        it("returns the cached local provider's basePath", async ()=>{
-            await service.createProvider({
-                provider: 'local',
-                config: {
-                    basePath: './my-uploads'
-                }
-            });
-            expect(service.getLocalProviderBasePath()).toBe('./my-uploads');
-        });
-    });
-    describe('clearCache', ()=>{
-        it('empties the provider cache', async ()=>{
-            await service.createProvider({
-                provider: 'fake',
-                config: {
-                    bucket: 'x'
-                }
-            });
-            service.clearCache();
-            expect(service.getLocalProviderBasePath()).toBeNull();
-        });
-    });
-    describe('onModuleDestroy', ()=>{
-        it('calls close() on cached providers that implement it', async ()=>{
-            const provider = await service.createProvider({
-                provider: 'fake',
-                config: {
-                    bucket: 'x'
-                }
-            });
-            await service.onModuleDestroy();
-            expect(provider.close).toHaveBeenCalled();
-        });
-        it('does not throw when a provider close() call rejects', async ()=>{
-            const provider = await service.createProvider({
-                provider: 'fake',
-                config: {
-                    bucket: 'y'
-                }
-            });
-            provider.close.mockRejectedValue(new Error('close failed'));
-            await expect(service.onModuleDestroy()).resolves.toBeUndefined();
-        });
-        it('clears the cache after destroy', async ()=>{
-            await service.createProvider({
-                provider: 'fake',
-                config: {
-                    bucket: 'x'
-                }
-            });
-            await service.onModuleDestroy();
-            expect(service.getLocalProviderBasePath()).toBeNull();
-        });
-    });
-});

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

@@ -1,41 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "StorageProviderRegistry", {
-    enumerable: true,
-    get: function() {
-        return StorageProviderRegistry;
-    }
-});
-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;
-}
-let StorageProviderRegistry = class StorageProviderRegistry {
-    static register(name, providerClass) {
-        this.providers.set(name.toLowerCase(), providerClass);
-    }
-    static get(name) {
-        return this.providers.get(name.toLowerCase());
-    }
-    static has(name) {
-        return this.providers.has(name.toLowerCase());
-    }
-    static getAll() {
-        return Array.from(this.providers.keys());
-    }
-    static clear() {
-        this.providers.clear();
-    }
-};
-_define_property(StorageProviderRegistry, "providers", new Map());

package/cjs/providers/storage-provider.registry.spec.js

@@ -1,67 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-const _storageproviderregistry = require("./storage-provider.registry");
-let FakeProvider = class FakeProvider {
-    async uploadFile() {
-        return {};
-    }
-    async uploadMultipleFiles() {
-        return [];
-    }
-    async deleteFile() {}
-    async deleteMultipleFiles() {}
-    async generatePresignedUrl() {
-        return '';
-    }
-    async healthCheck() {
-        return true;
-    }
-};
-let AnotherFakeProvider = class AnotherFakeProvider extends FakeProvider {
-};
-describe('StorageProviderRegistry', ()=>{
-    afterEach(()=>{
-        _storageproviderregistry.StorageProviderRegistry.clear();
-    });
-    it('registers and retrieves a provider by name', ()=>{
-        _storageproviderregistry.StorageProviderRegistry.register('local', FakeProvider);
-        expect(_storageproviderregistry.StorageProviderRegistry.get('local')).toBe(FakeProvider);
-    });
-    it('normalizes provider names to lowercase on register and lookup', ()=>{
-        _storageproviderregistry.StorageProviderRegistry.register('LOCAL', FakeProvider);
-        expect(_storageproviderregistry.StorageProviderRegistry.get('local')).toBe(FakeProvider);
-        expect(_storageproviderregistry.StorageProviderRegistry.has('Local')).toBe(true);
-    });
-    it('returns undefined for a provider that was never registered', ()=>{
-        expect(_storageproviderregistry.StorageProviderRegistry.get('nonexistent')).toBeUndefined();
-    });
-    it('has() reports false for an unregistered provider', ()=>{
-        expect(_storageproviderregistry.StorageProviderRegistry.has('s3')).toBe(false);
-    });
-    it('has() reports true once a provider is registered', ()=>{
-        _storageproviderregistry.StorageProviderRegistry.register('s3', FakeProvider);
-        expect(_storageproviderregistry.StorageProviderRegistry.has('s3')).toBe(true);
-    });
-    it('getAll() lists every registered provider name', ()=>{
-        _storageproviderregistry.StorageProviderRegistry.register('local', FakeProvider);
-        _storageproviderregistry.StorageProviderRegistry.register('s3', AnotherFakeProvider);
-        expect(_storageproviderregistry.StorageProviderRegistry.getAll().sort()).toEqual([
-            'local',
-            's3'
-        ]);
-    });
-    it('overwrites an existing registration when registering the same name again', ()=>{
-        _storageproviderregistry.StorageProviderRegistry.register('local', FakeProvider);
-        _storageproviderregistry.StorageProviderRegistry.register('local', AnotherFakeProvider);
-        expect(_storageproviderregistry.StorageProviderRegistry.get('local')).toBe(AnotherFakeProvider);
-    });
-    it('clear() removes all registered providers', ()=>{
-        _storageproviderregistry.StorageProviderRegistry.register('local', FakeProvider);
-        _storageproviderregistry.StorageProviderRegistry.register('s3', AnotherFakeProvider);
-        _storageproviderregistry.StorageProviderRegistry.clear();
-        expect(_storageproviderregistry.StorageProviderRegistry.getAll()).toEqual([]);
-        expect(_storageproviderregistry.StorageProviderRegistry.has('local')).toBe(false);
-    });
-});