@hazeljs/core 0.2.0-beta.1

package/dist/decorators.js

@@ -0,0 +1,343 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HazelApp = exports.Module = exports.HazelModule = void 0;
+exports.Controller = Controller;
+exports.Injectable = Injectable;
+exports.Get = Get;
+exports.Post = Post;
+exports.Put = Put;
+exports.Delete = Delete;
+exports.Patch = Patch;
+exports.Inject = Inject;
+exports.Service = Service;
+exports.Body = Body;
+exports.Request = Request;
+exports.Param = Param;
+exports.Query = Query;
+exports.UsePipes = UsePipes;
+exports.UseInterceptors = UseInterceptors;
+exports.UseGuards = UseGuards;
+exports.AITask = AITask;
+exports.Req = Req;
+exports.Headers = Headers;
+exports.HttpCode = HttpCode;
+exports.Header = Header;
+exports.Redirect = Redirect;
+exports.Res = Res;
+require("reflect-metadata");
+const logger_1 = __importDefault(require("./logger"));
+const hazel_app_1 = require("./hazel-app");
+Object.defineProperty(exports, "HazelApp", { enumerable: true, get: function () { return hazel_app_1.HazelApp; } });
+const CONTROLLER_METADATA_KEY = 'hazel:controller';
+const INJECTABLE_METADATA_KEY = 'hazel:injectable';
+const ROUTE_METADATA_KEY = 'hazel:routes';
+const SERVICE_METADATA_KEY = 'hazel:service';
+const INJECT_METADATA_KEY = 'hazel:inject';
+const PIPE_METADATA_KEY = 'hazel:pipe';
+const INTERCEPTOR_METADATA_KEY = 'hazel:interceptor';
+const CLASS_INTERCEPTOR_METADATA_KEY = 'hazel:class-interceptors';
+const HTTP_CODE_METADATA_KEY = 'hazel:http-code';
+const HEADER_METADATA_KEY = 'hazel:headers';
+const REDIRECT_METADATA_KEY = 'hazel:redirect';
+// Re-export from hazel-module for backward compatibility
+var hazel_module_1 = require("./hazel-module");
+Object.defineProperty(exports, "HazelModule", { enumerable: true, get: function () { return hazel_module_1.HazelModule; } });
+Object.defineProperty(exports, "Module", { enumerable: true, get: function () { return hazel_module_1.Module; } });
+function Controller(options) {
+    return (target) => {
+        const opts = typeof options === 'string' ? { path: options } : options;
+        logger_1.default.debug(`Registering controller: ${target.constructor?.name || target.name} at path: ${opts.path}`);
+        Reflect.defineMetadata(CONTROLLER_METADATA_KEY, opts, target);
+    };
+}
+function Injectable(options = {}) {
+    return (target) => {
+        logger_1.default.debug(`Registering injectable: ${target.constructor?.name || target.name}`);
+        Reflect.defineMetadata(INJECTABLE_METADATA_KEY, options, target);
+        // Store scope metadata for container
+        if (options.scope) {
+            Reflect.defineMetadata('hazel:scope', options.scope, target);
+        }
+    };
+}
+function Get(options) {
+    const opts = typeof options === 'string' ? { path: options } : options || {};
+    return createRouteDecorator('GET', opts);
+}
+function Post(options) {
+    const opts = typeof options === 'string' ? { path: options } : options || {};
+    return createRouteDecorator('POST', opts);
+}
+function Put(options) {
+    const opts = typeof options === 'string' ? { path: options } : options || {};
+    return createRouteDecorator('PUT', opts);
+}
+function Delete(options) {
+    const opts = typeof options === 'string' ? { path: options } : options || {};
+    return createRouteDecorator('DELETE', opts);
+}
+function Patch(options) {
+    const opts = typeof options === 'string' ? { path: options } : options || {};
+    return createRouteDecorator('PATCH', opts);
+}
+function Inject(token) {
+    return (target, propertyKey, parameterIndex) => {
+        logger_1.default.debug(`Registering injection for parameter ${parameterIndex} in ${target.constructor?.name}`);
+        const injections = Reflect.getMetadata(INJECT_METADATA_KEY, target) || [];
+        injections[parameterIndex] = token;
+        Reflect.defineMetadata(INJECT_METADATA_KEY, injections, target);
+    };
+}
+function Service(options = {}) {
+    return function (target) {
+        Reflect.defineMetadata(SERVICE_METADATA_KEY, options, target);
+        // Store scope metadata for container
+        if (options.scope) {
+            Reflect.defineMetadata('hazel:scope', options.scope, target);
+        }
+        // Get constructor parameters
+        const paramTypes = Reflect.getMetadata('design:paramtypes', target) || [];
+        const repositories = paramTypes
+            .map((paramType, index) => {
+            const model = Reflect.getMetadata('hazel:repository', paramType)?.model;
+            if (model) {
+                return { index, model };
+            }
+            return null;
+        })
+            .filter(Boolean);
+        if (repositories.length > 0) {
+            Reflect.defineMetadata('hazel:repositories', repositories, target);
+        }
+    };
+}
+function Body(dtoType) {
+    return (target, propertyKey, parameterIndex) => {
+        if (!propertyKey) {
+            throw new Error('Body decorator must be used on a method parameter');
+        }
+        logger_1.default.debug(`Registering body parameter ${parameterIndex} in ${target.constructor?.name}`);
+        // Get the constructor of the target
+        const constructor = target
+            .constructor;
+        const injections = Reflect.getMetadata(INJECT_METADATA_KEY, constructor, propertyKey) || [];
+        // Store the injection metadata
+        injections[parameterIndex] = {
+            type: 'body',
+            dtoType,
+            token: dtoType,
+        };
+        logger_1.default.debug('Setting DTO type from Body decorator:', dtoType?.name);
+        logger_1.default.debug('Updated injections:', JSON.stringify(injections, null, 2));
+        Reflect.defineMetadata(INJECT_METADATA_KEY, injections, constructor, propertyKey);
+    };
+}
+function Request() {
+    return (target, propertyKey, parameterIndex) => {
+        if (!propertyKey) {
+            throw new Error('Request decorator must be used on a method parameter');
+        }
+        const constructor = target
+            .constructor;
+        const injections = Reflect.getMetadata(INJECT_METADATA_KEY, constructor, propertyKey) || [];
+        injections[parameterIndex] = { type: 'request' };
+        Reflect.defineMetadata(INJECT_METADATA_KEY, injections, constructor, propertyKey);
+    };
+}
+function Param(paramName, pipe) {
+    return (target, propertyKey, parameterIndex) => {
+        if (!propertyKey) {
+            throw new Error('Param decorator must be used on a method parameter');
+        }
+        logger_1.default.debug(`Registering param ${paramName} at index ${parameterIndex} in ${target.constructor?.name} with pipe:`, pipe?.name);
+        // Get the constructor of the target
+        const constructor = target
+            .constructor;
+        const injections = Reflect.getMetadata(INJECT_METADATA_KEY, constructor, propertyKey) || [];
+        injections[parameterIndex] = { type: 'param', name: paramName, pipe };
+        Reflect.defineMetadata(INJECT_METADATA_KEY, injections, constructor, propertyKey);
+        logger_1.default.debug('Updated injections:', JSON.stringify(injections, null, 2));
+    };
+}
+function Query(paramName, pipe) {
+    return (target, propertyKey, parameterIndex) => {
+        if (!propertyKey) {
+            throw new Error('Query decorator must be used on a method parameter');
+        }
+        logger_1.default.debug(`Registering query param ${paramName || 'all'} at index ${parameterIndex} in ${target.constructor?.name} with pipe:`, pipe?.name);
+        // Get the constructor of the target
+        const constructor = target
+            .constructor;
+        const injections = Reflect.getMetadata(INJECT_METADATA_KEY, constructor, propertyKey) || [];
+        injections[parameterIndex] = { type: 'query', name: paramName, pipe };
+        Reflect.defineMetadata(INJECT_METADATA_KEY, injections, constructor, propertyKey);
+        logger_1.default.debug('Updated injections:', JSON.stringify(injections, null, 2));
+    };
+}
+function UsePipes(...pipes) {
+    const decorator = (target, propertyKey) => {
+        const pipeMetadata = pipes.map((pipe) => {
+            if (typeof pipe === 'function') {
+                return { type: pipe };
+            }
+            return pipe;
+        });
+        if (propertyKey) {
+            // Method decorator
+            const routes = Reflect.getMetadata(ROUTE_METADATA_KEY, target.constructor) || [];
+            const route = routes.find((r) => r.propertyKey === propertyKey);
+            if (route) {
+                route.pipes = pipeMetadata;
+                logger_1.default.debug('Setting pipes for route:', {
+                    method: route.method,
+                    path: route.path,
+                    pipes: pipeMetadata.map((p) => p.type.name),
+                });
+                Reflect.defineMetadata(ROUTE_METADATA_KEY, routes, target.constructor);
+            }
+        }
+        else {
+            // Class decorator
+            const existingPipes = Reflect.getMetadata(PIPE_METADATA_KEY, target) || [];
+            Reflect.defineMetadata(PIPE_METADATA_KEY, [...existingPipes, ...pipeMetadata], target);
+        }
+    };
+    return decorator;
+}
+function UseInterceptors(...interceptors) {
+    const decorator = (target, propertyKey, descriptor) => {
+        const interceptorMetadata = interceptors.map((interceptor) => {
+            if (typeof interceptor === 'function') {
+                return { type: interceptor };
+            }
+            return interceptor;
+        });
+        if (propertyKey && descriptor) {
+            // Method decorator
+            logger_1.default.debug(`Registering interceptors for method ${String(propertyKey)} in ${target.constructor?.name}`);
+            Reflect.defineMetadata(INTERCEPTOR_METADATA_KEY, interceptorMetadata, target, propertyKey);
+            return descriptor;
+        }
+        else {
+            // Class decorator
+            logger_1.default.debug(`Registering interceptors for class ${target.name}`);
+            Reflect.defineMetadata(CLASS_INTERCEPTOR_METADATA_KEY, interceptorMetadata, target);
+        }
+    };
+    return decorator;
+}
+function UseGuards(...guards) {
+    const decorator = (target, propertyKey, descriptor) => {
+        if (propertyKey && descriptor) {
+            // Method decorator
+            const existingGuards = Reflect.getMetadata('hazel:guards', target, propertyKey) || [];
+            Reflect.defineMetadata('hazel:guards', [...existingGuards, ...guards], target, propertyKey);
+            return descriptor;
+        }
+        else {
+            // Class decorator
+            const existingGuards = Reflect.getMetadata('hazel:guards', target) || [];
+            Reflect.defineMetadata('hazel:guards', [...existingGuards, ...guards], target);
+        }
+    };
+    return decorator;
+}
+function AITask(options) {
+    return (target, propertyKey, descriptor) => {
+        Reflect.defineMetadata('hazel:ai-task', options, target, propertyKey);
+        return descriptor;
+    };
+}
+function Req() {
+    return (target, propertyKey, parameterIndex) => {
+        if (!propertyKey) {
+            throw new Error('Req decorator must be used on a method parameter');
+        }
+        const constructor = target
+            .constructor;
+        const injections = Reflect.getMetadata(INJECT_METADATA_KEY, constructor, propertyKey) || [];
+        injections[parameterIndex] = { type: 'request' };
+        Reflect.defineMetadata(INJECT_METADATA_KEY, injections, constructor, propertyKey);
+    };
+}
+function Headers(headerName) {
+    return (target, propertyKey, parameterIndex) => {
+        if (!propertyKey) {
+            throw new Error('Headers decorator must be used on a method parameter');
+        }
+        const constructor = target
+            .constructor;
+        const injections = Reflect.getMetadata(INJECT_METADATA_KEY, constructor, propertyKey) || [];
+        injections[parameterIndex] = { type: 'headers', name: headerName };
+        Reflect.defineMetadata(INJECT_METADATA_KEY, injections, constructor, propertyKey);
+    };
+}
+function HttpCode(statusCode) {
+    return (target, propertyKey, descriptor) => {
+        Reflect.defineMetadata(HTTP_CODE_METADATA_KEY, statusCode, target, propertyKey);
+        return descriptor;
+    };
+}
+function Header(name, value) {
+    return (target, propertyKey, descriptor) => {
+        const existingHeaders = Reflect.getMetadata(HEADER_METADATA_KEY, target, propertyKey) || [];
+        existingHeaders.push({ name, value });
+        Reflect.defineMetadata(HEADER_METADATA_KEY, existingHeaders, target, propertyKey);
+        return descriptor;
+    };
+}
+function Redirect(url, statusCode = 302) {
+    return (target, propertyKey, descriptor) => {
+        Reflect.defineMetadata(REDIRECT_METADATA_KEY, { url, statusCode }, target, propertyKey);
+        return descriptor;
+    };
+}
+function Res() {
+    return (target, propertyKey, parameterIndex) => {
+        if (!propertyKey) {
+            throw new Error('Res decorator must be used on a method parameter');
+        }
+        logger_1.default.debug(`Registering response parameter ${parameterIndex} in ${target.constructor?.name}`);
+        // Get the constructor of the target
+        const constructor = target
+            .constructor;
+        const injections = Reflect.getMetadata(INJECT_METADATA_KEY, constructor, propertyKey) || [];
+        // Store the injection metadata
+        injections[parameterIndex] = {
+            type: 'response',
+        };
+        Reflect.defineMetadata(INJECT_METADATA_KEY, injections, constructor, propertyKey);
+        logger_1.default.debug('Updated injections:', JSON.stringify(injections, null, 2));
+    };
+}
+function createRouteDecorator(method, options) {
+    return (target, propertyKey, descriptor) => {
+        logger_1.default.debug(`Registering ${method} route: ${String(propertyKey)}`);
+        const routes = Reflect.getMetadata(ROUTE_METADATA_KEY, target.constructor) ||
+            [];
+        const routeOptions = typeof options === 'string' ? { path: options } : options || {};
+        const pipes = Reflect.getMetadata(PIPE_METADATA_KEY, target, propertyKey) || [];
+        const interceptors = Reflect.getMetadata(INTERCEPTOR_METADATA_KEY, target, propertyKey) || [];
+        const classInterceptors = Reflect.getMetadata(CLASS_INTERCEPTOR_METADATA_KEY, target.constructor) || [];
+        logger_1.default.debug('Route metadata:', {
+            method,
+            path: routeOptions.path || '/',
+            propertyKey: String(propertyKey),
+            pipes: pipes.map((p) => p.type.name),
+            interceptors: interceptors.map((i) => i.type.name),
+        });
+        routes.push({
+            method,
+            path: routeOptions.path || '/',
+            propertyKey,
+            middlewares: routeOptions.middlewares || [],
+            pipes: [...pipes, ...(routeOptions.pipes || [])],
+            interceptors: [...classInterceptors, ...interceptors, ...(routeOptions.interceptors || [])],
+        });
+        Reflect.defineMetadata(ROUTE_METADATA_KEY, routes, target.constructor);
+        return descriptor;
+    };
+}

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

