@mxweb/core 1.0.0

package/dist/feature.d.ts

@@ -0,0 +1,239 @@
+/**
+ * @fileoverview Feature module for organizing application functionality.
+ *
+ * Features are the primary way to organize code in @mxweb/core.
+ * Each feature encapsulates a controller, router, and optional imports/injects.
+ * Similar to NestJS modules but optimized for Next.js App Router.
+ *
+ * @module feature
+ */
+import { ControllerConstructor } from "./controller";
+import { RouteMatched, Router } from "./router";
+import { FeatureHooks, FeatureHooksOptions } from "./hooks";
+import { FeatureInject, RouteMethod } from "./common";
+/**
+ * Type for feature-specific dependency injection configuration.
+ * Maps inject names to their instances.
+ */
+export type FeatureInjects = Record<string, FeatureInject>;
+/**
+ * Type for feature imports configuration.
+ * Imports are executed once when the feature loads for side effects
+ * (e.g., registering entities, migrations).
+ *
+ * Can be:
+ * - A static array of imports
+ * - A function returning an array
+ * - An async function returning an array
+ *
+ * @example
+ * ```ts
+ * // Static array
+ * imports: [Connection.forFeature([ProductEntity])]
+ *
+ * // Async function
+ * imports: async () => [
+ *   await Connection.forFeature([ProductEntity]),
+ *   Migration.forFeature([CreateProductTable]),
+ * ]
+ * ```
+ */
+export type FeatureImports = unknown[] | (() => unknown[]) | (() => Promise<unknown[]>);
+/**
+ * Configuration options for creating a Feature.
+ * Extends FeatureHooksOptions for lifecycle hooks.
+ *
+ * @example
+ * ```ts
+ * const options: FeatureInitialize = {
+ *   controller: ProductController,
+ *   router: Router.register(
+ *     Route.get("/products", "findAll"),
+ *     Route.post("/products", "create"),
+ *   ),
+ *   imports: [Connection.forFeature([ProductEntity])],
+ *   injects: { productRepo: new ProductRepository() },
+ *   onStart: () => console.log("Product feature started"),
+ *   onRequest: (ctx) => console.log("Product feature request"),
+ * };
+ * ```
+ */
+export interface FeatureInitialize extends FeatureHooksOptions {
+    /** The controller class that handles requests for this feature */
+    controller: ControllerConstructor<any>;
+    /** Router with registered routes for this feature */
+    router: Router;
+    /**
+     * Imports executed once when the feature loads.
+     * Used for side effects like registering entities or migrations.
+     * The return values are not stored.
+     */
+    imports?: FeatureImports;
+    /**
+     * Feature-specific injects (local to this feature).
+     * Accessible via `ctx.getLocalInject()` or `Inject()` decorator.
+     * Can be a static object, function, or async function.
+     */
+    injects?: FeatureInjects | (() => FeatureInjects) | (() => Promise<FeatureInjects>);
+}
+/**
+ * Simplified interface for feature registration.
+ * Contains only the required controller and router.
+ */
+export interface FeatureRegister {
+    /** The controller class */
+    controller: ControllerConstructor<any>;
+    /** Router with routes */
+    router: Router;
+}
+/**
+ * Feature class representing a module of functionality.
+ *
+ * Features are the building blocks of an @mxweb/core application.
+ * Each feature contains:
+ * - A controller for handling requests
+ * - A router with route definitions
+ * - Optional imports for side effects (entities, migrations)
+ * - Optional injects for feature-local dependencies
+ * - Lifecycle hooks (onStart, onRequest, onResponse)
+ *
+ * @remarks
+ * Features are registered with the Application using `Application.register()`.
+ * They are lazy-loaded on first request matching their routes.
+ *
+ * @example
+ * ```ts
+ * // product.feature.ts
+ * import { Application, Feature, Route, Router } from "@mxweb/core";
+ * import { ProductController } from "./product.controller";
+ *
+ * Application.register(
+ *   Feature.create({
+ *     controller: ProductController,
+ *     router: Router.register(
+ *       Route.get("/products", "findAll"),
+ *       Route.get("/products/:id", "findById"),
+ *       Route.post("/products", "create"),
+ *       Route.put("/products/:id", "update"),
+ *       Route.delete("/products/:id", "remove"),
+ *     ),
+ *     imports: [Connection.forFeature([ProductEntity])],
+ *     injects: {
+ *       productRepo: new ProductRepository(),
+ *     },
+ *     onStart: () => {
+ *       console.log("Product feature initialized");
+ *     },
+ *   })
+ * );
+ * ```
+ */
+export declare class Feature {
+    private readonly options;
+    private readonly ControllerContructor;
+    private readonly router;
+    /** The last matched route for this feature */
+    private routeMatched;
+    /** Feature hooks manager */
+    private hooks;
+    /** Cached controller instance (lazy instantiated) */
+    private controller;
+    /** Map of feature-local injects */
+    private injects;
+    /** Flag indicating if injects have been loaded */
+    private injectsLoaded;
+    /** Flag indicating if imports have been loaded */
+    private importsLoaded;
+    /**
+     * Private constructor - use Feature.create() to instantiate.
+     *
+     * @param options - Feature configuration options
+     * @param ControllerContructor - The controller class constructor
+     * @param router - The router instance
+     */
+    private constructor();
+    /**
+     * Factory method to create a new Feature instance.
+     *
+     * @param options - Feature configuration options
+     * @returns A new Feature instance
+     *
+     * @example
+     * ```ts
+     * const feature = Feature.create({
+     *   controller: ProductController,
+     *   router: Router.register(
+     *     Route.get("/products", "findAll"),
+     *   ),
+     * });
+     * ```
+     */
+    static create(options: FeatureInitialize): Feature;
+    /**
+     * Loads feature imports (side effects only, no storage).
+     * This method is idempotent - subsequent calls have no effect.
+     *
+     * @remarks
+     * Imports are used to register entities, migrations, or other side effects.
+     * The resolved values are not stored - only the side effects matter.
+     */
+    loadImports(): Promise<void>;
+    /**
+     * Loads feature-specific injects.
+     * Also loads imports first if not already loaded.
+     * This method is idempotent - subsequent calls have no effect.
+     *
+     * @remarks
+     * Calls the `onFeature()` lifecycle hook on each inject after loading.
+     */
+    loadInjects(): Promise<void>;
+    /**
+     * Destroys all feature-specific injects.
+     * Calls the `onFeatureDestroy()` lifecycle hook on each inject.
+     *
+     * @remarks
+     * Called during application shutdown via Application.registerShutdown().
+     */
+    destroyInjects(): Promise<void>;
+    /**
+     * Retrieves a feature-specific inject by name.
+     *
+     * @template T - Expected type of the inject (must extend FeatureInject)
+     * @param name - The name of the inject to retrieve
+     * @returns The inject instance or undefined if not found
+     *
+     * @example
+     * ```ts
+     * const repo = feature.getInject<ProductRepository>("productRepo");
+     * ```
+     */
+    getInject<T extends FeatureInject>(name: string): T | undefined;
+    /**
+     * Checks if a feature-specific inject exists by name.
+     *
+     * @param name - The inject name to check
+     * @returns true if the inject exists, false otherwise
+     */
+    hasInject(name: string): boolean;
+    /**
+     * Returns the controller instance for this feature.
+     * Lazily instantiates the controller on first access.
+     *
+     * @returns The controller instance
+     */
+    getController(): any;
+    /**
+     * Returns the feature hooks manager.
+     *
+     * @returns The FeatureHooks instance
+     */
+    getHooks(): FeatureHooks;
+    /**
+     * Attempts to match a request against this feature's routes.
+     *
+     * @param method - The HTTP method of the request
+     * @param path - The request path to match
+     * @returns The matched route info or null if no match
+     */
+    matchRoute(method: RouteMethod, path: string): RouteMatched | null;
+}

