@hazeljs/core 0.2.0-beta.1

package/dist/__tests__/errors/http.error.test.d.ts

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

package/dist/__tests__/errors/http.error.test.d.ts.map

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

package/dist/__tests__/errors/http.error.test.js

@@ -0,0 +1,117 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const http_error_1 = require("../../errors/http.error");
+describe('HTTP Errors', () => {
+    describe('HttpError', () => {
+        it('should create error with status code and message', () => {
+            const error = new http_error_1.HttpError(418, "I'm a teapot");
+            expect(error).toBeInstanceOf(Error);
+            expect(error.statusCode).toBe(418);
+            expect(error.message).toBe("I'm a teapot");
+            expect(error.name).toBe('HttpError');
+        });
+        it('should include validation errors', () => {
+            const validationErrors = ['Field1 is required', 'Field2 is invalid'];
+            const error = new http_error_1.HttpError(400, 'Validation failed', validationErrors);
+            expect(error.errors).toEqual(validationErrors);
+        });
+        it('should work without validation errors', () => {
+            const error = new http_error_1.HttpError(500, 'Server error');
+            expect(error.errors).toBeUndefined();
+        });
+    });
+    describe('BadRequestError', () => {
+        it('should create 400 error', () => {
+            const error = new http_error_1.BadRequestError('Invalid input');
+            expect(error).toBeInstanceOf(http_error_1.HttpError);
+            expect(error.statusCode).toBe(400);
+            expect(error.message).toBe('Invalid input');
+            expect(error.name).toBe('BadRequestError');
+        });
+        it('should include validation errors', () => {
+            const validationErrors = ['Email is required'];
+            const error = new http_error_1.BadRequestError('Validation failed', validationErrors);
+            expect(error.errors).toEqual(validationErrors);
+        });
+    });
+    describe('UnauthorizedError', () => {
+        it('should create 401 error with default message', () => {
+            const error = new http_error_1.UnauthorizedError();
+            expect(error).toBeInstanceOf(http_error_1.HttpError);
+            expect(error.statusCode).toBe(401);
+            expect(error.message).toBe('Unauthorized');
+            expect(error.name).toBe('UnauthorizedError');
+        });
+        it('should create 401 error with custom message', () => {
+            const error = new http_error_1.UnauthorizedError('Invalid token');
+            expect(error.statusCode).toBe(401);
+            expect(error.message).toBe('Invalid token');
+        });
+    });
+    describe('ForbiddenError', () => {
+        it('should create 403 error with default message', () => {
+            const error = new http_error_1.ForbiddenError();
+            expect(error).toBeInstanceOf(http_error_1.HttpError);
+            expect(error.statusCode).toBe(403);
+            expect(error.message).toBe('Forbidden');
+            expect(error.name).toBe('ForbiddenError');
+        });
+        it('should create 403 error with custom message', () => {
+            const error = new http_error_1.ForbiddenError('Access denied');
+            expect(error.statusCode).toBe(403);
+            expect(error.message).toBe('Access denied');
+        });
+    });
+    describe('NotFoundError', () => {
+        it('should create 404 error with default message', () => {
+            const error = new http_error_1.NotFoundError();
+            expect(error).toBeInstanceOf(http_error_1.HttpError);
+            expect(error.statusCode).toBe(404);
+            expect(error.message).toBe('Not Found');
+            expect(error.name).toBe('NotFoundError');
+        });
+        it('should create 404 error with custom message', () => {
+            const error = new http_error_1.NotFoundError('User not found');
+            expect(error.statusCode).toBe(404);
+            expect(error.message).toBe('User not found');
+        });
+    });
+    describe('ConflictError', () => {
+        it('should create 409 error', () => {
+            const error = new http_error_1.ConflictError('Resource already exists');
+            expect(error).toBeInstanceOf(http_error_1.HttpError);
+            expect(error.statusCode).toBe(409);
+            expect(error.message).toBe('Resource already exists');
+            expect(error.name).toBe('ConflictError');
+        });
+    });
+    describe('InternalServerError', () => {
+        it('should create 500 error with default message', () => {
+            const error = new http_error_1.InternalServerError();
+            expect(error).toBeInstanceOf(http_error_1.HttpError);
+            expect(error.statusCode).toBe(500);
+            expect(error.message).toBe('Internal Server Error');
+            expect(error.name).toBe('InternalServerError');
+        });
+        it('should create 500 error with custom message', () => {
+            const error = new http_error_1.InternalServerError('Database connection failed');
+            expect(error.statusCode).toBe(500);
+            expect(error.message).toBe('Database connection failed');
+        });
+    });
+    describe('Error inheritance', () => {
+        it('should be catchable as Error', () => {
+            const error = new http_error_1.BadRequestError('test');
+            expect(error instanceof Error).toBe(true);
+        });
+        it('should be catchable as HttpError', () => {
+            const error = new http_error_1.NotFoundError('test');
+            expect(error instanceof http_error_1.HttpError).toBe(true);
+        });
+        it('should have proper stack trace', () => {
+            const error = new http_error_1.InternalServerError('test');
+            expect(error.stack).toBeDefined();
+            expect(error.stack).toContain('InternalServerError');
+        });
+    });
+});