@@ -0,0 +1,31 @@
+export declare class HttpError extends Error {
+    readonly statusCode: number;
+    readonly errors?: string[] | undefined;
+    constructor(statusCode: number, message: string, errors?: string[] | undefined);
+}
+export declare class BadRequestError extends HttpError {
+    constructor(message: string, errors?: string[]);
+}
+export declare class UnauthorizedError extends HttpError {
+    constructor(message?: string);
+}
+export declare class ForbiddenError extends HttpError {
+    constructor(message?: string);
+}
+export declare class NotFoundError extends HttpError {
+    constructor(message?: string);
+}
+export declare class ConflictError extends HttpError {
+    constructor(message: string);
+}
+export declare class InternalServerError extends HttpError {
+    constructor(message?: string);
+}
+export declare const HttpException: typeof HttpError;
+export declare const BadRequestException: typeof BadRequestError;
+export declare const UnauthorizedException: typeof UnauthorizedError;
+export declare const ForbiddenException: typeof ForbiddenError;
+export declare const NotFoundException: typeof NotFoundError;
+export declare const ConflictException: typeof ConflictError;
+export declare const InternalServerErrorException: typeof InternalServerError;
+//# sourceMappingURL=http.error.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"http.error.d.ts","sourceRoot":"","sources":["../../src/errors/http.error.ts"],"names":[],"mappings":"AAAA,qBAAa,SAAU,SAAQ,KAAK;aAEhB,UAAU,EAAE,MAAM;aAElB,MAAM,CAAC,EAAE,MAAM,EAAE;gBAFjB,UAAU,EAAE,MAAM,EAClC,OAAO,EAAE,MAAM,EACC,MAAM,CAAC,EAAE,MAAM,EAAE,YAAA;CAKpC;AAED,qBAAa,eAAgB,SAAQ,SAAS;gBAChC,OAAO,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,EAAE;CAI/C;AAED,qBAAa,iBAAkB,SAAQ,SAAS;gBAClC,OAAO,GAAE,MAAuB;CAI7C;AAED,qBAAa,cAAe,SAAQ,SAAS;gBAC/B,OAAO,GAAE,MAAoB;CAI1C;AAED,qBAAa,aAAc,SAAQ,SAAS;gBAC9B,OAAO,GAAE,MAAoB;CAI1C;AAED,qBAAa,aAAc,SAAQ,SAAS;gBAC9B,OAAO,EAAE,MAAM;CAI5B;AAED,qBAAa,mBAAoB,SAAQ,SAAS;gBACpC,OAAO,GAAE,MAAgC;CAItD;AAGD,eAAO,MAAM,aAAa,kBAAY,CAAC;AACvC,eAAO,MAAM,mBAAmB,wBAAkB,CAAC;AACnD,eAAO,MAAM,qBAAqB,0BAAoB,CAAC;AACvD,eAAO,MAAM,kBAAkB,uBAAiB,CAAC;AACjD,eAAO,MAAM,iBAAiB,sBAAgB,CAAC;AAC/C,eAAO,MAAM,iBAAiB,sBAAgB,CAAC;AAC/C,eAAO,MAAM,4BAA4B,4BAAsB,CAAC"}

