@vercube/core 0.0.18 → 0.0.20

package/dist/index.d.mts

@@ -1,5 +1,5 @@
 import { Container } from "@vercube/di";
-import { FastResponse } from "srvx";
+import { FastResponse, ServerPlugin } from "srvx";
 import { LoggerTypes } from "@vercube/logger";
 import { DotenvOptions } from "c12";
 import { StandardSchemaV1 } from "@standard-schema/spec";
@@ -218,12 +218,12 @@ declare class App {
    */
   init(cfg: ConfigTypes.Config): Promise<void>;
   /**
-   * Registers a plugin.
+   * Add new plugin to the application.
    *
-   * @param {typeof Plugin} plugin - The plugin to register.
+   * @param {typeof Plugin} plugin - The plugin to add.
    * @param {unknown} options - The options to pass to the plugin.
    */
-  registerPlugin<T>(plugin: typeof BasePlugin<T>, options?: T): void;
+  addPlugin<T>(plugin: typeof BasePlugin<T>, options?: T): void;
   /**
    * Starts the application and begins listening for incoming requests.
    *
@@ -247,13 +247,156 @@ declare class App {
   private resolvePlugins;
 }
 //#endregion
+//#region src/Services/Middleware/BaseMiddleware.d.ts
+/**
+ * BaseMiddleware class that serves as a base for all middleware implementations.
+ */
+declare class BaseMiddleware<T = any, U = any> {
+  /**
+   * Middleware function that processes the HTTP event.
+   * This method should be overridden by subclasses to implement specific middleware logic.
+   * WARNING: This method cannot return a value, it will be ignored.
+   * Middleware can only modify the event object or throw an HttpError like BadRequestError, ForbiddenError, etc.
+   *
+   * @param {Request} request - The HTTP Request to process
+   * @param {T[]} args - Additional arguments for the middleware.
+   * @returns {void | Promise<void>} - A void or a promise that resolves when the processing is complete.
+   */
+  onRequest?(request: Request, response: Response, args: MiddlewareOptions<T>): MaybePromise<void | Response>;
+  /**
+   * Middleware function that processes the response.
+   * This method should be overridden by subclasses to implement specific middleware logic.
+   * WARNING: This method cannot return a value, it will be ignored.
+   * Middleware can only modify the event object or throw an HttpError like BadRequestError, ForbiddenError, etc.
+   *
+   * @param {Request} request - The HTTP Request to process
+   * @param {Response} response - The HTTP Response to process
+   * @returns {void | Promise<void>} - A void or a promise that resolves when the processing is complete.
+   */
+  onResponse?(request: Request, response: Response, payload: U): MaybePromise<void | Response>;
+}
+//#endregion
+//#region src/Types/RouterTypes.d.ts
+declare namespace RouterTypes {
+  interface Route {
+    path: string;
+    method: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' | 'OPTIONS' | 'HEAD' | 'CONNECT' | 'TRACE';
+    handler: RouterHandler;
+  }
+  interface RouteFind {
+    path: string;
+    method: string;
+  }
+  interface MiddlewareDefinition {
+    middleware: BaseMiddleware<unknown, unknown>;
+    target: string;
+    priority?: number;
+    args?: unknown;
+  }
+  interface RouterHandler {
+    instance: any;
+    propertyName: string;
+    args: MetadataTypes.Arg[];
+    middlewares: {
+      beforeMiddlewares: MiddlewareDefinition[];
+      afterMiddlewares: MiddlewareDefinition[];
+    };
+    actions: MetadataTypes.Action[];
+  }
+  interface RouteMatched<T = unknown> {
+    data: T;
+    params?: Record<string, string>;
+  }
+  type RouterEvent = RouterTypes.RouteMatched<RouterTypes.RouterHandler> & {
+    request: Request;
+    response: Response;
+  };
+}
+//#endregion
+//#region src/Types/ValidationTypes.d.ts
+declare namespace ValidationTypes {
+  type Schema = StandardSchemaV1;
+  type Result<T = any> = StandardSchemaV1.Result<T>;
+  type Input<T extends Schema = Schema> = StandardSchemaV1.InferInput<T>;
+}
+//#endregion
+//#region src/Types/MetadataTypes.d.ts
+declare namespace MetadataTypes {
+  interface Metadata {
+    __metadata: Ctx;
+  }
+  interface Ctx {
+    __controller: {
+      path: string;
+    };
+    __middlewares: Middleware[];
+    __methods: Record<string, Method>;
+    __meta?: Record<string, unknown>;
+  }
+  interface Method {
+    req: Request | null;
+    res: Response | null;
+    url: string | null;
+    method: string | null;
+    args: Arg[];
+    actions: Action[];
+    meta: Record<string, unknown>;
+  }
+  interface ResolvedData {
+    req: Request | null;
+    res: Response | null;
+    url: string | null;
+    args: Arg[];
+    actions: Action[];
+    middlewares: Middleware[];
+  }
+  interface Arg {
+    idx: number;
+    type: string;
+    data?: Record<string, any>;
+    resolver?: (event: RouterTypes.RouterEvent) => Promise<unknown>;
+    resolved?: unknown;
+    validate?: boolean;
+    validationSchema?: ValidationTypes.Schema;
+  }
+  interface Action {
+    handler: (req: Request, res: Response) => void | Response | ResponseInit;
+  }
+  interface Middleware<T = unknown, U = unknown> {
+    target: string;
+    priority?: number;
+    middleware: typeof BaseMiddleware<T, U>;
+    args?: unknown;
+  }
+  interface ResolveUrlParams {
+    instance: any;
+    path: string;
+    propertyName: string;
+  }
+}
+//#endregion
+//#region src/Types/CommonTypes.d.ts
+type MaybePromise<T> = T | Promise<T>;
+interface MiddlewareOptions<T = any> {
+  middlewareArgs?: T;
+  methodArgs?: MetadataTypes.Arg[];
+}
+type DeepPartial<T> = { [P in keyof T]?: T[P] extends object ? DeepPartial<T[P]> : T[P] };
+//#endregion
 //#region src/Common/CreateApp.d.ts
+interface CreateAppOptions {
+  cfg?: ConfigTypes.Config;
+  setup?: (app: App) => MaybePromise<void>;
+}
 /**
  * Creates and initializes an instance of the App.
  *
  * @returns {Promise<App>} A promise that resolves to an instance of the App.
  */
-declare function createApp(cfg?: ConfigTypes.Config): Promise<App>;
+declare function createApp({
+  cfg,
+  setup
+}?: CreateAppOptions): Promise<App>;
 //#endregion
 //#region src/Config/Config.d.ts
 /**
@@ -271,13 +414,6 @@ declare function defineConfig<T = Record<string, unknown>>(config: ConfigTypes.C
  */
 declare function loadVercubeConfig(overrides?: ConfigTypes.Config): Promise<ConfigTypes.Config>;
 //#endregion
-//#region src/Types/ValidationTypes.d.ts
-declare namespace ValidationTypes {
-  type Schema = StandardSchemaV1;
-  type Result<T = any> = StandardSchemaV1.Result<T>;
-  type Input<T extends Schema = Schema> = StandardSchemaV1.InferInput<T>;
-}
-//#endregion
 //#region src/Decorators/Http/Body.d.ts
 interface BodyDecoratorOptions {
   validationSchema?: ValidationTypes.Schema;
@@ -596,131 +732,6 @@ declare function Status(code: HTTPStatus): Function;
  */
 declare function Redirect(location: string, code?: HTTPStatus): Function;
 //#endregion
-//#region src/Types/RouterTypes.d.ts
-declare namespace RouterTypes {
-  interface Route {
-    path: string;
-    method: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' | 'OPTIONS' | 'HEAD' | 'CONNECT' | 'TRACE';
-    handler: RouterHandler;
-  }
-  interface RouteFind {
-    path: string;
-    method: string;
-  }
-  interface MiddlewareDefinition {
-    middleware: BaseMiddleware<unknown, unknown>;
-    target: string;
-    priority?: number;
-    args?: unknown;
-  }
-  interface RouterHandler {
-    instance: any;
-    propertyName: string;
-    args: MetadataTypes.Arg[];
-    middlewares: {
-      beforeMiddlewares: MiddlewareDefinition[];
-      afterMiddlewares: MiddlewareDefinition[];
-    };
-    actions: MetadataTypes.Action[];
-  }
-  interface RouteMatched<T = unknown> {
-    data: T;
-    params?: Record<string, string>;
-  }
-  type RouterEvent = RouterTypes.RouteMatched<RouterTypes.RouterHandler> & {
-    request: Request;
-    response: Response;
-  };
-}
-//#endregion
-//#region src/Types/MetadataTypes.d.ts
-declare namespace MetadataTypes {
-  interface Metadata {
-    __metadata: Ctx;
-  }
-  interface Ctx {
-    __controller: {
-      path: string;
-    };
-    __middlewares: Middleware[];
-    __methods: Record<string, Method>;
-  }
-  interface Method {
-    req: Request | null;
-    res: Response | null;
-    url: string | null;
-    args: Arg[];
-    actions: Action[];
-  }
-  interface ResolvedData {
-    req: Request | null;
-    res: Response | null;
-    url: string | null;
-    args: Arg[];
-    actions: Action[];
-    middlewares: Middleware[];
-  }
-  interface Arg {
-    idx: number;
-    type: string;
-    data?: Record<string, any>;
-    resolver?: (event: RouterTypes.RouterEvent) => Promise<unknown>;
-    resolved?: unknown;
-    validate?: boolean;
-    validationSchema?: ValidationTypes.Schema;
-  }
-  interface Action {
-    handler: (req: Request, res: Response) => void | Response | ResponseInit;
-  }
-  interface Middleware<T = unknown, U = unknown> {
-    target: string;
-    priority?: number;
-    middleware: typeof BaseMiddleware<T, U>;
-    args?: unknown;
-  }
-  interface ResolveUrlParams {
-    instance: any;
-    path: string;
-    propertyName: string;
-  }
-}
-//#endregion
-//#region src/Types/CommonTypes.d.ts
-type MaybePromise<T> = T | Promise<T>;
-interface MiddlewareOptions<T = any> {
-  middlewareArgs?: T;
-  methodArgs?: MetadataTypes.Arg[];
-}
-//#endregion
-//#region src/Services/Middleware/BaseMiddleware.d.ts
-/**
- * BaseMiddleware class that serves as a base for all middleware implementations.
- */
-declare class BaseMiddleware<T = any, U = any> {
-  /**
-   * Middleware function that processes the HTTP event.
-   * This method should be overridden by subclasses to implement specific middleware logic.
-   * WARNING: This method cannot return a value, it will be ignored.
-   * Middleware can only modify the event object or throw an HttpError like BadRequestError, ForbiddenError, etc.
-   *
-   * @param {Request} request - The HTTP Request to process
-   * @param {T[]} args - Additional arguments for the middleware.
-   * @returns {void | Promise<void>} - A void or a promise that resolves when the processing is complete.
-   */
-  onRequest?(request: Request, response: Response, args: MiddlewareOptions<T>): MaybePromise<void | Response>;
-  /**
-   * Middleware function that processes the response.
-   * This method should be overridden by subclasses to implement specific middleware logic.
-   * WARNING: This method cannot return a value, it will be ignored.
-   * Middleware can only modify the event object or throw an HttpError like BadRequestError, ForbiddenError, etc.
-   *
-   * @param {Request} request - The HTTP Request to process
-   * @param {Response} response - The HTTP Response to process
-   * @returns {void | Promise<void>} - A void or a promise that resolves when the processing is complete.
-   */
-  onResponse?(request: Request, response: Response, payload: U): MaybePromise<void | Response>;
-}
-//#endregion
 //#region src/Decorators/Http/Middleware.d.ts
 interface MiddlewareDecoratorParams extends Omit<MetadataTypes.Middleware, 'middleware'> {}
 /**
@@ -916,6 +927,18 @@ declare class HttpServer {
    * @private
    */
   private fServer;
+  /**
+   * List of plugins to be applied to the HTTP server
+   * @private
+   */
+  private fPlugins;
+  /**
+   * Adds a plugin to the HTTP server
+   *
+   * @param {ServerPlugin} plugin - The plugin to add
+   * @returns {void}
+   */
+  addPlugin(plugin: ServerPlugin): void;
   /**
    * Initializes the HTTP server and starts listening for requests
    *
@@ -1067,6 +1090,41 @@ declare class RuntimeConfig$1<T = Record<string, unknown>> {
   set runtimeConfig(value: ConfigTypes.CreateRuntimeConfig<T> | undefined);
 }
 //#endregion
+//#region src/Services/Validation/ValidationProvider.d.ts
+/**
+ * Abstract class representing a validation provider
+ * Provides a common interface for different validation implementations
+ *
+ * @abstract
+ * @class ValidationProvider
+ */
+declare abstract class ValidationProvider {
+  /**
+   * Validates data against a given schema
+   * @param schema - The validation schema to check against
+   * @param data - The data to validate
+   * @returns A validation result object or Promise of validation result
+   */
+  abstract validate(schema: ValidationTypes.Schema, data: ValidationTypes.Input): ValidationTypes.Result | Promise<ValidationTypes.Result>;
+}
+//#endregion
+//#region src/Services/Validation/StandardSchemaValidationProvider.d.ts
+/**
+ * StandardSchemaValidationProvider implements validation using StandardSchema schema validation
+ * @see https://github.com/standard-schema/standard-schema
+ * @class
+ * @implements {ValidationProvider}
+ */
+declare class StandardSchemaValidationProvider implements ValidationProvider {
+  /**
+   * Validates data against a schema
+   * @param {ValidationTypes.Schema} schema - The schema to validate against
+   * @param {ValidationTypes.Input} data - The data to validate
+   * @return {ValidationTypes.Result | Promise<ValidationTypes.Result>} The validation result
+   */
+  validate(schema: ValidationTypes.Schema, data: ValidationTypes.Input): ValidationTypes.Result | Promise<ValidationTypes.Result>;
+}
+//#endregion
 //#region src/Errors/HttpError.d.ts
 /**
  * Represents an HTTP error.
@@ -1212,6 +1270,334 @@ declare class UnauthorizedError extends HttpError {
   constructor(message?: string);
 }
 //#endregion
+//#region src/Types/HttpCodes.d.ts
+/**
+ * Hypertext Transfer Protocol (HTTP) response status codes.
+ * @see {@link https://en.wikipedia.org/wiki/List_of_HTTP_status_codes}
+ */
+declare enum HttpStatusCode {
+  /**
+   * The server has received the request headers and the client should proceed to send the request body
+   * (in the case of a request for which a body needs to be sent; for example, a POST request).
+   * Sending a large request body to a server after a request has been rejected for inappropriate headers would be inefficient.
+   * To have a server check the request's headers, a client must send Expect: 100-continue as a header in its initial request
+   * and receive a 100 Continue status code in response before sending the body. The response 417 Expectation Failed indicates
+   * the request should not be continued.
+   */
+  CONTINUE = 100,
+  /**
+   * The requester has asked the server to switch protocols and the server has agreed to do so.
+   */
+  SWITCHING_PROTOCOLS = 101,
+  /**
+   * A WebDAV request may contain many sub-requests involving file operations, requiring a long time to complete the request.
+   * This code indicates that the server has received and is processing the request, but no response is available yet.
+   * This prevents the client from timing out and assuming the request was lost.
+   */
+  PROCESSING = 102,
+  /**
+   * Standard response for successful HTTP requests.
+   * The actual response will depend on the request method used.
+   * In a GET request, the response will contain an entity corresponding to the requested resource.
+   * In a POST request, the response will contain an entity describing or containing the result of the action.
+   */
+  OK = 200,
+  /**
+   * The request has been fulfilled, resulting in the creation of a new resource.
+   */
+  CREATED = 201,
+  /**
+   * The request has been accepted for processing, but the processing has not been completed.
+   * The request might or might not be eventually acted upon, and may be disallowed when processing occurs.
+   */
+  ACCEPTED = 202,
+  /**
+   * SINCE HTTP/1.1
+   * The server is a transforming proxy that received a 200 OK from its origin,
+   * but is returning a modified version of the origin's response.
+   */
+  NON_AUTHORITATIVE_INFORMATION = 203,
+  /**
+   * The server successfully processed the request and is not returning any content.
+   */
+  NO_CONTENT = 204,
+  /**
+   * The server successfully processed the request, but is not returning any content.
+   * Unlike a 204 response, this response requires that the requester reset the document view.
+   */
+  RESET_CONTENT = 205,
+  /**
+   * The server is delivering only part of the resource (byte serving) due to a range header sent by the client.
+   * The range header is used by HTTP clients to enable resuming of interrupted downloads,
+   * or split a download into multiple simultaneous streams.
+   */
+  PARTIAL_CONTENT = 206,
+  /**
+   * The message body that follows is an XML message and can contain a number of separate response codes,
+   * depending on how many sub-requests were made.
+   */
+  MULTI_STATUS = 207,
+  /**
+   * The members of a DAV binding have already been enumerated in a preceding part of the (multistatus) response,
+   * and are not being included again.
+   */
+  ALREADY_REPORTED = 208,
+  /**
+   * The server has fulfilled a request for the resource,
+   * and the response is a representation of the result of one or more instance-manipulations applied to the current instance.
+   */
+  IM_USED = 226,
+  /**
+   * Indicates multiple options for the resource from which the client may choose (via agent-driven content negotiation).
+   * For example, this code could be used to present multiple video format options,
+   * to list files with different filename extensions, or to suggest word-sense disambiguation.
+   */
+  MULTIPLE_CHOICES = 300,
+  /**
+   * This and all future requests should be directed to the given URI.
+   */
+  MOVED_PERMANENTLY = 301,
+  /**
+   * This is an example of industry practice contradicting the standard.
+   * The HTTP/1.0 specification (RFC 1945) required the client to perform a temporary redirect
+   * (the original describing phrase was "Moved Temporarily"), but popular browsers implemented 302
+   * with the functionality of a 303 See Other. Therefore, HTTP/1.1 added status codes 303 and 307
+   * to distinguish between the two behaviours. However, some Web applications and frameworks
+   * use the 302 status code as if it were the 303.
+   */
+  FOUND = 302,
+  /**
+   * SINCE HTTP/1.1
+   * The response to the request can be found under another URI using a GET method.
+   * When received in response to a POST (or PUT/DELETE), the client should presume that
+   * the server has received the data and should issue a redirect with a separate GET message.
+   */
+  SEE_OTHER = 303,
+  /**
+   * Indicates that the resource has not been modified since the version specified by the request headers
+   * If-Modified-Since or If-None-Match.
+   * In such case, there is no need to retransmit the resource since the client still has a previously-downloaded copy.
+   */
+  NOT_MODIFIED = 304,
+  /**
+   * SINCE HTTP/1.1
+   * The requested resource is available only through a proxy, the address for which is provided in the response.
+   * Many HTTP clients (such as Mozilla and Internet Explorer) do not correctly handle responses with this status code,
+   * primarily for security reasons.
+   */
+  USE_PROXY = 305,
+  /**
+   * No longer used. Originally meant "Subsequent requests should use the specified proxy."
+   */
+  SWITCH_PROXY = 306,
+  /**
+   * SINCE HTTP/1.1
+   * In this case, the request should be repeated with another URI; however, future requests should still use the original URI.
+   * In contrast to how 302 was historically implemented, the request method is not allowed to be changed when reissuing
+   * the original request.
+   * For example, a POST request should be repeated using another POST request.
+   */
+  TEMPORARY_REDIRECT = 307,
+  /**
+   * The request and all future requests should be repeated using another URI.
+   * 307 and 308 parallel the behaviors of 302 and 301, but do not allow the HTTP method to change.
+   * So, for example, submitting a form to a permanently redirected resource may continue smoothly.
+   */
+  PERMANENT_REDIRECT = 308,
+  /**
+   * The server cannot or will not process the request due to an apparent client error
+   * (e.g., malformed request syntax, too large size, invalid request message framing, or deceptive request routing).
+   */
+  BAD_REQUEST = 400,
+  /**
+   * Similar to 403 Forbidden, but specifically for use when authentication is required and has failed or has not yet
+   * been provided. The response must include a WWW-Authenticate header field containing a challenge applicable to the
+   * requested resource. See Basic access authentication and Digest access authentication. 401 semantically means
+   * "unauthenticated",i.e. the user does not have the necessary credentials.
+   */
+  UNAUTHORIZED = 401,
+  /**
+   * Reserved for future use. The original intention was that this code might be used as part of some form of digital
+   * cash or micro payment scheme, but that has not happened, and this code is not usually used.
+   * Google Developers API uses this status if a particular developer has exceeded the daily limit on requests.
+   */
+  PAYMENT_REQUIRED = 402,
+  /**
+   * The request was valid, but the server is refusing action.
+   * The user might not have the necessary permissions for a resource.
+   */
+  FORBIDDEN = 403,
+  /**
+   * The requested resource could not be found but may be available in the future.
+   * Subsequent requests by the client are permissible.
+   */
+  NOT_FOUND = 404,
+  /**
+   * A request method is not supported for the requested resource;
+   * for example, a GET request on a form that requires data to be presented via POST, or a PUT request on a read-only resource.
+   */
+  METHOD_NOT_ALLOWED = 405,
+  /**
+   * The requested resource is capable of generating only content not acceptable according to the Accept
+   * headers sent in the request.
+   */
+  NOT_ACCEPTABLE = 406,
+  /**
+   * The client must first authenticate itself with the proxy.
+   */
+  PROXY_AUTHENTICATION_REQUIRED = 407,
+  /**
+   * The server timed out waiting for the request.
+   * According to HTTP specifications:
+   * "The client did not produce a request within the time that the server was prepared to wait. The client MAY repeat
+   * the request without modifications at any later time."
+   */
+  REQUEST_TIMEOUT = 408,
+  /**
+   * Indicates that the request could not be processed because of conflict in the request,
+   * such as an edit conflict between multiple simultaneous updates.
+   */
+  CONFLICT = 409,
+  /**
+   * Indicates that the resource requested is no longer available and will not be available again.
+   * This should be used when a resource has been intentionally removed and the resource should be purged.
+   * Upon receiving a 410 status code, the client should not request the resource in the future.
+   * Clients such as search engines should remove the resource from their indices.
+   * Most use cases do not require clients and search engines to purge the resource, and a "404 Not Found" may be used instead.
+   */
+  GONE = 410,
+  /**
+   * The request did not specify the length of its content, which is required by the requested resource.
+   */
+  LENGTH_REQUIRED = 411,
+  /**
+   * The server does not meet one of the preconditions that the requester put on the request.
+   */
+  PRECONDITION_FAILED = 412,
+  /**
+   * The request is larger than the server is willing or able to process. Previously called "Request Entity Too Large".
+   */
+  PAYLOAD_TOO_LARGE = 413,
+  /**
+   * The URI provided was too long for the server to process. Often the result of too much data being encoded
+   * as a query-string of a GET request,
+   * in which case it should be converted to a POST request.
+   * Called "Request-URI Too Long" previously.
+   */
+  URI_TOO_LONG = 414,
+  /**
+   * The request entity has a media type which the server or resource does not support.
+   * For example, the client uploads an image as image/svg+xml, but the server requires that images use a different format.
+   */
+  UNSUPPORTED_MEDIA_TYPE = 415,
+  /**
+   * The client has asked for a portion of the file (byte serving), but the server cannot supply that portion.
+   * For example, if the client asked for a part of the file that lies beyond the end of the file.
+   * Called "Requested Range Not Satisfiable" previously.
+   */
+  RANGE_NOT_SATISFIABLE = 416,
+  /**
+   * The server cannot meet the requirements of the Expect request-header field.
+   */
+  EXPECTATION_FAILED = 417,
+  /**
+   * This code was defined in 1998 as one of the traditional IETF April Fools' jokes, in RFC 2324,
+   * Hyper Text Coffee Pot Control Protocol,
+   * and is not expected to be implemented by actual HTTP servers. The RFC specifies this code should be returned by
+   * teapots requested to brew coffee. This HTTP status is used as an Easter egg in some websites, including Google.com.
+   */
+  I_AM_A_TEAPOT = 418,
+  /**
+   * The request was directed at a server that is not able to produce a response (for example because a connection reuse).
+   */
+  MISDIRECTED_REQUEST = 421,
+  /**
+   * The request was well-formed but was unable to be followed due to semantic errors.
+   */
+  UNPROCESSABLE_ENTITY = 422,
+  /**
+   * The resource that is being accessed is locked.
+   */
+  LOCKED = 423,
+  /**
+   * The request failed due to failure of a previous request (e.g., a PROPPATCH).
+   */
+  FAILED_DEPENDENCY = 424,
+  /**
+   * The client should switch to a different protocol such as TLS/1.0, given in the Upgrade header field.
+   */
+  UPGRADE_REQUIRED = 426,
+  /**
+   * The origin server requires the request to be conditional.
+   * Intended to prevent "the 'lost update' problem, where a client
+   * GETs a resource's state, modifies it, and PUTs it back to the server,
+   * when meanwhile a third party has modified the state on the server, leading to a conflict."
+   */
+  PRECONDITION_REQUIRED = 428,
+  /**
+   * The user has sent too many requests in a given amount of time. Intended for use with rate-limiting schemes.
+   */
+  TOO_MANY_REQUESTS = 429,
+  /**
+   * The server is unwilling to process the request because either an individual header field,
+   * or all the header fields collectively, are too large.
+   */
+  REQUEST_HEADER_FIELDS_TOO_LARGE = 431,
+  /**
+   * A server operator has received a legal demand to deny access to a resource or to a set of resources
+   * that includes the requested resource. The code 451 was chosen as a reference to the novel Fahrenheit 451.
+   */
+  UNAVAILABLE_FOR_LEGAL_REASONS = 451,
+  /**
+   * A generic error message, given when an unexpected condition was encountered and no more specific message is suitable.
+   */
+  INTERNAL_SERVER_ERROR = 500,
+  /**
+   * The server either does not recognize the request method, or it lacks the ability to fulfill the request.
+   * Usually this implies future availability (e.g., a new feature of a web-service API).
+   */
+  NOT_IMPLEMENTED = 501,
+  /**
+   * The server was acting as a gateway or proxy and received an invalid response from the upstream server.
+   */
+  BAD_GATEWAY = 502,
+  /**
+   * The server is currently unavailable (because it is overloaded or down for maintenance).
+   * Generally, this is a temporary state.
+   */
+  SERVICE_UNAVAILABLE = 503,
+  /**
+   * The server was acting as a gateway or proxy and did not receive a timely response from the upstream server.
+   */
+  GATEWAY_TIMEOUT = 504,
+  /**
+   * The server does not support the HTTP protocol version used in the request
+   */
+  HTTP_VERSION_NOT_SUPPORTED = 505,
+  /**
+   * Transparent content negotiation for the request results in a circular reference.
+   */
+  VARIANT_ALSO_NEGOTIATES = 506,
+  /**
+   * The server is unable to store the representation needed to complete the request.
+   */
+  INSUFFICIENT_STORAGE = 507,
+  /**
+   * The server detected an infinite loop while processing the request.
+   */
+  LOOP_DETECTED = 508,
+  /**
+   * Further extensions to the request are required for the server to fulfill it.
+   */
+  NOT_EXTENDED = 510,
+  /**
+   * The client needs to authenticate to gain network access.
+   * Intended for use by intercepting proxies used to control access to the network (e.g., "captive portals" used
+   * to require agreement to Terms of Service before granting full Internet access via a Wi-Fi hotspot).
+   */
+  NETWORK_AUTHENTICATION_REQUIRED = 511,
+}
+//#endregion
 //#region src/Utils/Utils.d.ts
 /**
  * Creates a new metadata context.
@@ -1235,4 +1621,4 @@ declare function initializeMetadataMethod(target: any, propertyName: string): Me
  */
 declare function initializeMetadata(target: any): MetadataTypes.Ctx;
 //#endregion
-export { App, BadRequestError, BaseMiddleware, BasePlugin, Body, ConfigTypes, Connect, Controller, Delete, ErrorHandlerProvider, FastResponse, ForbiddenError, Get, GlobalMiddlewareRegistry, HTTPStatus, Head, Header, Headers, HooksService, HooksTypes, HttpError, HttpServer, InternalServerError, Listen, MaybePromise, MetadataResolver, MetadataTypes, MethodNotAllowedError, Middleware$1 as Middleware, MiddlewareOptions, MultipartFormData, NotAcceptableError, NotFoundError, Options, Param, Patch, Post, Put, QueryParam, QueryParams, Redirect, Request$1 as Request, Response$1 as Response, Router, RouterTypes, RuntimeConfig$1 as RuntimeConfig, Session, SetHeader, Status, Trace, UnauthorizedError, createApp, createMetadataCtx, createMetadataMethod, defineConfig, initializeMetadata, initializeMetadataMethod, loadVercubeConfig };
+export { App, BadRequestError, BaseMiddleware, BasePlugin, Body, ConfigTypes, Connect, Controller, CreateAppOptions, DeepPartial, Delete, ErrorHandlerProvider, FastResponse, ForbiddenError, Get, GlobalMiddlewareRegistry, HTTPStatus, Head, Header, Headers, HooksService, HooksTypes, HttpError, HttpServer, HttpStatusCode, InternalServerError, Listen, MaybePromise, MetadataResolver, MetadataTypes, MethodNotAllowedError, Middleware$1 as Middleware, MiddlewareOptions, MultipartFormData, NotAcceptableError, NotFoundError, Options, Param, Patch, Post, Put, QueryParam, QueryParams, Redirect, Request$1 as Request, Response$1 as Response, Router, RouterTypes, RuntimeConfig$1 as RuntimeConfig, Session, SetHeader, StandardSchemaValidationProvider, Status, Trace, UnauthorizedError, ValidationProvider, ValidationTypes, createApp, createMetadataCtx, createMetadataMethod, defineConfig, initializeMetadata, initializeMetadataMethod, loadVercubeConfig };

package/dist/index.mjs

@@ -36,8 +36,8 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 }) : target, mod));
 
 //#endregion
