awilixify 2.2.1 → 3.0.0

package/dist/lib/di/providers/types/handler.types.d.ts

@@ -0,0 +1,9 @@
+import type { BuildResolverOptions, Constructor } from "awilix";
+import type { AnyContract } from "lib/mediator/contract.types.js";
+import type { Handler } from "lib/mediator/handler.types.js";
+export interface ConstructorHandler<C extends AnyContract = AnyContract> {
+    new (...args: any[]): Handler<C>;
+}
+export type ClassHandler<H extends Constructor<any> = Constructor<any>> = {
+    useClass: H;
+} & BuildResolverOptions<any>;

package/dist/lib/di/providers/types/handler.types.js

@@ -0,0 +1 @@
+export {};

package/dist/lib/di/providers/types/index.d.ts

@@ -0,0 +1,7 @@
+export * from "./controller.types.js";
+export * from "./decorator-context.types.js";
+export * from "./handler.types.js";
+export * from "./initializer.types.js";
+export * from "./interceptor.types.js";
+export * from "./middleware.types.js";
+export * from "./provider.types.js";

package/dist/lib/di/providers/types/index.js

@@ -0,0 +1,7 @@
+export * from "./controller.types.js";
+export * from "./decorator-context.types.js";
+export * from "./handler.types.js";
+export * from "./initializer.types.js";
+export * from "./interceptor.types.js";
+export * from "./middleware.types.js";
+export * from "./provider.types.js";

package/dist/lib/di/providers/types/initializer.types.d.ts

@@ -0,0 +1,16 @@
+import type { Constructor } from "awilix";
+import type { AnyDecoratorToken, DecoratorExecutionContext } from "./decorator-context.types.js";
+export type DefInitializerMap = Record<string, ConstructorInitializer>;
+export interface ConstructorInitializer {
+    new (...args: any[]): Initializer<any, boolean>;
+}
+export type MetadataInitializerContext<TToken extends AnyDecoratorToken = AnyDecoratorToken> = DecoratorExecutionContext<TToken, Constructor<any>>;
+export type InitializerContext<TToken extends AnyDecoratorToken = AnyDecoratorToken> = MetadataInitializerContext<TToken> & {
+    invoke: (...args: unknown[]) => unknown | Promise<unknown>;
+};
+export declare abstract class Initializer<TToken extends AnyDecoratorToken = AnyDecoratorToken, TUsesInvoke extends boolean = true> {
+    abstract readonly token: TToken;
+    readonly usesInvoke: TUsesInvoke;
+    abstract initialize(context: TUsesInvoke extends true ? InitializerContext<TToken> : MetadataInitializerContext<TToken>): void | Promise<void>;
+}
+export type AnyInitializer = ConstructorInitializer;

package/dist/lib/di/providers/types/initializer.types.js

@@ -0,0 +1,3 @@
+export class Initializer {
+    usesInvoke = true;
+}

package/dist/lib/di/providers/types/interceptor.types.d.ts

@@ -0,0 +1,18 @@
+import type { BuildResolverOptions, Constructor } from "awilix";
+import type { AnyDecoratorToken, DecoratorExecutionContext } from "./decorator-context.types.js";
+export type DefInterceptorMap = Record<string, object>;
+export interface ConstructorInterceptor {
+    new (...args: any[]): Interceptor;
+}
+export type ClassInterceptor<I extends Constructor<any> = Constructor<any>> = {
+    useClass: I;
+} & BuildResolverOptions<any>;
+export type AnyInterceptor = ClassInterceptor | ConstructorInterceptor;
+export type InterceptContext<TToken extends AnyDecoratorToken = AnyDecoratorToken> = DecoratorExecutionContext<TToken> & {
+    args: unknown[];
+    proceed: () => unknown | Promise<unknown>;
+};
+export interface Interceptor<TToken extends AnyDecoratorToken = AnyDecoratorToken> {
+    token: TToken;
+    intercept(context: InterceptContext<TToken>): unknown | Promise<unknown>;
+}

package/dist/lib/di/providers/types/interceptor.types.js

@@ -0,0 +1 @@
+export {};

package/dist/lib/di/providers/types/middleware.types.d.ts