package/dist/errors/http.error.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InternalServerErrorException = exports.ConflictException = exports.NotFoundException = exports.ForbiddenException = exports.UnauthorizedException = exports.BadRequestException = exports.HttpException = exports.InternalServerError = exports.ConflictError = exports.NotFoundError = exports.ForbiddenError = exports.UnauthorizedError = exports.BadRequestError = exports.HttpError = void 0;
+class HttpError extends Error {
+    constructor(statusCode, message, errors) {
+        super(message);
+        this.statusCode = statusCode;
+        this.errors = errors;
+        this.name = 'HttpError';
+    }
+}
+exports.HttpError = HttpError;
+class BadRequestError extends HttpError {
+    constructor(message, errors) {
+        super(400, message, errors);
+        this.name = 'BadRequestError';
+    }
+}
+exports.BadRequestError = BadRequestError;
+class UnauthorizedError extends HttpError {
+    constructor(message = 'Unauthorized') {
+        super(401, message);
+        this.name = 'UnauthorizedError';
+    }
+}
+exports.UnauthorizedError = UnauthorizedError;
+class ForbiddenError extends HttpError {
+    constructor(message = 'Forbidden') {
+        super(403, message);
+        this.name = 'ForbiddenError';
+    }
+}
+exports.ForbiddenError = ForbiddenError;
+class NotFoundError extends HttpError {
+    constructor(message = 'Not Found') {
+        super(404, message);
+        this.name = 'NotFoundError';
+    }
+}
+exports.NotFoundError = NotFoundError;
+class ConflictError extends HttpError {
+    constructor(message) {
+        super(409, message);
+        this.name = 'ConflictError';
+    }
+}
+exports.ConflictError = ConflictError;
+class InternalServerError extends HttpError {
+    constructor(message = 'Internal Server Error') {
+        super(500, message);
+        this.name = 'InternalServerError';
+    }
+}
+exports.InternalServerError = InternalServerError;
+// Aliases using Exception naming convention (matches documentation)
+exports.HttpException = HttpError;
+exports.BadRequestException = BadRequestError;
+exports.UnauthorizedException = UnauthorizedError;
+exports.ForbiddenException = ForbiddenError;
+exports.NotFoundException = NotFoundError;
+exports.ConflictException = ConflictError;
+exports.InternalServerErrorException = InternalServerError;

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