package/dist/feature.js

@@ -0,0 +1 @@
+"use strict";var t=require("./hooks.js");class e{constructor(e,o,s){this.options=e,this.ControllerContructor=o,this.router=s,this.routeMatched=null,this.controller=null,this.injects=new Map,this.injectsLoaded=!1,this.importsLoaded=!1,this.hooks=new t.FeatureHooks(this.options)}static create(t){return new e(t,t.controller,t.router)}async loadImports(){if(this.importsLoaded)return;this.importsLoaded=!0;const{imports:t}=this.options;if(!t)return;"function"==typeof t&&await t()}async loadInjects(){if(await this.loadImports(),this.injectsLoaded)return;this.injectsLoaded=!0;const{injects:t}=this.options;if(!t)return;const e="function"==typeof t?await t():t;for(const[t,o]of Object.entries(e))this.injects.set(t,o),o.onFeature&&await o.onFeature()}async destroyInjects(){for(const t of this.injects.values())t.onFeatureDestroy&&await t.onFeatureDestroy();this.injects.clear(),this.injectsLoaded=!1}getInject(t){return this.injects.get(t)}hasInject(t){return this.injects.has(t)}getController(){if(!this.controller){const t=this.ControllerContructor;this.controller=new t}return this.controller}getHooks(){return this.hooks}matchRoute(t,e){return this.routeMatched=this.router.match(t,e),this.routeMatched}}exports.Feature=e;