package/dist/__tests__/filters/exception-filter.test.d.ts

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

package/dist/__tests__/filters/exception-filter.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"exception-filter.test.d.ts","sourceRoot":"","sources":["../../../src/__tests__/filters/exception-filter.test.ts"],"names":[],"mappings":"AAMA,OAAO,kBAAkB,CAAC"}

package/dist/__tests__/filters/exception-filter.test.js

@@ -0,0 +1,135 @@
+"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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const exception_filter_1 = require("../../filters/exception-filter");
+require("reflect-metadata");
+describe('Exception Filters', () => {
+    let mockReq;
+    let mockRes;
+    beforeEach(() => {
+        mockReq = {
+            method: 'GET',
+            url: '/test',
+            headers: {},
+        };
+        mockRes = {
+            status: jest.fn().mockReturnThis(),
+            json: jest.fn(),
+            setHeader: jest.fn(),
+        };
+    });
+    describe('ArgumentsHostImpl', () => {
+        it('should create arguments host', () => {
+            const host = new exception_filter_1.ArgumentsHostImpl(mockReq, mockRes);
+            expect(host).toBeDefined();
+        });
+        it('should switch to HTTP context', () => {
+            const host = new exception_filter_1.ArgumentsHostImpl(mockReq, mockRes);
+            const http = host.switchToHttp();
+            expect(http).toBeDefined();
+            expect(typeof http.getRequest).toBe('function');
+            expect(typeof http.getResponse).toBe('function');
+        });
+        it('should get request from HTTP context', () => {
+            const host = new exception_filter_1.ArgumentsHostImpl(mockReq, mockRes);
+            const http = host.switchToHttp();
+            const request = http.getRequest();
+            expect(request).toBe(mockReq);
+        });
+        it('should get response from HTTP context', () => {
+            const host = new exception_filter_1.ArgumentsHostImpl(mockReq, mockRes);
+            const http = host.switchToHttp();
+            const response = http.getResponse();
+            expect(response).toBe(mockRes);
+        });
+        it('should return http type', () => {
+            const host = new exception_filter_1.ArgumentsHostImpl(mockReq, mockRes);
+            expect(host.getType()).toBe('http');
+        });
+        it('should support generic types', () => {
+            const host = new exception_filter_1.ArgumentsHostImpl(mockReq, mockRes);
+            const http = host.switchToHttp();
+            const request = http.getRequest();
+            const response = http.getResponse();
+            expect(request).toBe(mockReq);
+            expect(response).toBe(mockRes);
+        });
+    });
+    describe('Catch decorator', () => {
+        it('should mark class with exception metadata', () => {
+            class CustomError extends Error {
+            }
+            let TestFilter = class TestFilter {
+            };
+            TestFilter = __decorate([
+                (0, exception_filter_1.Catch)(CustomError)
+            ], TestFilter);
+            const metadata = Reflect.getMetadata('hazel:exception-filter', TestFilter);
+            expect(metadata).toEqual([CustomError]);
+        });
+        it('should support multiple exception types', () => {
+            class ErrorA extends Error {
+            }
+            class ErrorB extends Error {
+            }
+            let TestFilter = class TestFilter {
+            };
+            TestFilter = __decorate([
+                (0, exception_filter_1.Catch)(ErrorA, ErrorB)
+            ], TestFilter);
+            const metadata = Reflect.getMetadata('hazel:exception-filter', TestFilter);
+            expect(metadata).toEqual([ErrorA, ErrorB]);
+        });
+        it('should work with no exceptions', () => {
+            let TestFilter = class TestFilter {
+            };
+            TestFilter = __decorate([
+                (0, exception_filter_1.Catch)()
+            ], TestFilter);
+            const metadata = Reflect.getMetadata('hazel:exception-filter', TestFilter);
+            expect(metadata).toEqual([]);
+        });
+    });
+    describe('getFilterExceptions', () => {
+        it('should get exceptions from filter', () => {
+            class CustomError extends Error {
+            }
+            let TestFilter = class TestFilter {
+            };
+            TestFilter = __decorate([
+                (0, exception_filter_1.Catch)(CustomError)
+            ], TestFilter);
+            const filter = new TestFilter();
+            const exceptions = (0, exception_filter_1.getFilterExceptions)(filter);
+            expect(exceptions).toEqual([CustomError]);
+        });
+        it('should return empty array if no metadata', () => {
+            class TestFilter {
+            }
+            const filter = new TestFilter();
+            const exceptions = (0, exception_filter_1.getFilterExceptions)(filter);
+            expect(exceptions).toEqual([]);
+        });
+        it('should get multiple exceptions', () => {
+            class ErrorA extends Error {
+            }
+            class ErrorB extends Error {
+            }
+            class ErrorC extends Error {
+            }
+            let TestFilter = class TestFilter {
+            };
+            TestFilter = __decorate([
+                (0, exception_filter_1.Catch)(ErrorA, ErrorB, ErrorC)
+            ], TestFilter);
+            const filter = new TestFilter();
+            const exceptions = (0, exception_filter_1.getFilterExceptions)(filter);
+            expect(exceptions).toEqual([ErrorA, ErrorB, ErrorC]);
+        });
+    });
+});