@@ -0,0 +1,10 @@
+import type { BuildResolverOptions, Constructor } from "awilix";
+import type { AnyMiddlewareContract, Middleware } from "lib/mediator/middleware.types.js";
+export type DefPreHandlerMap = Record<string, object>;
+export interface ConstructorMiddleware<C extends AnyMiddlewareContract = AnyMiddlewareContract> {
+    new (...args: any[]): Middleware<C>;
+}
+export type ClassMiddleware<M extends Constructor<any> = Constructor<any>> = {
+    useClass: M;
+} & BuildResolverOptions<any>;
+export type AnyMiddleware = ClassMiddleware | Constructor<Middleware>;

package/dist/lib/di/providers/types/middleware.types.js

@@ -0,0 +1 @@
+export {};

package/dist/lib/di/providers/types/provider.types.d.ts

@@ -0,0 +1,26 @@
+import type { BuildResolverOptions, Constructor } from "awilix";
+export type DefProviderMap = Record<string, object | string | boolean | number>;
+export type ConstructorProvider<T extends object = object> = Constructor<T>;
+export type PrimitiveProvider = string | number | boolean | symbol | bigint;
+export type FunctionProvider = (...args: any[]) => any;
+export type FactoryProvider<T extends object, DepsMap extends Record<string, unknown>, Keys extends readonly Extract<keyof DepsMap, string>[], Strict extends boolean = true> = {
+    inject?: Keys;
+    initAfter?: readonly Extract<keyof DepsMap, string>[];
+    eager?: boolean;
+    useFactory: Strict extends true ? (...args: MapKeysToValues<DepsMap, Keys>) => T | Promise<T> : (...args: any[]) => T | Promise<T>;
+} & BuildResolverOptions<T>;
+export type ClassProvider<T extends object, DepsMap extends Record<string, unknown> = Record<string, unknown>> = {
+    useClass: Constructor<T>;
+    allowCircular?: boolean;
+    eager?: boolean;
+    initAfter?: readonly Extract<keyof DepsMap, string>[];
+} & BuildResolverOptions<T>;
+export interface ProviderInit {
+    init(): void | Promise<void>;
+}
+export type Provider<T extends object, DepsMap extends Record<string, unknown> = Record<string, unknown>> = FactoryProvider<T, DepsMap, readonly Extract<keyof DepsMap, string>[], false> | ClassProvider<T, DepsMap> | ConstructorProvider<T>;
+export type AnyProvider = FactoryProvider<any, any, readonly string[], false> | ClassProvider<any> | ConstructorProvider<any> | PrimitiveProvider | FunctionProvider | object;
+type MapKeysToValues<DepsMap extends Record<string, unknown>, Keys extends readonly Extract<keyof DepsMap, string>[]> = {
+    [K in keyof Keys]: Keys[K] extends keyof DepsMap ? DepsMap[Keys[K]] : never;
+};
+export {};

package/dist/lib/di/providers/types/provider.types.js

@@ -0,0 +1 @@
+export {};

package/dist/lib/di/request-scope-context.d.ts

@@ -0,0 +1,5 @@
+import type * as Awilix from "awilix";
+export declare function runInRequestScopeContext<T>(fn: () => T): T;
+export declare function hasRequestScopeContext(): boolean;
+export declare function getOrCreateRequestScope(scope: Awilix.AwilixContainer): Awilix.AwilixContainer;
+export declare function resolveFromRequestScope<T>(scope: Awilix.AwilixContainer, token: string | symbol): T;

package/dist/lib/di/request-scope-context.js

@@ -0,0 +1,28 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+const requestScopeStorage = new AsyncLocalStorage();
+export function runInRequestScopeContext(fn) {
+    const existingStore = requestScopeStorage.getStore();
+    if (existingStore) {
+        return fn();
+    }
+    return requestScopeStorage.run(new Map(), fn);
+}
+export function hasRequestScopeContext() {
+    return !!requestScopeStorage.getStore();
+}
+export function getOrCreateRequestScope(scope) {
+    const store = requestScopeStorage.getStore();
+    if (!store) {
+        return scope.createScope();
+    }
+    const existingScope = store.get(scope);
+    if (existingScope) {
+        return existingScope;
+    }
+    const requestScope = scope.createScope();
+    store.set(scope, requestScope);
+    return requestScope;
+}
+export function resolveFromRequestScope(scope, token) {
+    return getOrCreateRequestScope(scope).resolve(token);
+}

