@hazeljs/core 0.2.0-beta.8 → 0.2.0-beta.81

package/dist/__tests__/decorators.test.js

@@ -690,4 +690,548 @@ describe('Decorators', () => {
             expect(routes[0].method).toBe('POST');
         });
     });
+    // -------------------------------------------------------------------------
+    // @Req() parameter decorator
+    // -------------------------------------------------------------------------
+    describe('Req', () => {
+        it('should register request injection type', () => {
+            class TestController {
+                handleRequest(req) {
+                    return req;
+                }
+            }
+            __decorate([
+                __param(0, (0, decorators_1.Req)()),
+                __metadata("design:type", Function),
+                __metadata("design:paramtypes", [Object]),
+                __metadata("design:returntype", void 0)
+            ], TestController.prototype, "handleRequest", null);
+            const injections = Reflect.getMetadata('hazel:inject', TestController, 'handleRequest');
+            expect(injections[0].type).toBe('request');
+        });
+        it('should throw error when used outside a method parameter', () => {
+            expect(() => {
+                const decorator = (0, decorators_1.Req)();
+                decorator({}, undefined, 0);
+            }).toThrow('Req decorator must be used on a method parameter');
+        });
+    });
+    // -------------------------------------------------------------------------
+    // @Headers() parameter decorator
+    // -------------------------------------------------------------------------
+    describe('Headers', () => {
+        it('should register headers injection with a specific header name', () => {
+            class TestController {
+                getAuth(auth) {
+                    return auth;
+                }
+            }
+            __decorate([
+                __param(0, (0, decorators_1.Headers)('authorization')),
+                __metadata("design:type", Function),
+                __metadata("design:paramtypes", [String]),
+                __metadata("design:returntype", void 0)
+            ], TestController.prototype, "getAuth", null);
+            const injections = Reflect.getMetadata('hazel:inject', TestController, 'getAuth');
+            expect(injections[0].type).toBe('headers');
+            expect(injections[0].name).toBe('authorization');
+        });
+        it('should register headers injection without a name (all headers)', () => {
+            class TestController {
+                getAllHeaders(headers) {
+                    return headers;
+                }
+            }
+            __decorate([
+                __param(0, (0, decorators_1.Headers)()),
+                __metadata("design:type", Function),
+                __metadata("design:paramtypes", [Object]),
+                __metadata("design:returntype", void 0)
+            ], TestController.prototype, "getAllHeaders", null);
+            const injections = Reflect.getMetadata('hazel:inject', TestController, 'getAllHeaders');
+            expect(injections[0].type).toBe('headers');
+            expect(injections[0].name).toBeUndefined();
+        });
+        it('should throw error when used outside a method parameter', () => {
+            expect(() => {
+                const decorator = (0, decorators_1.Headers)();
+                decorator({}, undefined, 0);
+            }).toThrow('Headers decorator must be used on a method parameter');
+        });
+    });
+    // -------------------------------------------------------------------------
+    // @HttpCode() method decorator
+    // -------------------------------------------------------------------------
+    describe('HttpCode', () => {
+        it('should store the status code in metadata', () => {
+            class TestController {
+                create() {
+                    return { id: 1 };
+                }
+            }
+            __decorate([
+                (0, decorators_1.HttpCode)(201),
+                __metadata("design:type", Function),
+                __metadata("design:paramtypes", []),
+                __metadata("design:returntype", void 0)
+            ], TestController.prototype, "create", null);
+            const code = Reflect.getMetadata('hazel:http-code', TestController.prototype, 'create');
+            expect(code).toBe(201);
+        });
+        it('should allow 204 for no-content responses', () => {
+            class TestController {
+                remove() {
+                    return undefined;
+                }
+            }
+            __decorate([
+                (0, decorators_1.HttpCode)(204),
+                __metadata("design:type", Function),
+                __metadata("design:paramtypes", []),
+                __metadata("design:returntype", void 0)
+            ], TestController.prototype, "remove", null);
+            const code = Reflect.getMetadata('hazel:http-code', TestController.prototype, 'remove');
+            expect(code).toBe(204);
+        });
+    });
+    // -------------------------------------------------------------------------
+    // @Header() method decorator (custom response headers)
+    // -------------------------------------------------------------------------
+    describe('Header', () => {
+        it('should store a single custom response header', () => {
+            class TestController {
+                getVersion() {
+                    return {};
+                }
+            }
+            __decorate([
+                (0, decorators_1.Header)('X-Version', '1.0'),
+                __metadata("design:type", Function),
+                __metadata("design:paramtypes", []),
+                __metadata("design:returntype", void 0)
+            ], TestController.prototype, "getVersion", null);
+            const headers = Reflect.getMetadata('hazel:headers', TestController.prototype, 'getVersion');
+            expect(headers).toHaveLength(1);
+            expect(headers[0]).toEqual({ name: 'X-Version', value: '1.0' });
+        });
+        it('should accumulate multiple @Header decorators on the same method', () => {
+            class TestController {
+                getData() {
+                    return {};
+                }
+            }
+            __decorate([
+                (0, decorators_1.Header)('X-First', 'a'),
+                (0, decorators_1.Header)('X-Second', 'b'),
+                __metadata("design:type", Function),
+                __metadata("design:paramtypes", []),
+                __metadata("design:returntype", void 0)
+            ], TestController.prototype, "getData", null);
+            const headers = Reflect.getMetadata('hazel:headers', TestController.prototype, 'getData');
+            expect(headers).toHaveLength(2);
+            expect(headers.map((h) => h.name)).toContain('X-First');
+            expect(headers.map((h) => h.name)).toContain('X-Second');
+        });
+    });
+    // -------------------------------------------------------------------------
+    // @Redirect() method decorator
+    // -------------------------------------------------------------------------
+    describe('Redirect', () => {
+        it('should store redirect url with default 302 status', () => {
+            class TestController {
+                goSomewhere() {
+                    return undefined;
+                }
+            }
+            __decorate([
+                (0, decorators_1.Redirect)('/new-location'),
+                __metadata("design:type", Function),
+                __metadata("design:paramtypes", []),
+                __metadata("design:returntype", void 0)
+            ], TestController.prototype, "goSomewhere", null);
+            const meta = Reflect.getMetadata('hazel:redirect', TestController.prototype, 'goSomewhere');
+            expect(meta).toEqual({ url: '/new-location', statusCode: 302 });
+        });
+        it('should store redirect url with custom status code', () => {
+            class TestController {
+                movedPermanently() {
+                    return undefined;
+                }
+            }
+            __decorate([
+                (0, decorators_1.Redirect)('/permanent', 301),
+                __metadata("design:type", Function),
+                __metadata("design:paramtypes", []),
+                __metadata("design:returntype", void 0)
+            ], TestController.prototype, "movedPermanently", null);
+            const meta = Reflect.getMetadata('hazel:redirect', TestController.prototype, 'movedPermanently');
+            expect(meta).toEqual({ url: '/permanent', statusCode: 301 });
+        });
+    });
+    // -------------------------------------------------------------------------
+    // @AITask() method decorator
+    // -------------------------------------------------------------------------
+    describe('AITask', () => {
+        it('should store AI task options in metadata', () => {
+            const options = {
+                name: 'summarise',
+                prompt: 'Summarise the following text: {{input}}',
+                provider: 'openai',
+                model: 'gpt-4o',
+                outputType: 'string',
+            };
+            class TestController {
+                summarise() {
+                    return undefined;
+                }
+            }
+            __decorate([
+                (0, decorators_1.AITask)(options),
+                __metadata("design:type", Function),
+                __metadata("design:paramtypes", []),
+                __metadata("design:returntype", void 0)
+            ], TestController.prototype, "summarise", null);
+            const meta = Reflect.getMetadata('hazel:ai-task', TestController.prototype, 'summarise');
+            expect(meta).toEqual(options);
+        });
+    });
+    // -------------------------------------------------------------------------
+    // @UsePipes() class-level metadata verification
+    // -------------------------------------------------------------------------
+    describe('UsePipes class-level metadata', () => {
+        it('should store pipe metadata on the class itself when used as class decorator', () => {
+            class TrimPipe {
+                transform(value) {
+                    return value.trim();
+                }
+            }
+            let TestController = class TestController {
+            };
+            TestController = __decorate([
+                (0, decorators_1.UsePipes)(TrimPipe)
+            ], TestController);
+            const pipeMeta = Reflect.getMetadata('hazel:pipe', TestController);
+            expect(pipeMeta).toBeDefined();
+            expect(Array.isArray(pipeMeta)).toBe(true);
+            expect(pipeMeta.length).toBeGreaterThan(0);
+        });
+    });
+    // -------------------------------------------------------------------------
+    // @UseGuards() class-level metadata verification
+    // -------------------------------------------------------------------------
+    describe('UseGuards class-level metadata', () => {
+        it('should store guard metadata on the class when used as class decorator', () => {
+            class AuthGuard {
+                canActivate() {
+                    return true;
+                }
+            }
+            let TestController = class TestController {
+            };
+            TestController = __decorate([
+                (0, decorators_1.UseGuards)(AuthGuard)
+            ], TestController);
+            const guardMeta = Reflect.getMetadata('hazel:guards', TestController);
+            expect(guardMeta).toBeDefined();
+            expect(guardMeta).toContain(AuthGuard);
+        });
+        it('should store guard metadata on the method when used as method decorator', () => {
+            class RoleGuard {
+                canActivate() {
+                    return true;
+                }
+            }
+            class TestController {
+                getProtected() {
+                    return {};
+                }
+            }
+            __decorate([
+                (0, decorators_1.UseGuards)(RoleGuard),
+                (0, decorators_1.Get)('/protected'),
+                __metadata("design:type", Function),
+                __metadata("design:paramtypes", []),
+                __metadata("design:returntype", void 0)
+            ], TestController.prototype, "getProtected", null);
+            const guardMeta = Reflect.getMetadata('hazel:guards', TestController.prototype, 'getProtected');
+            expect(guardMeta).toBeDefined();
+            expect(guardMeta).toContain(RoleGuard);
+        });
+    });
+    describe('Ip', () => {
+        it('should register ip injection type', () => {
+            class TestController {
+                get(ip) {
+                    return { ip };
+                }
+            }
+            __decorate([
+                (0, decorators_1.Get)('/'),
+                __param(0, (0, decorators_1.Ip)()),
+                __metadata("design:type", Function),
+                __metadata("design:paramtypes", [String]),
+                __metadata("design:returntype", void 0)
+            ], TestController.prototype, "get", null);
+            const injections = Reflect.getMetadata('hazel:inject', TestController, 'get');
+            expect(injections[0]).toEqual({ type: 'ip' });
+        });
+        it('should throw when used outside a method parameter', () => {
+            class Ctrl {
+                get() { }
+            }
+            expect(() => (0, decorators_1.Ip)()(Ctrl.prototype, undefined, 0)).toThrow('Ip decorator must be used on a method parameter');
+        });
+    });
+    describe('Host', () => {
+        it('should register host injection type', () => {
+            class TestController {
+                get(host) {
+                    return { host };
+                }
+            }
+            __decorate([
+                (0, decorators_1.Get)('/'),
+                __param(0, (0, decorators_1.Host)()),
+                __metadata("design:type", Function),
+                __metadata("design:paramtypes", [String]),
+                __metadata("design:returntype", void 0)
+            ], TestController.prototype, "get", null);
+            const injections = Reflect.getMetadata('hazel:inject', TestController, 'get');
+            expect(injections[0]).toEqual({ type: 'host' });
+        });
+        it('should throw when used outside a method parameter', () => {
+            class Ctrl {
+                get() { }
+            }
+            expect(() => (0, decorators_1.Host)()(Ctrl.prototype, undefined, 0)).toThrow('Host decorator must be used on a method parameter');
+        });
+    });
+    describe('Public', () => {
+        it('should set public metadata on class', () => {
+            let TestController = class TestController {
+            };
+            TestController = __decorate([
+                (0, decorators_1.Public)()
+            ], TestController);
+            expect(Reflect.getMetadata('hazel:public', TestController)).toBe(true);
+        });
+        it('should set public metadata on method', () => {
+            class TestController {
+                login() {
+                    return {};
+                }
+            }
+            __decorate([
+                (0, decorators_1.Public)(),
+                (0, decorators_1.Get)('/login'),
+                __metadata("design:type", Function),
+                __metadata("design:paramtypes", []),
+                __metadata("design:returntype", void 0)
+            ], TestController.prototype, "login", null);
+            expect(Reflect.getMetadata('hazel:public', TestController.prototype, 'login')).toBe(true);
+        });
+    });
+    describe('SkipAuth', () => {
+        it('should be an alias for Public', () => {
+            expect(decorators_1.SkipAuth).toBe(decorators_1.Public);
+        });
+    });
+    describe('Timeout', () => {
+        it('should store timeout in metadata', () => {
+            class TestController {
+                get() {
+                    return {};
+                }
+            }
+            __decorate([
+                (0, decorators_1.Timeout)(5000),
+                (0, decorators_1.Get)('/'),
+                __metadata("design:type", Function),
+                __metadata("design:paramtypes", []),
+                __metadata("design:returntype", void 0)
+            ], TestController.prototype, "get", null);
+            expect(Reflect.getMetadata('hazel:timeout', TestController.prototype, 'get')).toBe(5000);
+        });
+    });
+    describe('Optional', () => {
+        it('should add parameter index to optional indices', () => {
+            class TestController {
+                get(q) {
+                    return { q };
+                }
+            }
+            __decorate([
+                (0, decorators_1.Get)('/'),
+                __param(0, (0, decorators_1.Optional)()),
+                __param(0, (0, decorators_1.Query)('q')),
+                __metadata("design:type", Function),
+                __metadata("design:paramtypes", [String]),
+                __metadata("design:returntype", void 0)
+            ], TestController.prototype, "get", null);
+            const indices = Reflect.getMetadata('hazel:optional-indices', TestController, 'get');
+            expect(indices).toContain(0);
+        });
+        it('should throw when used outside a method parameter', () => {
+            class Ctrl {
+                get() { }
+            }
+            expect(() => (0, decorators_1.Optional)()(Ctrl.prototype, undefined, 0)).toThrow('Optional decorator must be used on a method parameter');
+        });
+    });
+    describe('Session', () => {
+        it('should register session injection type', () => {
+            class TestController {
+                get(session) {
+                    return { session };
+                }
+            }
+            __decorate([
+                (0, decorators_1.Get)('/'),
+                __param(0, (0, decorators_1.Session)()),
+                __metadata("design:type", Function),
+                __metadata("design:paramtypes", [Object]),
+                __metadata("design:returntype", void 0)
+            ], TestController.prototype, "get", null);
+            const injections = Reflect.getMetadata('hazel:inject', TestController, 'get');
+            expect(injections[0]).toEqual({ type: 'session' });
+        });
+        it('should throw when used outside a method parameter', () => {
+            class Ctrl {
+                get() { }
+            }
+            expect(() => (0, decorators_1.Session)()(Ctrl.prototype, undefined, 0)).toThrow('Session decorator must be used on a method parameter');
+        });
+    });
+    describe('Retry', () => {
+        it('should store retry options and add RetryInterceptor to route', () => {
+            class TestController {
+                get() {
+                    return {};
+                }
+            }
+            __decorate([
+                (0, decorators_1.Retry)({ count: 3, delay: 100 }),
+                (0, decorators_1.Get)('/'),
+                __metadata("design:type", Function),
+                __metadata("design:paramtypes", []),
+                __metadata("design:returntype", void 0)
+            ], TestController.prototype, "get", null);
+            expect(Reflect.getMetadata('hazel:retry', TestController.prototype, 'get')).toEqual({
+                count: 3,
+                delay: 100,
+            });
+            const routes = Reflect.getMetadata('hazel:routes', TestController);
+            const route = routes.find((r) => r.propertyKey === 'get');
+            expect(route?.interceptors?.[0]?.type?.name).toBe('RetryInterceptor');
+        });
+    });
+    describe('ApiTags', () => {
+        it('should set api tags on class', () => {
+            let TestController = class TestController {
+            };
+            TestController = __decorate([
+                (0, decorators_1.ApiTags)('users', 'admin')
+            ], TestController);
+            expect(Reflect.getMetadata('hazel:api:tags', TestController)).toEqual(['users', 'admin']);
+        });
+        it('should set api tags on method', () => {
+            class TestController {
+                login() {
+                    return {};
+                }
+            }
+            __decorate([
+                (0, decorators_1.ApiTags)('auth'),
+                (0, decorators_1.Get)('/login'),
+                __metadata("design:type", Function),
+                __metadata("design:paramtypes", []),
+                __metadata("design:returntype", void 0)
+            ], TestController.prototype, "login", null);
+            expect(Reflect.getMetadata('hazel:api:tags', TestController.prototype, 'login')).toEqual(['auth']);
+        });
+    });
+    describe('ApiOperation', () => {
+        it('should store operation options when given object', () => {
+            class TestController {
+                get() {
+                    return {};
+                }
+            }
+            __decorate([
+                (0, decorators_1.ApiOperation)({ summary: 'Get user', description: 'Returns a user', operationId: 'getUser' }),
+                (0, decorators_1.Get)('/'),
+                __metadata("design:type", Function),
+                __metadata("design:paramtypes", []),
+                __metadata("design:returntype", void 0)
+            ], TestController.prototype, "get", null);
+            expect(Reflect.getMetadata('hazel:api:operation', TestController.prototype, 'get')).toEqual({
+                summary: 'Get user',
+                description: 'Returns a user',
+                operationId: 'getUser',
+            });
+        });
+        it('should accept string as summary', () => {
+            class TestController {
+                get() {
+                    return {};
+                }
+            }
+            __decorate([
+                (0, decorators_1.ApiOperation)('List users'),
+                (0, decorators_1.Get)('/'),
+                __metadata("design:type", Function),
+                __metadata("design:paramtypes", []),
+                __metadata("design:returntype", void 0)
+            ], TestController.prototype, "get", null);
+            expect(Reflect.getMetadata('hazel:api:operation', TestController.prototype, 'get')).toEqual({
+                summary: 'List users',
+            });
+        });
+    });
+    describe('SetMetadata and getMetadata', () => {
+        it('should set and get class-level metadata', () => {
+            let AdminController = class AdminController {
+            };
+            AdminController = __decorate([
+                (0, decorators_1.SetMetadata)('roles', ['admin'])
+            ], AdminController);
+            expect((0, decorators_1.getMetadata)('roles', AdminController)).toEqual(['admin']);
+            expect(Reflect.getMetadata(`${decorators_1.CUSTOM_METADATA_PREFIX}roles`, AdminController)).toEqual(['admin']);
+        });
+        it('should set and get method-level metadata', () => {
+            class TestController {
+                get() {
+                    return {};
+                }
+            }
+            __decorate([
+                (0, decorators_1.SetMetadata)('roles', ['user']),
+                (0, decorators_1.Get)('/'),
+                __metadata("design:type", Function),
+                __metadata("design:paramtypes", []),
+                __metadata("design:returntype", void 0)
+            ], TestController.prototype, "get", null);
+            expect((0, decorators_1.getMetadata)('roles', TestController.prototype, 'get')).toEqual(['user']);
+        });
+    });
+    describe('createParamDecorator', () => {
+        it('should register custom inject metadata', () => {
+            const MyParam = (0, decorators_1.createParamDecorator)((_req, ctx) => ctx.query?.foo);
+            class TestController {
+                get(foo) {
+                    return { foo };
+                }
+            }
+            __decorate([
+                (0, decorators_1.Get)('/'),
+                __param(0, MyParam),
+                __metadata("design:type", Function),
+                __metadata("design:paramtypes", [String]),
+                __metadata("design:returntype", void 0)
+            ], TestController.prototype, "get", null);
+            const injections = Reflect.getMetadata('hazel:inject', TestController, 'get');
+            expect(injections).toBeDefined();
+            expect(injections[0]).toEqual({ type: 'custom', resolve: expect.any(Function) });
+        });
+    });
 });

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