@@ -0,0 +1,39 @@
+import { Request, Response } from '../types';
+/**
+ * Arguments host provides access to the underlying platform request/response
+ */
+export interface ArgumentsHost {
+    switchToHttp(): {
+        getRequest<T = Request>(): T;
+        getResponse<T = Response>(): T;
+    };
+    getType(): string;
+}
+/**
+ * Exception filter interface
+ */
+export interface ExceptionFilter<T = unknown> {
+    catch(exception: T, host: ArgumentsHost): void | Promise<void>;
+}
+/**
+ * Implementation of ArgumentsHost
+ */
+export declare class ArgumentsHostImpl implements ArgumentsHost {
+    private readonly request;
+    private readonly response;
+    constructor(request: Request, response: Response);
+    switchToHttp(): {
+        getRequest: <T = Request>() => T;
+        getResponse: <T = Response>() => T;
+    };
+    getType(): string;
+}
+/**
+ * Decorator to mark a class as an exception filter
+ */
+export declare function Catch(...exceptions: Array<new (...args: never[]) => unknown>): ClassDecorator;
+/**
+ * Get exception types that a filter handles
+ */
+export declare function getFilterExceptions(filter: object): Array<new (...args: unknown[]) => unknown>;
+//# sourceMappingURL=exception-filter.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"exception-filter.d.ts","sourceRoot":"","sources":["../../src/filters/exception-filter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AAE7C;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B,YAAY,IAAI;QACd,UAAU,CAAC,CAAC,GAAG,OAAO,KAAK,CAAC,CAAC;QAC7B,WAAW,CAAC,CAAC,GAAG,QAAQ,KAAK,CAAC,CAAC;KAChC,CAAC;IACF,OAAO,IAAI,MAAM,CAAC;CACnB;AAED;;GAEG;AACH,MAAM,WAAW,eAAe,CAAC,CAAC,GAAG,OAAO;IAC1C,KAAK,CAAC,SAAS,EAAE,CAAC,EAAE,IAAI,EAAE,aAAa,GAAG,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CAChE;AAED;;GAEG;AACH,qBAAa,iBAAkB,YAAW,aAAa;IAEnD,OAAO,CAAC,QAAQ,CAAC,OAAO;IACxB,OAAO,CAAC,QAAQ,CAAC,QAAQ;gBADR,OAAO,EAAE,OAAO,EAChB,QAAQ,EAAE,QAAQ;IAGrC,YAAY,IAAI;QAAE,UAAU,EAAE,CAAC,CAAC,GAAG,OAAO,OAAO,CAAC,CAAC;QAAC,WAAW,EAAE,CAAC,CAAC,GAAG,QAAQ,OAAO,CAAC,CAAA;KAAE;IAOxF,OAAO,IAAI,MAAM;CAGlB;AAED;;GAEG;AACH,wBAAgB,KAAK,CAAC,GAAG,UAAU,EAAE,KAAK,CAAC,KAAK,GAAG,IAAI,EAAE,KAAK,EAAE,KAAK,OAAO,CAAC,GAAG,cAAc,CAI7F;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,MAAM,GAAG,KAAK,CAAC,KAAK,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,OAAO,CAAC,CAE9F"}