package/dist/__tests__/filters/http-exception.filter.test.d.ts

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

package/dist/__tests__/filters/http-exception.filter.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"http-exception.filter.test.d.ts","sourceRoot":"","sources":["../../../src/__tests__/filters/http-exception.filter.test.ts"],"names":[],"mappings":"AAAA,OAAO,kBAAkB,CAAC"}

package/dist/__tests__/filters/http-exception.filter.test.js

@@ -0,0 +1,119 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+require("reflect-metadata");
+const http_exception_filter_1 = require("../../filters/http-exception.filter");
+const exception_filter_1 = require("../../filters/exception-filter");
+const http_error_1 = require("../../errors/http.error");
+// Mock logger
+jest.mock('../../logger', () => ({
+    error: jest.fn(),
+    debug: jest.fn(),
+}));
+describe('HttpExceptionFilter', () => {
+    let filter;
+    let mockReq;
+    let mockRes;
+    beforeEach(() => {
+        filter = new http_exception_filter_1.HttpExceptionFilter();
+        mockReq = {
+            method: 'GET',
+            url: '/test',
+            headers: {},
+        };
+        mockRes = {
+            status: jest.fn().mockReturnThis(),
+            json: jest.fn(),
+            setHeader: jest.fn(),
+        };
+    });
+    it('should catch HttpError and send response', () => {
+        const error = new http_error_1.HttpError(400, 'Bad request');
+        const host = new exception_filter_1.ArgumentsHostImpl(mockReq, mockRes);
+        filter.catch(error, host);
+        expect(mockRes.status).toHaveBeenCalledWith(400);
+        expect(mockRes.json).toHaveBeenCalledWith({
+            statusCode: 400,
+            message: 'Bad request',
+            timestamp: expect.any(String),
+            path: '/test',
+        });
+    });
+    it('should handle BadRequestError', () => {
+        const error = new http_error_1.BadRequestError('Invalid input');
+        const host = new exception_filter_1.ArgumentsHostImpl(mockReq, mockRes);
+        filter.catch(error, host);
+        expect(mockRes.status).toHaveBeenCalledWith(400);
+        expect(mockRes.json).toHaveBeenCalledWith({
+            statusCode: 400,
+            message: 'Invalid input',
+            timestamp: expect.any(String),
+            path: '/test',
+        });
+    });
+    it('should handle NotFoundError', () => {
+        const error = new http_error_1.NotFoundError('Resource not found');
+        const host = new exception_filter_1.ArgumentsHostImpl(mockReq, mockRes);
+        filter.catch(error, host);
+        expect(mockRes.status).toHaveBeenCalledWith(404);
+        expect(mockRes.json).toHaveBeenCalledWith({
+            statusCode: 404,
+            message: 'Resource not found',
+            timestamp: expect.any(String),
+            path: '/test',
+        });
+    });
+    it('should include validation errors if present', () => {
+        const validationErrors = ['Field1 is required', 'Field2 is invalid'];
+        const error = new http_error_1.HttpError(400, 'Validation failed', validationErrors);
+        const host = new exception_filter_1.ArgumentsHostImpl(mockReq, mockRes);
+        filter.catch(error, host);
+        expect(mockRes.json).toHaveBeenCalledWith({
+            statusCode: 400,
+            message: 'Validation failed',
+            timestamp: expect.any(String),
+            path: '/test',
+            errors: validationErrors,
+        });
+    });
+    it('should use 500 status code if not provided', () => {
+        const error = new http_error_1.HttpError(0, 'Unknown error');
+        error.statusCode = undefined;
+        const host = new exception_filter_1.ArgumentsHostImpl(mockReq, mockRes);
+        filter.catch(error, host);
+        expect(mockRes.status).toHaveBeenCalledWith(500);
+    });
+    it('should use default message if not provided', () => {
+        const error = new http_error_1.HttpError(500, '');
+        error.message = undefined;
+        const host = new exception_filter_1.ArgumentsHostImpl(mockReq, mockRes);
+        filter.catch(error, host);
+        expect(mockRes.json).toHaveBeenCalledWith(expect.objectContaining({
+            message: 'Internal server error',
+        }));
+    });
+    it('should include timestamp in ISO format', () => {
+        const error = new http_error_1.HttpError(400, 'Test error');
+        const host = new exception_filter_1.ArgumentsHostImpl(mockReq, mockRes);
+        filter.catch(error, host);
+        const callArgs = mockRes.json.mock.calls[0][0];
+        const timestamp = new Date(callArgs.timestamp);
+        expect(timestamp.toISOString()).toBe(callArgs.timestamp);
+    });
+    it('should include request path', () => {
+        mockReq.url = '/api/users/123';
+        const error = new http_error_1.HttpError(404, 'User not found');
+        const host = new exception_filter_1.ArgumentsHostImpl(mockReq, mockRes);
+        filter.catch(error, host);
+        expect(mockRes.json).toHaveBeenCalledWith(expect.objectContaining({
+            path: '/api/users/123',
+        }));
+    });
+    it('should handle POST requests', () => {
+        mockReq.method = 'POST';
+        mockReq.url = '/api/users';
+        const error = new http_error_1.BadRequestError('Invalid data');
+        const host = new exception_filter_1.ArgumentsHostImpl(mockReq, mockRes);
+        filter.catch(error, host);
+        expect(mockRes.status).toHaveBeenCalledWith(400);
+    });
+});

package/dist/__tests__/hazel-app.test.d.ts

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

package/dist/__tests__/hazel-app.test.d.ts.map

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