@hazeljs/core 0.2.0-beta.58 → 0.2.0-beta.60

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

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

package/dist/__tests__/decorators.test.js

@@ -690,4 +690,272 @@ 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);
+        });
+    });
 });

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();
+        });
+    });
 });

package/dist/__tests__/router.test.js

@@ -676,5 +676,508 @@ describe('Router', () => {
                 }));
             }
         });
+        // -----------------------------------------------------------------------
+        // Parameter injection — extended types
+        // -----------------------------------------------------------------------
+        it('should inject named header via { type: "headers", name }', async () => {
+            class TestController {
+                getHeader(authHeader) {
+                    return { auth: authHeader };
+                }
+            }
+            container.register(TestController, new TestController());
+            Reflect.defineMetadata('hazel:controller', { path: '/test' }, TestController);
+            Reflect.defineMetadata('hazel:routes', [{ method: 'GET', path: '/header-named', propertyKey: 'getHeader' }], TestController);
+            Reflect.defineMetadata('hazel:inject', [{ type: 'headers', name: 'authorization' }], TestController, 'getHeader');
+            router.registerController(TestController);
+            const context = {
+                params: {},
+                query: {},
+                body: {},
+                headers: { authorization: 'Bearer token123' },
+                method: 'GET',
+                url: '/test/header-named',
+            };
+            const route = await router.match('GET', '/test/header-named', context);
+            expect(route).toBeDefined();
+            if (route) {
+                await route.handler(mockReq, mockRes, context);
+                expect(mockRes.json).toHaveBeenCalledWith({ auth: 'Bearer token123' });
+            }
+        });
+        it('should inject all headers when { type: "headers" } has no name', async () => {
+            class TestController {
+                getAllHeaders(headers) {
+                    return headers;
+                }
+            }
+            container.register(TestController, new TestController());
+            Reflect.defineMetadata('hazel:controller', { path: '/test' }, TestController);
+            Reflect.defineMetadata('hazel:routes', [{ method: 'GET', path: '/headers-all', propertyKey: 'getAllHeaders' }], TestController);
+            Reflect.defineMetadata('hazel:inject', [{ type: 'headers' }], TestController, 'getAllHeaders');
+            router.registerController(TestController);
+            const context = {
+                params: {},
+                query: {},
+                body: {},
+                headers: { 'x-custom': 'value' },
+                method: 'GET',
+                url: '/test/headers-all',
+            };
+            const route = await router.match('GET', '/test/headers-all', context);
+            expect(route).toBeDefined();
+            if (route) {
+                await route.handler(mockReq, mockRes, context);
+                expect(mockRes.json).toHaveBeenCalledWith(expect.objectContaining({ 'x-custom': 'value' }));
+            }
+        });
+        it('should inject user object via { type: "user" } without field', async () => {
+            class TestController {
+                whoAmI(user) {
+                    return user;
+                }
+            }
+            container.register(TestController, new TestController());
+            Reflect.defineMetadata('hazel:controller', { path: '/test' }, TestController);
+            Reflect.defineMetadata('hazel:routes', [{ method: 'GET', path: '/me', propertyKey: 'whoAmI' }], TestController);
+            Reflect.defineMetadata('hazel:inject', [{ type: 'user' }], TestController, 'whoAmI');
+            router.registerController(TestController);
+            const context = {
+                params: {},
+                query: {},
+                body: {},
+                headers: {},
+                method: 'GET',
+                url: '/test/me',
+            };
+            const reqWithUser = { ...mockReq, user: { sub: 'u1', role: 'admin' } };
+            const route = await router.match('GET', '/test/me', context);
+            expect(route).toBeDefined();
+            if (route) {
+                await route.handler(reqWithUser, mockRes, context);
+                expect(mockRes.json).toHaveBeenCalledWith({ sub: 'u1', role: 'admin' });
+            }
+        });
+        it('should inject specific user field via { type: "user", field }', async () => {
+            class TestController {
+                getRole(role) {
+                    return { role };
+                }
+            }
+            container.register(TestController, new TestController());
+            Reflect.defineMetadata('hazel:controller', { path: '/test' }, TestController);
+            Reflect.defineMetadata('hazel:routes', [{ method: 'GET', path: '/role', propertyKey: 'getRole' }], TestController);
+            Reflect.defineMetadata('hazel:inject', [{ type: 'user', field: 'role' }], TestController, 'getRole');
+            router.registerController(TestController);
+            const context = {
+                params: {},
+                query: {},
+                body: {},
+                headers: {},
+                method: 'GET',
+                url: '/test/role',
+            };
+            const reqWithUser = { ...mockReq, user: { sub: 'u1', role: 'manager' } };
+            const route = await router.match('GET', '/test/role', context);
+            expect(route).toBeDefined();
+            if (route) {
+                await route.handler(reqWithUser, mockRes, context);
+                expect(mockRes.json).toHaveBeenCalledWith({ role: 'manager' });
+            }
+        });
+        it('should invoke a custom resolver via { type: "custom", resolve }', async () => {
+            const resolvedValue = { custom: 'injected' };
+            const resolveFn = jest.fn().mockReturnValue(resolvedValue);
+            class TestController {
+                getCustom(val) {
+                    return val;
+                }
+            }
+            container.register(TestController, new TestController());
+            Reflect.defineMetadata('hazel:controller', { path: '/test' }, TestController);
+            Reflect.defineMetadata('hazel:routes', [{ method: 'GET', path: '/custom', propertyKey: 'getCustom' }], TestController);
+            Reflect.defineMetadata('hazel:inject', [{ type: 'custom', resolve: resolveFn }], TestController, 'getCustom');
+            router.registerController(TestController);
+            const context = {
+                params: {},
+                query: {},
+                body: {},
+                headers: {},
+                method: 'GET',
+                url: '/test/custom',
+            };
+            const route = await router.match('GET', '/test/custom', context);
+            expect(route).toBeDefined();
+            if (route) {
+                await route.handler(mockReq, mockRes, context);
+                expect(resolveFn).toHaveBeenCalled();
+                expect(mockRes.json).toHaveBeenCalledWith(resolvedValue);
+            }
+        });
+        it('should auto-inject RequestContext for undecorated parameters', async () => {
+            class TestController {
+                contextReceiver(ctx) {
+                    return { url: ctx.url };
+                }
+            }
+            container.register(TestController, new TestController());
+            Reflect.defineMetadata('hazel:controller', { path: '/test' }, TestController);
+            Reflect.defineMetadata('hazel:routes', [{ method: 'GET', path: '/ctx', propertyKey: 'contextReceiver' }], TestController);
+            // No injection metadata — relies on design:paramtypes auto-inject
+            Reflect.defineMetadata('hazel:inject', [], TestController, 'contextReceiver');
+            Reflect.defineMetadata('design:paramtypes', [Object], // one undecorated parameter
+            TestController.prototype, 'contextReceiver');
+            router.registerController(TestController);
+            const context = {
+                params: {},
+                query: {},
+                body: {},
+                headers: {},
+                method: 'GET',
+                url: '/test/ctx',
+            };
+            const route = await router.match('GET', '/test/ctx', context);
+            expect(route).toBeDefined();
+            if (route) {
+                await route.handler(mockReq, mockRes, context);
+                expect(mockRes.json).toHaveBeenCalledWith({ url: '/test/ctx' });
+            }
+        });
+        // -----------------------------------------------------------------------
+        // @Redirect metadata
+        // -----------------------------------------------------------------------
+        it('should send a redirect response when @Redirect metadata is set', async () => {
+            class TestController {
+                goHome() {
+                    return undefined;
+                }
+            }
+            container.register(TestController, new TestController());
+            Reflect.defineMetadata('hazel:controller', { path: '/test' }, TestController);
+            Reflect.defineMetadata('hazel:routes', [{ method: 'GET', path: '/redirect', propertyKey: 'goHome' }], TestController);
+            Reflect.defineMetadata('hazel:inject', [], TestController, 'goHome');
+            // Simulate @Redirect('/home', 301) on the prototype
+            Reflect.defineMetadata('hazel:redirect', { url: '/home', statusCode: 301 }, TestController.prototype, 'goHome');
+            router.registerController(TestController);
+            const context = {
+                params: {},
+                query: {},
+                body: {},
+                headers: {},
+                method: 'GET',
+                url: '/test/redirect',
+            };
+            const route = await router.match('GET', '/test/redirect', context);
+            expect(route).toBeDefined();
+            if (route) {
+                mockRes.setHeader = jest.fn();
+                await route.handler(mockReq, mockRes, context);
+                expect(mockRes.status).toHaveBeenCalledWith(301);
+                expect(mockRes.setHeader).toHaveBeenCalledWith('Location', '/home');
+            }
+        });
+        // -----------------------------------------------------------------------
+        // @Header metadata (custom response headers)
+        // -----------------------------------------------------------------------
+        it('should set custom response headers when @Header metadata is set', async () => {
+            class TestController {
+                headered() {
+                    return { ok: true };
+                }
+            }
+            container.register(TestController, new TestController());
+            Reflect.defineMetadata('hazel:controller', { path: '/test' }, TestController);
+            Reflect.defineMetadata('hazel:routes', [{ method: 'GET', path: '/headered', propertyKey: 'headered' }], TestController);
+            Reflect.defineMetadata('hazel:inject', [], TestController, 'headered');
+            Reflect.defineMetadata('hazel:headers', [{ name: 'X-Custom', value: 'hello' }], TestController.prototype, 'headered');
+            router.registerController(TestController);
+            const context = {
+                params: {},
+                query: {},
+                body: {},
+                headers: {},
+                method: 'GET',
+                url: '/test/headered',
+            };
+            const route = await router.match('GET', '/test/headered', context);
+            expect(route).toBeDefined();
+            if (route) {
+                await route.handler(mockReq, mockRes, context);
+                expect(mockRes.setHeader).toHaveBeenCalledWith('X-Custom', 'hello');
+                expect(mockRes.json).toHaveBeenCalledWith({ ok: true });
+            }
+        });
+        // -----------------------------------------------------------------------
+        // @HttpCode metadata
+        // -----------------------------------------------------------------------
+        it('should use custom HTTP status code from @HttpCode when result is defined', async () => {
+            class TestController {
+                create() {
+                    return { created: true };
+                }
+            }
+            container.register(TestController, new TestController());
+            Reflect.defineMetadata('hazel:controller', { path: '/test' }, TestController);
+            Reflect.defineMetadata('hazel:routes', [{ method: 'POST', path: '/http-code', propertyKey: 'create' }], TestController);
+            Reflect.defineMetadata('hazel:inject', [], TestController, 'create');
+            Reflect.defineMetadata('hazel:http-code', 201, TestController.prototype, 'create');
+            router.registerController(TestController);
+            const context = {
+                params: {},
+                query: {},
+                body: {},
+                headers: {},
+                method: 'POST',
+                url: '/test/http-code',
+            };
+            const route = await router.match('POST', '/test/http-code', context);
+            expect(route).toBeDefined();
+            if (route) {
+                await route.handler(mockReq, mockRes, context);
+                expect(mockRes.status).toHaveBeenCalledWith(201);
+                expect(mockRes.json).toHaveBeenCalledWith({ created: true });
+            }
+        });
+        it('should use custom HTTP status code from @HttpCode when result is undefined', async () => {
+            class TestController {
+                noContent() {
+                    return undefined;
+                }
+            }
+            container.register(TestController, new TestController());
+            Reflect.defineMetadata('hazel:controller', { path: '/test' }, TestController);
+            Reflect.defineMetadata('hazel:routes', [{ method: 'DELETE', path: '/no-content', propertyKey: 'noContent' }], TestController);
+            Reflect.defineMetadata('hazel:inject', [], TestController, 'noContent');
+            Reflect.defineMetadata('hazel:http-code', 204, TestController.prototype, 'noContent');
+            router.registerController(TestController);
+            const context = {
+                params: {},
+                query: {},
+                body: {},
+                headers: {},
+                method: 'DELETE',
+                url: '/test/no-content',
+            };
+            const route = await router.match('DELETE', '/test/no-content', context);
+            expect(route).toBeDefined();
+            if (route) {
+                await route.handler(mockReq, mockRes, context);
+                expect(mockRes.status).toHaveBeenCalledWith(204);
+                expect(mockRes.end).toHaveBeenCalled();
+            }
+        });
+        // -----------------------------------------------------------------------
+        // Guard execution
+        // -----------------------------------------------------------------------
+        it('should throw UnauthorizedError when guard canActivate returns false', async () => {
+            class DenyGuard {
+                canActivate() {
+                    return false;
+                }
+            }
+            container.register(DenyGuard, new DenyGuard());
+            class TestController {
+                secret() {
+                    return { secret: true };
+                }
+            }
+            container.register(TestController, new TestController());
+            Reflect.defineMetadata('hazel:controller', { path: '/test' }, TestController);
+            Reflect.defineMetadata('hazel:routes', [{ method: 'GET', path: '/secret', propertyKey: 'secret' }], TestController);
+            Reflect.defineMetadata('hazel:inject', [], TestController, 'secret');
+            Reflect.defineMetadata('hazel:guards', [DenyGuard], TestController);
+            router.registerController(TestController);
+            const context = {
+                params: {},
+                query: {},
+                body: {},
+                headers: {},
+                method: 'GET',
+                url: '/test/secret',
+            };
+            const route = await router.match('GET', '/test/secret', context);
+            expect(route).toBeDefined();
+            if (route) {
+                await route.handler(mockReq, mockRes, context);
+                expect(mockRes.status).toHaveBeenCalledWith(401);
+            }
+        });
+        it('should propagate req.user to context.user after guards pass', async () => {
+            class AllowGuard {
+                canActivate() {
+                    return true;
+                }
+            }
+            container.register(AllowGuard, new AllowGuard());
+            class TestController {
+                whoAmI(user) {
+                    return user;
+                }
+            }
+            container.register(TestController, new TestController());
+            Reflect.defineMetadata('hazel:controller', { path: '/test' }, TestController);
+            Reflect.defineMetadata('hazel:routes', [{ method: 'GET', path: '/user-propagate', propertyKey: 'whoAmI' }], TestController);
+            Reflect.defineMetadata('hazel:inject', [{ type: 'user' }], TestController, 'whoAmI');
+            Reflect.defineMetadata('hazel:guards', [AllowGuard], TestController);
+            router.registerController(TestController);
+            const context = {
+                params: {},
+                query: {},
+                body: {},
+                headers: {},
+                method: 'GET',
+                url: '/test/user-propagate',
+            };
+            const reqWithUser = { ...mockReq, user: { sub: 'u99' } };
+            const route = await router.match('GET', '/test/user-propagate', context);
+            expect(route).toBeDefined();
+            if (route) {
+                await route.handler(reqWithUser, mockRes, context);
+                expect(mockRes.json).toHaveBeenCalledWith({ sub: 'u99' });
+            }
+        });
+        // -----------------------------------------------------------------------
+        // Legacy string-based injection
+        // -----------------------------------------------------------------------
+        it('should handle legacy string injection "body"', async () => {
+            class TestController {
+                legacyBody(body) {
+                    return body;
+                }
+            }
+            container.register(TestController, new TestController());
+            Reflect.defineMetadata('hazel:controller', { path: '/test' }, TestController);
+            Reflect.defineMetadata('hazel:routes', [{ method: 'POST', path: '/legacy-body', propertyKey: 'legacyBody' }], TestController);
+            Reflect.defineMetadata('hazel:inject', ['body'], TestController, 'legacyBody');
+            router.registerController(TestController);
+            const context = {
+                params: {},
+                query: {},
+                body: { name: 'legacy' },
+                headers: {},
+                method: 'POST',
+                url: '/test/legacy-body',
+            };
+            const route = await router.match('POST', '/test/legacy-body', context);
+            if (route) {
+                await route.handler(mockReq, mockRes, context);
+                expect(mockRes.json).toHaveBeenCalledWith({ name: 'legacy' });
+            }
+        });
+        it('should handle legacy string injection "param"', async () => {
+            class TestController {
+                legacyParam(params) {
+                    return params;
+                }
+            }
+            container.register(TestController, new TestController());
+            Reflect.defineMetadata('hazel:controller', { path: '/test' }, TestController);
+            Reflect.defineMetadata('hazel:routes', [{ method: 'GET', path: '/legacy-param/:id', propertyKey: 'legacyParam' }], TestController);
+            Reflect.defineMetadata('hazel:inject', ['param'], TestController, 'legacyParam');
+            router.registerController(TestController);
+            const context = {
+                params: { id: '42' },
+                query: {},
+                body: {},
+                headers: {},
+                method: 'GET',
+                url: '/test/legacy-param/42',
+            };
+            const route = await router.match('GET', '/test/legacy-param/42', context);
+            if (route) {
+                await route.handler(mockReq, mockRes, context);
+                expect(mockRes.json).toHaveBeenCalledWith({ id: '42' });
+            }
+        });
+        it('should handle legacy string injection "query"', async () => {
+            class TestController {
+                legacyQuery(query) {
+                    return query;
+                }
+            }
+            container.register(TestController, new TestController());
+            Reflect.defineMetadata('hazel:controller', { path: '/test' }, TestController);
+            Reflect.defineMetadata('hazel:routes', [{ method: 'GET', path: '/legacy-query', propertyKey: 'legacyQuery' }], TestController);
+            Reflect.defineMetadata('hazel:inject', ['query'], TestController, 'legacyQuery');
+            router.registerController(TestController);
+            const context = {
+                params: {},
+                query: { filter: 'active' },
+                body: {},
+                headers: {},
+                method: 'GET',
+                url: '/test/legacy-query',
+            };
+            const route = await router.match('GET', '/test/legacy-query', context);
+            if (route) {
+                await route.handler(mockReq, mockRes, context);
+                expect(mockRes.json).toHaveBeenCalledWith({ filter: 'active' });
+            }
+        });
+        it('should handle legacy string injection "headers"', async () => {
+            class TestController {
+                legacyHeaders(headers) {
+                    return headers;
+                }
+            }
+            container.register(TestController, new TestController());
+            Reflect.defineMetadata('hazel:controller', { path: '/test' }, TestController);
+            Reflect.defineMetadata('hazel:routes', [{ method: 'GET', path: '/legacy-headers', propertyKey: 'legacyHeaders' }], TestController);
+            Reflect.defineMetadata('hazel:inject', ['headers'], TestController, 'legacyHeaders');
+            router.registerController(TestController);
+            const context = {
+                params: {},
+                query: {},
+                body: {},
+                headers: { 'x-trace': 'abc' },
+                method: 'GET',
+                url: '/test/legacy-headers',
+            };
+            const route = await router.match('GET', '/test/legacy-headers', context);
+            if (route) {
+                await route.handler(mockReq, mockRes, context);
+                expect(mockRes.json).toHaveBeenCalledWith(expect.objectContaining({ 'x-trace': 'abc' }));
+            }
+        });
+        // -----------------------------------------------------------------------
+        // handleRequest edge cases
+        // -----------------------------------------------------------------------
+        it('should return "Internal Server Error" when a non-Error is thrown in handleRequest', async () => {
+            jest.spyOn(router, 'match').mockRejectedValue('string-error');
+            mockReq.method = 'GET';
+            mockReq.url = '/test';
+            await router.handleRequest(mockReq, mockRes);
+            expect(mockRes.status).toHaveBeenCalledWith(500);
+            expect(mockRes.json).toHaveBeenCalledWith({ error: 'Internal Server Error' });
+        });
+        it('should use production error message when NODE_ENV is production', async () => {
+            const originalEnv = process.env.NODE_ENV;
+            process.env.NODE_ENV = 'production';
+            class TestController {
+                throwInProd() {
+                    throw new Error('Sensitive internal details');
+                }
+            }
+            container.register(TestController, new TestController());
+            Reflect.defineMetadata('hazel:controller', { path: '/test' }, TestController);
+            Reflect.defineMetadata('hazel:routes', [{ method: 'GET', path: '/prod-error', propertyKey: 'throwInProd' }], TestController);
+            Reflect.defineMetadata('hazel:inject', [], TestController, 'throwInProd');
+            router.registerController(TestController);
+            const context = {
+                params: {},
+                query: {},
+                body: {},
+                headers: {},
+                method: 'GET',
+                url: '/test/prod-error',
+            };
+            const route = await router.match('GET', '/test/prod-error', context);
+            if (route) {
+                await route.handler(mockReq, mockRes, context);
+                expect(mockRes.status).toHaveBeenCalledWith(500);
+                expect(mockRes.json).toHaveBeenCalledWith(expect.objectContaining({ message: 'Internal server error' }));
+            }
+            process.env.NODE_ENV = originalEnv;
+        });
     });
 });

