@hazeljs/core 0.2.0-alpha.1

package/dist/decorators.js

@@ -0,0 +1,538 @@
+"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.SkipAuth = exports.Module = exports.HazelModule = exports.CUSTOM_METADATA_PREFIX = 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;
+exports.Ip = Ip;
+exports.Host = Host;
+exports.Public = Public;
+exports.Timeout = Timeout;
+exports.Optional = Optional;
+exports.Session = Session;
+exports.Retry = Retry;
+exports.ApiTags = ApiTags;
+exports.ApiOperation = ApiOperation;
+exports.SetMetadata = SetMetadata;
+exports.getMetadata = getMetadata;
+exports.createParamDecorator = createParamDecorator;
+require("reflect-metadata");
+const logger_1 = __importDefault(require("./logger"));
+const interceptor_1 = require("./interceptors/interceptor");
+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';
+const PUBLIC_METADATA_KEY = 'hazel:public';
+const TIMEOUT_METADATA_KEY = 'hazel:timeout';
+const OPTIONAL_INDICES_METADATA_KEY = 'hazel:optional-indices';
+const RETRY_METADATA_KEY = 'hazel:retry';
+const API_TAGS_METADATA_KEY = 'hazel:api:tags';
+const API_OPERATION_METADATA_KEY = 'hazel:api:operation';
+exports.CUSTOM_METADATA_PREFIX = 'hazel:meta:';
+// 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 Ip() {
+    return (target, propertyKey, parameterIndex) => {
+        if (!propertyKey) {
+            throw new Error('Ip decorator must be used on a method parameter');
+        }
+        const constructor = target
+            .constructor;
+        const injections = Reflect.getMetadata(INJECT_METADATA_KEY, constructor, propertyKey) || [];
+        injections[parameterIndex] = { type: 'ip' };
+        Reflect.defineMetadata(INJECT_METADATA_KEY, injections, constructor, propertyKey);
+    };
+}
+function Host() {
+    return (target, propertyKey, parameterIndex) => {
+        if (!propertyKey) {
+            throw new Error('Host decorator must be used on a method parameter');
+        }
+        const constructor = target
+            .constructor;
+        const injections = Reflect.getMetadata(INJECT_METADATA_KEY, constructor, propertyKey) || [];
+        injections[parameterIndex] = { type: 'host' };
+        Reflect.defineMetadata(INJECT_METADATA_KEY, injections, constructor, propertyKey);
+    };
+}
+/**
+ * Marks a controller or route as public (no auth required).
+ * Guards should check Reflect.getMetadata(PUBLIC_METADATA_KEY, target, propertyKey)
+ * or Reflect.getMetadata(PUBLIC_METADATA_KEY, target) and allow the request when true.
+ */
+function Public() {
+    const setPublic = (target, propertyKey) => {
+        if (propertyKey === undefined) {
+            Reflect.defineMetadata(PUBLIC_METADATA_KEY, true, target);
+        }
+        else {
+            Reflect.defineMetadata(PUBLIC_METADATA_KEY, true, target, propertyKey);
+        }
+    };
+    const decorator = (target, propertyKey, descriptor) => {
+        if (propertyKey !== undefined && descriptor !== undefined) {
+            setPublic(target, propertyKey);
+            return descriptor;
+        }
+        setPublic(target);
+    };
+    return decorator;
+}
+/** Alias for @Public(). Use when you want to skip auth for specific routes. */
+exports.SkipAuth = Public;
+function Timeout(ms) {
+    return (target, propertyKey, descriptor) => {
+        Reflect.defineMetadata(TIMEOUT_METADATA_KEY, ms, target, propertyKey);
+        return descriptor;
+    };
+}
+function Optional() {
+    return (target, propertyKey, parameterIndex) => {
+        if (!propertyKey) {
+            throw new Error('Optional decorator must be used on a method parameter');
+        }
+        const constructor = target
+            .constructor;
+        const indices = Reflect.getMetadata(OPTIONAL_INDICES_METADATA_KEY, constructor, propertyKey) || [];
+        if (!indices.includes(parameterIndex)) {
+            indices.push(parameterIndex);
+        }
+        Reflect.defineMetadata(OPTIONAL_INDICES_METADATA_KEY, indices, constructor, propertyKey);
+    };
+}
+function Session() {
+    return (target, propertyKey, parameterIndex) => {
+        if (!propertyKey) {
+            throw new Error('Session decorator must be used on a method parameter');
+        }
+        const constructor = target
+            .constructor;
+        const injections = Reflect.getMetadata(INJECT_METADATA_KEY, constructor, propertyKey) || [];
+        injections[parameterIndex] = { type: 'session' };
+        Reflect.defineMetadata(INJECT_METADATA_KEY, injections, constructor, propertyKey);
+    };
+}
+function Retry(options) {
+    return (target, propertyKey, descriptor) => {
+        Reflect.defineMetadata(RETRY_METADATA_KEY, options, target, propertyKey);
+        const routes = Reflect.getMetadata(ROUTE_METADATA_KEY, target.constructor) || [];
+        const route = routes.find((r) => r.propertyKey === propertyKey);
+        if (route) {
+            route.interceptors = route.interceptors || [];
+            route.interceptors.unshift({ type: interceptor_1.RetryInterceptor, options });
+            Reflect.defineMetadata(ROUTE_METADATA_KEY, routes, target.constructor);
+        }
+        return descriptor;
+    };
+}
+function ApiTags(...tags) {
+    const setTags = (target, propertyKey) => {
+        if (propertyKey === undefined) {
+            Reflect.defineMetadata(API_TAGS_METADATA_KEY, tags, target);
+        }
+        else {
+            Reflect.defineMetadata(API_TAGS_METADATA_KEY, tags, target, propertyKey);
+        }
+    };
+    const decorator = (target, propertyKey, descriptor) => {
+        if (propertyKey !== undefined && descriptor !== undefined) {
+            setTags(target, propertyKey);
+            return descriptor;
+        }
+        setTags(target);
+    };
+    return decorator;
+}
+function ApiOperation(options) {
+    const opts = typeof options === 'string' ? { summary: options } : options;
+    return (target, propertyKey, descriptor) => {
+        Reflect.defineMetadata(API_OPERATION_METADATA_KEY, opts, target, propertyKey);
+        return descriptor;
+    };
+}
+/**
+ * Sets arbitrary metadata on a class or method.
+ * Guards, interceptors, and other components can read it via getMetadata(key, target, propertyKey?).
+ *
+ * @param key - Metadata key (stored under hazel:meta:<key> to avoid collisions)
+ * @param value - Value to store (any serializable or object)
+ * @example
+ * SetMetadata('roles', ['admin'])(MyController)
+ * SetMetadata('roles', ['user'])(MyController.prototype, 'getProfile')
+ */
+function SetMetadata(key, value) {
+    const metaKey = `${exports.CUSTOM_METADATA_PREFIX}${key}`;
+    const decorator = (target, propertyKey, descriptor) => {
+        if (propertyKey !== undefined && descriptor !== undefined) {
+            Reflect.defineMetadata(metaKey, value, target, propertyKey);
+            return descriptor;
+        }
+        Reflect.defineMetadata(metaKey, value, target);
+    };
+    return decorator;
+}
+/**
+ * Reads custom metadata set with SetMetadata.
+ *
+ * @param key - Key passed to SetMetadata(key, value)
+ * @param target - Class or prototype
+ * @param propertyKey - Optional method name (for method-level metadata)
+ */
+function getMetadata(key, target, propertyKey) {
+    const metaKey = `${exports.CUSTOM_METADATA_PREFIX}${key}`;
+    if (propertyKey !== undefined) {
+        return Reflect.getMetadata(metaKey, target, propertyKey);
+    }
+    return Reflect.getMetadata(metaKey, target);
+}
+/**
+ * Creates a custom parameter decorator that injects a value computed from the request.
+ * The resolver receives the raw request, parsed request context, and the DI container.
+ * Return value can be a Promise for async resolution (e.g. loading the current user from DB).
+ *
+ * @param resolve - Function (req, context, container) => value | Promise<value>
+ * @example
+ * const CurrentUser = createParamDecorator(async (req, ctx, container) => ctx.user ?? req.user);
+ * // In controller: getProfile(@CurrentUser() user: User) { ... }
+ */
+function createParamDecorator(resolve) {
+    return (target, propertyKey, parameterIndex) => {
+        if (!propertyKey) {
+            throw new Error('createParamDecorator must be used on a method parameter');
+        }
+        const constructor = target.constructor;
+        const injections = Reflect.getMetadata(INJECT_METADATA_KEY, constructor, propertyKey) || [];
+        injections[parameterIndex] = { type: 'custom', resolve };
+        Reflect.defineMetadata(INJECT_METADATA_KEY, injections, constructor, propertyKey);
+    };
+}
+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,34 @@
+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 RequestTimeoutError 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,MAA0B;CAIhD;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,69 @@
+"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.RequestTimeoutError = 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 RequestTimeoutError extends HttpError {
+    constructor(message = 'Request Timeout') {
+        super(408, message);
+        this.name = 'RequestTimeoutError';
+    }
+}
+exports.RequestTimeoutError = RequestTimeoutError;
+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"}