@flusys/nestjs-storage 6.0.1 → 6.1.0

package/cjs/providers/local-provider.spec.js

@@ -0,0 +1,239 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _path = /*#__PURE__*/ _interop_require_wildcard(require("path"));
+const _localprovider = require("./local-provider");
+const _imagecompressorutil = require("../utils/image-compressor.util");
+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;
+}
+const mockMkdir = jest.fn();
+const mockWriteFile = jest.fn();
+const mockAccess = jest.fn();
+const mockUnlink = jest.fn();
+jest.mock('fs/promises', ()=>({
+        mkdir: (...args)=>mockMkdir(...args),
+        writeFile: (...args)=>mockWriteFile(...args),
+        access: (...args)=>mockAccess(...args),
+        unlink: (...args)=>mockUnlink(...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('LocalProvider', ()=>{
+    let provider;
+    beforeEach(async ()=>{
+        jest.clearAllMocks();
+        mockMkdir.mockResolvedValue(undefined);
+        mockWriteFile.mockResolvedValue(undefined);
+        mockAccess.mockResolvedValue(undefined);
+        mockUnlink.mockResolvedValue(undefined);
+        provider = new _localprovider.LocalProvider();
+        await provider.initialize({
+            basePath: './uploads-test',
+            baseUrl: 'http://localhost:2002'
+        });
+    });
+    describe('initialize', ()=>{
+        it('resolves the base path and ensures the directory exists', async ()=>{
+            expect(mockMkdir).toHaveBeenCalledWith(_path.resolve('./uploads-test'), expect.objectContaining({
+                recursive: true
+            }));
+        });
+        it('defaults basePath to ./uploads when not provided', async ()=>{
+            mockMkdir.mockClear();
+            const defaultProvider = new _localprovider.LocalProvider();
+            await defaultProvider.initialize({});
+            expect(mockMkdir).toHaveBeenCalledWith(_path.resolve('./uploads'), expect.objectContaining({
+                recursive: true
+            }));
+        });
+    });
+    describe('uploadFile', ()=>{
+        it('writes the file to disk and returns metadata with a self-contained key', async ()=>{
+            const file = buildMulterFile();
+            const result = await provider.uploadFile(file, {});
+            expect(mockWriteFile).toHaveBeenCalled();
+            expect(result.name).toMatch(/photo\.jpg$/);
+            expect(result.key).toContain('uploads-test');
+            expect(result.size).toBe(file.buffer.length);
+            expect(result.contentType).toBe('image/jpeg');
+        });
+        it('nests the file under folderPath when provided', async ()=>{
+            const file = buildMulterFile();
+            const result = await provider.uploadFile(file, {
+                folderPath: 'avatars'
+            });
+            expect(result.key).toContain('avatars');
+            expect(mockMkdir).toHaveBeenCalledWith(expect.stringContaining('avatars'), expect.objectContaining({
+                recursive: true
+            }));
+        });
+        it('compresses image files 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,
+                maxWidth: 800,
+                maxHeight: 600,
+                quality: 70
+            });
+            expect(_imagecompressorutil.ImageCompressor.compress).toHaveBeenCalledWith(file.buffer, 'image/jpeg', expect.objectContaining({
+                maxWidth: 800,
+                maxHeight: 600,
+                quality: 70
+            }));
+            expect(result.contentType).toBe('image/webp');
+            expect(result.size).toBe(Buffer.from('compressed').length);
+        });
+        it('does not compress non-image mimetypes even when compress=true', async ()=>{
+            const file = buildMulterFile({
+                mimetype: 'application/pdf',
+                originalname: 'doc.pdf'
+            });
+            await provider.uploadFile(file, {
+                compress: true
+            });
+            expect(_imagecompressorutil.ImageCompressor.compress).not.toHaveBeenCalled();
+        });
+        it('rejects a folderPath that attempts to escape the base directory via path traversal', async ()=>{
+            const file = buildMulterFile();
+            await expect(provider.uploadFile(file, {
+                folderPath: '../../../etc'
+            })).rejects.toThrow();
+        });
+    });
+    describe('uploadMultipleFiles', ()=>{
+        it('uploads all files and returns their metadata', async ()=>{
+            const files = [
+                buildMulterFile({
+                    originalname: 'a.jpg'
+                }),
+                buildMulterFile({
+                    originalname: 'b.jpg'
+                })
+            ];
+            const results = await provider.uploadMultipleFiles(files, {});
+            expect(results).toHaveLength(2);
+            expect(mockWriteFile).toHaveBeenCalledTimes(2);
+        });
+    });
+    describe('deleteFile', ()=>{
+        it('deletes a file that exists at the resolved key path', async ()=>{
+            const key = _path.join('uploads-test', 'some-uuid-photo.jpg');
+            await provider.deleteFile(key);
+            expect(mockUnlink).toHaveBeenCalled();
+        });
+        it('falls back to basePath-prefixed lookup when the direct key path does not exist', async ()=>{
+            mockAccess.mockRejectedValueOnce(new Error('ENOENT')).mockResolvedValueOnce(undefined);
+            await provider.deleteFile('uploads-test/some-uuid-photo.jpg');
+            expect(mockUnlink).toHaveBeenCalled();
+        });
+        it('silently returns (no throw, no unlink) when the file does not exist at either location', async ()=>{
+            mockAccess.mockRejectedValue(new Error('ENOENT'));
+            await expect(provider.deleteFile('uploads-test/missing-file.jpg')).resolves.toBeUndefined();
+            expect(mockUnlink).not.toHaveBeenCalled();
+        });
+        it('rejects an empty key', async ()=>{
+            await expect(provider.deleteFile('')).rejects.toThrow();
+        });
+        it('rejects a key containing a null byte', async ()=>{
+            await expect(provider.deleteFile('evil\0.txt')).rejects.toThrow();
+        });
+        it('re-throws path traversal security errors rather than silently swallowing them', async ()=>{
+            await expect(provider.deleteFile('../../../etc/passwd')).rejects.toThrow(/Invalid/);
+        });
+    });
+    describe('deleteMultipleFiles', ()=>{
+        it('deletes every provided key', async ()=>{
+            await provider.deleteMultipleFiles([
+                'uploads-test/a.jpg',
+                'uploads-test/b.jpg'
+            ]);
+            expect(mockUnlink).toHaveBeenCalledTimes(2);
+        });
+    });
+    describe('generatePresignedUrl', ()=>{
+        it('builds a full URL using the configured baseUrl', async ()=>{
+            const url = await provider.generatePresignedUrl('uploads-test/photo.jpg');
+            expect(url).toBe('http://localhost:2002/storage/upload/file/uploads-test/photo.jpg');
+        });
+        it('returns a relative path when no baseUrl was configured', async ()=>{
+            const noUrlProvider = new _localprovider.LocalProvider();
+            await noUrlProvider.initialize({
+                basePath: './uploads-test2'
+            });
+            const url = await noUrlProvider.generatePresignedUrl('uploads-test2/photo.jpg');
+            expect(url).toBe('/storage/upload/file/uploads-test2/photo.jpg');
+        });
+    });
+    describe('healthCheck', ()=>{
+        it('returns true when the base path is accessible', async ()=>{
+            mockAccess.mockResolvedValue(undefined);
+            await expect(provider.healthCheck()).resolves.toBe(true);
+        });
+        it('returns false when the base path is not accessible', async ()=>{
+            mockAccess.mockRejectedValue(new Error('ENOENT'));
+            await expect(provider.healthCheck()).resolves.toBe(false);
+        });
+    });
+});

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

@@ -0,0 +1,243 @@
+"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);
+        });
+    });
+});