package/dist/lib/di/type-guards.d.ts

@@ -0,0 +1,35 @@
+import type { BuildResolverOptions, Constructor } from "awilix";
+import type { ForwardRef } from "./modules/module-ref.types.js";
+import type { FactoryProvider, FunctionProvider, PrimitiveProvider } from "./providers/provider.types.js";
+export declare function hasUseClass<T extends object = object>(value: unknown): value is {
+    useClass: Constructor<T>;
+    allowCircular?: boolean;
+    eager?: boolean;
+    initAfter?: readonly string[];
+} & Partial<BuildResolverOptions<any>>;
+export declare function isFactoryProvider<T extends object>(provider: unknown): provider is FactoryProvider<T, any, readonly string[], false>;
+export declare function isAsyncFactoryProvider(provider: unknown): boolean;
+export declare function isCostructorProvider<T extends object>(provider: unknown): provider is Constructor<T>;
+export declare function isPrimitive(provider: unknown): provider is PrimitiveProvider;
+export declare function isPlainFunction(provider: unknown): provider is FunctionProvider;
+export declare function isForwardRef(value: unknown): value is ForwardRef;
+export declare function isPromiseLike<T = unknown>(value: unknown): value is Promise<T>;
+export declare function isEagerProvider(provider: unknown): provider is {
+    eager: true;
+};
+export declare function hasProviderInit(value: unknown): value is {
+    init: () => void | Promise<void>;
+};
+export declare function hasProviderPostInit(value: unknown): value is {
+    postInit: () => void | Promise<void>;
+};
+export declare function hasInitAfter(provider: unknown): provider is {
+    initAfter: readonly string[];
+};
+export declare function isResultLike(value: unknown): value is {
+    ok: true;
+    value: unknown;
+} | {
+    ok: false;
+    error: unknown;
+};

package/dist/lib/di/type-guards.js

@@ -0,0 +1,84 @@
+export function hasUseClass(value) {
+    return typeof value === "object" && value !== null && "useClass" in value;
+}
+export function isFactoryProvider(provider) {
+    return (typeof provider === "object" &&
+        provider !== null &&
+        "useFactory" in provider);
+}
+export function isAsyncFactoryProvider(provider) {
+    return (isFactoryProvider(provider) &&
+        provider.useFactory.constructor.name === "AsyncFunction");
+}
+export function isCostructorProvider(provider) {
+    if (typeof provider !== "function")
+        return false;
+    if (!("prototype" in provider))
+        return false;
+    const proto = provider.prototype;
+    if (!proto || typeof proto !== "object")
+        return false;
+    const protoKeys = Object.getOwnPropertyNames(proto);
+    if (protoKeys.length === 0 ||
+        (protoKeys.length === 1 && protoKeys[0] === "constructor")) {
+        return provider.toString().trim().startsWith("class");
+    }
+    return true;
+}
+export function isPrimitive(provider) {
+    return (typeof provider === "string" ||
+        typeof provider === "number" ||
+        typeof provider === "boolean" ||
+        typeof provider === "symbol" ||
+        typeof provider === "bigint");
+}
+export function isPlainFunction(provider) {
+    return (typeof provider === "function" &&
+        (!provider.prototype || Object.keys(provider.prototype).length === 0));
+}
+export function isForwardRef(value) {
+    return (typeof value === "object" &&
+        value !== null &&
+        "__forward_ref__" in value &&
+        value.__forward_ref__ === true &&
+        "resolve" in value &&
+        typeof value.resolve === "function");
+}
+export function isPromiseLike(value) {
+    return (typeof value === "object" &&
+        value !== null &&
+        "then" in value &&
+        typeof value.then === "function");
+}
+export function isEagerProvider(provider) {
+    return (typeof provider === "object" &&
+        provider !== null &&
+        "eager" in provider &&
+        provider.eager === true);
+}
+export function hasProviderInit(value) {
+    return (typeof value === "object" &&
+        value !== null &&
+        "init" in value &&
+        typeof value.init === "function");
+}
+export function hasProviderPostInit(value) {
+    return (typeof value === "object" &&
+        value !== null &&
+        "postInit" in value &&
+        typeof value.postInit === "function");
+}
+export function hasInitAfter(provider) {
+    return (typeof provider === "object" &&
+        provider !== null &&
+        "initAfter" in provider &&
+        Array.isArray(provider.initAfter));
+}
+export function isResultLike(value) {
+    return (typeof value === "object" &&
+        value !== null &&
+        "ok" in value &&
+        (value.ok === true
+            ? "value" in value
+            : value.ok === false && "error" in value));
+}

