@flusys/nestjs-storage 7.1.0 → 8.0.0

package/cjs/providers/s3-provider.optional.spec.js

@@ -1,243 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-const _s3provideroptional = require("./s3-provider.optional");
-const _imagecompressorutil = require("../utils/image-compressor.util");
-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 mockS3ClientSend = jest.fn();
-const mockS3ClientCtor = jest.fn().mockImplementation(()=>({
-        send: mockS3ClientSend
-    }));
-let MockDeleteObjectCommand = class MockDeleteObjectCommand {
-    constructor(input){
-        _define_property(this, "input", void 0);
-        this.input = input;
-    }
-};
-let MockDeleteObjectsCommand = class MockDeleteObjectsCommand {
-    constructor(input){
-        _define_property(this, "input", void 0);
-        this.input = input;
-    }
-};
-let MockGetObjectCommand = class MockGetObjectCommand {
-    constructor(input){
-        _define_property(this, "input", void 0);
-        this.input = input;
-    }
-};
-let MockHeadBucketCommand = class MockHeadBucketCommand {
-    constructor(input){
-        _define_property(this, "input", void 0);
-        this.input = input;
-    }
-};
-jest.mock('@aws-sdk/client-s3', ()=>({
-        S3Client: mockS3ClientCtor,
-        DeleteObjectCommand: MockDeleteObjectCommand,
-        DeleteObjectsCommand: MockDeleteObjectsCommand,
-        GetObjectCommand: MockGetObjectCommand,
-        HeadBucketCommand: MockHeadBucketCommand
-    }));
-const mockUploadDone = jest.fn();
-const mockUploadCtor = jest.fn().mockImplementation(()=>({
-        done: mockUploadDone
-    }));
-jest.mock('@aws-sdk/lib-storage', ()=>({
-        Upload: mockUploadCtor
-    }));
-const mockGetSignedUrl = jest.fn();
-jest.mock('@aws-sdk/s3-request-presigner', ()=>({
-        getSignedUrl: (...args)=>mockGetSignedUrl(...args)
-    }));
-jest.mock('../utils/image-compressor.util', ()=>({
-        ImageCompressor: {
-            compress: jest.fn()
-        }
-    }));
-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('S3Provider', ()=>{
-    let provider;
-    beforeEach(async ()=>{
-        jest.clearAllMocks();
-        mockUploadDone.mockResolvedValue(undefined);
-        provider = new _s3provideroptional.S3Provider();
-        await provider.initialize({
-            region: 'us-east-1',
-            bucket: 'my-bucket'
-        });
-    });
-    describe('initialize', ()=>{
-        it('creates an S3Client with region/endpoint/credentials', async ()=>{
-            jest.clearAllMocks();
-            const p = new _s3provideroptional.S3Provider();
-            await p.initialize({
-                region: 'eu-west-1',
-                bucket: 'bucket-2',
-                accessKeyId: 'AKIA...',
-                secretAccessKey: 'secret',
-                endpoint: 'https://s3.custom.example.com'
-            });
-            expect(mockS3ClientCtor).toHaveBeenCalledWith(expect.objectContaining({
-                region: 'eu-west-1',
-                endpoint: 'https://s3.custom.example.com',
-                credentials: {
-                    accessKeyId: 'AKIA...',
-                    secretAccessKey: 'secret'
-                }
-            }));
-        });
-        it('omits credentials when access key / secret are not provided', async ()=>{
-            jest.clearAllMocks();
-            const p = new _s3provideroptional.S3Provider();
-            await p.initialize({
-                region: 'us-east-1',
-                bucket: 'bucket-3'
-            });
-            expect(mockS3ClientCtor).toHaveBeenCalledWith(expect.objectContaining({
-                credentials: undefined
-            }));
-        });
-        it('throws InternalServerErrorException when the AWS SDK cannot be initialized', async ()=>{
-            mockS3ClientCtor.mockImplementationOnce(()=>{
-                throw new Error('module not found');
-            });
-            const brokenProvider = new _s3provideroptional.S3Provider();
-            await expect(brokenProvider.initialize({
-                region: 'us-east-1',
-                bucket: 'x'
-            })).rejects.toThrow('AWS SDK not found');
-        });
-    });
-    describe('uploadFile', ()=>{
-        it('uploads via the S3 Upload helper and returns file metadata', async ()=>{
-            const file = buildMulterFile();
-            const result = await provider.uploadFile(file, {});
-            expect(mockUploadCtor).toHaveBeenCalledWith(expect.objectContaining({
-                params: expect.objectContaining({
-                    Bucket: 'my-bucket',
-                    ContentType: 'image/jpeg'
-                })
-            }));
-            expect(mockUploadDone).toHaveBeenCalled();
-            expect(result.name).toMatch(/photo\.jpg$/);
-            expect(result.key).toBe(result.name);
-        });
-        it('prefixes the key with folderPath when provided', async ()=>{
-            const file = buildMulterFile();
-            const result = await provider.uploadFile(file, {
-                folderPath: 'avatars'
-            });
-            expect(result.key).toMatch(/^avatars\//);
-        });
-        it('compresses image files before upload when options.compress is true', async ()=>{
-            _imagecompressorutil.ImageCompressor.compress.mockResolvedValue({
-                buffer: Buffer.from('compressed'),
-                format: 'image/webp'
-            });
-            const file = buildMulterFile();
-            const result = await provider.uploadFile(file, {
-                compress: true
-            });
-            expect(_imagecompressorutil.ImageCompressor.compress).toHaveBeenCalled();
-            expect(result.contentType).toBe('image/webp');
-        });
-    });
-    describe('uploadMultipleFiles', ()=>{
-        it('uploads each file and returns metadata for all', async ()=>{
-            const files = [
-                buildMulterFile({
-                    originalname: 'a.jpg'
-                }),
-                buildMulterFile({
-                    originalname: 'b.jpg'
-                })
-            ];
-            const results = await provider.uploadMultipleFiles(files, {});
-            expect(results).toHaveLength(2);
-            expect(mockUploadCtor).toHaveBeenCalledTimes(2);
-        });
-    });
-    describe('deleteFile', ()=>{
-        it('sends a DeleteObjectCommand with bucket and key', async ()=>{
-            await provider.deleteFile('some/key.jpg');
-            expect(mockS3ClientSend).toHaveBeenCalledWith(expect.any(MockDeleteObjectCommand));
-            const sentCommand = mockS3ClientSend.mock.calls[0][0];
-            expect(sentCommand.input).toEqual({
-                Bucket: 'my-bucket',
-                Key: 'some/key.jpg'
-            });
-        });
-    });
-    describe('deleteMultipleFiles', ()=>{
-        it('sends a DeleteObjectsCommand containing all keys', async ()=>{
-            await provider.deleteMultipleFiles([
-                'a.jpg',
-                'b.jpg'
-            ]);
-            const sentCommand = mockS3ClientSend.mock.calls[0][0];
-            expect(sentCommand.input.Delete.Objects).toEqual([
-                {
-                    Key: 'a.jpg'
-                },
-                {
-                    Key: 'b.jpg'
-                }
-            ]);
-        });
-    });
-    describe('generatePresignedUrl', ()=>{
-        it('delegates to getSignedUrl with the configured expiry', async ()=>{
-            mockGetSignedUrl.mockResolvedValue('https://signed.example.com/some/key.jpg');
-            const url = await provider.generatePresignedUrl('some/key.jpg', 900);
-            expect(mockGetSignedUrl).toHaveBeenCalledWith(expect.anything(), expect.any(MockGetObjectCommand), {
-                expiresIn: 900
-            });
-            expect(url).toBe('https://signed.example.com/some/key.jpg');
-        });
-        it('defaults expiry to 3600 seconds when not provided', async ()=>{
-            mockGetSignedUrl.mockResolvedValue('https://signed.example.com/x');
-            await provider.generatePresignedUrl('x');
-            expect(mockGetSignedUrl).toHaveBeenCalledWith(expect.anything(), expect.anything(), {
-                expiresIn: 3600
-            });
-        });
-    });
-    describe('healthCheck', ()=>{
-        it('returns true when HeadBucketCommand succeeds', async ()=>{
-            mockS3ClientSend.mockResolvedValue({});
-            await expect(provider.healthCheck()).resolves.toBe(true);
-        });
-        it('returns false when HeadBucketCommand rejects (bucket missing/unauthorized)', async ()=>{
-            mockS3ClientSend.mockRejectedValue(new Error('Forbidden'));
-            await expect(provider.healthCheck()).resolves.toBe(false);
-        });
-    });
-});

package/cjs/providers/sftp-provider.optional.js

@@ -1,203 +0,0 @@
-/**
- * OPTIONAL SFTP Provider
- *
- * This provider requires ssh2-sftp-client package to be installed.
- * Only import this if you need SFTP storage.
- *
- * Installation:
- * npm install ssh2-sftp-client
- * npm install -D @types/ssh2-sftp-client
- *
- * Usage:
- * import { SftpProvider } from '@flusys/nestjs-storage/providers/sftp-provider.optional';
- * import { StorageProviderRegistry, FileLocationEnum } from '@flusys/nestjs-storage';
- *
- * StorageProviderRegistry.register(FileLocationEnum.SFTP, SftpProvider);
- */ "use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "SftpProvider", {
-    enumerable: true,
-    get: function() {
-        return SftpProvider;
-    }
-});
-const _common = require("@nestjs/common");
-const _constants = require("@flusys/nestjs-shared/constants");
-const _imagecompressorutil = require("../utils/image-compressor.util");
-const _path = /*#__PURE__*/ _interop_require_wildcard(require("path"));
-const _uuid = require("uuid");
-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;
-}
-let SftpProvider = class SftpProvider {
-    /**
-   * Initialize SFTP provider with configuration
-   */ async initialize(config) {
-        try {
-            // Dynamic import - only loads SFTP SDK if this provider is used
-            const sftp = await Promise.resolve().then(()=>/*#__PURE__*/ _interop_require_wildcard(require("ssh2-sftp-client")));
-            const SftpClient = sftp.default || sftp;
-            this.sftp = new SftpClient();
-            this.config = {
-                host: config.host,
-                port: config.port || 22,
-                username: config.username,
-                password: config.password,
-                privateKey: config.privateKey,
-                basePath: config.basePath || '/uploads'
-            };
-            // Connect
-            await this.connect();
-            // Ensure base directory exists
-            await this.ensureDirectory(this.config.basePath);
-        } catch  {
-            throw new _common.InternalServerErrorException({
-                message: 'SFTP client not found',
-                messageKey: _constants.SYSTEM_MESSAGES.SDK_NOT_INSTALLED,
-                messageVariables: {
-                    sdk: 'ssh2-sftp-client'
-                }
-            });
-        }
-    }
-    async connect() {
-        if (!this.connected) {
-            await this.sftp.connect({
-                host: this.config.host,
-                port: this.config.port,
-                username: this.config.username,
-                password: this.config.password,
-                privateKey: this.config.privateKey
-            });
-            this.connected = true;
-        }
-    }
-    async ensureDirectory(dirPath) {
-        try {
-            await this.sftp.mkdir(dirPath, true);
-        } catch  {
-        // Directory might already exist
-        }
-    }
-    async uploadFile(file, options) {
-        await this.connect();
-        let processedBuffer = file.buffer;
-        let contentType = file.mimetype;
-        const fileName = `${(0, _uuid.v4)()}-${file.originalname}`;
-        // Compress image if needed
-        if (options.compress && file.mimetype.startsWith('image/')) {
-            const result = await _imagecompressorutil.ImageCompressor.compress(file.buffer, file.mimetype, {
-                maxWidth: options.maxWidth,
-                maxHeight: options.maxHeight,
-                quality: options.quality,
-                format: options.format
-            });
-            processedBuffer = result.buffer;
-            contentType = result.format;
-        }
-        const remotePath = options.folderPath ? _path.join(this.config.basePath, options.folderPath, fileName) : _path.join(this.config.basePath, fileName);
-        // Ensure parent directory exists
-        const remoteDir = _path.dirname(remotePath);
-        await this.ensureDirectory(remoteDir);
-        // Upload file
-        await this.sftp.put(processedBuffer, remotePath);
-        return {
-            name: fileName,
-            key: remotePath,
-            size: processedBuffer.length,
-            contentType
-        };
-    }
-    async uploadMultipleFiles(files, options) {
-        return Promise.all(files.map((file)=>this.uploadFile(file, options)));
-    }
-    async deleteFile(key) {
-        await this.connect();
-        try {
-            await this.sftp.delete(key);
-        } catch  {
-        // Silent failure
-        }
-    }
-    async deleteMultipleFiles(keys) {
-        await Promise.all(keys.map((key)=>this.deleteFile(key)));
-    }
-    async generatePresignedUrl(key, _expiresInSeconds) {
-        // SFTP doesn't support presigned URLs, return the key
-        return key;
-    }
-    async healthCheck() {
-        try {
-            await this.connect();
-            return this.connected;
-        } catch  {
-            return false;
-        }
-    }
-    /**
-   * Close SFTP connection
-   */ async close() {
-        if (this.connected) {
-            await this.sftp.end();
-            this.connected = false;
-        }
-    }
-    constructor(){
-        _define_property(this, "sftp", void 0); // SftpClient
-        _define_property(this, "config", void 0);
-        _define_property(this, "connected", false);
-    }
-};

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

@@ -1,217 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-const _sftpprovideroptional = require("./sftp-provider.optional");
-const _imagecompressorutil = require("../utils/image-compressor.util");
-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()
-        }
-    }));
-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 _sftpprovideroptional.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 _sftpprovideroptional.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 _sftpprovideroptional.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 _sftpprovideroptional.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 ()=>{
-            _imagecompressorutil.ImageCompressor.compress.mockResolvedValue({
-                buffer: Buffer.from('small'),
-                format: 'image/webp'
-            });
-            const file = buildMulterFile();
-            const result = await provider.uploadFile(file, {
-                compress: true
-            });
-            expect(_imagecompressorutil.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 _sftpprovideroptional.SftpProvider();
-            await expect(freshProvider.close()).resolves.toBeUndefined();
-            expect(mockEnd).not.toHaveBeenCalled();
-        });
-    });
-});