@@ -679,4 +679,132 @@ describe('HazelApp', () => {
             expect(app).toBeDefined();
         });
     });
+    // -------------------------------------------------------------------------
+    // getRouter
+    // -------------------------------------------------------------------------
+    describe('getRouter', () => {
+        let app;
+        beforeEach(() => {
+            class AppModule {
+            }
+            Reflect.defineMetadata('hazel:module', {}, AppModule);
+            app = new hazel_app_1.HazelApp(AppModule);
+        });
+        it('should return the internal Router instance', () => {
+            const router = app.getRouter();
+            expect(router).toBeDefined();
+            expect(typeof router.registerController).toBe('function');
+        });
+    });
+    // -------------------------------------------------------------------------
+    // registerShutdownHandler
+    // -------------------------------------------------------------------------
+    describe('registerShutdownHandler', () => {
+        let app;
+        beforeEach(() => {
+            class AppModule {
+            }
+            Reflect.defineMetadata('hazel:module', {}, AppModule);
+            app = new hazel_app_1.HazelApp(AppModule);
+        });
+        it('should register a shutdown handler without throwing', () => {
+            expect(() => {
+                app.registerShutdownHandler({
+                    name: 'db',
+                    handler: async () => { },
+                });
+            }).not.toThrow();
+        });
+        it('should register a shutdown handler with a timeout', () => {
+            expect(() => {
+                app.registerShutdownHandler({
+                    name: 'cache',
+                    handler: async () => { },
+                    timeout: 5000,
+                });
+            }).not.toThrow();
+        });
+    });
+    // -------------------------------------------------------------------------
+    // registerHealthCheck
+    // -------------------------------------------------------------------------
+    describe('registerHealthCheck', () => {
+        let app;
+        beforeEach(() => {
+            class AppModule {
+            }
+            Reflect.defineMetadata('hazel:module', {}, AppModule);
+            app = new hazel_app_1.HazelApp(AppModule);
+        });
+        it('should register a health check without throwing', () => {
+            expect(() => {
+                app.registerHealthCheck({
+                    name: 'db',
+                    check: async () => ({ status: 'healthy' }),
+                });
+            }).not.toThrow();
+        });
+        it('should register a critical health check with a timeout', () => {
+            expect(() => {
+                app.registerHealthCheck({
+                    name: 'redis',
+                    check: async () => ({ status: 'healthy', message: 'connected' }),
+                    critical: true,
+                    timeout: 3000,
+                });
+            }).not.toThrow();
+        });
+    });
+    // -------------------------------------------------------------------------
+    // addEarlyHandler
+    // -------------------------------------------------------------------------
+    describe('addEarlyHandler', () => {
+        let app;
+        beforeEach(() => {
+            class AppModule {
+            }
+            Reflect.defineMetadata('hazel:module', {}, AppModule);
+            app = new hazel_app_1.HazelApp(AppModule);
+        });
+        it('should register an early handler without throwing', () => {
+            const handler = jest.fn().mockResolvedValue(false);
+            expect(() => {
+                app.addEarlyHandler('/internal', handler);
+            }).not.toThrow();
+        });
+        it('should register multiple early handlers', () => {
+            const h1 = jest.fn().mockResolvedValue(false);
+            const h2 = jest.fn().mockResolvedValue(false);
+            expect(() => {
+                app.addEarlyHandler('/a', h1);
+                app.addEarlyHandler('/b', h2);
+            }).not.toThrow();
+        });
+    });
+    // -------------------------------------------------------------------------
+    // addProxyHandler
+    // -------------------------------------------------------------------------
+    describe('addProxyHandler', () => {
+        let app;
+        beforeEach(() => {
+            class AppModule {
+            }
+            Reflect.defineMetadata('hazel:module', {}, AppModule);
+            app = new hazel_app_1.HazelApp(AppModule);
+        });
+        it('should register a proxy handler without throwing', () => {
+            const handler = jest.fn().mockResolvedValue(false);
+            expect(() => {
+                app.addProxyHandler('/api', handler);
+            }).not.toThrow();
+        });
+        it('should register multiple proxy handlers for different prefixes', () => {
+            const h1 = jest.fn().mockResolvedValue(false);
+            const h2 = jest.fn().mockResolvedValue(false);
+            expect(() => {
+                app.addProxyHandler('/service-a', h1);
+                app.addProxyHandler('/service-b', h2);
+            }).not.toThrow();
+        });
+    });
 });