package/dist/lib/http/decorators.d.ts

@@ -0,0 +1,33 @@
+import type { DecoratorState, DecoratorToken } from "../decorators/decorator-state.types.js";
+import { type HttpVerb } from "./http-verbs.js";
+import type { RouteSchema } from "./openapi-builder.js";
+type MiddlewareParameter = any[] | any;
+type ControllerOptions = string | string[] | {
+    path: string | string[];
+};
+interface RootState {
+    paths: string[];
+    beforeMiddleware: any[];
+    afterMiddleware: any[];
+}
+interface MethodState {
+    paths: string[];
+    beforeMiddleware: any[];
+    afterMiddleware: any[];
+    verbs: HttpVerb[];
+    schema: RouteSchema;
+}
+export interface HttpDecoratorState extends DecoratorState<MethodState, RootState> {
+}
+export declare const HTTP_DECORATOR_STATE_TOKEN: DecoratorToken<HttpDecoratorState>;
+export declare const GET: (path?: string) => (target: any, context: ClassMethodDecoratorContext) => any;
+export declare const POST: (path?: string) => (target: any, context: ClassMethodDecoratorContext) => any;
+export declare const PUT: (path?: string) => (target: any, context: ClassMethodDecoratorContext) => any;
+export declare const DELETE: (path?: string) => (target: any, context: ClassMethodDecoratorContext) => any;
+export declare const PATCH: (path?: string) => (target: any, context: ClassMethodDecoratorContext) => any;
+export declare function controller(options?: ControllerOptions): (target: any, context: ClassDecoratorContext) => any;
+export declare function before(middleware: MiddlewareParameter): (target: any, context: ClassMethodDecoratorContext | ClassDecoratorContext) => any;
+export declare function after(middleware: MiddlewareParameter): (target: any, context: ClassMethodDecoratorContext | ClassDecoratorContext) => any;
+export declare function schema(schema: RouteSchema): (target: any, context: ClassMethodDecoratorContext) => any;
+export declare function rollUpHttpDecoratorState(root: RootState, method: MethodState): MethodState;
+export {};

package/dist/lib/http/decorators.js

