@hazeljs/core 0.2.0-beta.1

package/dist/__tests__/health.test.js

@@ -0,0 +1,147 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const health_1 = require("../health");
+describe('HealthCheckManager', () => {
+    let healthManager;
+    beforeEach(() => {
+        healthManager = new health_1.HealthCheckManager();
+    });
+    describe('registerCheck', () => {
+        it('should register a health check', () => {
+            const check = {
+                name: 'test-check',
+                check: async () => ({ status: 'healthy' }),
+            };
+            healthManager.registerCheck(check);
+            expect(healthManager).toBeDefined();
+        });
+    });
+    describe('runChecks', () => {
+        it('should return healthy status when all checks pass', async () => {
+            healthManager.registerCheck({
+                name: 'check-1',
+                check: async () => ({ status: 'healthy' }),
+            });
+            healthManager.registerCheck({
+                name: 'check-2',
+                check: async () => ({ status: 'healthy' }),
+            });
+            const result = await healthManager.runChecks();
+            expect(result.status).toBe('healthy');
+            expect(result.checks['check-1'].status).toBe('healthy');
+            expect(result.checks['check-2'].status).toBe('healthy');
+        });
+        it('should return degraded status when non-critical check fails', async () => {
+            healthManager.registerCheck({
+                name: 'critical-check',
+                check: async () => ({ status: 'healthy' }),
+                critical: true,
+            });
+            healthManager.registerCheck({
+                name: 'non-critical-check',
+                check: async () => ({ status: 'degraded' }),
+                critical: false,
+            });
+            const result = await healthManager.runChecks();
+            expect(result.status).toBe('degraded');
+        });
+        it('should return unhealthy status when critical check fails', async () => {
+            healthManager.registerCheck({
+                name: 'critical-check',
+                check: async () => ({ status: 'unhealthy' }),
+                critical: true,
+            });
+            const result = await healthManager.runChecks();
+            expect(result.status).toBe('unhealthy');
+        });
+        it('should handle check timeouts', async () => {
+            healthManager.registerCheck({
+                name: 'slow-check',
+                check: async () => {
+                    await new Promise((resolve) => setTimeout(resolve, 100));
+                    return { status: 'healthy' };
+                },
+                timeout: 50,
+            });
+            const result = await healthManager.runChecks();
+            expect(result.checks['slow-check'].status).toBe('unhealthy');
+        });
+        it('should include response time in results', async () => {
+            healthManager.registerCheck({
+                name: 'fast-check',
+                check: async () => ({ status: 'healthy' }),
+            });
+            const result = await healthManager.runChecks();
+            expect(result.checks['fast-check'].responseTime).toBeDefined();
+            expect(typeof result.checks['fast-check'].responseTime).toBe('number');
+        });
+        it('should include timestamp and uptime', async () => {
+            const result = await healthManager.runChecks();
+            expect(result.timestamp).toBeDefined();
+            expect(result.uptime).toBeDefined();
+            expect(typeof result.uptime).toBe('number');
+        });
+    });
+    describe('getLiveness', () => {
+        it('should return alive status', async () => {
+            const result = await healthManager.getLiveness();
+            expect(result.status).toBe('alive');
+            expect(result.timestamp).toBeDefined();
+        });
+    });
+    describe('getReadiness', () => {
+        it('should run all checks', async () => {
+            healthManager.registerCheck({
+                name: 'test-check',
+                check: async () => ({ status: 'healthy' }),
+            });
+            const result = await healthManager.getReadiness();
+            expect(result.checks['test-check']).toBeDefined();
+        });
+    });
+    describe('getStartup', () => {
+        it('should return startup status', async () => {
+            const result = await healthManager.getStartup();
+            expect(result.status).toBe('started');
+            expect(result.uptime).toBeDefined();
+            expect(result.timestamp).toBeDefined();
+        });
+    });
+});
+describe('BuiltInHealthChecks', () => {
+    describe('memoryCheck', () => {
+        it('should return healthy when memory usage is below threshold', async () => {
+            const check = health_1.BuiltInHealthChecks.memoryCheck(10000); // 10GB threshold
+            const result = await check.check();
+            expect(result.status).toBe('healthy');
+            expect(result.details).toBeDefined();
+        });
+        it('should return degraded when memory usage is above threshold', async () => {
+            const check = health_1.BuiltInHealthChecks.memoryCheck(1); // 1MB threshold (very low)
+            const result = await check.check();
+            expect(result.status).toBe('degraded');
+            expect(result.message).toContain('High memory usage');
+        });
+        it('should include memory details', async () => {
+            const check = health_1.BuiltInHealthChecks.memoryCheck();
+            const result = await check.check();
+            expect(result.details).toBeDefined();
+            expect(result.details?.heapUsed).toBeDefined();
+            expect(result.details?.heapTotal).toBeDefined();
+        });
+    });
+    describe('eventLoopCheck', () => {
+        it('should return healthy when event loop lag is low', async () => {
+            const check = health_1.BuiltInHealthChecks.eventLoopCheck(1000); // 1 second threshold
+            const result = await check.check();
+            expect(result.status).toBe('healthy');
+            expect(result.details).toBeDefined();
+        });
+        it('should include lag details', async () => {
+            const check = health_1.BuiltInHealthChecks.eventLoopCheck();
+            const result = await check.check();
+            expect(result.details).toBeDefined();
+            expect(result.details?.lag).toBeDefined();
+        });
+    });
+});