package/dist/feature.mjs

@@ -0,0 +1 @@
+import{FeatureHooks as t}from"./hooks.mjs";class o{constructor(o,e,s){this.options=o,this.ControllerContructor=e,this.router=s,this.routeMatched=null,this.controller=null,this.injects=new Map,this.injectsLoaded=!1,this.importsLoaded=!1,this.hooks=new t(this.options)}static create(t){return new o(t,t.controller,t.router)}async loadImports(){if(this.importsLoaded)return;this.importsLoaded=!0;const{imports:t}=this.options;if(!t)return;"function"==typeof t&&await t()}async loadInjects(){if(await this.loadImports(),this.injectsLoaded)return;this.injectsLoaded=!0;const{injects:t}=this.options;if(!t)return;const o="function"==typeof t?await t():t;for(const[t,e]of Object.entries(o))this.injects.set(t,e),e.onFeature&&await e.onFeature()}async destroyInjects(){for(const t of this.injects.values())t.onFeatureDestroy&&await t.onFeatureDestroy();this.injects.clear(),this.injectsLoaded=!1}getInject(t){return this.injects.get(t)}hasInject(t){return this.injects.has(t)}getController(){if(!this.controller){const t=this.ControllerContructor;this.controller=new t}return this.controller}getHooks(){return this.hooks}matchRoute(t,o){return this.routeMatched=this.router.match(t,o),this.routeMatched}}export{o as Feature};

package/dist/hooks.d.ts