@@ -0,0 +1,151 @@
+import { createDecoratorStateUpdater } from "../decorators/decorator-state.js";
+import { HttpVerbs } from "./http-verbs.js";
+const { update, token } = createDecoratorStateUpdater("http-decorator-state", {
+    method: () => ({
+        paths: [],
+        beforeMiddleware: [],
+        afterMiddleware: [],
+        verbs: [],
+        schema: {},
+    }),
+    root: () => ({
+        paths: [],
+        beforeMiddleware: [],
+        afterMiddleware: [],
+    }),
+});
+export const HTTP_DECORATOR_STATE_TOKEN = token;
+function createRouteDecorator(httpVerb) {
+    return (path = "/") => (target, context) => {
+        update(context, {
+            method: (previous) => {
+                return {
+                    ...previous,
+                    verbs: uniq([...previous.verbs, httpVerb]),
+                    paths: uniq([...previous.paths, path]),
+                };
+            },
+        });
+        return target;
+    };
+}
+export const GET = createRouteDecorator(HttpVerbs.GET);
+export const POST = createRouteDecorator(HttpVerbs.POST);
+export const PUT = createRouteDecorator(HttpVerbs.PUT);
+export const DELETE = createRouteDecorator(HttpVerbs.DELETE);
+export const PATCH = createRouteDecorator(HttpVerbs.PATCH);
+export function controller(options) {
+    return (target, context) => {
+        if (!options)
+            return target;
+        update(context, {
+            root: (previous) => {
+                return {
+                    ...previous,
+                    paths: uniq([...previous.paths, ...normalizePaths(options)]),
+                };
+            },
+        });
+        return target;
+    };
+}
+export function before(middleware) {
+    return (target, context) => {
+        if (context.kind === "class") {
+            update(context, {
+                root: (previous) => {
+                    return {
+                        ...previous,
+                        beforeMiddleware: appendMiddleware(previous.beforeMiddleware, middleware),
+                    };
+                },
+            });
+            return target;
+        }
+        update(context, {
+            method: (previous) => {
+                return {
+                    ...previous,
+                    beforeMiddleware: appendMiddleware(previous.beforeMiddleware, middleware),
+                };
+            },
+        });
+        return target;
+    };
+}
+export function after(middleware) {
+    return (target, context) => {
+        if (context.kind === "class") {
+            update(context, {
+                root: (previous) => {
+                    return {
+                        ...previous,
+                        afterMiddleware: appendMiddleware(previous.afterMiddleware, middleware),
+                    };
+                },
+            });
+            return target;
+        }
+        update(context, {
+            method: (previous) => {
+                return {
+                    ...previous,
+                    afterMiddleware: appendMiddleware(previous.afterMiddleware, middleware),
+                };
+            },
+        });
+        return target;
+    };
+}
+export function schema(schema) {
+    return (target, context) => {
+        update(context, {
+            method: (previous) => {
+                return {
+                    ...previous,
+                    schema,
+                };
+            },
+        });
+        return target;
+    };
+}
+function uniq(items) {
+    const result = [];
+    for (const item of items) {
+        if (!result.includes(item))
+            result.push(item);
+    }
+    return result;
+}
+function normalizePaths(options) {
+    if (typeof options === "string")
+        return [options];
+    if (Array.isArray(options))
+        return options;
+    return Array.isArray(options.path) ? options.path : [options.path];
+}
+function appendMiddleware(target, incoming) {
+    return Array.isArray(incoming)
+        ? [...target, ...incoming]
+        : [...target, incoming];
+}
+export function rollUpHttpDecoratorState(root, method) {
+    return {
+        ...method,
+        paths: concatPaths(root.paths, method.paths),
+        beforeMiddleware: [...root.beforeMiddleware, ...method.beforeMiddleware],
+        afterMiddleware: [...method.afterMiddleware, ...root.afterMiddleware],
+    };
+}
+function concatPaths(rootPaths, methodPaths) {
+    if (rootPaths.length === 0)
+        return [...methodPaths];
+    const result = [];
+    rootPaths.forEach((rootPath) => {
+        methodPaths.forEach((methodPath) => {
+            result.push(rootPath + methodPath);
+        });
+    });
+    return result;
+}

package/dist/lib/http/exceptions.d.ts

