@hazeljs/core 0.2.0-beta.1

package/dist/__tests__/pipes/pipe.test.js

@@ -0,0 +1,245 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const pipe_1 = require("../../pipes/pipe");
+// Mock logger
+jest.mock('../../logger', () => ({
+    debug: jest.fn(),
+    error: jest.fn(),
+}));
+describe('Pipes', () => {
+    let context;
+    beforeEach(() => {
+        context = {
+            method: 'GET',
+            url: '/test',
+            headers: {},
+            params: { id: '123' },
+            query: {},
+            body: {},
+        };
+    });
+    describe('ValidationError', () => {
+        it('should create validation error with message and errors', () => {
+            const errors = [
+                {
+                    property: 'email',
+                    constraints: { isEmail: 'email must be a valid email' },
+                    value: 'invalid',
+                },
+            ];
+            const error = new pipe_1.ValidationError('Validation failed', errors);
+            expect(error.message).toBe('Validation failed');
+            expect(error.errors).toEqual(errors);
+            expect(error.name).toBe('ValidationError');
+        });
+        it('should convert to JSON format', () => {
+            const errors = [
+                {
+                    property: 'email',
+                    constraints: {
+                        isEmail: 'email must be a valid email',
+                        isNotEmpty: 'email should not be empty',
+                    },
+                    value: 'invalid',
+                },
+                {
+                    property: 'age',
+                    constraints: { isInt: 'age must be an integer' },
+                    value: 'abc',
+                },
+            ];
+            const error = new pipe_1.ValidationError('Validation failed', errors);
+            const json = error.toJSON();
+            expect(json).toEqual({
+                message: 'Validation failed',
+                errors: [
+                    {
+                        field: 'email',
+                        messages: ['email must be a valid email', 'email should not be empty'],
+                        value: 'invalid',
+                    },
+                    {
+                        field: 'age',
+                        messages: ['age must be an integer'],
+                        value: 'abc',
+                    },
+                ],
+            });
+        });
+    });
+    describe('ParseIntPipe', () => {
+        let pipe;
+        beforeEach(() => {
+            pipe = new pipe_1.ParseIntPipe();
+        });
+        it('should parse valid integer string', () => {
+            const result = pipe.transform('123', context);
+            expect(result).toBe(123);
+        });
+        it('should parse negative integers', () => {
+            const result = pipe.transform('-456', context);
+            expect(result).toBe(-456);
+        });
+        it('should parse zero', () => {
+            const result = pipe.transform('0', context);
+            expect(result).toBe(0);
+        });
+        it('should throw error for empty string', () => {
+            expect(() => pipe.transform('', context)).toThrow(pipe_1.ValidationError);
+        });
+        it('should throw error for non-numeric string', () => {
+            expect(() => pipe.transform('abc', context)).toThrow(pipe_1.ValidationError);
+        });
+        it('should throw error for float string', () => {
+            const result = pipe.transform('123.45', context);
+            // parseInt truncates, so this should return 123
+            expect(result).toBe(123);
+        });
+        it('should throw error for null/undefined', () => {
+            expect(() => pipe.transform(null, context)).toThrow(pipe_1.ValidationError);
+        });
+        it('should include proper error details', () => {
+            try {
+                pipe.transform('invalid', context);
+                fail('Should have thrown error');
+            }
+            catch (error) {
+                expect(error).toBeInstanceOf(pipe_1.ValidationError);
+                const validationError = error;
+                expect(validationError.errors[0].property).toBe('id');
+                expect(validationError.errors[0].constraints.isInt).toBeDefined();
+            }
+        });
+    });
+    describe('ParseFloatPipe', () => {
+        let pipe;
+        beforeEach(() => {
+            pipe = new pipe_1.ParseFloatPipe();
+        });
+        it('should parse valid float string', () => {
+            const result = pipe.transform('123.45', context);
+            expect(result).toBe(123.45);
+        });
+        it('should parse integer as float', () => {
+            const result = pipe.transform('100', context);
+            expect(result).toBe(100);
+        });
+        it('should parse negative floats', () => {
+            const result = pipe.transform('-99.99', context);
+            expect(result).toBe(-99.99);
+        });
+        it('should parse scientific notation', () => {
+            const result = pipe.transform('1.5e2', context);
+            expect(result).toBe(150);
+        });
+        it('should throw error for non-numeric string', () => {
+            expect(() => pipe.transform('abc', context)).toThrow(pipe_1.ValidationError);
+        });
+        it('should throw error for empty string', () => {
+            expect(() => pipe.transform('', context)).toThrow(pipe_1.ValidationError);
+        });
+        it('should include proper error details', () => {
+            try {
+                pipe.transform('invalid', context);
+                fail('Should have thrown error');
+            }
+            catch (error) {
+                expect(error).toBeInstanceOf(pipe_1.ValidationError);
+                const validationError = error;
+                expect(validationError.errors[0].constraints.isFloat).toBeDefined();
+            }
+        });
+    });
+    describe('ParseBoolPipe', () => {
+        let pipe;
+        beforeEach(() => {
+            pipe = new pipe_1.ParseBoolPipe();
+        });
+        it('should parse "true" string to true', () => {
+            const result = pipe.transform('true', context);
+            expect(result).toBe(true);
+        });
+        it('should parse "false" string to false', () => {
+            const result = pipe.transform('false', context);
+            expect(result).toBe(false);
+        });
+        it('should throw error for "1"', () => {
+            expect(() => pipe.transform('1', context)).toThrow(pipe_1.ValidationError);
+        });
+        it('should throw error for "0"', () => {
+            expect(() => pipe.transform('0', context)).toThrow(pipe_1.ValidationError);
+        });
+        it('should throw error for "yes"', () => {
+            expect(() => pipe.transform('yes', context)).toThrow(pipe_1.ValidationError);
+        });
+        it('should throw error for empty string', () => {
+            expect(() => pipe.transform('', context)).toThrow(pipe_1.ValidationError);
+        });
+        it('should throw error for invalid boolean string', () => {
+            expect(() => pipe.transform('invalid', context)).toThrow(pipe_1.ValidationError);
+        });
+        it('should include proper error details', () => {
+            try {
+                pipe.transform('invalid', context);
+                fail('Should have thrown error');
+            }
+            catch (error) {
+                expect(error).toBeInstanceOf(pipe_1.ValidationError);
+                const validationError = error;
+                expect(validationError.errors[0].constraints.isBoolean).toBeDefined();
+            }
+        });
+    });
+    describe('DefaultValuePipe', () => {
+        it('should return default value for undefined', () => {
+            const pipe = new pipe_1.DefaultValuePipe('default');
+            const result = pipe.transform(undefined);
+            expect(result).toBe('default');
+        });
+        it('should return actual value when defined', () => {
+            const pipe = new pipe_1.DefaultValuePipe('default');
+            const result = pipe.transform('actual');
+            expect(result).toBe('actual');
+        });
+        it('should work with number default', () => {
+            const pipe = new pipe_1.DefaultValuePipe(42);
+            expect(pipe.transform(undefined)).toBe(42);
+            expect(pipe.transform(10)).toBe(10);
+        });
+        it('should work with boolean default', () => {
+            const pipe = new pipe_1.DefaultValuePipe(true);
+            expect(pipe.transform(undefined)).toBe(true);
+            expect(pipe.transform(false)).toBe(false);
+        });
+        it('should work with object default', () => {
+            const defaultObj = { key: 'value' };
+            const pipe = new pipe_1.DefaultValuePipe(defaultObj);
+            expect(pipe.transform(undefined)).toBe(defaultObj);
+        });
+        it('should work with array default', () => {
+            const defaultArr = [1, 2, 3];
+            const pipe = new pipe_1.DefaultValuePipe(defaultArr);
+            expect(pipe.transform(undefined)).toBe(defaultArr);
+        });
+        it('should not treat null as undefined', () => {
+            const pipe = new pipe_1.DefaultValuePipe('default');
+            const result = pipe.transform(null);
+            expect(result).toBe(null);
+        });
+        it('should not treat empty string as undefined', () => {
+            const pipe = new pipe_1.DefaultValuePipe('default');
+            const result = pipe.transform('');
+            expect(result).toBe('');
+        });
+        it('should not treat zero as undefined', () => {
+            const pipe = new pipe_1.DefaultValuePipe(42);
+            const result = pipe.transform(0);
+            expect(result).toBe(0);
+        });
+        it('should not treat false as undefined', () => {
+            const pipe = new pipe_1.DefaultValuePipe(true);
+            const result = pipe.transform(false);
+            expect(result).toBe(false);
+        });
+    });
+});