@@ -0,0 +1,251 @@
+/**
+ * @fileoverview Lifecycle hooks for Application and Feature levels.
+ *
+ * This module provides hook interfaces and managers for executing code at
+ * specific points in the application and request lifecycle:
+ * - `onStart`: Called once during initialization
+ * - `onRequest`: Called on every request before handling
+ * - `onResponse`: Called on every request after handling
+ *
+ * @module hooks
+ */
+import { NextRequest } from "next/server";
+import { RouteMethod } from "./common";
+import type { RequestContext } from "./execute";
+/**
+ * Configuration options for Application-level lifecycle hooks.
+ *
+ * Application hooks run at the global level and have access to different
+ * context depending on the hook:
+ * - `onStart`: No context (runs once at initialization)
+ * - `onRequest`: Raw request only (before route matching)
+ * - `onResponse`: Full request context (after handling)
+ *
+ * @example
+ * ```ts
+ * const app = Application.create({
+ *   onStart: () => {
+ *     console.log("Application started");
+ *   },
+ *   onRequest: (req, method) => {
+ *     console.log(`${method} ${req.url}`);
+ *   },
+ *   onResponse: (context) => {
+ *     console.log(`Response for ${context.path}`);
+ *   },
+ * });
+ * ```
+ */
+export interface ApplicationHooksOptions {
+    /**
+     * Called ONCE when the application is initialized.
+     * No request context is available at this point.
+     * Use for one-time setup, logging, or initialization tasks.
+     */
+    onStart?(): void | Promise<void>;
+    /**
+     * Called on every request BEFORE route matching.
+     * No full context is available - only the raw request and method.
+     * Use for early request logging, global rate limiting, etc.
+     *
+     * @param req - The incoming Next.js request
+     * @param method - The HTTP method of the request
+     */
+    onRequest?(req: NextRequest, method: RouteMethod): void | Promise<void>;
+    /**
+     * Called on every request AFTER the route handler completes.
+     * Full request context is available.
+     * Use for response logging, cleanup, metrics collection, etc.
+     *
+     * @param context - The request context containing request, response, params, etc.
+     */
+    onResponse?(context: RequestContext): void | Promise<void>;
+}
+/**
+ * Configuration options for Feature-level lifecycle hooks.
+ *
+ * Feature hooks run at the feature/module level and have access to
+ * the full request context (unlike Application's onRequest).
+ *
+ * @example
+ * ```ts
+ * Feature.create({
+ *   controller: ProductController,
+ *   router: productRouter,
+ *   onStart: () => {
+ *     console.log("Product feature initialized");
+ *   },
+ *   onRequest: (context) => {
+ *     console.log(`Product request: ${context.method} ${context.path}`);
+ *   },
+ *   onResponse: (context) => {
+ *     console.log(`Product response sent`);
+ *   },
+ * });
+ * ```
+ */
+export interface FeatureHooksOptions {
+    /**
+     * Called ONCE when the feature is initialized.
+     * No request context is available at this point.
+     * Use for feature-specific setup or logging.
+     */
+    onStart?(): void | Promise<void>;
+    /**
+     * Called on every request to this feature BEFORE the route handler.
+     * Full request context is available (after route matching).
+     * Use for feature-specific request logging, validation, etc.
+     *
+     * @param context - The request context for the current request
+     */
+    onRequest?(context: RequestContext): void | Promise<void>;
+    /**
+     * Called on every request to this feature AFTER the route handler.
+     * Full request context is available.
+     * Use for feature-specific response logging, cleanup, etc.
+     *
+     * @param context - The request context for the current request
+     */
+    onResponse?(context: RequestContext): void | Promise<void>;
+}
+/**
+ * Manager class for Application-level hooks.
+ * Created during Application.create() and executes onStart immediately.
+ *
+ * @example
+ * ```ts
+ * const hooks = new ApplicationHooks({
+ *   onStart: () => console.log("Started"),
+ *   onRequest: (req, method) => console.log(`${method} request`),
+ * });
+ * // onStart is called immediately in constructor
+ * ```
+ */
+export declare class ApplicationHooks {
+    private readonly options;
+    /**
+     * Creates a new ApplicationHooks instance.
+     * Immediately executes the onStart hook if provided.
+     *
+     * @param options - The hook configuration options
+     */
+    constructor(options: ApplicationHooksOptions);
+    /**
+     * Returns the hook options.
+     * @returns The ApplicationHooksOptions object
+     */
+    getOptions(): ApplicationHooksOptions;
+}
+/**
+ * Manager class for Feature-level hooks.
+ * Created during Feature.create() and executes onStart immediately.
+ *
+ * @example
+ * ```ts
+ * const hooks = new FeatureHooks({
+ *   onStart: () => console.log("Feature started"),
+ *   onRequest: (ctx) => console.log(`Request to ${ctx.path}`),
+ * });
+ * // onStart is called immediately in constructor
+ * ```
+ */
+export declare class FeatureHooks {
+    private readonly options;
+    /**
+     * Creates a new FeatureHooks instance.
+     * Immediately executes the onStart hook if provided.
+     *
+     * @param options - The hook configuration options
+     */
+    constructor(options: FeatureHooksOptions);
+    /**
+     * Returns the hook options.
+     * @returns The FeatureHooksOptions object
+     */
+    getOptions(): FeatureHooksOptions;
+}
+/**
+ * Per-request hook execution manager.
+ *
+ * Each request creates a new RequestHooks instance to track which hooks
+ * have been called, ensuring each hook runs at most once per request.
+ *
+ * @remarks
+ * This class manages the execution order:
+ * 1. Application onRequest (before route matching)
+ * 2. Feature onRequest (after route matching, before handler)
+ * 3. Handler execution
+ * 4. Feature onResponse (after handler)
+ * 5. Application onResponse (after all)
+ *
+ * @example
+ * ```ts
+ * // Created internally by Application for each request
+ * const requestHooks = new RequestHooks(applicationHooks);
+ *
+ * // Set feature hooks after route matching
+ * requestHooks.setFeatureHooks(matchedFeature.getHooks());
+ *
+ * // Execute hooks at appropriate times
+ * await requestHooks.appRequest(req, method);
+ * await requestHooks.featureRequest(context);
+ * // ... handle request ...
+ * await requestHooks.featureResponse(context);
+ * await requestHooks.appResponse(context);
+ * ```
+ */
+export declare class RequestHooks {
+    private readonly appHooks;
+    private featureHooks;
+    /** Flag to ensure appRequest is only called once */
+    private appRequestCalled;
+    /** Flag to ensure appResponse is only called once */
+    private appResponseCalled;
+    /** Flag to ensure featureRequest is only called once */
+    private featureRequestCalled;
+    /** Flag to ensure featureResponse is only called once */
+    private featureResponseCalled;
+    /**
+     * Creates a new RequestHooks instance.
+     *
+     * @param appHooks - The application-level hooks manager
+     * @param featureHooks - Optional feature-level hooks manager (set later via setFeatureHooks)
+     */
+    constructor(appHooks: ApplicationHooks, featureHooks?: FeatureHooks | null);
+    /**
+     * Sets the feature hooks after route matching.
+     * Called when the matching feature is determined.
+     *
+     * @param hooks - The FeatureHooks instance from the matched feature
+     */
+    setFeatureHooks(hooks: FeatureHooks): void;
+    /**
+     * Executes the Application onRequest hook.
+     * Called before route matching. Only runs once per request.
+     *
+     * @param req - The incoming Next.js request
+     * @param method - The HTTP method
+     */
+    appRequest(req: NextRequest, method: RouteMethod): Promise<void>;
+    /**
+     * Executes the Application onResponse hook.
+     * Called after dispatch and feature hooks. Only runs once per request.
+     *
+     * @param context - The request context
+     */
+    appResponse(context: RequestContext): Promise<void>;
+    /**
+     * Executes the Feature onRequest hook.
+     * Called after route matching, before handler. Only runs once per request.
+     *
+     * @param context - The request context
+     */
+    featureRequest(context: RequestContext): Promise<void>;
+    /**
+     * Executes the Feature onResponse hook.
+     * Called after handler, before app onResponse. Only runs once per request.
+     *
+     * @param context - The request context
+     */
+    featureResponse(context: RequestContext): Promise<void>;
+}