package/dist/filters/exception-filter.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ArgumentsHostImpl = void 0;
+exports.Catch = Catch;
+exports.getFilterExceptions = getFilterExceptions;
+/**
+ * Implementation of ArgumentsHost
+ */
+class ArgumentsHostImpl {
+    constructor(request, response) {
+        this.request = request;
+        this.response = response;
+    }
+    switchToHttp() {
+        return {
+            getRequest: () => this.request,
+            getResponse: () => this.response,
+        };
+    }
+    getType() {
+        return 'http';
+    }
+}
+exports.ArgumentsHostImpl = ArgumentsHostImpl;
+/**
+ * Decorator to mark a class as an exception filter
+ */
+function Catch(...exceptions) {
+    return (target) => {
+        Reflect.defineMetadata('hazel:exception-filter', exceptions, target);
+    };
+}
+/**
+ * Get exception types that a filter handles
+ */
+function getFilterExceptions(filter) {
+    return Reflect.getMetadata('hazel:exception-filter', filter.constructor) || [];
+}

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

@@ -0,0 +1,9 @@
+import { ExceptionFilter, ArgumentsHost } from './exception-filter';
+import { HttpError } from '../errors/http.error';
+/**
+ * Built-in HTTP exception filter
+ */
+export declare class HttpExceptionFilter implements ExceptionFilter<HttpError> {
+    catch(exception: HttpError, host: ArgumentsHost): void;
+}
+//# sourceMappingURL=http-exception.filter.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"http-exception.filter.d.ts","sourceRoot":"","sources":["../../src/filters/http-exception.filter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,aAAa,EAAS,MAAM,oBAAoB,CAAC;AAC3E,OAAO,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AAGjD;;GAEG;AACH,qBACa,mBAAoB,YAAW,eAAe,CAAC,SAAS,CAAC;IACpE,KAAK,CAAC,SAAS,EAAE,SAAS,EAAE,IAAI,EAAE,aAAa,GAAG,IAAI;CAsBvD"}

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