package/dist/__tests__/index.test.d.ts

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

package/dist/__tests__/index.test.d.ts.map

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

package/dist/__tests__/index.test.js

@@ -0,0 +1,239 @@
+"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 __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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const HazelExports = __importStar(require("../index"));
+describe('Index exports', () => {
+    describe('main exports', () => {
+        it('should export HazelApp', () => {
+            expect(HazelExports.HazelApp).toBeDefined();
+        });
+        it('should export HazelModule', () => {
+            expect(HazelExports.HazelModule).toBeDefined();
+        });
+        it('should export Module', () => {
+            expect(HazelExports.Module).toBeDefined();
+        });
+    });
+    describe('decorator exports', () => {
+        it('should export Controller', () => {
+            expect(HazelExports.Controller).toBeDefined();
+        });
+        it('should export Injectable', () => {
+            expect(HazelExports.Injectable).toBeDefined();
+        });
+        it('should export Service', () => {
+            expect(HazelExports.Service).toBeDefined();
+        });
+        it('should export Get', () => {
+            expect(HazelExports.Get).toBeDefined();
+        });
+        it('should export Post', () => {
+            expect(HazelExports.Post).toBeDefined();
+        });
+        it('should export Put', () => {
+            expect(HazelExports.Put).toBeDefined();
+        });
+        it('should export Delete', () => {
+            expect(HazelExports.Delete).toBeDefined();
+        });
+        it('should export Patch', () => {
+            expect(HazelExports.Patch).toBeDefined();
+        });
+        it('should export Body', () => {
+            expect(HazelExports.Body).toBeDefined();
+        });
+        it('should export Param', () => {
+            expect(HazelExports.Param).toBeDefined();
+        });
+        it('should export Res', () => {
+            expect(HazelExports.Res).toBeDefined();
+        });
+        it('should export Inject', () => {
+            expect(HazelExports.Inject).toBeDefined();
+        });
+        it('should export UsePipes', () => {
+            expect(HazelExports.UsePipes).toBeDefined();
+        });
+        it('should export UseInterceptors', () => {
+            expect(HazelExports.UseInterceptors).toBeDefined();
+        });
+        it('should export UseGuards', () => {
+            expect(HazelExports.UseGuards).toBeDefined();
+        });
+    });
+    describe('container exports', () => {
+        it('should export Container', () => {
+            expect(HazelExports.Container).toBeDefined();
+        });
+        it('should export Scope', () => {
+            expect(HazelExports.Scope).toBeDefined();
+        });
+    });
+    describe('error exports', () => {
+        it('should export HttpError', () => {
+            expect(HazelExports.HttpError).toBeDefined();
+        });
+        it('should export BadRequestError', () => {
+            expect(HazelExports.BadRequestError).toBeDefined();
+        });
+        it('should export UnauthorizedError', () => {
+            expect(HazelExports.UnauthorizedError).toBeDefined();
+        });
+        it('should export ForbiddenError', () => {
+            expect(HazelExports.ForbiddenError).toBeDefined();
+        });
+        it('should export NotFoundError', () => {
+            expect(HazelExports.NotFoundError).toBeDefined();
+        });
+        it('should export InternalServerError', () => {
+            expect(HazelExports.InternalServerError).toBeDefined();
+        });
+    });
+    describe('pipe exports', () => {
+        it('should export ValidationPipe', () => {
+            expect(HazelExports.ValidationPipe).toBeDefined();
+        });
+        it('should export ParseIntPipe', () => {
+            expect(HazelExports.ParseIntPipe).toBeDefined();
+        });
+        it('should export ValidationError', () => {
+            expect(HazelExports.ValidationError).toBeDefined();
+        });
+    });
+    describe('middleware exports', () => {
+        it('should export CorsMiddleware', () => {
+            expect(HazelExports.CorsMiddleware).toBeDefined();
+        });
+        it('should export CsrfMiddleware', () => {
+            expect(HazelExports.CsrfMiddleware).toBeDefined();
+        });
+        it('should export RateLimitMiddleware', () => {
+            expect(HazelExports.RateLimitMiddleware).toBeDefined();
+        });
+        it('should export SecurityHeadersMiddleware', () => {
+            expect(HazelExports.SecurityHeadersMiddleware).toBeDefined();
+        });
+        it('should export TimeoutMiddleware', () => {
+            expect(HazelExports.TimeoutMiddleware).toBeDefined();
+        });
+    });
+    describe('filter exports', () => {
+        it('should export Catch', () => {
+            expect(HazelExports.Catch).toBeDefined();
+        });
+        it('should export HttpExceptionFilter', () => {
+            expect(HazelExports.HttpExceptionFilter).toBeDefined();
+        });
+    });
+    describe('interceptor exports', () => {
+        it('should have interceptor types exported', () => {
+            // Interceptor is exported as a type
+            expect(HazelExports).toBeDefined();
+        });
+    });
+    describe('testing exports', () => {
+        it('should export Test', () => {
+            expect(HazelExports.Test).toBeDefined();
+        });
+    });
+    describe('health exports', () => {
+        it('should export HealthCheckManager', () => {
+            expect(HazelExports.HealthCheckManager).toBeDefined();
+        });
+        it('should export BuiltInHealthChecks', () => {
+            expect(HazelExports.BuiltInHealthChecks).toBeDefined();
+        });
+    });
+    describe('shutdown exports', () => {
+        it('should export ShutdownManager', () => {
+            expect(HazelExports.ShutdownManager).toBeDefined();
+        });
+    });
+    describe('upload exports', () => {
+        it('should export FileUploadInterceptor', () => {
+            expect(HazelExports.FileUploadInterceptor).toBeDefined();
+        });
+        it('should export UploadedFile', () => {
+            expect(HazelExports.UploadedFile).toBeDefined();
+        });
+        it('should export UploadedFiles', () => {
+            expect(HazelExports.UploadedFiles).toBeDefined();
+        });
+    });
+    describe('utility exports', () => {
+        it('should export sanitizeHtml', () => {
+            expect(HazelExports.sanitizeHtml).toBeDefined();
+        });
+        it('should export sanitizeString', () => {
+            expect(HazelExports.sanitizeString).toBeDefined();
+        });
+        it('should export sanitizeUrl', () => {
+            expect(HazelExports.sanitizeUrl).toBeDefined();
+        });
+        it('should export sanitizeEmail', () => {
+            expect(HazelExports.sanitizeEmail).toBeDefined();
+        });
+        it('should export sanitizeObject', () => {
+            expect(HazelExports.sanitizeObject).toBeDefined();
+        });
+        it('should export escapeHtml', () => {
+            expect(HazelExports.escapeHtml).toBeDefined();
+        });
+    });
+    describe('type exports', () => {
+        it('should have type exports available', () => {
+            // Request and Response are type-only exports
+            expect(HazelExports).toBeDefined();
+        });
+    });
+    describe('all exports are functions or classes', () => {
+        it('should have callable decorators', () => {
+            expect(typeof HazelExports.Controller).toBe('function');
+            expect(typeof HazelExports.Get).toBe('function');
+            expect(typeof HazelExports.Post).toBe('function');
+            expect(typeof HazelExports.Injectable).toBe('function');
+        });
+        it('should have instantiable classes', () => {
+            expect(typeof HazelExports.HazelApp).toBe('function');
+            expect(typeof HazelExports.Container).toBe('function');
+            expect(typeof HazelExports.ValidationPipe).toBe('function');
+        });
+        it('should have utility functions', () => {
+            expect(typeof HazelExports.sanitizeHtml).toBe('function');
+            expect(typeof HazelExports.sanitizeString).toBe('function');
+            expect(typeof HazelExports.escapeHtml).toBe('function');
+        });
+    });
+});