package/dist/hooks.js

@@ -0,0 +1 @@
+"use strict";exports.ApplicationHooks=class{constructor(e){this.options=e,this.options.onStart?.()}getOptions(){return this.options}},exports.FeatureHooks=class{constructor(e){this.options=e,this.options.onStart?.()}getOptions(){return this.options}},exports.RequestHooks=class{constructor(e,s=null){this.appHooks=e,this.featureHooks=s,this.appRequestCalled=!1,this.appResponseCalled=!1,this.featureRequestCalled=!1,this.featureResponseCalled=!1}setFeatureHooks(e){this.featureHooks=e}async appRequest(e,s){if(!this.appRequestCalled)return this.appRequestCalled=!0,await(this.appHooks.getOptions().onRequest?.(e,s))}async appResponse(e){if(!this.appResponseCalled)return this.appResponseCalled=!0,await(this.appHooks.getOptions().onResponse?.(e))}async featureRequest(e){if(!this.featureRequestCalled&&this.featureHooks)return this.featureRequestCalled=!0,await(this.featureHooks.getOptions().onRequest?.(e))}async featureResponse(e){if(!this.featureResponseCalled&&this.featureHooks)return this.featureResponseCalled=!0,await(this.featureHooks.getOptions().onResponse?.(e))}};

package/dist/hooks.mjs

@@ -0,0 +1 @@
+class e{constructor(e){this.options=e,this.options.onStart?.()}getOptions(){return this.options}}class s{constructor(e){this.options=e,this.options.onStart?.()}getOptions(){return this.options}}class t{constructor(e,s=null){this.appHooks=e,this.featureHooks=s,this.appRequestCalled=!1,this.appResponseCalled=!1,this.featureRequestCalled=!1,this.featureResponseCalled=!1}setFeatureHooks(e){this.featureHooks=e}async appRequest(e,s){if(!this.appRequestCalled)return this.appRequestCalled=!0,await(this.appHooks.getOptions().onRequest?.(e,s))}async appResponse(e){if(!this.appResponseCalled)return this.appResponseCalled=!0,await(this.appHooks.getOptions().onResponse?.(e))}async featureRequest(e){if(!this.featureRequestCalled&&this.featureHooks)return this.featureRequestCalled=!0,await(this.featureHooks.getOptions().onRequest?.(e))}async featureResponse(e){if(!this.featureResponseCalled&&this.featureHooks)return this.featureResponseCalled=!0,await(this.featureHooks.getOptions().onResponse?.(e))}}export{e as ApplicationHooks,s as FeatureHooks,t as RequestHooks};

package/dist/index.d.ts

@@ -0,0 +1,14 @@
+export * from "./application";
+export * from "./common";
+export * from "./config";
+export * from "./controller";
+export * from "./decorator";
+export * from "./error";
+export * from "./execute";
+export * from "./feature";
+export * from "./hooks";
+export * from "./logger";
+export * from "./response";
+export * from "./route";
+export * from "./router";
+export * from "./service";