package/dist/decorators.d.ts

@@ -1,5 +1,5 @@
 import 'reflect-metadata';
-import { Type } from './types';
+import { Type, RequestContext } from './types';
 import { PipeTransform, PipeMetadata } from './pipes/pipe';
 import { Interceptor, InterceptorMetadata } from './interceptors/interceptor';
 import { HazelApp } from './hazel-app';
@@ -44,6 +44,12 @@ export interface ExecutionContext {
     switchToHttp(): {
         getRequest(): unknown;
         getResponse(): unknown;
+        /**
+         * Returns the fully parsed RequestContext for this request.
+         * Gives guards access to `params`, `query`, `headers`, `user`, and `body`
+         * without having to re-parse the raw Node.js IncomingMessage.
+         */
+        getContext(): RequestContext;
     };
 }
 export interface CanActivate {

package/dist/decorators.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"decorators.d.ts","sourceRoot":"","sources":["../src/decorators.ts"],"names":[],"mappings":"AAAA,OAAO,kBAAkB,CAAC;AAE1B,OAAO,EAAE,IAAI,EAAE,MAAM,SAAS,CAAC;AAC/B,OAAO,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAC3D,OAAO,EAAE,WAAW,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAC;AAC9E,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAcvC,MAAM,WAAW,kBAAkB;IACjC,IAAI,EAAE,MAAM,CAAC;IACb,YAAY,CAAC,EAAE,mBAAmB,EAAE,CAAC;CACtC;AAED,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,GAAG,MAAM,CAAC;IACzB,WAAW,CAAC,EAAE,IAAI,CAAC,OAAO,CAAC,EAAE,CAAC;IAC9B,KAAK,CAAC,EAAE,YAAY,EAAE,CAAC;CACxB;AAED,MAAM,WAAW,iBAAiB;IAChC,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,YAAY;IAC3B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,WAAW,CAAC,EAAE,IAAI,CAAC,OAAO,CAAC,EAAE,CAAC;IAC9B,KAAK,CAAC,EAAE,YAAY,EAAE,CAAC;IACvB,YAAY,CAAC,EAAE,mBAAmB,EAAE,CAAC;CACtC;AAID,MAAM,WAAW,cAAc;IAC7B,KAAK,CAAC,EAAE,WAAW,GAAG,WAAW,GAAG,SAAS,CAAC;CAC/C;AAED,MAAM,WAAW,iBAAiB;IAChC,KAAK,CAAC,EAAE,WAAW,GAAG,WAAW,GAAG,SAAS,CAAC;CAC/C;AAED,MAAM,WAAW,iBAAiB;IAChC,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,WAAW,GAAG,WAAW,GAAG,SAAS,CAAC;CAC/C;AAED,MAAM,WAAW,YAAY;IAC3B,YAAY,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CAC/B;AAED,MAAM,WAAW,eAAe;IAC9B,eAAe,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CAClC;AAED,MAAM,WAAW,gBAAgB;IAC/B,YAAY,IAAI;QACd,UAAU,IAAI,OAAO,CAAC;QACtB,WAAW,IAAI,OAAO,CAAC;KACxB,CAAC;CACH;AAED,MAAM,WAAW,WAAW;IAC1B,WAAW,CAAC,OAAO,EAAE,gBAAgB,GAAG,OAAO,CAAC,OAAO,CAAC,GAAG,OAAO,CAAC;CACpE;AAGD,OAAO,EAAE,WAAW,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAC;AAErD,wBAAgB,UAAU,CAAC,OAAO,EAAE,iBAAiB,GAAG,MAAM,GAAG,cAAc,CAQ9E;AAED,wBAAgB,UAAU,CAAC,OAAO,GAAE,iBAAsB,GAAG,cAAc,CAS1E;AAED,wBAAgB,GAAG,CAAC,OAAO,CAAC,EAAE;IAAE,IAAI,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,MAAM,GAAG,eAAe,CAGzE;AAED,wBAAgB,IAAI,CAAC,OAAO,CAAC,EAAE;IAAE,IAAI,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,MAAM,GAAG,eAAe,CAG1E;AAED,wBAAgB,GAAG,CAAC,OAAO,CAAC,EAAE;IAAE,IAAI,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,MAAM,GAAG,eAAe,CAGzE;AAED,wBAAgB,MAAM,CAAC,OAAO,CAAC,EAAE;IAAE,IAAI,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,MAAM,GAAG,eAAe,CAG5E;AAED,wBAAgB,KAAK,CAAC,OAAO,CAAC,EAAE;IAAE,IAAI,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,MAAM,GAAG,eAAe,CAG3E;AAED,wBAAgB,MAAM,CAAC,KAAK,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAAC,OAAO,CAAC,GAAG,kBAAkB,CAalF;AAED,wBAAgB,OAAO,CAAC,OAAO,GAAE,cAAmB,GAAG,cAAc,CAyBpE;AAED,wBAAgB,IAAI,CAAC,OAAO,CAAC,EAAE,IAAI,CAAC,OAAO,CAAC,GAAG,kBAAkB,CA6BhE;AAED,wBAAgB,OAAO,IAAI,kBAAkB,CAgB5C;AAED,wBAAgB,KAAK,CAAC,SAAS,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,IAAI,CAAC,aAAa,CAAC,GAAG,kBAAkB,CAuBvF;AAED,wBAAgB,KAAK,CAAC,SAAS,CAAC,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,IAAI,CAAC,aAAa,CAAC,GAAG,kBAAkB,CAuBxF;AAED,wBAAgB,QAAQ,CACtB,GAAG,KAAK,EAAE,CAAC,IAAI,CAAC,aAAa,CAAC,GAAG,YAAY,CAAC,EAAE,GAC/C,cAAc,GAAG,eAAe,CAgClC;AAED,wBAAgB,eAAe,CAC7B,GAAG,YAAY,EAAE,CAAC,IAAI,CAAC,WAAW,CAAC,GAAG,mBAAmB,CAAC,EAAE,GAC3D,cAAc,GAAG,eAAe,CA4BlC;AAED,wBAAgB,SAAS,CAAC,GAAG,MAAM,EAAE,IAAI,CAAC,WAAW,CAAC,EAAE,GAAG,cAAc,GAAG,eAAe,CAmB1F;AAED,wBAAgB,MAAM,CAAC,OAAO,EAAE;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,EAAE,MAAM,CAAC;CACpB,GAAG,eAAe,CASlB;AAED,wBAAgB,GAAG,IAAI,kBAAkB,CAgBxC;AAED,wBAAgB,OAAO,CAAC,UAAU,CAAC,EAAE,MAAM,GAAG,kBAAkB,CAgB/D;AAED,wBAAgB,QAAQ,CAAC,UAAU,EAAE,MAAM,GAAG,eAAe,CAS5D;AAED,wBAAgB,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,eAAe,CAYnE;AAED,wBAAgB,QAAQ,CAAC,GAAG,EAAE,MAAM,EAAE,UAAU,GAAE,MAAY,GAAG,eAAe,CAS/E;AAED,wBAAgB,GAAG,IAAI,kBAAkB,CAyBxC;AA8CD,OAAO,EAAE,QAAQ,EAAE,CAAC"}
+{"version":3,"file":"decorators.d.ts","sourceRoot":"","sources":["../src/decorators.ts"],"names":[],"mappings":"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"}