package/dist/__tests__/interceptors/interceptor.test.d.ts

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

package/dist/__tests__/interceptors/interceptor.test.d.ts.map

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

package/dist/__tests__/interceptors/interceptor.test.js

@@ -0,0 +1,166 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const interceptor_1 = require("../../interceptors/interceptor");
+const logger_1 = __importDefault(require("../../logger"));
+// Mock logger
+jest.mock('../../logger', () => ({
+    info: jest.fn(),
+    error: jest.fn(),
+}));
+describe('Interceptors', () => {
+    let context;
+    beforeEach(() => {
+        context = {
+            method: 'GET',
+            url: '/test',
+            headers: {},
+            params: {},
+            query: {},
+            body: {},
+        };
+        jest.clearAllMocks();
+    });
+    describe('LoggingInterceptor', () => {
+        let interceptor;
+        beforeEach(() => {
+            interceptor = new interceptor_1.LoggingInterceptor();
+        });
+        it('should log request start', async () => {
+            const next = jest.fn().mockResolvedValue({ data: 'test' });
+            await interceptor.intercept(context, next);
+            expect(logger_1.default.info).toHaveBeenCalledWith('[GET] /test');
+        });
+        it('should log request completion with duration', async () => {
+            const next = jest.fn().mockResolvedValue({ data: 'test' });
+            await interceptor.intercept(context, next);
+            expect(logger_1.default.info).toHaveBeenCalledWith(expect.stringMatching(/\[GET\] \/test - \d+ms/));
+        });
+        it('should call next handler', async () => {
+            const next = jest.fn().mockResolvedValue({ data: 'test' });
+            await interceptor.intercept(context, next);
+            expect(next).toHaveBeenCalled();
+        });
+        it('should return result from next handler', async () => {
+            const expectedResult = { data: 'test' };
+            const next = jest.fn().mockResolvedValue(expectedResult);
+            const result = await interceptor.intercept(context, next);
+            expect(result).toBe(expectedResult);
+        });
+        it('should log errors with duration', async () => {
+            const error = new Error('Test error');
+            const next = jest.fn().mockRejectedValue(error);
+            await expect(interceptor.intercept(context, next)).rejects.toThrow('Test error');
+            expect(logger_1.default.error).toHaveBeenCalledWith(expect.stringMatching(/\[GET\] \/test - Test error \(\d+ms\)/));
+        });
+        it('should rethrow errors', async () => {
+            const error = new Error('Test error');
+            const next = jest.fn().mockRejectedValue(error);
+            await expect(interceptor.intercept(context, next)).rejects.toThrow(error);
+        });
+        it('should log POST requests', async () => {
+            context.method = 'POST';
+            context.url = '/api/users';
+            const next = jest.fn().mockResolvedValue({ id: 1 });
+            await interceptor.intercept(context, next);
+            expect(logger_1.default.info).toHaveBeenCalledWith('[POST] /api/users');
+        });
+    });
+    describe('CacheInterceptor', () => {
+        let interceptor;
+        beforeEach(() => {
+            interceptor = new interceptor_1.CacheInterceptor();
+            // Clear cache between tests
+            interceptor_1.CacheInterceptor.cache.clear();
+        });
+        it('should cache GET request results', async () => {
+            const next = jest.fn().mockResolvedValue({ data: 'test' });
+            const result1 = await interceptor.intercept(context, next);
+            const result2 = await interceptor.intercept(context, next);
+            expect(next).toHaveBeenCalledTimes(1);
+            expect(result1).toEqual(result2);
+        });
+        it('should not cache non-GET requests', async () => {
+            context.method = 'POST';
+            const next = jest.fn().mockResolvedValue({ data: 'test' });
+            await interceptor.intercept(context, next);
+            await interceptor.intercept(context, next);
+            expect(next).toHaveBeenCalledTimes(2);
+        });
+        it('should use custom TTL', async () => {
+            jest.useFakeTimers();
+            interceptor = new interceptor_1.CacheInterceptor({ ttl: 1000 });
+            const next = jest.fn().mockResolvedValue({ data: 'test' });
+            // First call - cache miss
+            await interceptor.intercept(context, next);
+            expect(next).toHaveBeenCalledTimes(1);
+            // Second call within TTL - cache hit
+            jest.advanceTimersByTime(500);
+            await interceptor.intercept(context, next);
+            expect(next).toHaveBeenCalledTimes(1);
+            // Third call after TTL - cache miss
+            jest.advanceTimersByTime(600);
+            await interceptor.intercept(context, next);
+            expect(next).toHaveBeenCalledTimes(2);
+            jest.useRealTimers();
+        });
+        it('should use default TTL of 60 seconds', async () => {
+            jest.useFakeTimers();
+            const next = jest.fn().mockResolvedValue({ data: 'test' });
+            await interceptor.intercept(context, next);
+            jest.advanceTimersByTime(59000);
+            await interceptor.intercept(context, next);
+            expect(next).toHaveBeenCalledTimes(1);
+            jest.useRealTimers();
+        });
+        it('should cache different URLs separately', async () => {
+            const next1 = jest.fn().mockResolvedValue({ data: 'test1' });
+            const next2 = jest.fn().mockResolvedValue({ data: 'test2' });
+            const context1 = { ...context, url: '/test1' };
+            const context2 = { ...context, url: '/test2' };
+            await interceptor.intercept(context1, next1);
+            await interceptor.intercept(context2, next2);
+            expect(next1).toHaveBeenCalledTimes(1);
+            expect(next2).toHaveBeenCalledTimes(1);
+        });
+        it('should return cached data', async () => {
+            const expectedData = { data: 'cached' };
+            const next = jest.fn().mockResolvedValue(expectedData);
+            const result1 = await interceptor.intercept(context, next);
+            const result2 = await interceptor.intercept(context, next);
+            expect(result1).toEqual(expectedData);
+            expect(result2).toEqual(expectedData);
+        });
+        it('should handle PUT requests without caching', async () => {
+            context.method = 'PUT';
+            const next = jest.fn().mockResolvedValue({ data: 'updated' });
+            await interceptor.intercept(context, next);
+            await interceptor.intercept(context, next);
+            expect(next).toHaveBeenCalledTimes(2);
+        });
+        it('should handle DELETE requests without caching', async () => {
+            context.method = 'DELETE';
+            const next = jest.fn().mockResolvedValue({ success: true });
+            await interceptor.intercept(context, next);
+            await interceptor.intercept(context, next);
+            expect(next).toHaveBeenCalledTimes(2);
+        });
+        it('should cache complex objects', async () => {
+            const complexData = {
+                users: [
+                    { id: 1, name: 'John' },
+                    { id: 2, name: 'Jane' },
+                ],
+                meta: { total: 2, page: 1 },
+            };
+            const next = jest.fn().mockResolvedValue(complexData);
+            const result1 = await interceptor.intercept(context, next);
+            const result2 = await interceptor.intercept(context, next);
+            expect(next).toHaveBeenCalledTimes(1);
+            expect(result1).toEqual(complexData);
+            expect(result2).toEqual(complexData);
+        });
+    });
+});

package/dist/__tests__/logger.test.d.ts

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

package/dist/__tests__/logger.test.d.ts.map

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