@hazeljs/core 0.2.0-beta.1

package/dist/__tests__/hazel-module.test.js

@@ -0,0 +1,408 @@
+"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 hazel_module_1 = require("../hazel-module");
+require("reflect-metadata");
+// Mock logger
+jest.mock('../logger', () => ({
+    debug: jest.fn(),
+    info: jest.fn(),
+    warn: jest.fn(),
+    error: jest.fn(),
+    isDebugEnabled: jest.fn().mockReturnValue(false),
+}));
+// Mock container
+jest.mock('../container', () => {
+    const actualContainer = jest.requireActual('../container');
+    return {
+        ...actualContainer,
+        Container: {
+            getInstance: jest.fn(() => actualContainer.Container.createTestInstance()),
+            createTestInstance: actualContainer.Container.createTestInstance,
+        },
+    };
+});
+describe('HazelModule', () => {
+    describe('HazelModule decorator', () => {
+        it('should set module metadata', () => {
+            let TestModule = class TestModule {
+            };
+            TestModule = __decorate([
+                (0, hazel_module_1.HazelModule)({
+                    controllers: [],
+                    providers: [],
+                })
+            ], TestModule);
+            const metadata = (0, hazel_module_1.getModuleMetadata)(TestModule);
+            expect(metadata).toBeDefined();
+            expect(metadata?.controllers).toEqual([]);
+            expect(metadata?.providers).toEqual([]);
+        });
+        it('should set metadata with imports', () => {
+            class ImportedModule {
+            }
+            let TestModule = class TestModule {
+            };
+            TestModule = __decorate([
+                (0, hazel_module_1.HazelModule)({
+                    imports: [ImportedModule],
+                })
+            ], TestModule);
+            const metadata = (0, hazel_module_1.getModuleMetadata)(TestModule);
+            expect(metadata?.imports).toEqual([ImportedModule]);
+        });
+        it('should set metadata with exports', () => {
+            class ExportedService {
+            }
+            let TestModule = class TestModule {
+            };
+            TestModule = __decorate([
+                (0, hazel_module_1.HazelModule)({
+                    exports: [ExportedService],
+                })
+            ], TestModule);
+            const metadata = (0, hazel_module_1.getModuleMetadata)(TestModule);
+            expect(metadata?.exports).toEqual([ExportedService]);
+        });
+    });
+    describe('Module alias', () => {
+        it('should work as alias for HazelModule', () => {
+            let TestModule = class TestModule {
+            };
+            TestModule = __decorate([
+                (0, hazel_module_1.Module)({
+                    controllers: [],
+                })
+            ], TestModule);
+            const metadata = (0, hazel_module_1.getModuleMetadata)(TestModule);
+            expect(metadata).toBeDefined();
+        });
+    });
+    describe('getModuleMetadata', () => {
+        it('should return undefined for class without metadata', () => {
+            class PlainClass {
+            }
+            const metadata = (0, hazel_module_1.getModuleMetadata)(PlainClass);
+            expect(metadata).toBeUndefined();
+        });
+        it('should return metadata for decorated class', () => {
+            let TestModule = class TestModule {
+            };
+            TestModule = __decorate([
+                (0, hazel_module_1.HazelModule)({
+                    providers: [],
+                })
+            ], TestModule);
+            const metadata = (0, hazel_module_1.getModuleMetadata)(TestModule);
+            expect(metadata).toBeDefined();
+            expect(metadata?.providers).toEqual([]);
+        });
+    });
+    describe('HazelModuleInstance', () => {
+        describe('initialization', () => {
+            it('should initialize module without metadata', () => {
+                class TestModule {
+                }
+                const instance = new hazel_module_1.HazelModuleInstance(TestModule);
+                expect(instance).toBeDefined();
+                expect(instance.getContainer()).toBeDefined();
+            });
+            it('should initialize module with providers', () => {
+                class TestService {
+                    getValue() {
+                        return 'test';
+                    }
+                }
+                let TestModule = class TestModule {
+                };
+                TestModule = __decorate([
+                    (0, hazel_module_1.HazelModule)({
+                        providers: [TestService],
+                    })
+                ], TestModule);
+                const instance = new hazel_module_1.HazelModuleInstance(TestModule);
+                expect(instance).toBeDefined();
+            });
+            it('should initialize module with controllers', () => {
+                class TestController {
+                    getStatus() {
+                        return 'ok';
+                    }
+                }
+                let TestModule = class TestModule {
+                };
+                TestModule = __decorate([
+                    (0, hazel_module_1.HazelModule)({
+                        controllers: [TestController],
+                    })
+                ], TestModule);
+                const instance = new hazel_module_1.HazelModuleInstance(TestModule);
+                expect(instance).toBeDefined();
+            });
+            it('should initialize module with imports', () => {
+                let ImportedModule = class ImportedModule {
+                };
+                ImportedModule = __decorate([
+                    (0, hazel_module_1.HazelModule)({})
+                ], ImportedModule);
+                let TestModule = class TestModule {
+                };
+                TestModule = __decorate([
+                    (0, hazel_module_1.HazelModule)({
+                        imports: [ImportedModule],
+                    })
+                ], TestModule);
+                const instance = new hazel_module_1.HazelModuleInstance(TestModule);
+                expect(instance).toBeDefined();
+            });
+        });
+        describe('request-scoped providers', () => {
+            it('should handle request-scoped providers', () => {
+                class RequestScopedService {
+                }
+                Reflect.defineMetadata('hazel:scope', 'request', RequestScopedService);
+                let TestModule = class TestModule {
+                };
+                TestModule = __decorate([
+                    (0, hazel_module_1.HazelModule)({
+                        providers: [RequestScopedService],
+                    })
+                ], TestModule);
+                const instance = new hazel_module_1.HazelModuleInstance(TestModule);
+                expect(instance).toBeDefined();
+            });
+            it('should handle singleton providers', () => {
+                class SingletonService {
+                }
+                let TestModule = class TestModule {
+                };
+                TestModule = __decorate([
+                    (0, hazel_module_1.HazelModule)({
+                        providers: [SingletonService],
+                    })
+                ], TestModule);
+                const instance = new hazel_module_1.HazelModuleInstance(TestModule);
+                expect(instance).toBeDefined();
+            });
+        });
+        describe('controllers with dependencies', () => {
+            it('should handle controller with request-scoped dependencies', () => {
+                class RequestScopedService {
+                }
+                Reflect.defineMetadata('hazel:scope', 'request', RequestScopedService);
+                class TestController {
+                    constructor(service) {
+                        this.service = service;
+                    }
+                }
+                Reflect.defineMetadata('design:paramtypes', [RequestScopedService], TestController);
+                let TestModule = class TestModule {
+                };
+                TestModule = __decorate([
+                    (0, hazel_module_1.HazelModule)({
+                        providers: [RequestScopedService],
+                        controllers: [TestController],
+                    })
+                ], TestModule);
+                const instance = new hazel_module_1.HazelModuleInstance(TestModule);
+                expect(instance).toBeDefined();
+            });
+            it('should handle controller without request-scoped dependencies', () => {
+                class NormalService {
+                }
+                class TestController {
+                    constructor(service) {
+                        this.service = service;
+                    }
+                }
+                Reflect.defineMetadata('design:paramtypes', [NormalService], TestController);
+                let TestModule = class TestModule {
+                };
+                TestModule = __decorate([
+                    (0, hazel_module_1.HazelModule)({
+                        providers: [NormalService],
+                        controllers: [TestController],
+                    })
+                ], TestModule);
+                const instance = new hazel_module_1.HazelModuleInstance(TestModule);
+                expect(instance).toBeDefined();
+            });
+            it('should handle controller without dependencies', () => {
+                class TestController {
+                    getStatus() {
+                        return 'ok';
+                    }
+                }
+                let TestModule = class TestModule {
+                };
+                TestModule = __decorate([
+                    (0, hazel_module_1.HazelModule)({
+                        controllers: [TestController],
+                    })
+                ], TestModule);
+                const instance = new hazel_module_1.HazelModuleInstance(TestModule);
+                expect(instance).toBeDefined();
+            });
+            it('should handle controller with null paramTypes', () => {
+                class TestController {
+                }
+                Reflect.defineMetadata('design:paramtypes', [null], TestController);
+                let TestModule = class TestModule {
+                };
+                TestModule = __decorate([
+                    (0, hazel_module_1.HazelModule)({
+                        controllers: [TestController],
+                    })
+                ], TestModule);
+                const instance = new hazel_module_1.HazelModuleInstance(TestModule);
+                expect(instance).toBeDefined();
+            });
+        });
+        describe('route registration', () => {
+            it('should register controller routes', () => {
+                class TestController {
+                    getUsers() {
+                        return [];
+                    }
+                    getUser() {
+                        return {};
+                    }
+                }
+                Reflect.defineMetadata('hazel:route', { method: 'GET', path: '/users' }, TestController.prototype, 'getUsers');
+                Reflect.defineMetadata('hazel:route', { method: 'GET', path: '/users/:id' }, TestController.prototype, 'getUser');
+                let TestModule = class TestModule {
+                };
+                TestModule = __decorate([
+                    (0, hazel_module_1.HazelModule)({
+                        controllers: [TestController],
+                    })
+                ], TestModule);
+                const instance = new hazel_module_1.HazelModuleInstance(TestModule);
+                expect(instance).toBeDefined();
+            });
+            it('should handle controller without routes', () => {
+                class TestController {
+                    someMethod() {
+                        return 'test';
+                    }
+                }
+                let TestModule = class TestModule {
+                };
+                TestModule = __decorate([
+                    (0, hazel_module_1.HazelModule)({
+                        controllers: [TestController],
+                    })
+                ], TestModule);
+                const instance = new hazel_module_1.HazelModuleInstance(TestModule);
+                expect(instance).toBeDefined();
+            });
+        });
+        describe('nested modules', () => {
+            it('should initialize nested imported modules', () => {
+                let Level3Module = class Level3Module {
+                };
+                Level3Module = __decorate([
+                    (0, hazel_module_1.HazelModule)({})
+                ], Level3Module);
+                let Level2Module = class Level2Module {
+                };
+                Level2Module = __decorate([
+                    (0, hazel_module_1.HazelModule)({
+                        imports: [Level3Module],
+                    })
+                ], Level2Module);
+                let Level1Module = class Level1Module {
+                };
+                Level1Module = __decorate([
+                    (0, hazel_module_1.HazelModule)({
+                        imports: [Level2Module],
+                    })
+                ], Level1Module);
+                const instance = new hazel_module_1.HazelModuleInstance(Level1Module);
+                expect(instance).toBeDefined();
+            });
+            it('should handle multiple imports', () => {
+                let Module1 = class Module1 {
+                };
+                Module1 = __decorate([
+                    (0, hazel_module_1.HazelModule)({})
+                ], Module1);
+                let Module2 = class Module2 {
+                };
+                Module2 = __decorate([
+                    (0, hazel_module_1.HazelModule)({})
+                ], Module2);
+                let Module3 = class Module3 {
+                };
+                Module3 = __decorate([
+                    (0, hazel_module_1.HazelModule)({})
+                ], Module3);
+                let TestModule = class TestModule {
+                };
+                TestModule = __decorate([
+                    (0, hazel_module_1.HazelModule)({
+                        imports: [Module1, Module2, Module3],
+                    })
+                ], TestModule);
+                const instance = new hazel_module_1.HazelModuleInstance(TestModule);
+                expect(instance).toBeDefined();
+            });
+        });
+        describe('getContainer', () => {
+            it('should return container instance', () => {
+                let TestModule = class TestModule {
+                };
+                TestModule = __decorate([
+                    (0, hazel_module_1.HazelModule)({})
+                ], TestModule);
+                const instance = new hazel_module_1.HazelModuleInstance(TestModule);
+                const container = instance.getContainer();
+                expect(container).toBeDefined();
+            });
+        });
+        describe('complex scenarios', () => {
+            it('should handle module with all options', () => {
+                class SharedService {
+                }
+                let SharedModule = class SharedModule {
+                };
+                SharedModule = __decorate([
+                    (0, hazel_module_1.HazelModule)({
+                        providers: [SharedService],
+                        exports: [SharedService],
+                    })
+                ], SharedModule);
+                class AppService {
+                }
+                class AppController {
+                }
+                let AppModule = class AppModule {
+                };
+                AppModule = __decorate([
+                    (0, hazel_module_1.HazelModule)({
+                        imports: [SharedModule],
+                        providers: [AppService],
+                        controllers: [AppController],
+                        exports: [AppService],
+                    })
+                ], AppModule);
+                const instance = new hazel_module_1.HazelModuleInstance(AppModule);
+                expect(instance).toBeDefined();
+            });
+            it('should handle empty module options', () => {
+                let EmptyModule = class EmptyModule {
+                };
+                EmptyModule = __decorate([
+                    (0, hazel_module_1.HazelModule)({})
+                ], EmptyModule);
+                const instance = new hazel_module_1.HazelModuleInstance(EmptyModule);
+                expect(instance).toBeDefined();
+            });
+        });
+    });
+});

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

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

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

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