package/dist/__tests__/pipes/validation.pipe.test.d.ts

@@ -0,0 +1,2 @@
+import 'reflect-metadata';
+//# sourceMappingURL=validation.pipe.test.d.ts.map

package/dist/__tests__/pipes/validation.pipe.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validation.pipe.test.d.ts","sourceRoot":"","sources":["../../../src/__tests__/pipes/validation.pipe.test.ts"],"names":[],"mappings":"AAIA,OAAO,kBAAkB,CAAC"}

package/dist/__tests__/pipes/validation.pipe.test.js

@@ -0,0 +1,297 @@
+"use strict";
+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 __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const validation_pipe_1 = require("../../pipes/validation.pipe");
+const pipe_1 = require("../../pipes/pipe");
+const class_validator_1 = require("class-validator");
+require("reflect-metadata");
+// Mock logger
+jest.mock('../../logger', () => ({
+    debug: jest.fn(),
+    error: jest.fn(),
+    info: jest.fn(),
+    warn: jest.fn(),
+}));
+describe('ValidationPipe', () => {
+    let pipe;
+    beforeEach(() => {
+        pipe = new validation_pipe_1.ValidationPipe();
+    });
+    describe('transform', () => {
+        it('should return value as-is when no DTO type provided', async () => {
+            const value = { name: 'test' };
+            const context = {};
+            const result = await pipe.transform(value, context);
+            expect(result).toBe(value);
+        });
+        it('should return value as-is when DTO type is not a constructor', async () => {
+            const value = { name: 'test' };
+            const context = {
+                dtoType: 'not-a-constructor',
+            };
+            const result = await pipe.transform(value, context);
+            expect(result).toBe(value);
+        });
+        it('should validate and transform valid DTO', async () => {
+            class CreateUserDto {
+            }
+            __decorate([
+                (0, class_validator_1.IsString)(),
+                __metadata("design:type", String)
+            ], CreateUserDto.prototype, "name", void 0);
+            __decorate([
+                (0, class_validator_1.IsInt)(),
+                (0, class_validator_1.Min)(0),
+                __metadata("design:type", Number)
+            ], CreateUserDto.prototype, "age", void 0);
+            const value = { name: 'John', age: 25 };
+            const context = {
+                dtoType: CreateUserDto,
+            };
+            const result = await pipe.transform(value, context);
+            expect(result).toBeInstanceOf(CreateUserDto);
+            expect(result.name).toBe('John');
+            expect(result.age).toBe(25);
+        });
+        it('should throw ValidationError for invalid DTO', async () => {
+            class CreateUserDto {
+            }
+            __decorate([
+                (0, class_validator_1.IsString)(),
+                __metadata("design:type", String)
+            ], CreateUserDto.prototype, "name", void 0);
+            __decorate([
+                (0, class_validator_1.IsInt)(),
+                (0, class_validator_1.Min)(18),
+                __metadata("design:type", Number)
+            ], CreateUserDto.prototype, "age", void 0);
+            const value = { name: 'John', age: 15 };
+            const context = {
+                dtoType: CreateUserDto,
+            };
+            await expect(pipe.transform(value, context)).rejects.toThrow(pipe_1.ValidationError);
+        });
+        it('should throw ValidationError when value is not an object', async () => {
+            class CreateUserDto {
+            }
+            __decorate([
+                (0, class_validator_1.IsString)(),
+                __metadata("design:type", String)
+            ], CreateUserDto.prototype, "name", void 0);
+            const value = 'not an object';
+            const context = {
+                dtoType: CreateUserDto,
+            };
+            await expect(pipe.transform(value, context)).rejects.toThrow(pipe_1.ValidationError);
+            await expect(pipe.transform(value, context)).rejects.toThrow('Invalid input: expected an object');
+        });
+        it('should throw ValidationError when value is null', async () => {
+            class CreateUserDto {
+            }
+            __decorate([
+                (0, class_validator_1.IsString)(),
+                __metadata("design:type", String)
+            ], CreateUserDto.prototype, "name", void 0);
+            const value = null;
+            const context = {
+                dtoType: CreateUserDto,
+            };
+            await expect(pipe.transform(value, context)).rejects.toThrow(pipe_1.ValidationError);
+        });
+        it('should handle multiple validation errors', async () => {
+            class CreateUserDto {
+            }
+            __decorate([
+                (0, class_validator_1.IsString)(),
+                __metadata("design:type", String)
+            ], CreateUserDto.prototype, "name", void 0);
+            __decorate([
+                (0, class_validator_1.IsInt)(),
+                __metadata("design:type", Number)
+            ], CreateUserDto.prototype, "age", void 0);
+            __decorate([
+                (0, class_validator_1.IsEmail)(),
+                __metadata("design:type", String)
+            ], CreateUserDto.prototype, "email", void 0);
+            const value = { name: 123, age: 'not-a-number', email: 'invalid-email' };
+            const context = {
+                dtoType: CreateUserDto,
+            };
+            try {
+                await pipe.transform(value, context);
+                fail('Should have thrown ValidationError');
+            }
+            catch (error) {
+                expect(error).toBeInstanceOf(pipe_1.ValidationError);
+                const validationError = error;
+                expect(validationError.errors.length).toBeGreaterThan(0);
+            }
+        });
+        it('should handle empty constraints', async () => {
+            class CreateUserDto {
+            }
+            __decorate([
+                (0, class_validator_1.IsString)(),
+                __metadata("design:type", String)
+            ], CreateUserDto.prototype, "name", void 0);
+            const value = { name: 123 };
+            const context = {
+                dtoType: CreateUserDto,
+            };
+            try {
+                await pipe.transform(value, context);
+                fail('Should have thrown ValidationError');
+            }
+            catch (error) {
+                expect(error).toBeInstanceOf(pipe_1.ValidationError);
+            }
+        });
+        it('should transform nested objects', async () => {
+            class AddressDto {
+            }
+            __decorate([
+                (0, class_validator_1.IsString)(),
+                __metadata("design:type", String)
+            ], AddressDto.prototype, "street", void 0);
+            __decorate([
+                (0, class_validator_1.IsString)(),
+                __metadata("design:type", String)
+            ], AddressDto.prototype, "city", void 0);
+            class CreateUserDto {
+            }
+            __decorate([
+                (0, class_validator_1.IsString)(),
+                __metadata("design:type", String)
+            ], CreateUserDto.prototype, "name", void 0);
+            const value = {
+                name: 'John',
+                address: {
+                    street: '123 Main St',
+                    city: 'New York',
+                },
+            };
+            const context = {
+                dtoType: CreateUserDto,
+            };
+            const result = await pipe.transform(value, context);
+            expect(result).toBeInstanceOf(CreateUserDto);
+            expect(result.name).toBe('John');
+        });
+        it('should handle arrays in DTO', async () => {
+            class CreateUserDto {
+            }
+            __decorate([
+                (0, class_validator_1.IsString)(),
+                __metadata("design:type", String)
+            ], CreateUserDto.prototype, "name", void 0);
+            const value = {
+                name: 'John',
+                tags: ['developer', 'typescript'],
+            };
+            const context = {
+                dtoType: CreateUserDto,
+            };
+            const result = await pipe.transform(value, context);
+            expect(result).toBeInstanceOf(CreateUserDto);
+            expect(result.tags).toEqual(['developer', 'typescript']);
+        });
+        it('should validate email format', async () => {
+            class CreateUserDto {
+            }
+            __decorate([
+                (0, class_validator_1.IsEmail)(),
+                __metadata("design:type", String)
+            ], CreateUserDto.prototype, "email", void 0);
+            const validValue = { email: 'user@example.com' };
+            const invalidValue = { email: 'not-an-email' };
+            const context = {
+                dtoType: CreateUserDto,
+            };
+            const validResult = await pipe.transform(validValue, context);
+            expect(validResult).toBeInstanceOf(CreateUserDto);
+            await expect(pipe.transform(invalidValue, context)).rejects.toThrow(pipe_1.ValidationError);
+        });
+        it('should handle minimum value validation', async () => {
+            class CreateProductDto {
+            }
+            __decorate([
+                (0, class_validator_1.IsInt)(),
+                (0, class_validator_1.Min)(1),
+                __metadata("design:type", Number)
+            ], CreateProductDto.prototype, "quantity", void 0);
+            const validValue = { quantity: 5 };
+            const invalidValue = { quantity: 0 };
+            const context = {
+                dtoType: CreateProductDto,
+            };
+            const validResult = await pipe.transform(validValue, context);
+            expect(validResult).toBeInstanceOf(CreateProductDto);
+            await expect(pipe.transform(invalidValue, context)).rejects.toThrow(pipe_1.ValidationError);
+        });
+        it('should preserve extra properties', async () => {
+            class CreateUserDto {
+            }
+            __decorate([
+                (0, class_validator_1.IsString)(),
+                __metadata("design:type", String)
+            ], CreateUserDto.prototype, "name", void 0);
+            const value = { name: 'John', extra: 'property' };
+            const context = {
+                dtoType: CreateUserDto,
+            };
+            const result = await pipe.transform(value, context);
+            expect(result).toBeInstanceOf(CreateUserDto);
+            expect(result.name).toBe('John');
+        });
+        it('should handle validation error with constraints', async () => {
+            class CreateUserDto {
+            }
+            __decorate([
+                (0, class_validator_1.IsString)(),
+                (0, class_validator_1.IsEmail)(),
+                __metadata("design:type", String)
+            ], CreateUserDto.prototype, "email", void 0);
+            const value = { email: 'invalid' };
+            const context = {
+                dtoType: CreateUserDto,
+            };
+            try {
+                await pipe.transform(value, context);
+                fail('Should have thrown ValidationError');
+            }
+            catch (error) {
+                expect(error).toBeInstanceOf(pipe_1.ValidationError);
+                const validationError = error;
+                expect(validationError.message).toBe('Validation failed');
+                expect(validationError.errors[0].property).toBe('email');
+            }
+        });
+        it('should rethrow caught errors', async () => {
+            class CreateUserDto {
+            }
+            __decorate([
+                (0, class_validator_1.IsString)(),
+                __metadata("design:type", String)
+            ], CreateUserDto.prototype, "name", void 0);
+            const value = { name: 123 };
+            const context = {
+                dtoType: CreateUserDto,
+            };
+            try {
+                await pipe.transform(value, context);
+                fail('Should have thrown error');
+            }
+            catch (error) {
+                expect(error).toBeDefined();
+            }
+        });
+    });
+});

package/dist/__tests__/request-parser.test.d.ts

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

package/dist/__tests__/request-parser.test.d.ts.map

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