package/dist/router.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"router.d.ts","sourceRoot":"","sources":["../src/router.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,SAAS,CAAC;AAC/B,OAAO,EAAE,cAAc,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAC5D,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAMxC,OAAO,kBAAkB,CAAC;AAY1B,UAAU,UAAU;IAClB,OAAO,EAAE,YAAY,CAAC;IACtB,OAAO,EAAE,cAAc,CAAC;CACzB;AAED,KAAK,YAAY,GAAG,CAAC,GAAG,EAAE,OAAO,EAAE,GAAG,EAAE,QAAQ,EAAE,OAAO,CAAC,EAAE,cAAc,KAAK,IAAI,CAAC;AAEpF,qBAAa,MAAM;IAKL,OAAO,CAAC,SAAS;IAJ7B,OAAO,CAAC,MAAM,CAA0C;IACxD,OAAO,CAAC,cAAc,CAAuD;IAC7E,OAAO,CAAC,iBAAiB,CAAoB;gBAEzB,SAAS,EAAE,SAAS;IAUxC,kBAAkB,CAAC,UAAU,EAAE,IAAI,CAAC,OAAO,CAAC,GAAG,IAAI;YA4DrC,UAAU;YAsBV,iBAAiB;IAe/B,OAAO,CAAC,kBAAkB;IAwQ1B,OAAO,CAAC,aAAa;IAiBrB,OAAO,CAAC,SAAS;IAiBjB,OAAO,CAAC,kBAAkB;IAW1B,OAAO,CAAC,aAAa;IAOf,KAAK,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,cAAc,GAAG,OAAO,CAAC,UAAU,GAAG,IAAI,CAAC;IA0C7F,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,YAAY,EAAE,GAAG,IAAI;IAIjD,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,YAAY,EAAE,GAAG,IAAI;IAIlD,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,YAAY,EAAE,GAAG,IAAI;IAIjD,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,YAAY,EAAE,GAAG,IAAI;IAIpD,OAAO,CAAC,QAAQ;IAKV,aAAa,CAAC,GAAG,EAAE,OAAO,EAAE,GAAG,EAAE,QAAQ,GAAG,OAAO,CAAC,IAAI,CAAC;CAkChE"}
+{"version":3,"file":"router.d.ts","sourceRoot":"","sources":["../src/router.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,SAAS,CAAC;AAC/B,OAAO,EAAE,cAAc,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAC5D,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAMxC,OAAO,kBAAkB,CAAC;AAY1B,UAAU,UAAU;IAClB,OAAO,EAAE,YAAY,CAAC;IACtB,OAAO,EAAE,cAAc,CAAC;CACzB;AAED,KAAK,YAAY,GAAG,CAAC,GAAG,EAAE,OAAO,EAAE,GAAG,EAAE,QAAQ,EAAE,OAAO,CAAC,EAAE,cAAc,KAAK,IAAI,CAAC;AAEpF,qBAAa,MAAM;IAKL,OAAO,CAAC,SAAS;IAJ7B,OAAO,CAAC,MAAM,CAA0C;IACxD,OAAO,CAAC,cAAc,CAAuD;IAC7E,OAAO,CAAC,iBAAiB,CAAoB;gBAEzB,SAAS,EAAE,SAAS;IAUxC,kBAAkB,CAAC,UAAU,EAAE,IAAI,CAAC,OAAO,CAAC,GAAG,IAAI;YA4DrC,UAAU;YAsBV,iBAAiB;IAe/B,OAAO,CAAC,kBAAkB;IAiR1B,OAAO,CAAC,aAAa;IAiBrB,OAAO,CAAC,SAAS;IAiBjB,OAAO,CAAC,kBAAkB;IAW1B,OAAO,CAAC,aAAa;IAOf,KAAK,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,cAAc,GAAG,OAAO,CAAC,UAAU,GAAG,IAAI,CAAC;IA0C7F,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,YAAY,EAAE,GAAG,IAAI;IAIjD,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,YAAY,EAAE,GAAG,IAAI;IAIlD,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,YAAY,EAAE,GAAG,IAAI;IAIjD,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,YAAY,EAAE,GAAG,IAAI;IAIpD,OAAO,CAAC,QAAQ;IAKV,aAAa,CAAC,GAAG,EAAE,OAAO,EAAE,GAAG,EAAE,QAAQ,GAAG,OAAO,CAAC,IAAI,CAAC;CAkChE"}

package/dist/router.js

@@ -142,6 +142,7 @@ class Router {
                         switchToHttp: () => ({
                             getRequest: () => req,
                             getResponse: () => res,
+                            getContext: () => context,
                         }),
                     };
                     for (const guardType of allGuards) {
@@ -235,6 +236,16 @@ class Router {
                                 args[i] = queryValue;
                             }
                         }
+                        else if (injection.type === 'user') {
+                            // Handle @CurrentUser() decorator — reads from context.user (set by a guard)
+                            const user = context.user ?? req.user;
+                            args[i] = injection.field ? user?.[injection.field] : user;
+                        }
+                        else if (injection.type === 'custom' && typeof injection.resolve === 'function') {
+                            // Handle custom parameter decorators (e.g. @Ability() from @hazeljs/casl).
+                            // The decorator stores a resolver function; call it with request, context, container.
+                            args[i] = await injection.resolve(req, context, this.container);
+                        }
                     }
                 }
                 // Auto-inject RequestContext for undecorated parameters

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hazeljs/core",
-  "version": "0.2.0-beta.58",
+  "version": "0.2.0-beta.60",
   "description": "Core HazelJS framework - Dependency injection, routing, decorators, and base functionality",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -63,5 +63,5 @@
     "url": "https://github.com/hazeljs/hazel-js/issues"
   },
   "homepage": "https://hazeljs.com",
-  "gitHead": "ce3821b373043284ac4847315371efb137dc860d"
+  "gitHead": "8cd6f3cf5b77aba504ec10691324937130feb2c3"
 }