@@ -0,0 +1,58 @@
+export declare enum HttpStatus {
+    OK = 200,
+    CREATED = 201,
+    BAD_REQUEST = 400,
+    UNAUTHORIZED = 401,
+    FORBIDDEN = 403,
+    NOT_FOUND = 404,
+    METHOD_NOT_ALLOWED = 405,
+    NOT_ACCEPTABLE = 406,
+    REQUEST_TIMEOUT = 408,
+    CONFLICT = 409,
+    GONE = 410,
+    PRECONDITION_FAILED = 412,
+    PAYLOAD_TOO_LARGE = 413,
+    UNSUPPORTED_MEDIA_TYPE = 415,
+    I_AM_A_TEAPOT = 418,
+    UNPROCESSABLE_ENTITY = 422,
+    INTERNAL_SERVER_ERROR = 500,
+    NOT_IMPLEMENTED = 501,
+    BAD_GATEWAY = 502,
+    SERVICE_UNAVAILABLE = 503,
+    GATEWAY_TIMEOUT = 504,
+    HTTP_VERSION_NOT_SUPPORTED = 505
+}
+export declare class HttpException<TMessage extends string, TStatus extends HttpStatus = HttpStatus> extends Error {
+    readonly message: TMessage;
+    readonly statusCode: TStatus;
+    readonly response?: (Record<string, any> | null) | undefined;
+    constructor(message: TMessage, statusCode: TStatus, response?: (Record<string, any> | null) | undefined);
+    getResponse(): {
+        message: TMessage;
+        statusCode: TStatus;
+        [key: string]: any;
+    };
+    getStatus(): TStatus;
+}
+export declare const httpException: {
+    badRequest: <M extends string = "Bad Request">(message?: M | undefined, response?: Record<string, any>) => HttpException<M extends undefined ? "Bad Request" : M, HttpStatus.BAD_REQUEST>;
+    unauthorized: <M extends string = "Unauthorized">(message?: M | undefined, response?: Record<string, any>) => HttpException<M extends undefined ? "Unauthorized" : M, HttpStatus.UNAUTHORIZED>;
+    forbidden: <M extends string = "Forbidden">(message?: M | undefined, response?: Record<string, any>) => HttpException<M extends undefined ? "Forbidden" : M, HttpStatus.FORBIDDEN>;
+    notFound: <M extends string = "Not Found">(message?: M | undefined, response?: Record<string, any>) => HttpException<M extends undefined ? "Not Found" : M, HttpStatus.NOT_FOUND>;
+    methodNotAllowed: <M extends string = "Method Not Allowed">(message?: M | undefined, response?: Record<string, any>) => HttpException<M extends undefined ? "Method Not Allowed" : M, HttpStatus.METHOD_NOT_ALLOWED>;
+    notAcceptable: <M extends string = "Not Acceptable">(message?: M | undefined, response?: Record<string, any>) => HttpException<M extends undefined ? "Not Acceptable" : M, HttpStatus.NOT_ACCEPTABLE>;
+    requestTimeout: <M extends string = "Request Timeout">(message?: M | undefined, response?: Record<string, any>) => HttpException<M extends undefined ? "Request Timeout" : M, HttpStatus.REQUEST_TIMEOUT>;
+    conflict: <M extends string = "Conflict">(message?: M | undefined, response?: Record<string, any>) => HttpException<M extends undefined ? "Conflict" : M, HttpStatus.CONFLICT>;
+    gone: <M extends string = "Gone">(message?: M | undefined, response?: Record<string, any>) => HttpException<M extends undefined ? "Gone" : M, HttpStatus.GONE>;
+    preconditionFailed: <M extends string = "Precondition Failed">(message?: M | undefined, response?: Record<string, any>) => HttpException<M extends undefined ? "Precondition Failed" : M, HttpStatus.PRECONDITION_FAILED>;
+    payloadTooLarge: <M extends string = "Payload Too Large">(message?: M | undefined, response?: Record<string, any>) => HttpException<M extends undefined ? "Payload Too Large" : M, HttpStatus.PAYLOAD_TOO_LARGE>;
+    unsupportedMediaType: <M extends string = "Unsupported Media Type">(message?: M | undefined, response?: Record<string, any>) => HttpException<M extends undefined ? "Unsupported Media Type" : M, HttpStatus.UNSUPPORTED_MEDIA_TYPE>;
+    imATeapot: <M extends string = "I'm a teapot">(message?: M | undefined, response?: Record<string, any>) => HttpException<M extends undefined ? "I'm a teapot" : M, HttpStatus.I_AM_A_TEAPOT>;
+    unprocessableEntity: <M extends string = "Unprocessable Entity">(message?: M | undefined, response?: Record<string, any>) => HttpException<M extends undefined ? "Unprocessable Entity" : M, HttpStatus.UNPROCESSABLE_ENTITY>;
+    internalServerError: <M extends string = "Internal Server Error">(message?: M | undefined, response?: Record<string, any>) => HttpException<M extends undefined ? "Internal Server Error" : M, HttpStatus.INTERNAL_SERVER_ERROR>;
+    notImplemented: <M extends string = "Not Implemented">(message?: M | undefined, response?: Record<string, any>) => HttpException<M extends undefined ? "Not Implemented" : M, HttpStatus.NOT_IMPLEMENTED>;
+    badGateway: <M extends string = "Bad Gateway">(message?: M | undefined, response?: Record<string, any>) => HttpException<M extends undefined ? "Bad Gateway" : M, HttpStatus.BAD_GATEWAY>;
+    serviceUnavailable: <M extends string = "Service Unavailable">(message?: M | undefined, response?: Record<string, any>) => HttpException<M extends undefined ? "Service Unavailable" : M, HttpStatus.SERVICE_UNAVAILABLE>;
+    gatewayTimeout: <M extends string = "Gateway Timeout">(message?: M | undefined, response?: Record<string, any>) => HttpException<M extends undefined ? "Gateway Timeout" : M, HttpStatus.GATEWAY_TIMEOUT>;
+    httpVersionNotSupported: <M extends string = "HTTP Version Not Supported">(message?: M | undefined, response?: Record<string, any>) => HttpException<M extends undefined ? "HTTP Version Not Supported" : M, HttpStatus.HTTP_VERSION_NOT_SUPPORTED>;
+};