@@ -0,0 +1,42 @@
+"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;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpExceptionFilter = void 0;
+const exception_filter_1 = require("./exception-filter");
+const http_error_1 = require("../errors/http.error");
+const logger_1 = __importDefault(require("../logger"));
+/**
+ * Built-in HTTP exception filter
+ */
+let HttpExceptionFilter = class HttpExceptionFilter {
+    catch(exception, host) {
+        const ctx = host.switchToHttp();
+        const response = ctx.getResponse();
+        const request = ctx.getRequest();
+        const status = exception.statusCode || 500;
+        const message = exception.message || 'Internal server error';
+        logger_1.default.error(`[${request.method}] ${request.url} - ${message} (${status})`);
+        if (process.env.NODE_ENV === 'development' && exception.stack) {
+            logger_1.default.debug(exception.stack);
+        }
+        response.status(status).json({
+            statusCode: status,
+            message,
+            timestamp: new Date().toISOString(),
+            path: request.url,
+            ...(exception.errors && { errors: exception.errors }),
+        });
+    }
+};
+exports.HttpExceptionFilter = HttpExceptionFilter;
+exports.HttpExceptionFilter = HttpExceptionFilter = __decorate([
+    (0, exception_filter_1.Catch)(http_error_1.HttpError)
+], HttpExceptionFilter);