package/dist/index.js

@@ -0,0 +1 @@
+"use strict";var r=require("./application.js"),e=require("./common.js"),o=require("./config.js"),t=require("./controller.js"),s=require("./decorator.js"),a=require("./error.js"),p=require("./execute.js"),x=require("./feature.js"),i=require("./hooks.js"),u=require("./logger.js"),n=require("./response.js"),l=require("./route.js"),c=require("./router.js"),E=require("./service.js");exports.Application=r.Application,exports.InjectionRegistry=e.InjectionRegistry,Object.defineProperty(exports,"RouteMethod",{enumerable:!0,get:function(){return e.RouteMethod}}),exports.Config=o.Config,exports.Controller=t.Controller,exports.controller=t.controller,exports.Body=s.Body,exports.FormData=s.FormData,exports.Header=s.Header,exports.Headers=s.Headers,exports.Inject=s.Inject,exports.Metadata=s.Metadata,exports.Param=s.Param,exports.Params=s.Params,exports.Query=s.Query,exports.QueryParam=s.QueryParam,exports.Request=s.Request,exports.SetMetadata=s.SetMetadata,exports.Text=s.Text,exports.UseFilters=s.UseFilters,exports.UseGuards=s.UseGuards,exports.UseInterceptors=s.UseInterceptors,exports.UsePipes=s.UsePipes,exports.applyDecorators=s.applyDecorators,exports.createDecorator=s.createDecorator,exports.BadGatewayError=a.BadGatewayError,exports.BadRequestError=a.BadRequestError,exports.ConflictError=a.ConflictError,exports.ForbiddenError=a.ForbiddenError,exports.GatewayTimeoutError=a.GatewayTimeoutError,exports.GoneError=a.GoneError,exports.HttpError=a.HttpError,exports.InternalServerError=a.InternalServerError,exports.MethodNotAllowedError=a.MethodNotAllowedError,exports.NotAcceptableError=a.NotAcceptableError,exports.NotFoundError=a.NotFoundError,exports.NotImplementedError=a.NotImplementedError,exports.PayloadTooLargeError=a.PayloadTooLargeError,exports.RequestTimeoutError=a.RequestTimeoutError,exports.ServiceUnavailableError=a.ServiceUnavailableError,exports.TooManyRequestsError=a.TooManyRequestsError,exports.UnauthorizedError=a.UnauthorizedError,exports.UnprocessableEntityError=a.UnprocessableEntityError,exports.UnsupportedMediaTypeError=a.UnsupportedMediaTypeError,exports.ValidateError=a.ValidateError,exports.ExecuteContext=p.ExecuteContext,exports.Reflect=p.Reflect,exports.Feature=x.Feature,exports.ApplicationHooks=i.ApplicationHooks,exports.FeatureHooks=i.FeatureHooks,exports.RequestHooks=i.RequestHooks,exports.Logger=u.Logger,exports.logger=u.logger,exports.ServerResponse=n.ServerResponse,exports.Route=l.Route,exports.Router=c.Router,exports.Service=E.Service,exports.service=E.service;

package/dist/index.mjs

@@ -0,0 +1 @@
+export{Application}from"./application.mjs";export{InjectionRegistry,RouteMethod}from"./common.mjs";export{Config}from"./config.mjs";export{Controller,controller}from"./controller.mjs";export{Body,FormData,Header,Headers,Inject,Metadata,Param,Params,Query,QueryParam,Request,SetMetadata,Text,UseFilters,UseGuards,UseInterceptors,UsePipes,applyDecorators,createDecorator}from"./decorator.mjs";export{BadGatewayError,BadRequestError,ConflictError,ForbiddenError,GatewayTimeoutError,GoneError,HttpError,InternalServerError,MethodNotAllowedError,NotAcceptableError,NotFoundError,NotImplementedError,PayloadTooLargeError,RequestTimeoutError,ServiceUnavailableError,TooManyRequestsError,UnauthorizedError,UnprocessableEntityError,UnsupportedMediaTypeError,ValidateError}from"./error.mjs";export{ExecuteContext,Reflect}from"./execute.mjs";export{Feature}from"./feature.mjs";export{ApplicationHooks,FeatureHooks,RequestHooks}from"./hooks.mjs";export{Logger,logger}from"./logger.mjs";export{ServerResponse}from"./response.mjs";export{Route}from"./route.mjs";export{Router}from"./router.mjs";export{Service,service}from"./service.mjs";