package/dist/lib/http/exceptions.js

@@ -0,0 +1,71 @@
+export var HttpStatus;
+(function (HttpStatus) {
+    HttpStatus[HttpStatus["OK"] = 200] = "OK";
+    HttpStatus[HttpStatus["CREATED"] = 201] = "CREATED";
+    HttpStatus[HttpStatus["BAD_REQUEST"] = 400] = "BAD_REQUEST";
+    HttpStatus[HttpStatus["UNAUTHORIZED"] = 401] = "UNAUTHORIZED";
+    HttpStatus[HttpStatus["FORBIDDEN"] = 403] = "FORBIDDEN";
+    HttpStatus[HttpStatus["NOT_FOUND"] = 404] = "NOT_FOUND";
+    HttpStatus[HttpStatus["METHOD_NOT_ALLOWED"] = 405] = "METHOD_NOT_ALLOWED";
+    HttpStatus[HttpStatus["NOT_ACCEPTABLE"] = 406] = "NOT_ACCEPTABLE";
+    HttpStatus[HttpStatus["REQUEST_TIMEOUT"] = 408] = "REQUEST_TIMEOUT";
+    HttpStatus[HttpStatus["CONFLICT"] = 409] = "CONFLICT";
+    HttpStatus[HttpStatus["GONE"] = 410] = "GONE";
+    HttpStatus[HttpStatus["PRECONDITION_FAILED"] = 412] = "PRECONDITION_FAILED";
+    HttpStatus[HttpStatus["PAYLOAD_TOO_LARGE"] = 413] = "PAYLOAD_TOO_LARGE";
+    HttpStatus[HttpStatus["UNSUPPORTED_MEDIA_TYPE"] = 415] = "UNSUPPORTED_MEDIA_TYPE";
+    HttpStatus[HttpStatus["I_AM_A_TEAPOT"] = 418] = "I_AM_A_TEAPOT";
+    HttpStatus[HttpStatus["UNPROCESSABLE_ENTITY"] = 422] = "UNPROCESSABLE_ENTITY";
+    HttpStatus[HttpStatus["INTERNAL_SERVER_ERROR"] = 500] = "INTERNAL_SERVER_ERROR";
+    HttpStatus[HttpStatus["NOT_IMPLEMENTED"] = 501] = "NOT_IMPLEMENTED";
+    HttpStatus[HttpStatus["BAD_GATEWAY"] = 502] = "BAD_GATEWAY";
+    HttpStatus[HttpStatus["SERVICE_UNAVAILABLE"] = 503] = "SERVICE_UNAVAILABLE";
+    HttpStatus[HttpStatus["GATEWAY_TIMEOUT"] = 504] = "GATEWAY_TIMEOUT";
+    HttpStatus[HttpStatus["HTTP_VERSION_NOT_SUPPORTED"] = 505] = "HTTP_VERSION_NOT_SUPPORTED";
+})(HttpStatus || (HttpStatus = {}));
+export class HttpException extends Error {
+    message;
+    statusCode;
+    response;
+    constructor(message, statusCode, response) {
+        super(message);
+        this.message = message;
+        this.statusCode = statusCode;
+        this.response = response;
+        this.name = this.constructor.name;
+        Error.captureStackTrace(this, this.constructor);
+    }
+    getResponse() {
+        return {
+            message: this.message,
+            statusCode: this.statusCode,
+            ...this.response,
+        };
+    }
+    getStatus() {
+        return this.statusCode;
+    }
+}
+const createFactory = (defaultMessage, status) => (message, response) => new HttpException((message ?? defaultMessage), status, response);
+export const httpException = {
+    badRequest: createFactory("Bad Request", HttpStatus.BAD_REQUEST),
+    unauthorized: createFactory("Unauthorized", HttpStatus.UNAUTHORIZED),
+    forbidden: createFactory("Forbidden", HttpStatus.FORBIDDEN),
+    notFound: createFactory("Not Found", HttpStatus.NOT_FOUND),
+    methodNotAllowed: createFactory("Method Not Allowed", HttpStatus.METHOD_NOT_ALLOWED),
+    notAcceptable: createFactory("Not Acceptable", HttpStatus.NOT_ACCEPTABLE),
+    requestTimeout: createFactory("Request Timeout", HttpStatus.REQUEST_TIMEOUT),
+    conflict: createFactory("Conflict", HttpStatus.CONFLICT),
+    gone: createFactory("Gone", HttpStatus.GONE),
+    preconditionFailed: createFactory("Precondition Failed", HttpStatus.PRECONDITION_FAILED),
+    payloadTooLarge: createFactory("Payload Too Large", HttpStatus.PAYLOAD_TOO_LARGE),
+    unsupportedMediaType: createFactory("Unsupported Media Type", HttpStatus.UNSUPPORTED_MEDIA_TYPE),
+    imATeapot: createFactory("I'm a teapot", HttpStatus.I_AM_A_TEAPOT),
+    unprocessableEntity: createFactory("Unprocessable Entity", HttpStatus.UNPROCESSABLE_ENTITY),
+    internalServerError: createFactory("Internal Server Error", HttpStatus.INTERNAL_SERVER_ERROR),
+    notImplemented: createFactory("Not Implemented", HttpStatus.NOT_IMPLEMENTED),
+    badGateway: createFactory("Bad Gateway", HttpStatus.BAD_GATEWAY),
+    serviceUnavailable: createFactory("Service Unavailable", HttpStatus.SERVICE_UNAVAILABLE),
+    gatewayTimeout: createFactory("Gateway Timeout", HttpStatus.GATEWAY_TIMEOUT),
+    httpVersionNotSupported: createFactory("HTTP Version Not Supported", HttpStatus.HTTP_VERSION_NOT_SUPPORTED),
+};