package/dist/hazel-app.d.ts

@@ -0,0 +1,78 @@
+import { Type } from './types';
+import { Container } from './container';
+import { Router } from './router';
+import 'reflect-metadata';
+import { Request, Response } from './types';
+import { ShutdownManager } from './shutdown';
+import { HealthCheckManager } from './health';
+import { TimeoutOptions } from './middleware/timeout.middleware';
+import { CorsOptions } from './middleware/cors.middleware';
+export declare class HazelApp {
+    private readonly moduleType;
+    private container;
+    private router;
+    private requestParser;
+    private server;
+    private module;
+    private shutdownManager;
+    private healthManager;
+    private requestTimeout;
+    private corsEnabled;
+    private corsOptions?;
+    private timeoutMiddleware?;
+    constructor(moduleType: Type<unknown>);
+    private initialize;
+    private collectControllers;
+    register<T>(component: Type<T>): HazelApp;
+    get(path: string, ...handlers: Array<(req: Request, res: Response) => void>): HazelApp;
+    post(path: string, ...handlers: Array<(req: Request, res: Response) => void>): HazelApp;
+    put(path: string, ...handlers: Array<(req: Request, res: Response) => void>): HazelApp;
+    delete(path: string, ...handlers: Array<(req: Request, res: Response) => void>): HazelApp;
+    listen(port: number): Promise<void>;
+    private handleRoute;
+    close(): Promise<void>;
+    /**
+     * Register a custom shutdown handler
+     */
+    registerShutdownHandler(handler: {
+        name: string;
+        handler: () => Promise<void>;
+        timeout?: number;
+    }): void;
+    /**
+     * Register a custom health check
+     */
+    registerHealthCheck(check: {
+        name: string;
+        check: () => Promise<{
+            status: 'healthy' | 'unhealthy' | 'degraded';
+            message?: string;
+            details?: Record<string, unknown>;
+        }>;
+        critical?: boolean;
+        timeout?: number;
+    }): void;
+    /**
+     * Set request timeout
+     */
+    setRequestTimeout(timeout: number, options?: TimeoutOptions): void;
+    /**
+     * Enable CORS
+     */
+    enableCors(options?: CorsOptions): void;
+    /**
+     * Disable CORS
+     */
+    disableCors(): void;
+    /**
+     * Get health check manager
+     */
+    getHealthManager(): HealthCheckManager;
+    /**
+     * Get shutdown manager
+     */
+    getShutdownManager(): ShutdownManager;
+    getContainer(): Container;
+    getRouter(): Router;
+}
+//# sourceMappingURL=hazel-app.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"hazel-app.d.ts","sourceRoot":"","sources":["../src/hazel-app.ts"],"names":[],"mappings":"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"}