-//#region ../../node_modules/.pnpm/@oxc-project+runtime@0.77.0/node_modules/@oxc-project/runtime/src/helpers/decorate.js
-var require_decorate = __commonJS({ "../../node_modules/.pnpm/@oxc-project+runtime@0.77.0/node_modules/@oxc-project/runtime/src/helpers/decorate.js"(exports, module) {
+//#region ../../node_modules/.pnpm/@oxc-project+runtime@0.77.3/node_modules/@oxc-project/runtime/src/helpers/decorate.js
+var require_decorate = __commonJS({ "../../node_modules/.pnpm/@oxc-project+runtime@0.77.3/node_modules/@oxc-project/runtime/src/helpers/decorate.js"(exports, module) {
 	function __decorate(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);
@@ -463,7 +463,7 @@ var MetadataResolver = class {
 			case "headers": return getRequestHeaders(event);
 			case "request": return event.request;
 			case "response": return event.response;
-			case "custom": return arg.data?.resolve(event);
+			case "custom": return arg.resolver?.(event);
 			case "session": return null;
 			default: throw new Error(`Unknown argument type: ${arg.type}`);
 		}
@@ -798,6 +798,20 @@ var HttpServer = class {
 	*/
 	fServer;
 	/**
+	* List of plugins to be applied to the HTTP server
+	* @private
+	*/
+	fPlugins = [];
+	/**
+	* Adds a plugin to the HTTP server
+	* 
+	* @param {ServerPlugin} plugin - The plugin to add
+	* @returns {void}
+	*/
+	addPlugin(plugin) {
+		this.fPlugins.push(plugin);
+	}
+	/**
 	* Initializes the HTTP server and starts listening for requests
 	* 
 	* @returns {Promise<void>} A promise that resolves when the server is ready
@@ -812,8 +826,10 @@ var HttpServer = class {
 				return this.gContainer.get(ErrorHandlerProvider).handleError(error);
 			} },
 			hostname: host,
+			reusePort: true,
 			port,
-			fetch: this.handleRequest.bind(this)
+			fetch: this.handleRequest.bind(this),
+			plugins: this.fPlugins
 		});
 	}
 	/**
@@ -938,18 +954,19 @@ var App = class {
 	*/
 	async init(cfg) {
 		this.fConfig = cfg;
+		await this.resolvePlugins();
 		await this.gHttpServer.initialize(this.fConfig);
 		if (this.fConfig.server?.static) this.gStaticRequestHandler.initialize(this.fConfig.server?.static);
 		if (this.fConfig.runtime) this.gRuntimeConfig.runtimeConfig = this.fConfig.runtime;
 		this.gRouter.initialize();
 	}
 	/**
-	* Registers a plugin.
+	* Add new plugin to the application.
 	*
-	* @param {typeof Plugin} plugin - The plugin to register.
+	* @param {typeof Plugin} plugin - The plugin to add.
 	* @param {unknown} options - The options to pass to the plugin.
 	*/
-	registerPlugin(plugin, options) {
+	addPlugin(plugin, options) {
 		this.gPluginsRegistry.register(plugin, options);
 	}
 	/**
@@ -960,7 +977,6 @@ var App = class {
 	*/
 	async listen() {
 		if (this.fIsInitialized) throw new Error("App is already initialized");
-		await this.resolvePlugins();
 		initializeContainer(this.container);
 		await this.gHttpServer.listen();
 		this.fIsInitialized = true;
@@ -1144,7 +1160,7 @@ const defaultConfig = {
 	runtime: { session: {
 		secret: process.env?.SECRET ?? generateRandomHash(),
 		name: "vercube_session",
-		duration: 60 * 60 * 24 * 7
+		duration: 3600 * 24 * 7
 	} }
 };
 
@@ -1174,12 +1190,13 @@ async function loadVercubeConfig(overrides) {
 *
 * @returns {Promise<App>} A promise that resolves to an instance of the App.
 */
-async function createApp(cfg) {
+async function createApp({ cfg = {}, setup = void 0 } = {}) {
 	const config = await loadVercubeConfig(cfg);
 	const container = createContainer(config);
 	const app = container.resolve(App);
 	container.get(RuntimeConfig).runtimeConfig = config?.runtime ?? {};
 	app.container = container;
+	if (setup) await setup(app);
 	await app.init(config);
 	initializeContainer(container);
 	return app;
@@ -1254,8 +1271,10 @@ function createMetadataMethod() {
 		req: null,
 		res: null,
 		url: null,
+		method: null,
 		args: [],
-		actions: []
+		actions: [],
+		meta: {}
 	};
 }
 /**
@@ -1345,6 +1364,9 @@ var ConnectDecorator = class extends BaseDecorator {
 	* with the Router, and sets up the event handler for the CONNECT request.
 	*/
 	created() {
+		initializeMetadata(this.prototype);
+		const method = initializeMetadataMethod(this.prototype, this.propertyName);
+		method.method = "CONNECT";
 		this.options.path = this.gMetadataResolver.resolveUrl({
 			instance: this.instance,
 			path: this.options.path,
@@ -1421,7 +1443,8 @@ var DeleteDecorator = class extends BaseDecorator {
 	*/
 	created() {
 		initializeMetadata(this.prototype);
-		initializeMetadataMethod(this.prototype, this.propertyName);
+		const method = initializeMetadataMethod(this.prototype, this.propertyName);
+		method.method = "DELETE";
 		this.options.path = this.gMetadataResolver.resolveUrl({
 			instance: this.instance,
 			path: this.options.path,
@@ -1477,7 +1500,8 @@ var GetDecorator = class extends BaseDecorator {
 	*/
 	created() {
 		initializeMetadata(this.prototype);
-		initializeMetadataMethod(this.prototype, this.propertyName);
+		const method = initializeMetadataMethod(this.prototype, this.propertyName);
+		method.method = "GET";
 		this.options.path = this.gMetadataResolver.resolveUrl({
 			instance: this.instance,
 			path: this.options.path,
@@ -1533,7 +1557,8 @@ var HeadDecorator = class extends BaseDecorator {
 	*/
 	created() {
 		initializeMetadata(this.prototype);
-		initializeMetadataMethod(this.prototype, this.propertyName);
+		const method = initializeMetadataMethod(this.prototype, this.propertyName);
+		method.method = "HEAD";
 		this.options.path = this.gMetadataResolver.resolveUrl({
 			instance: this.instance,
 			path: this.options.path,
@@ -1670,7 +1695,8 @@ var OptionsDecorator = class extends BaseDecorator {
 	*/
 	created() {
 		initializeMetadata(this.prototype);
-		initializeMetadataMethod(this.prototype, this.propertyName);
+		const method = initializeMetadataMethod(this.prototype, this.propertyName);
+		method.method = "OPTIONS";
 		this.options.path = this.gMetadataResolver.resolveUrl({
 			instance: this.instance,
 			path: this.options.path,
@@ -1771,6 +1797,9 @@ var PatchDecorator = class extends BaseDecorator {
 	* with the Router, and sets up the event handler for the PATCH request.
 	*/
 	created() {
+		initializeMetadata(this.prototype);
+		const method = initializeMetadataMethod(this.prototype, this.propertyName);
+		method.method = "PATCH";
 		this.options.path = this.gMetadataResolver.resolveUrl({
 			instance: this.instance,
 			path: this.options.path,
@@ -1826,7 +1855,8 @@ var PostDecorator = class extends BaseDecorator {
 	*/
 	created() {
 		initializeMetadata(this.prototype);
-		initializeMetadataMethod(this.prototype, this.propertyName);
+		const method = initializeMetadataMethod(this.prototype, this.propertyName);
+		method.method = "POST";
 		this.options.path = this.gMetadataResolver.resolveUrl({
 			instance: this.instance,
 			path: this.options.path,
@@ -1882,7 +1912,8 @@ var PutDecorator = class extends BaseDecorator {
 	*/
 	created() {
 		initializeMetadata(this.prototype);
-		initializeMetadataMethod(this.prototype, this.propertyName);
+		const method = initializeMetadataMethod(this.prototype, this.propertyName);
+		method.method = "PUT";
 		this.options.path = this.gMetadataResolver.resolveUrl({
 			instance: this.instance,
 			path: this.options.path,
@@ -2114,7 +2145,8 @@ var TraceDecorator = class extends BaseDecorator {
 	*/
 	created() {
 		initializeMetadata(this.prototype);
-		initializeMetadataMethod(this.prototype, this.propertyName);
+		const method = initializeMetadataMethod(this.prototype, this.propertyName);
+		method.method = "TRACE";
 		this.options.path = this.gMetadataResolver.resolveUrl({
 			instance: this.instance,
 			path: this.options.path,
@@ -2368,7 +2400,7 @@ var SessionDecorator = class extends BaseDecorator {
 			data: {
 				name: this.gRuntimeConfig.runtimeConfig.session?.name ?? "vercube_session",
 				secret: this.gRuntimeConfig.runtimeConfig.session?.secret ?? generateRandomHash(),
-				duration: this.gRuntimeConfig.runtimeConfig.session?.duration ?? 60 * 60 * 24 * 7
+				duration: this.gRuntimeConfig.runtimeConfig.session?.duration ?? 3600 * 24 * 7
 			}
 		});
 	}
@@ -2629,4 +2661,334 @@ let HTTPStatus = /* @__PURE__ */ function(HTTPStatus$1) {
 }({});
 
 //#endregion
-export { App, BadRequestError, BaseMiddleware, BasePlugin, Body, Connect, Controller, Delete, ErrorHandlerProvider, FastResponse, ForbiddenError, Get, GlobalMiddlewareRegistry, HTTPStatus, Head, Header, Headers$1 as Headers, HooksService, HttpError, HttpServer, InternalServerError, Listen, MetadataResolver, MethodNotAllowedError, Middleware, MultipartFormData, NotAcceptableError, NotFoundError, Options, Param, Patch, Post, Put, QueryParam, QueryParams, Redirect, Request, Response$1 as Response, Router, RuntimeConfig, Session, SetHeader, Status, Trace, UnauthorizedError, createApp, createMetadataCtx, createMetadataMethod, defineConfig, initializeMetadata, initializeMetadataMethod, loadVercubeConfig };
+//#region src/Types/HttpCodes.ts
+/**
+* Hypertext Transfer Protocol (HTTP) response status codes.
+* @see {@link https://en.wikipedia.org/wiki/List_of_HTTP_status_codes}
+*/
+let HttpStatusCode = /* @__PURE__ */ function(HttpStatusCode$1) {
+	/**
+	* The server has received the request headers and the client should proceed to send the request body
+	* (in the case of a request for which a body needs to be sent; for example, a POST request).
+	* Sending a large request body to a server after a request has been rejected for inappropriate headers would be inefficient.
+	* To have a server check the request's headers, a client must send Expect: 100-continue as a header in its initial request
+	* and receive a 100 Continue status code in response before sending the body. The response 417 Expectation Failed indicates
+	* the request should not be continued.
+	*/
+	HttpStatusCode$1[HttpStatusCode$1["CONTINUE"] = 100] = "CONTINUE";
+	/**
+	* The requester has asked the server to switch protocols and the server has agreed to do so.
+	*/
+	HttpStatusCode$1[HttpStatusCode$1["SWITCHING_PROTOCOLS"] = 101] = "SWITCHING_PROTOCOLS";
+	/**
+	* A WebDAV request may contain many sub-requests involving file operations, requiring a long time to complete the request.
+	* This code indicates that the server has received and is processing the request, but no response is available yet.
+	* This prevents the client from timing out and assuming the request was lost.
+	*/
+	HttpStatusCode$1[HttpStatusCode$1["PROCESSING"] = 102] = "PROCESSING";
+	/**
+	* Standard response for successful HTTP requests.
+	* The actual response will depend on the request method used.
+	* In a GET request, the response will contain an entity corresponding to the requested resource.
+	* In a POST request, the response will contain an entity describing or containing the result of the action.
+	*/
+	HttpStatusCode$1[HttpStatusCode$1["OK"] = 200] = "OK";
+	/**
+	* The request has been fulfilled, resulting in the creation of a new resource.
+	*/
+	HttpStatusCode$1[HttpStatusCode$1["CREATED"] = 201] = "CREATED";
+	/**
+	* The request has been accepted for processing, but the processing has not been completed.
+	* The request might or might not be eventually acted upon, and may be disallowed when processing occurs.
+	*/
+	HttpStatusCode$1[HttpStatusCode$1["ACCEPTED"] = 202] = "ACCEPTED";
+	/**
+	* SINCE HTTP/1.1
+	* The server is a transforming proxy that received a 200 OK from its origin,
+	* but is returning a modified version of the origin's response.
+	*/
+	HttpStatusCode$1[HttpStatusCode$1["NON_AUTHORITATIVE_INFORMATION"] = 203] = "NON_AUTHORITATIVE_INFORMATION";
+	/**
+	* The server successfully processed the request and is not returning any content.
+	*/
+	HttpStatusCode$1[HttpStatusCode$1["NO_CONTENT"] = 204] = "NO_CONTENT";
+	/**
+	* The server successfully processed the request, but is not returning any content.
+	* Unlike a 204 response, this response requires that the requester reset the document view.
+	*/
+	HttpStatusCode$1[HttpStatusCode$1["RESET_CONTENT"] = 205] = "RESET_CONTENT";
+	/**
+	* The server is delivering only part of the resource (byte serving) due to a range header sent by the client.
+	* The range header is used by HTTP clients to enable resuming of interrupted downloads,
+	* or split a download into multiple simultaneous streams.
+	*/
+	HttpStatusCode$1[HttpStatusCode$1["PARTIAL_CONTENT"] = 206] = "PARTIAL_CONTENT";
+	/**
+	* The message body that follows is an XML message and can contain a number of separate response codes,
+	* depending on how many sub-requests were made.
+	*/
+	HttpStatusCode$1[HttpStatusCode$1["MULTI_STATUS"] = 207] = "MULTI_STATUS";
+	/**
+	* The members of a DAV binding have already been enumerated in a preceding part of the (multistatus) response,
+	* and are not being included again.
+	*/
+	HttpStatusCode$1[HttpStatusCode$1["ALREADY_REPORTED"] = 208] = "ALREADY_REPORTED";
+	/**
+	* The server has fulfilled a request for the resource,
+	* and the response is a representation of the result of one or more instance-manipulations applied to the current instance.
+	*/
+	HttpStatusCode$1[HttpStatusCode$1["IM_USED"] = 226] = "IM_USED";
+	/**
+	* Indicates multiple options for the resource from which the client may choose (via agent-driven content negotiation).
+	* For example, this code could be used to present multiple video format options,
+	* to list files with different filename extensions, or to suggest word-sense disambiguation.
+	*/
+	HttpStatusCode$1[HttpStatusCode$1["MULTIPLE_CHOICES"] = 300] = "MULTIPLE_CHOICES";
+	/**
+	* This and all future requests should be directed to the given URI.
+	*/
+	HttpStatusCode$1[HttpStatusCode$1["MOVED_PERMANENTLY"] = 301] = "MOVED_PERMANENTLY";
+	/**
+	* This is an example of industry practice contradicting the standard.
+	* The HTTP/1.0 specification (RFC 1945) required the client to perform a temporary redirect
+	* (the original describing phrase was "Moved Temporarily"), but popular browsers implemented 302
+	* with the functionality of a 303 See Other. Therefore, HTTP/1.1 added status codes 303 and 307
+	* to distinguish between the two behaviours. However, some Web applications and frameworks
+	* use the 302 status code as if it were the 303.
+	*/
+	HttpStatusCode$1[HttpStatusCode$1["FOUND"] = 302] = "FOUND";
+	/**
+	* SINCE HTTP/1.1
+	* The response to the request can be found under another URI using a GET method.
+	* When received in response to a POST (or PUT/DELETE), the client should presume that
+	* the server has received the data and should issue a redirect with a separate GET message.
+	*/
+	HttpStatusCode$1[HttpStatusCode$1["SEE_OTHER"] = 303] = "SEE_OTHER";
+	/**
+	* Indicates that the resource has not been modified since the version specified by the request headers
+	* If-Modified-Since or If-None-Match.
+	* In such case, there is no need to retransmit the resource since the client still has a previously-downloaded copy.
+	*/
+	HttpStatusCode$1[HttpStatusCode$1["NOT_MODIFIED"] = 304] = "NOT_MODIFIED";
+	/**
+	* SINCE HTTP/1.1
+	* The requested resource is available only through a proxy, the address for which is provided in the response.
+	* Many HTTP clients (such as Mozilla and Internet Explorer) do not correctly handle responses with this status code,
+	* primarily for security reasons.
+	*/
+	HttpStatusCode$1[HttpStatusCode$1["USE_PROXY"] = 305] = "USE_PROXY";
+	/**
+	* No longer used. Originally meant "Subsequent requests should use the specified proxy."
+	*/
+	HttpStatusCode$1[HttpStatusCode$1["SWITCH_PROXY"] = 306] = "SWITCH_PROXY";
+	/**
+	* SINCE HTTP/1.1
+	* In this case, the request should be repeated with another URI; however, future requests should still use the original URI.
+	* In contrast to how 302 was historically implemented, the request method is not allowed to be changed when reissuing
+	* the original request.
+	* For example, a POST request should be repeated using another POST request.
+	*/
+	HttpStatusCode$1[HttpStatusCode$1["TEMPORARY_REDIRECT"] = 307] = "TEMPORARY_REDIRECT";
+	/**
+	* The request and all future requests should be repeated using another URI.
+	* 307 and 308 parallel the behaviors of 302 and 301, but do not allow the HTTP method to change.
+	* So, for example, submitting a form to a permanently redirected resource may continue smoothly.
+	*/
+	HttpStatusCode$1[HttpStatusCode$1["PERMANENT_REDIRECT"] = 308] = "PERMANENT_REDIRECT";
+	/**
+	* The server cannot or will not process the request due to an apparent client error
+	* (e.g., malformed request syntax, too large size, invalid request message framing, or deceptive request routing).
+	*/
+	HttpStatusCode$1[HttpStatusCode$1["BAD_REQUEST"] = 400] = "BAD_REQUEST";
+	/**
+	* Similar to 403 Forbidden, but specifically for use when authentication is required and has failed or has not yet
+	* been provided. The response must include a WWW-Authenticate header field containing a challenge applicable to the
+	* requested resource. See Basic access authentication and Digest access authentication. 401 semantically means
+	* "unauthenticated",i.e. the user does not have the necessary credentials.
+	*/
+	HttpStatusCode$1[HttpStatusCode$1["UNAUTHORIZED"] = 401] = "UNAUTHORIZED";
+	/**
+	* Reserved for future use. The original intention was that this code might be used as part of some form of digital
+	* cash or micro payment scheme, but that has not happened, and this code is not usually used.
+	* Google Developers API uses this status if a particular developer has exceeded the daily limit on requests.
+	*/
+	HttpStatusCode$1[HttpStatusCode$1["PAYMENT_REQUIRED"] = 402] = "PAYMENT_REQUIRED";
+	/**
+	* The request was valid, but the server is refusing action.
+	* The user might not have the necessary permissions for a resource.
+	*/
+	HttpStatusCode$1[HttpStatusCode$1["FORBIDDEN"] = 403] = "FORBIDDEN";
+	/**
+	* The requested resource could not be found but may be available in the future.
+	* Subsequent requests by the client are permissible.
+	*/
+	HttpStatusCode$1[HttpStatusCode$1["NOT_FOUND"] = 404] = "NOT_FOUND";
+	/**
+	* A request method is not supported for the requested resource;
+	* for example, a GET request on a form that requires data to be presented via POST, or a PUT request on a read-only resource.
+	*/
+	HttpStatusCode$1[HttpStatusCode$1["METHOD_NOT_ALLOWED"] = 405] = "METHOD_NOT_ALLOWED";
+	/**
+	* The requested resource is capable of generating only content not acceptable according to the Accept
+	* headers sent in the request.
+	*/
+	HttpStatusCode$1[HttpStatusCode$1["NOT_ACCEPTABLE"] = 406] = "NOT_ACCEPTABLE";
+	/**
+	* The client must first authenticate itself with the proxy.
+	*/
+	HttpStatusCode$1[HttpStatusCode$1["PROXY_AUTHENTICATION_REQUIRED"] = 407] = "PROXY_AUTHENTICATION_REQUIRED";
+	/**
+	* The server timed out waiting for the request.
+	* According to HTTP specifications:
+	* "The client did not produce a request within the time that the server was prepared to wait. The client MAY repeat
+	* the request without modifications at any later time."
+	*/
+	HttpStatusCode$1[HttpStatusCode$1["REQUEST_TIMEOUT"] = 408] = "REQUEST_TIMEOUT";
+	/**
+	* Indicates that the request could not be processed because of conflict in the request,
+	* such as an edit conflict between multiple simultaneous updates.
+	*/
+	HttpStatusCode$1[HttpStatusCode$1["CONFLICT"] = 409] = "CONFLICT";
+	/**
+	* Indicates that the resource requested is no longer available and will not be available again.
+	* This should be used when a resource has been intentionally removed and the resource should be purged.
+	* Upon receiving a 410 status code, the client should not request the resource in the future.
+	* Clients such as search engines should remove the resource from their indices.
+	* Most use cases do not require clients and search engines to purge the resource, and a "404 Not Found" may be used instead.
+	*/
+	HttpStatusCode$1[HttpStatusCode$1["GONE"] = 410] = "GONE";
+	/**
+	* The request did not specify the length of its content, which is required by the requested resource.
+	*/
+	HttpStatusCode$1[HttpStatusCode$1["LENGTH_REQUIRED"] = 411] = "LENGTH_REQUIRED";
+	/**
+	* The server does not meet one of the preconditions that the requester put on the request.
+	*/
+	HttpStatusCode$1[HttpStatusCode$1["PRECONDITION_FAILED"] = 412] = "PRECONDITION_FAILED";
+	/**
+	* The request is larger than the server is willing or able to process. Previously called "Request Entity Too Large".
+	*/
+	HttpStatusCode$1[HttpStatusCode$1["PAYLOAD_TOO_LARGE"] = 413] = "PAYLOAD_TOO_LARGE";
+	/**
+	* The URI provided was too long for the server to process. Often the result of too much data being encoded
+	* as a query-string of a GET request,
+	* in which case it should be converted to a POST request.
+	* Called "Request-URI Too Long" previously.
+	*/
+	HttpStatusCode$1[HttpStatusCode$1["URI_TOO_LONG"] = 414] = "URI_TOO_LONG";
+	/**
+	* The request entity has a media type which the server or resource does not support.
+	* For example, the client uploads an image as image/svg+xml, but the server requires that images use a different format.
+	*/
+	HttpStatusCode$1[HttpStatusCode$1["UNSUPPORTED_MEDIA_TYPE"] = 415] = "UNSUPPORTED_MEDIA_TYPE";
+	/**
+	* The client has asked for a portion of the file (byte serving), but the server cannot supply that portion.
+	* For example, if the client asked for a part of the file that lies beyond the end of the file.
+	* Called "Requested Range Not Satisfiable" previously.
+	*/
+	HttpStatusCode$1[HttpStatusCode$1["RANGE_NOT_SATISFIABLE"] = 416] = "RANGE_NOT_SATISFIABLE";
+	/**
+	* The server cannot meet the requirements of the Expect request-header field.
+	*/
+	HttpStatusCode$1[HttpStatusCode$1["EXPECTATION_FAILED"] = 417] = "EXPECTATION_FAILED";
+	/**
+	* This code was defined in 1998 as one of the traditional IETF April Fools' jokes, in RFC 2324,
+	* Hyper Text Coffee Pot Control Protocol,
+	* and is not expected to be implemented by actual HTTP servers. The RFC specifies this code should be returned by
+	* teapots requested to brew coffee. This HTTP status is used as an Easter egg in some websites, including Google.com.
+	*/
+	HttpStatusCode$1[HttpStatusCode$1["I_AM_A_TEAPOT"] = 418] = "I_AM_A_TEAPOT";
+	/**
+	* The request was directed at a server that is not able to produce a response (for example because a connection reuse).
+	*/
+	HttpStatusCode$1[HttpStatusCode$1["MISDIRECTED_REQUEST"] = 421] = "MISDIRECTED_REQUEST";
+	/**
+	* The request was well-formed but was unable to be followed due to semantic errors.
+	*/
+	HttpStatusCode$1[HttpStatusCode$1["UNPROCESSABLE_ENTITY"] = 422] = "UNPROCESSABLE_ENTITY";
+	/**
+	* The resource that is being accessed is locked.
+	*/
+	HttpStatusCode$1[HttpStatusCode$1["LOCKED"] = 423] = "LOCKED";
+	/**
+	* The request failed due to failure of a previous request (e.g., a PROPPATCH).
+	*/
+	HttpStatusCode$1[HttpStatusCode$1["FAILED_DEPENDENCY"] = 424] = "FAILED_DEPENDENCY";
+	/**
+	* The client should switch to a different protocol such as TLS/1.0, given in the Upgrade header field.
+	*/
+	HttpStatusCode$1[HttpStatusCode$1["UPGRADE_REQUIRED"] = 426] = "UPGRADE_REQUIRED";
+	/**
+	* The origin server requires the request to be conditional.
+	* Intended to prevent "the 'lost update' problem, where a client
+	* GETs a resource's state, modifies it, and PUTs it back to the server,
+	* when meanwhile a third party has modified the state on the server, leading to a conflict."
+	*/
+	HttpStatusCode$1[HttpStatusCode$1["PRECONDITION_REQUIRED"] = 428] = "PRECONDITION_REQUIRED";
+	/**
+	* The user has sent too many requests in a given amount of time. Intended for use with rate-limiting schemes.
+	*/
+	HttpStatusCode$1[HttpStatusCode$1["TOO_MANY_REQUESTS"] = 429] = "TOO_MANY_REQUESTS";
+	/**
+	* The server is unwilling to process the request because either an individual header field,
+	* or all the header fields collectively, are too large.
+	*/
+	HttpStatusCode$1[HttpStatusCode$1["REQUEST_HEADER_FIELDS_TOO_LARGE"] = 431] = "REQUEST_HEADER_FIELDS_TOO_LARGE";
+	/**
+	* A server operator has received a legal demand to deny access to a resource or to a set of resources
+	* that includes the requested resource. The code 451 was chosen as a reference to the novel Fahrenheit 451.
+	*/
+	HttpStatusCode$1[HttpStatusCode$1["UNAVAILABLE_FOR_LEGAL_REASONS"] = 451] = "UNAVAILABLE_FOR_LEGAL_REASONS";
+	/**
+	* A generic error message, given when an unexpected condition was encountered and no more specific message is suitable.
+	*/
+	HttpStatusCode$1[HttpStatusCode$1["INTERNAL_SERVER_ERROR"] = 500] = "INTERNAL_SERVER_ERROR";
+	/**
+	* The server either does not recognize the request method, or it lacks the ability to fulfill the request.
+	* Usually this implies future availability (e.g., a new feature of a web-service API).
+	*/
+	HttpStatusCode$1[HttpStatusCode$1["NOT_IMPLEMENTED"] = 501] = "NOT_IMPLEMENTED";
+	/**
+	* The server was acting as a gateway or proxy and received an invalid response from the upstream server.
+	*/
+	HttpStatusCode$1[HttpStatusCode$1["BAD_GATEWAY"] = 502] = "BAD_GATEWAY";
+	/**
+	* The server is currently unavailable (because it is overloaded or down for maintenance).
+	* Generally, this is a temporary state.
+	*/
+	HttpStatusCode$1[HttpStatusCode$1["SERVICE_UNAVAILABLE"] = 503] = "SERVICE_UNAVAILABLE";
+	/**
+	* The server was acting as a gateway or proxy and did not receive a timely response from the upstream server.
+	*/
+	HttpStatusCode$1[HttpStatusCode$1["GATEWAY_TIMEOUT"] = 504] = "GATEWAY_TIMEOUT";
+	/**
+	* The server does not support the HTTP protocol version used in the request
+	*/
+	HttpStatusCode$1[HttpStatusCode$1["HTTP_VERSION_NOT_SUPPORTED"] = 505] = "HTTP_VERSION_NOT_SUPPORTED";
+	/**
+	* Transparent content negotiation for the request results in a circular reference.
+	*/
+	HttpStatusCode$1[HttpStatusCode$1["VARIANT_ALSO_NEGOTIATES"] = 506] = "VARIANT_ALSO_NEGOTIATES";
+	/**
+	* The server is unable to store the representation needed to complete the request.
+	*/
+	HttpStatusCode$1[HttpStatusCode$1["INSUFFICIENT_STORAGE"] = 507] = "INSUFFICIENT_STORAGE";
+	/**
+	* The server detected an infinite loop while processing the request.
+	*/
+	HttpStatusCode$1[HttpStatusCode$1["LOOP_DETECTED"] = 508] = "LOOP_DETECTED";
+	/**
+	* Further extensions to the request are required for the server to fulfill it.
+	*/
+	HttpStatusCode$1[HttpStatusCode$1["NOT_EXTENDED"] = 510] = "NOT_EXTENDED";
+	/**
+	* The client needs to authenticate to gain network access.
+	* Intended for use by intercepting proxies used to control access to the network (e.g., "captive portals" used
+	* to require agreement to Terms of Service before granting full Internet access via a Wi-Fi hotspot).
+	*/
+	HttpStatusCode$1[HttpStatusCode$1["NETWORK_AUTHENTICATION_REQUIRED"] = 511] = "NETWORK_AUTHENTICATION_REQUIRED";
+	return HttpStatusCode$1;
+}({});
+
+//#endregion
+export { App, BadRequestError, BaseMiddleware, BasePlugin, Body, Connect, Controller, Delete, ErrorHandlerProvider, FastResponse, ForbiddenError, Get, GlobalMiddlewareRegistry, HTTPStatus, Head, Header, Headers$1 as Headers, HooksService, HttpError, HttpServer, HttpStatusCode, InternalServerError, Listen, MetadataResolver, MethodNotAllowedError, Middleware, MultipartFormData, NotAcceptableError, NotFoundError, Options, Param, Patch, Post, Put, QueryParam, QueryParams, Redirect, Request, Response$1 as Response, Router, RuntimeConfig, Session, SetHeader, StandardSchemaValidationProvider, Status, Trace, UnauthorizedError, ValidationProvider, createApp, createMetadataCtx, createMetadataMethod, defineConfig, initializeMetadata, initializeMetadataMethod, loadVercubeConfig };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vercube/core",
-  "version": "0.0.18",
+  "version": "0.0.20",
   "description": "Core module for Vercube framework",
   "repository": {
     "type": "git",
@@ -28,8 +28,8 @@
     "pathe": "2.0.3",
     "rou3": "0.7.3",
     "srvx": "0.8.2",
-    "@vercube/di": "0.0.18",
-    "@vercube/logger": "0.0.18"
+    "@vercube/di": "0.0.20",
+    "@vercube/logger": "0.0.20"
   },
   "publishConfig": {
     "access": "public"