package/dist/lib/http/http-verbs.d.ts

@@ -0,0 +1,12 @@
+export type HttpVerb = "GET" | "HEAD" | "POST" | "PUT" | "DELETE" | "CONNECT" | "OPTIONS" | "PATCH" | "*";
+export declare const HttpVerbs: {
+    readonly GET: "GET";
+    readonly HEAD: "HEAD";
+    readonly POST: "POST";
+    readonly PUT: "PUT";
+    readonly DELETE: "DELETE";
+    readonly CONNECT: "CONNECT";
+    readonly OPTIONS: "OPTIONS";
+    readonly PATCH: "PATCH";
+    readonly ALL: "*";
+};

package/dist/lib/http/http-verbs.js

@@ -0,0 +1,11 @@
+export const HttpVerbs = {
+    GET: "GET",
+    HEAD: "HEAD",
+    POST: "POST",
+    PUT: "PUT",
+    DELETE: "DELETE",
+    CONNECT: "CONNECT",
+    OPTIONS: "OPTIONS",
+    PATCH: "PATCH",
+    ALL: "*",
+};

package/dist/lib/http/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./decorators.js";
+export * from "./exceptions.js";
+export * from "./openapi-builder.js";

package/dist/lib/http/index.js

@@ -0,0 +1,3 @@
+export * from "./decorators.js";
+export * from "./exceptions.js";
+export * from "./openapi-builder.js";