@flusys/nestjs-storage 7.0.2 → 8.0.0-beta.1

package/fesm/providers/sftp-provider.optional.spec.js

@@ -1,213 +0,0 @@
-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;
-}
-const mockConnect = jest.fn();
-const mockMkdir = jest.fn();
-const mockPut = jest.fn();
-const mockDelete = jest.fn();
-const mockEnd = jest.fn();
-let MockSftpClient = class MockSftpClient {
-    constructor(){
-        _define_property(this, "connect", mockConnect);
-        _define_property(this, "mkdir", mockMkdir);
-        _define_property(this, "put", mockPut);
-        _define_property(this, "delete", mockDelete);
-        _define_property(this, "end", mockEnd);
-    }
-};
-jest.mock('ssh2-sftp-client', ()=>({
-        __esModule: true,
-        default: MockSftpClient
-    }), {
-    virtual: true
-});
-jest.mock('../utils/image-compressor.util', ()=>({
-        ImageCompressor: {
-            compress: jest.fn()
-        }
-    }));
-import { SftpProvider } from './sftp-provider.optional';
-import { ImageCompressor } from '../utils/image-compressor.util';
-function buildMulterFile(overrides = {}) {
-    return {
-        fieldname: 'file',
-        originalname: 'photo.jpg',
-        encoding: '7bit',
-        mimetype: 'image/jpeg',
-        buffer: Buffer.from('file-bytes'),
-        size: 10,
-        stream: undefined,
-        destination: '',
-        filename: '',
-        path: '',
-        ...overrides
-    };
-}
-describe('SftpProvider', ()=>{
-    let provider;
-    beforeEach(async ()=>{
-        jest.clearAllMocks();
-        mockConnect.mockResolvedValue(undefined);
-        mockMkdir.mockResolvedValue(undefined);
-        mockPut.mockResolvedValue(undefined);
-        mockDelete.mockResolvedValue(undefined);
-        mockEnd.mockResolvedValue(undefined);
-        provider = new SftpProvider();
-        await provider.initialize({
-            host: 'sftp.example.com',
-            username: 'deploy',
-            password: 'secret',
-            basePath: '/uploads'
-        });
-    });
-    describe('initialize', ()=>{
-        it('connects and ensures the base directory exists', ()=>{
-            expect(mockConnect).toHaveBeenCalledWith(expect.objectContaining({
-                host: 'sftp.example.com',
-                username: 'deploy',
-                password: 'secret'
-            }));
-            expect(mockMkdir).toHaveBeenCalledWith('/uploads', true);
-        });
-        it('defaults port to 22 and basePath to /uploads when not provided', async ()=>{
-            jest.clearAllMocks();
-            mockConnect.mockResolvedValue(undefined);
-            mockMkdir.mockResolvedValue(undefined);
-            const p = new SftpProvider();
-            await p.initialize({
-                host: 'h',
-                username: 'u'
-            });
-            expect(mockConnect).toHaveBeenCalledWith(expect.objectContaining({
-                port: 22
-            }));
-            expect(mockMkdir).toHaveBeenCalledWith('/uploads', true);
-        });
-        it('swallows mkdir errors (directory might already exist)', async ()=>{
-            jest.clearAllMocks();
-            mockConnect.mockResolvedValue(undefined);
-            mockMkdir.mockRejectedValue(new Error('EEXIST'));
-            const p = new SftpProvider();
-            await expect(p.initialize({
-                host: 'h',
-                username: 'u',
-                basePath: '/data'
-            })).resolves.toBeUndefined();
-        });
-        it('throws InternalServerErrorException when the SFTP client cannot connect during initialize', async ()=>{
-            mockConnect.mockRejectedValueOnce(new Error('ECONNREFUSED'));
-            const brokenProvider = new SftpProvider();
-            await expect(brokenProvider.initialize({
-                host: 'unreachable',
-                username: 'u'
-            })).rejects.toThrow('SFTP client not found');
-        });
-    });
-    describe('uploadFile', ()=>{
-        it('uploads the file under basePath and returns metadata', async ()=>{
-            const file = buildMulterFile();
-            const result = await provider.uploadFile(file, {});
-            expect(mockPut).toHaveBeenCalledWith(file.buffer, expect.stringContaining('/uploads/'));
-            expect(result.name).toMatch(/photo\.jpg$/);
-            expect(result.key).toContain('/uploads/');
-        });
-        it('nests the remote path under folderPath when provided', async ()=>{
-            const file = buildMulterFile();
-            const result = await provider.uploadFile(file, {
-                folderPath: 'images'
-            });
-            expect(result.key).toContain('/uploads/images/');
-        });
-        it('compresses image files when options.compress is true', async ()=>{
-            ImageCompressor.compress.mockResolvedValue({
-                buffer: Buffer.from('small'),
-                format: 'image/webp'
-            });
-            const file = buildMulterFile();
-            const result = await provider.uploadFile(file, {
-                compress: true
-            });
-            expect(ImageCompressor.compress).toHaveBeenCalled();
-            expect(result.contentType).toBe('image/webp');
-        });
-        it('reconnects if not already connected before uploading', async ()=>{
-            const file = buildMulterFile();
-            mockConnect.mockClear();
-            await provider.uploadFile(file, {});
-            // already connected from initialize(); connect() should be a no-op guarded by `connected` flag
-            expect(mockConnect).not.toHaveBeenCalled();
-        });
-    });
-    describe('uploadMultipleFiles', ()=>{
-        it('uploads all files', async ()=>{
-            const files = [
-                buildMulterFile({
-                    originalname: 'a.jpg'
-                }),
-                buildMulterFile({
-                    originalname: 'b.jpg'
-                })
-            ];
-            const results = await provider.uploadMultipleFiles(files, {});
-            expect(results).toHaveLength(2);
-            expect(mockPut).toHaveBeenCalledTimes(2);
-        });
-    });
-    describe('deleteFile', ()=>{
-        it('deletes the file at the given remote path', async ()=>{
-            await provider.deleteFile('/uploads/photo.jpg');
-            expect(mockDelete).toHaveBeenCalledWith('/uploads/photo.jpg');
-        });
-        it('silently swallows delete errors', async ()=>{
-            mockDelete.mockRejectedValue(new Error('not found'));
-            await expect(provider.deleteFile('/uploads/missing.jpg')).resolves.toBeUndefined();
-        });
-    });
-    describe('deleteMultipleFiles', ()=>{
-        it('deletes every provided key', async ()=>{
-            await provider.deleteMultipleFiles([
-                '/uploads/a.jpg',
-                '/uploads/b.jpg'
-            ]);
-            expect(mockDelete).toHaveBeenCalledTimes(2);
-        });
-    });
-    describe('generatePresignedUrl', ()=>{
-        it('returns the key unchanged since SFTP has no presigned URL support', async ()=>{
-            const url = await provider.generatePresignedUrl('/uploads/photo.jpg', 3600);
-            expect(url).toBe('/uploads/photo.jpg');
-        });
-    });
-    describe('healthCheck', ()=>{
-        it('returns true when connected', async ()=>{
-            await expect(provider.healthCheck()).resolves.toBe(true);
-        });
-        it('returns false when reconnecting fails', async ()=>{
-            // Disconnect first so healthCheck() must attempt to reconnect via this.connect()
-            await provider.close();
-            mockConnect.mockRejectedValueOnce(new Error('unreachable'));
-            await expect(provider.healthCheck()).resolves.toBe(false);
-        });
-    });
-    describe('close', ()=>{
-        it('ends the connection when connected', async ()=>{
-            await provider.close();
-            expect(mockEnd).toHaveBeenCalled();
-        });
-        it('does nothing when not connected', async ()=>{
-            const freshProvider = new SftpProvider();
-            await expect(freshProvider.close()).resolves.toBeUndefined();
-            expect(mockEnd).not.toHaveBeenCalled();
-        });
-    });
-});

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

