@hazeljs/core 0.2.0-beta.1

package/dist/__tests__/upload/file-upload.test.js

@@ -0,0 +1,498 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __decorate = (this && this.__decorate) || function (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;
+};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const file_upload_1 = require("../../upload/file-upload");
+const fs = __importStar(require("fs"));
+require("reflect-metadata");
+// Mock logger
+jest.mock('../../logger', () => ({
+    info: jest.fn(),
+    debug: jest.fn(),
+    warn: jest.fn(),
+    error: jest.fn(),
+}));
+// Mock fs
+jest.mock('fs', () => ({
+    existsSync: jest.fn(),
+    mkdirSync: jest.fn(),
+    promises: {
+        writeFile: jest.fn(),
+    },
+}));
+describe('FileUploadInterceptor', () => {
+    let uploadDir;
+    beforeEach(() => {
+        uploadDir = './test-uploads';
+        jest.clearAllMocks();
+        fs.existsSync.mockReturnValue(false);
+    });
+    describe('constructor', () => {
+        it('should create interceptor with default options', () => {
+            const interceptor = new file_upload_1.FileUploadInterceptor();
+            expect(interceptor).toBeDefined();
+        });
+        it('should create interceptor with custom destination', () => {
+            const interceptor = new file_upload_1.FileUploadInterceptor({
+                destination: uploadDir,
+            });
+            expect(interceptor).toBeDefined();
+            expect(fs.mkdirSync).toHaveBeenCalledWith(uploadDir, { recursive: true });
+        });
+        it('should create interceptor with custom filename function', () => {
+            const customFilename = jest.fn(() => 'custom-name.txt');
+            const interceptor = new file_upload_1.FileUploadInterceptor({
+                filename: customFilename,
+            });
+            expect(interceptor).toBeDefined();
+        });
+        it('should create interceptor with file size limits', () => {
+            const interceptor = new file_upload_1.FileUploadInterceptor({
+                limits: {
+                    fileSize: 1024 * 1024, // 1MB
+                    files: 5,
+                },
+            });
+            expect(interceptor).toBeDefined();
+        });
+        it('should create interceptor with file filter', () => {
+            const fileFilter = jest.fn(() => true);
+            const interceptor = new file_upload_1.FileUploadInterceptor({
+                fileFilter,
+            });
+            expect(interceptor).toBeDefined();
+        });
+        it('should create interceptor with memory storage', () => {
+            const interceptor = new file_upload_1.FileUploadInterceptor({
+                storage: 'memory',
+            });
+            expect(interceptor).toBeDefined();
+        });
+        it('should not create directory if it exists', () => {
+            fs.existsSync.mockReturnValue(true);
+            const interceptor = new file_upload_1.FileUploadInterceptor({
+                destination: uploadDir,
+            });
+            expect(interceptor).toBeDefined();
+            expect(fs.mkdirSync).not.toHaveBeenCalled();
+        });
+        it('should not create directory for memory storage', () => {
+            const interceptor = new file_upload_1.FileUploadInterceptor({
+                storage: 'memory',
+                destination: uploadDir,
+            });
+            expect(interceptor).toBeDefined();
+            expect(fs.mkdirSync).not.toHaveBeenCalled();
+        });
+    });
+    describe('parseMultipart', () => {
+        it('should throw error for non-multipart content type', async () => {
+            const interceptor = new file_upload_1.FileUploadInterceptor();
+            const mockReq = {
+                headers: {
+                    'content-type': 'application/json',
+                },
+            };
+            await expect(interceptor.parseMultipart(mockReq)).rejects.toThrow('Content-Type must be multipart/form-data');
+        });
+        it('should throw error for missing boundary', async () => {
+            const interceptor = new file_upload_1.FileUploadInterceptor();
+            const mockReq = {
+                headers: {
+                    'content-type': 'multipart/form-data',
+                },
+            };
+            await expect(interceptor.parseMultipart(mockReq)).rejects.toThrow('Missing boundary in Content-Type');
+        });
+        it('should parse multipart data with boundary', async () => {
+            const interceptor = new file_upload_1.FileUploadInterceptor({ storage: 'memory' });
+            const boundary = '----WebKitFormBoundary';
+            const fileContent = 'test file content';
+            const multipartData = [
+                `------WebKitFormBoundary`,
+                `Content-Disposition: form-data; name="field1"`,
+                ``,
+                `value1`,
+                `------WebKitFormBoundary`,
+                `Content-Disposition: form-data; name="file"; filename="test.txt"`,
+                `Content-Type: text/plain`,
+                ``,
+                fileContent,
+                `------WebKitFormBoundary--`,
+            ].join('\r\n');
+            const mockReq = {
+                headers: {
+                    'content-type': `multipart/form-data; boundary=${boundary}`,
+                },
+                on: jest.fn((event, handler) => {
+                    if (event === 'data') {
+                        handler(Buffer.from(multipartData));
+                    }
+                    if (event === 'end') {
+                        handler();
+                    }
+                }),
+            };
+            const result = await interceptor.parseMultipart(mockReq);
+            expect(result.fields).toBeDefined();
+            expect(result.files).toBeDefined();
+        });
+        it('should handle request error', async () => {
+            const interceptor = new file_upload_1.FileUploadInterceptor();
+            const error = new Error('Request error');
+            const mockReq = {
+                headers: {
+                    'content-type': 'multipart/form-data; boundary=test',
+                },
+                on: jest.fn((event, handler) => {
+                    if (event === 'error') {
+                        handler(error);
+                    }
+                }),
+            };
+            await expect(interceptor.parseMultipart(mockReq)).rejects.toThrow('Request error');
+        });
+    });
+    describe('extractBoundary', () => {
+        it('should extract boundary from content type', () => {
+            const interceptor = new file_upload_1.FileUploadInterceptor();
+            const contentType = 'multipart/form-data; boundary=----WebKitFormBoundary';
+            const boundary = interceptor.extractBoundary(contentType);
+            expect(boundary).toBe('----WebKitFormBoundary');
+        });
+        it('should trim boundary whitespace', () => {
+            const interceptor = new file_upload_1.FileUploadInterceptor();
+            const contentType = 'multipart/form-data; boundary= ----WebKitFormBoundary ';
+            const boundary = interceptor.extractBoundary(contentType);
+            expect(boundary).toBe('----WebKitFormBoundary');
+        });
+        it('should return null for missing boundary', () => {
+            const interceptor = new file_upload_1.FileUploadInterceptor();
+            const contentType = 'multipart/form-data';
+            const boundary = interceptor.extractBoundary(contentType);
+            expect(boundary).toBeNull();
+        });
+    });
+    describe('splitBuffer', () => {
+        it('should split buffer by boundary', () => {
+            const interceptor = new file_upload_1.FileUploadInterceptor();
+            const boundary = Buffer.from('--boundary');
+            const buffer = Buffer.from('part1--boundarypart2--boundarypart3');
+            const parts = interceptor.splitBuffer(buffer, boundary);
+            expect(parts.length).toBeGreaterThan(0);
+        });
+        it('should handle empty buffer', () => {
+            const interceptor = new file_upload_1.FileUploadInterceptor();
+            const boundary = Buffer.from('--boundary');
+            const buffer = Buffer.from('');
+            const parts = interceptor.splitBuffer(buffer, boundary);
+            expect(parts).toEqual([]);
+        });
+        it('should handle buffer without boundary', () => {
+            const interceptor = new file_upload_1.FileUploadInterceptor();
+            const boundary = Buffer.from('--boundary');
+            const buffer = Buffer.from('no boundary here');
+            const parts = interceptor.splitBuffer(buffer, boundary);
+            expect(parts).toEqual([]);
+        });
+    });
+    describe('parsePart', () => {
+        it('should parse part with headers and body', () => {
+            const interceptor = new file_upload_1.FileUploadInterceptor();
+            const part = Buffer.from('Content-Disposition: form-data; name="field"\r\n' +
+                'Content-Type: text/plain\r\n' +
+                '\r\n' +
+                'body content');
+            const result = interceptor.parsePart(part);
+            expect(result.headers).toBeDefined();
+            expect(result.headers['content-disposition']).toContain('form-data');
+            expect(result.body.toString()).toBe('body content');
+        });
+        it('should handle part without headers', () => {
+            const interceptor = new file_upload_1.FileUploadInterceptor();
+            const part = Buffer.from('just body');
+            const result = interceptor.parsePart(part);
+            expect(result.headers).toEqual({});
+            expect(result.body).toEqual(part);
+        });
+        it('should parse multiple headers', () => {
+            const interceptor = new file_upload_1.FileUploadInterceptor();
+            const part = Buffer.from('Content-Disposition: form-data\r\n' +
+                'Content-Type: application/json\r\n' +
+                'X-Custom-Header: value\r\n' +
+                '\r\n' +
+                'body');
+            const result = interceptor.parsePart(part);
+            expect(result.headers['content-disposition']).toBe('form-data');
+            expect(result.headers['content-type']).toBe('application/json');
+            expect(result.headers['x-custom-header']).toBe('value');
+        });
+    });
+    describe('processFile', () => {
+        it('should process file with disk storage', async () => {
+            fs.promises.writeFile.mockResolvedValue(undefined);
+            const interceptor = new file_upload_1.FileUploadInterceptor({
+                storage: 'disk',
+                destination: uploadDir,
+            });
+            const file = {
+                fieldname: 'file',
+                originalname: 'test.txt',
+                encoding: '7bit',
+                mimetype: 'text/plain',
+                size: 100,
+                buffer: Buffer.from('test content'),
+            };
+            const result = await interceptor.processFile(file);
+            expect(result).toBeDefined();
+            expect(result.originalname).toBe('test.txt');
+            expect(result.destination).toBe(uploadDir);
+            expect(fs.promises.writeFile).toHaveBeenCalled();
+        });
+        it('should process file with memory storage', async () => {
+            const interceptor = new file_upload_1.FileUploadInterceptor({
+                storage: 'memory',
+            });
+            const file = {
+                fieldname: 'file',
+                originalname: 'test.txt',
+                encoding: '7bit',
+                mimetype: 'text/plain',
+                size: 100,
+                buffer: Buffer.from('test content'),
+            };
+            const result = await interceptor.processFile(file);
+            expect(result).toBeDefined();
+            expect(result.buffer).toBeDefined();
+            expect(fs.promises.writeFile).not.toHaveBeenCalled();
+        });
+        it('should reject file by filter', async () => {
+            const fileFilter = jest.fn(() => false);
+            const interceptor = new file_upload_1.FileUploadInterceptor({
+                fileFilter,
+            });
+            const file = {
+                fieldname: 'file',
+                originalname: 'test.exe',
+                encoding: '7bit',
+                mimetype: 'application/x-msdownload',
+                size: 100,
+                buffer: Buffer.from('test'),
+            };
+            const result = await interceptor.processFile(file);
+            expect(result).toBeNull();
+            expect(fileFilter).toHaveBeenCalledWith(file);
+        });
+        it('should throw error for file too large', async () => {
+            const interceptor = new file_upload_1.FileUploadInterceptor({
+                limits: {
+                    fileSize: 50,
+                },
+            });
+            const file = {
+                fieldname: 'file',
+                originalname: 'large.txt',
+                encoding: '7bit',
+                mimetype: 'text/plain',
+                size: 100,
+                buffer: Buffer.from('x'.repeat(100)),
+            };
+            await expect(interceptor.processFile(file)).rejects.toThrow('File too large');
+        });
+        it('should use custom filename function', async () => {
+            const customFilename = jest.fn(() => 'custom-123.txt');
+            const interceptor = new file_upload_1.FileUploadInterceptor({
+                storage: 'memory',
+                filename: customFilename,
+            });
+            const file = {
+                fieldname: 'file',
+                originalname: 'original.txt',
+                encoding: '7bit',
+                mimetype: 'text/plain',
+                size: 100,
+                buffer: Buffer.from('test'),
+            };
+            const result = await interceptor.processFile(file);
+            expect(customFilename).toHaveBeenCalledWith(file);
+            expect(result.filename).toBe('custom-123.txt');
+        });
+    });
+    describe('defaultFilename', () => {
+        it('should generate unique filename', () => {
+            const interceptor = new file_upload_1.FileUploadInterceptor();
+            const file = {
+                originalname: 'test.txt',
+            };
+            const filename1 = interceptor.defaultFilename(file);
+            const filename2 = interceptor.defaultFilename(file);
+            expect(filename1).toContain('.txt');
+            expect(filename2).toContain('.txt');
+            expect(filename1).not.toBe(filename2);
+        });
+        it('should preserve file extension', () => {
+            const interceptor = new file_upload_1.FileUploadInterceptor();
+            const file = {
+                originalname: 'document.pdf',
+            };
+            const filename = interceptor.defaultFilename(file);
+            expect(filename).toContain('.pdf');
+        });
+        it('should handle files without extension', () => {
+            const interceptor = new file_upload_1.FileUploadInterceptor();
+            const file = {
+                originalname: 'README',
+            };
+            const filename = interceptor.defaultFilename(file);
+            expect(filename).toBeDefined();
+            expect(filename).not.toContain('.');
+        });
+    });
+});
+describe('UploadedFileDecorator', () => {
+    it('should set metadata for file parameter', () => {
+        class TestController {
+            upload(file) {
+                return file;
+            }
+        }
+        __decorate([
+            __param(0, (0, file_upload_1.UploadedFileDecorator)('avatar')),
+            __metadata("design:type", Function),
+            __metadata("design:paramtypes", [Object]),
+            __metadata("design:returntype", void 0)
+        ], TestController.prototype, "upload", null);
+        const metadata = Reflect.getMetadata('hazel:inject', TestController, 'upload');
+        expect(metadata).toBeDefined();
+        expect(metadata[0]).toEqual({
+            type: 'file',
+            fieldname: 'avatar',
+        });
+    });
+    it('should work without fieldname', () => {
+        class TestController {
+            upload(file) {
+                return file;
+            }
+        }
+        __decorate([
+            __param(0, (0, file_upload_1.UploadedFileDecorator)()),
+            __metadata("design:type", Function),
+            __metadata("design:paramtypes", [Object]),
+            __metadata("design:returntype", void 0)
+        ], TestController.prototype, "upload", null);
+        const metadata = Reflect.getMetadata('hazel:inject', TestController, 'upload');
+        expect(metadata).toBeDefined();
+        expect(metadata[0].type).toBe('file');
+    });
+    it('should throw error when used outside method parameter', () => {
+        expect(() => {
+            const decorator = (0, file_upload_1.UploadedFileDecorator)();
+            decorator({}, undefined, 0);
+        }).toThrow('UploadedFile decorator must be used on a method parameter');
+    });
+});
+describe('UploadedFilesDecorator', () => {
+    it('should set metadata for files parameter', () => {
+        class TestController {
+            uploadMultiple(files) {
+                return files;
+            }
+        }
+        __decorate([
+            __param(0, (0, file_upload_1.UploadedFilesDecorator)('photos')),
+            __metadata("design:type", Function),
+            __metadata("design:paramtypes", [Object]),
+            __metadata("design:returntype", void 0)
+        ], TestController.prototype, "uploadMultiple", null);
+        const metadata = Reflect.getMetadata('hazel:inject', TestController, 'uploadMultiple');
+        expect(metadata).toBeDefined();
+        expect(metadata[0]).toEqual({
+            type: 'files',
+            fieldname: 'photos',
+        });
+    });
+    it('should work without fieldname', () => {
+        class TestController {
+            uploadMultiple(files) {
+                return files;
+            }
+        }
+        __decorate([
+            __param(0, (0, file_upload_1.UploadedFilesDecorator)()),
+            __metadata("design:type", Function),
+            __metadata("design:paramtypes", [Object]),
+            __metadata("design:returntype", void 0)
+        ], TestController.prototype, "uploadMultiple", null);
+        const metadata = Reflect.getMetadata('hazel:inject', TestController, 'uploadMultiple');
+        expect(metadata).toBeDefined();
+        expect(metadata[0].type).toBe('files');
+    });
+    it('should throw error when used outside method parameter', () => {
+        expect(() => {
+            const decorator = (0, file_upload_1.UploadedFilesDecorator)();
+            decorator({}, undefined, 0);
+        }).toThrow('UploadedFiles decorator must be used on a method parameter');
+    });
+    it('should handle multiple parameters', () => {
+        class TestController {
+            upload(avatar, photos) {
+                return { avatar, photos };
+            }
+        }
+        __decorate([
+            __param(0, (0, file_upload_1.UploadedFileDecorator)('avatar')),
+            __param(1, (0, file_upload_1.UploadedFilesDecorator)('photos')),
+            __metadata("design:type", Function),
+            __metadata("design:paramtypes", [Object, Object]),
+            __metadata("design:returntype", void 0)
+        ], TestController.prototype, "upload", null);
+        const metadata = Reflect.getMetadata('hazel:inject', TestController, 'upload');
+        expect(metadata).toBeDefined();
+        expect(metadata[0].type).toBe('file');
+        expect(metadata[1].type).toBe('files');
+    });
+});

package/dist/__tests__/utils/sanitize.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=sanitize.test.d.ts.map

package/dist/__tests__/utils/sanitize.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sanitize.test.d.ts","sourceRoot":"","sources":["../../../src/__tests__/utils/sanitize.test.ts"],"names":[],"mappings":""}