package/dist/__tests__/hazel-response.test.js

@@ -0,0 +1,138 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const hazel_response_1 = require("../hazel-response");
+describe('HazelExpressResponse', () => {
+    let mockRes;
+    let hazelResponse;
+    beforeEach(() => {
+        mockRes = {
+            setHeader: jest.fn(),
+            status: jest.fn().mockReturnThis(),
+            json: jest.fn(),
+            send: jest.fn(),
+            end: jest.fn(),
+        };
+        hazelResponse = new hazel_response_1.HazelExpressResponse(mockRes);
+    });
+    describe('setHeader', () => {
+        it('should set header when headers not sent', () => {
+            hazelResponse.setHeader('Content-Type', 'application/json');
+            expect(mockRes.setHeader).toHaveBeenCalledWith('Content-Type', 'application/json');
+        });
+        it('should not set header after headers are sent', () => {
+            // Trigger header sending by writing
+            hazelResponse.write('test');
+            jest.clearAllMocks();
+            hazelResponse.setHeader('X-Custom', 'value');
+            expect(mockRes.setHeader).not.toHaveBeenCalled();
+        });
+    });
+    describe('status', () => {
+        it('should set status code', () => {
+            const result = hazelResponse.status(404);
+            expect(mockRes.status).toHaveBeenCalledWith(404);
+            expect(result).toBe(hazelResponse);
+        });
+        it('should return this for chaining', () => {
+            const result = hazelResponse.status(200);
+            expect(result).toBeInstanceOf(hazel_response_1.HazelExpressResponse);
+        });
+        it('should not set status after headers are sent', () => {
+            hazelResponse.write('test');
+            jest.clearAllMocks();
+            hazelResponse.status(500);
+            expect(mockRes.status).not.toHaveBeenCalled();
+        });
+    });
+    describe('write', () => {
+        it('should set streaming headers on first write', () => {
+            hazelResponse.write('chunk1');
+            expect(mockRes.setHeader).toHaveBeenCalledWith('Content-Type', 'text/plain');
+            expect(mockRes.setHeader).toHaveBeenCalledWith('Transfer-Encoding', 'chunked');
+            expect(mockRes.send).toHaveBeenCalledWith('chunk1');
+        });
+        it('should send subsequent chunks without setting headers', () => {
+            hazelResponse.write('chunk1');
+            jest.clearAllMocks();
+            hazelResponse.write('chunk2');
+            expect(mockRes.setHeader).not.toHaveBeenCalled();
+            expect(mockRes.send).toHaveBeenCalledWith('chunk2');
+        });
+    });
+    describe('end', () => {
+        it('should end response when streaming', () => {
+            hazelResponse.write('test');
+            hazelResponse.end();
+            expect(mockRes.end).toHaveBeenCalled();
+        });
+        it('should not end response when not streaming', () => {
+            hazelResponse.end();
+            expect(mockRes.end).not.toHaveBeenCalled();
+        });
+    });
+    describe('json', () => {
+        it('should send JSON data', () => {
+            const data = { message: 'success' };
+            hazelResponse.json(data);
+            expect(mockRes.json).toHaveBeenCalledWith(data);
+        });
+        it('should handle error objects specially', () => {
+            const data = { error: 'Something went wrong' };
+            hazelResponse.json(data);
+            expect(mockRes.json).toHaveBeenCalledWith({ error: 'Something went wrong' });
+        });
+        it('should not send JSON if streaming', () => {
+            hazelResponse.write('streaming');
+            hazelResponse.json({ data: 'test' });
+            expect(mockRes.json).not.toHaveBeenCalled();
+        });
+        it('should not send JSON if headers already sent', () => {
+            hazelResponse.write('test');
+            hazelResponse.json({ data: 'test' });
+            expect(mockRes.json).not.toHaveBeenCalled();
+        });
+        it('should handle circular references safely', () => {
+            const data = { name: 'test' };
+            data.res = mockRes;
+            hazelResponse.json(data);
+            expect(mockRes.json).toHaveBeenCalledWith({
+                name: 'test',
+                res: '[Response Object]',
+            });
+        });
+        it('should handle primitive values', () => {
+            hazelResponse.json('string value');
+            expect(mockRes.json).toHaveBeenCalledWith('string value');
+            jest.clearAllMocks();
+            hazelResponse = new hazel_response_1.HazelExpressResponse(mockRes);
+            hazelResponse.json(123);
+            expect(mockRes.json).toHaveBeenCalledWith(123);
+            jest.clearAllMocks();
+            hazelResponse = new hazel_response_1.HazelExpressResponse(mockRes);
+            hazelResponse.json(true);
+            expect(mockRes.json).toHaveBeenCalledWith(true);
+        });
+        it('should handle null and undefined', () => {
+            hazelResponse.json(null);
+            expect(mockRes.json).toHaveBeenCalledWith(null);
+            jest.clearAllMocks();
+            hazelResponse = new hazel_response_1.HazelExpressResponse(mockRes);
+            hazelResponse.json(undefined);
+            expect(mockRes.json).toHaveBeenCalledWith(undefined);
+        });
+        it('should handle JSON stringify errors', () => {
+            // Create an object that will fail JSON.stringify
+            const circular = {};
+            circular.self = circular;
+            // Mock JSON.stringify to throw
+            const originalStringify = JSON.stringify;
+            JSON.stringify = jest.fn().mockImplementation(() => {
+                throw new Error('Stringify failed');
+            });
+            hazelResponse.json(circular);
+            expect(mockRes.json).toHaveBeenCalledWith({ error: 'Failed to serialize response' });
+            // Restore original
+            JSON.stringify = originalStringify;
+        });
+    });
+});

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

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

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

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