@@ -1,124 +0,0 @@
-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 _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);
-    };
-}
-import { SYSTEM_MESSAGES } from '@flusys/nestjs-shared/constants';
-import { Inject, Injectable, InternalServerErrorException, NotFoundException } from '@nestjs/common';
-import * as crypto from 'crypto';
-import { StorageConfigService } from '../services';
-import { StorageProviderRegistry } from './storage-provider.registry';
-export class StorageFactoryService {
-    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({
-                message: `Storage provider '${config.provider}' not available. Available: ${StorageProviderRegistry.getAll().join(', ')}`,
-                messageKey: SYSTEM_MESSAGES.SERVICE_NOT_AVAILABLE,
-                messageVariables: {
-                    provider: config.provider,
-                    available: 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 InternalServerErrorException({
-                message: `Failed to initialize '${config.provider}': ${errorMessage}`,
-                messageKey: 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([
-    Injectable(),
-    _ts_param(0, Inject(StorageConfigService)),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        typeof StorageConfigService === "undefined" ? Object : StorageConfigService
-    ])
-], StorageFactoryService);

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

@@ -1,249 +0,0 @@
-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 { NotFoundException, InternalServerErrorException } from '@nestjs/common';
-import { StorageFactoryService } from './storage-factory.service';
-import { StorageProviderRegistry } from './storage-provider.registry';
-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.clear();
-        StorageProviderRegistry.register('fake', FakeProvider);
-        StorageProviderRegistry.register('local', FakeProvider);
-        StorageProviderRegistry.register('noinit', NoInitProvider);
-        mockConfigService = {
-            getAppUrl: jest.fn().mockReturnValue('http://localhost:2002')
-        };
-        service = new StorageFactoryService(mockConfigService);
-    });
-    afterEach(()=>{
-        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(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.register('throwing', ThrowingProvider);
-            await expect(service.createProvider({
-                provider: 'throwing',
-                config: {}
-            })).rejects.toThrow(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/fesm/providers/storage-provider.registry.js

@@ -1,34 +0,0 @@
-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;
-}
-/**
- * Static registry for storage provider classes
- * Allows dynamic registration at runtime
- */ export 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/fesm/providers/storage-provider.registry.spec.js

@@ -1,63 +0,0 @@
-import { StorageProviderRegistry } from './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.clear();
-    });
-    it('registers and retrieves a provider by name', ()=>{
-        StorageProviderRegistry.register('local', FakeProvider);
-        expect(StorageProviderRegistry.get('local')).toBe(FakeProvider);
-    });
-    it('normalizes provider names to lowercase on register and lookup', ()=>{
-        StorageProviderRegistry.register('LOCAL', FakeProvider);
-        expect(StorageProviderRegistry.get('local')).toBe(FakeProvider);
-        expect(StorageProviderRegistry.has('Local')).toBe(true);
-    });
-    it('returns undefined for a provider that was never registered', ()=>{
-        expect(StorageProviderRegistry.get('nonexistent')).toBeUndefined();
-    });
-    it('has() reports false for an unregistered provider', ()=>{
-        expect(StorageProviderRegistry.has('s3')).toBe(false);
-    });
-    it('has() reports true once a provider is registered', ()=>{
-        StorageProviderRegistry.register('s3', FakeProvider);
-        expect(StorageProviderRegistry.has('s3')).toBe(true);
-    });
-    it('getAll() lists every registered provider name', ()=>{
-        StorageProviderRegistry.register('local', FakeProvider);
-        StorageProviderRegistry.register('s3', AnotherFakeProvider);
-        expect(StorageProviderRegistry.getAll().sort()).toEqual([
-            'local',
-            's3'
-        ]);
-    });
-    it('overwrites an existing registration when registering the same name again', ()=>{
-        StorageProviderRegistry.register('local', FakeProvider);
-        StorageProviderRegistry.register('local', AnotherFakeProvider);
-        expect(StorageProviderRegistry.get('local')).toBe(AnotherFakeProvider);
-    });
-    it('clear() removes all registered providers', ()=>{
-        StorageProviderRegistry.register('local', FakeProvider);
-        StorageProviderRegistry.register('s3', AnotherFakeProvider);
-        StorageProviderRegistry.clear();
-        expect(StorageProviderRegistry.getAll()).toEqual([]);
-        expect(StorageProviderRegistry.has('local')).toBe(false);
-    });
-});