honestjs 0.1.0

package/dist/index.js

@@ -0,0 +1 @@
+import"reflect-metadata";import{Hono as s}from"hono";class w{instances=new Map;resolve(Q){if(this.instances.has(Q))return this.instances.get(Q);let X=(Reflect.getMetadata("design:paramtypes",Q)||[]).map((Z)=>{return this.resolve(Z)}),Y=new Q(...X);return this.instances.set(Q,Y),Y}register(Q,W){this.instances.set(Q,W)}}import{HTTPException as i}from"hono/http-exception";function P(Q,W,X){let Y=new Date().toISOString(),Z=W.get("requestId"),$=W.req.path;if(Q instanceof i)return{response:{status:X?.status||Q.status,message:X?.title||Q.message,timestamp:Y,path:$,requestId:Z,code:X?.code,details:X?.additionalDetails,...X?.detail&&{detail:X.detail}},status:X?.status||Q.status};if(Q.statusCode||Q.status){let j=Q.statusCode||Q.status,z=X?.status||j;return{response:{status:z,message:X?.title||Q.message,timestamp:Y,path:$,requestId:Z,code:X?.code||Q.name,details:X?.additionalDetails,...X?.detail&&{detail:X.detail}},status:z}}let J=X?.status||500;return{response:{status:J,message:X?.title||Q.message,timestamp:Y,path:$,requestId:Z,code:X?.code||Q.name,details:X?.additionalDetails||{stack:Q.stack},...X?.detail&&{detail:X.detail}},status:J}}class B{static routes=new Map;static controllers=new Map;static controllerOptions=new Map;static services=new Set;static modules=new Map;static parameters=new Map;static contextIndices=new Map;static global=new Map([["middleware",new Set],["guard",new Set],["pipe",new Set],["filter",new Set]]);static controller=new Map([["middleware",new Map],["guard",new Map],["pipe",new Map],["filter",new Map]]);static handler=new Map([["middleware",new Map],["guard",new Map],["pipe",new Map],["filter",new Map]]);static getRoutes(Q){return this.routes.get(Q)||[]}static setRoutes(Q,W){this.routes.set(Q,W)}static addRoute(Q,W){if(!this.routes.has(Q))this.routes.set(Q,[]);this.routes.get(Q).push(W)}static getControllerPath(Q){return this.controllers.get(Q)||""}static setControllerPath(Q,W){this.controllers.set(Q,W)}static getControllerOptions(Q){return this.controllerOptions.get(Q)||{}}static setControllerOptions(Q,W){this.controllerOptions.set(Q,W)}static isService(Q){return this.services.has(Q)}static addService(Q){this.services.add(Q)}static getAllServices(){return this.services}static getModuleOptions(Q){return this.modules.get(Q)}static setModuleOptions(Q,W){this.modules.set(Q,W)}static getParameters(Q){return this.parameters.get(Q)||new Map}static setParameterMap(Q,W){this.parameters.set(Q,W)}static getContextIndices(Q){return this.contextIndices.get(Q)||new Map}static setContextIndices(Q,W){this.contextIndices.set(Q,W)}static registerGlobal(Q,W){this.global.get(Q).add(W)}static getGlobal(Q){return this.global.get(Q)}static registerController(Q,W,X){let Y=this.controller.get(Q);if(!Y.has(W))Y.set(W,[]);Y.get(W).push(X)}static getController(Q,W){return this.controller.get(Q).get(W)||[]}static registerHandler(Q,W,X){let Y=this.handler.get(Q);if(!Y.has(W))Y.set(W,[]);Y.get(W).push(X)}static getHandler(Q,W){return this.handler.get(Q).get(W)||[]}}class N{static routes=[];static registerRoute(Q){this.routes.push(Q)}static getRoutes(){return this.routes}static getRoutesByController(Q){return this.routes.filter((W)=>W.controller===Q)}static getRoutesByMethod(Q){return this.routes.filter((W)=>W.method.toUpperCase()===Q.toUpperCase())}static getRoutesByPath(Q){return this.routes.filter((W)=>Q.test(W.fullPath))}static clear(){this.routes.length=0}}function E(Q){return(W="",X={})=>{return(Y,Z,$)=>{let J=Y.constructor;B.addRoute(J,{path:W,method:Q,handlerName:Z,parameterMetadata:[],version:X.version})}}}function _(Q,W){return(X)=>{return(Y,Z,$)=>{let J=Y.constructor;if(!B.getParameters(J).size)B.setParameterMap(J,new Map);let U=B.getParameters(J);if(!U.has(Z))U.set(Z,[]);let z=Reflect.getMetadata("design:paramtypes",Y,Z)?.[$];if(U.get(Z).push({index:$,name:Q,data:X,factory:W,metatype:z}),Q==="context"){if(!B.getContextIndices(J).size)B.setContextIndices(J,new Map);B.getContextIndices(J).set(Z,$)}}}}class f{static handle(){return async(Q,W)=>{return W.json(P(Q,W))}}}class M{static handle(){return async(Q)=>{return Q.json({message:`Not Found - ${Q.req.path}`},404)}}}var S=(Q)=>Q!==null&&typeof Q==="object";class q{static container;static init(Q){this.container=Q}static setupGlobalComponents(Q){let W=Q.components||{};if(W.middleware)this.registerGlobal("middleware",...W.middleware);if(W.guards)this.registerGlobal("guard",...W.guards);if(W.pipes)this.registerGlobal("pipe",...W.pipes);if(W.filters)this.registerGlobal("filter",...W.filters)}static registerGlobal(Q,...W){W.forEach((X)=>{B.registerGlobal(Q,X)})}static registerController(Q,W,...X){X.forEach((Y)=>{B.registerController(Q,W,Y)})}static registerHandler(Q,W,X,...Y){let Z=`${W.name}:${String(X)}`;Y.forEach(($)=>{B.registerHandler(Q,Z,$)})}static getComponents(Q,W,X){let Y=`${W.name}:${String(X)}`,Z=B.getHandler(Q,Y),$=B.getController(Q,W);return[...Array.from(B.getGlobal(Q)),...$,...Z]}static resolveMiddleware(Q){return Q.map((W)=>{if(S(W)&&"use"in W)return W.use.bind(W);let X=this.container.resolve(W);return X.use.bind(X)})}static getHandlerMiddleware(Q,W){let X=this.getComponents("middleware",Q,W);return this.resolveMiddleware(X)}static getGlobalMiddleware(){let Q=Array.from(B.getGlobal("middleware"));return this.resolveMiddleware(Q)}static resolveGuards(Q){return Q.map((W)=>{if(S(W)&&"canActivate"in W)return W;return this.container.resolve(W)})}static getHandlerGuards(Q,W){let X=this.getComponents("guard",Q,W);return this.resolveGuards(X)}static resolvePipes(Q){return Q.map((W)=>{if(S(W)&&"transform"in W)return W;return this.container.resolve(W)})}static getHandlerPipes(Q,W){let X=this.getComponents("pipe",Q,W);return this.resolvePipes(X)}static async executePipes(Q,W,X){let Y=Q;for(let Z of X)Y=await Z.transform(Y,W);return Y}static async handleException(Q,W){let X=W.get("controllerClass"),Y=W.get("handlerName");if(X&&Y){let $=B.getHandler("filter",`${X.name}:${Y}`);if($.length>0){let J=await this.executeFilters($,Q,W);if(J)return J}}if(X){let $=B.getController("filter",X);if($.length>0){let J=await this.executeFilters($,Q,W);if(J)return J}}let Z=Array.from(B.getGlobal("filter"));if(Z.length>0){let $=await this.executeFilters(Z,Q,W);if($)return $}return console.log("No filter handled the exception, creating default response"),W.json(P(Q,W))}static async executeFilters(Q,W,X){for(let Y of Q){let Z;if(S(Y)&&"catch"in Y)Z=Y;else Z=this.container.resolve(Y);try{let $=await Z.catch(W,X);if($!==void 0)return $}catch($){console.error("Error in exception filter:",$)}}return}static async registerModule(Q,W){let X=B.getModuleOptions(Q);if(!X)throw new Error(`Module ${Q.name} is not properly decorated with @Module()`);let Y=[];if(X.imports&&X.imports.length>0)for(let Z of X.imports){let $=await this.registerModule(Z,W);Y.push(...$)}if(X.services&&X.services.length>0)for(let Z of X.services)W.resolve(Z);if(X.controllers&&X.controllers.length>0)Y.push(...X.controllers);return Y}}import{HTTPException as p}from"hono/http-exception";var x=Symbol("VERSION_NEUTRAL");var bQ=(Q)=>typeof Q==="undefined",O=(Q)=>Q===null||typeof Q==="undefined",I=(Q)=>Q!==null&&typeof Q==="object",NQ=(Q)=>{if(!I(Q))return!1;let W=Object.getPrototypeOf(Q);if(W===null)return!0;let X=Object.prototype.hasOwnProperty.call(W,"constructor")&&W.constructor;return typeof X==="function"&&X instanceof X&&Function.prototype.toString.call(X)===Function.prototype.toString.call(Object)},h=(Q)=>typeof Q==="function",C=(Q)=>typeof Q==="string",KQ=(Q)=>typeof Q==="number",RQ=(Q)=>Q.length===0,TQ=(Q)=>typeof Q==="symbol",PQ=(Q)=>typeof Q==="string"?Q.charAt(0)!=="/"?"/"+Q:Q:"",v=(Q)=>Q?Q.startsWith("/")?("/"+Q.replace(/\/+$/,"")).replace(/\/+/g,"/"):"/"+Q.replace(/\/+$/,""):"/",SQ=(Q)=>Q.endsWith("/")?Q.slice(0,-1):Q,m=(Q)=>{return h(Q)&&!O(Q.prototype)&&!h(Q.prototype)&&Object.getOwnPropertyNames(Q.prototype).length>1};class y{hono;container;globalPrefix;globalVersion;constructor(Q,W,X={}){this.hono=Q,this.container=W,this.globalPrefix=X.prefix!==void 0?this.normalizePath(X.prefix):void 0,this.globalVersion=X.version,this.applyGlobalMiddleware()}applyGlobalMiddleware(){let Q=q.getGlobalMiddleware();for(let W of Q)this.hono.use("*",W)}normalizePath(Q){if(C(Q))return v(Q);return Q?`/${Q}`:""}registerRouteHandler(Q,W,X,Y){if(X.length>0)this.hono.on(Q.toUpperCase(),W,...X,Y);else this.hono.on(Q.toUpperCase(),W,Y)}buildRoutePath(Q,W,X,Y){return v(`${Q}${W}${X}${Y}`)}formatVersionSegment(Q){if(O(Q))return"";return Q===x?"":`/v${String(Q)}`}async registerController(Q){let W=B.getControllerPath(Q)||"",X=B.getControllerOptions(Q)||{},Y=B.getRoutes(Q)||[],Z=B.getParameters(Q)||new Map,$=B.getContextIndices(Q)||new Map,J=this.container.resolve(Q),U=!O(X.prefix)?X.prefix:this.globalPrefix,j=!O(U)?this.normalizePath(U):"",z=this.normalizePath(W),L=X.version!==void 0?X.version:this.globalVersion;for(let G of Y){let{path:K,method:F,handlerName:u,version:R}=G,A=R!==void 0?R:L,D=this.normalizePath(K);if(O(A)){this.registerRoute(J,G,Z,$,Q,j,"",z,D,F);continue}if(A===x){this.registerRoute(J,G,Z,$,Q,j,"",z,D,F),this.registerRoute(J,G,Z,$,Q,j,"/:version{v[0-9]+}",z,D,F);continue}if(Array.isArray(A)){for(let H of A){let T=this.formatVersionSegment(H);this.registerRoute(J,G,Z,$,Q,j,T,z,D,F)}continue}let k=this.formatVersionSegment(A);this.registerRoute(J,G,Z,$,Q,j,k,z,D,F)}}registerRoute(Q,W,X,Y,Z,$,J,U,j,z){let{handlerName:L}=W,G=this.buildRoutePath($,J,U,j),K=Q[L].bind(Q),F=X.get(L)||[],u=Y.get(L),R=q.getHandlerMiddleware(Z,L),A=q.getHandlerPipes(Z,L);N.registerRoute({controller:Z.name,handler:L,method:z,prefix:$,version:J,route:U,path:j,fullPath:G,parameters:F});let D=async(k)=>{try{k.set("controllerClass",Z),k.set("handlerName",String(L));let H=q.getHandlerGuards(Z,L);for(let V of H)if(!await V.canActivate(k))throw new p(403,{message:"Forbidden"});let T=new Array(K.length);for(let V of F){let g=V.factory(V.data,k),c=await q.executePipes(g,{type:V.type,metatype:V.metatype,data:V.data},A);T[V.index]=c}let b=await K(...T);if(u!==void 0)return b;if(O(b))return k.json(null);if(C(b))return k.text(b);return k.json(b)}catch(H){return q.handleException(H,k)}};this.registerRouteHandler(z,G,R,D)}}class d{hono;container;routeManager;options;constructor(Q={}){this.options=I(Q)?Q:{},this.hono=new s(this.options.hono),this.container=this.options.container||new w,this.routeManager=new y(this.hono,this.container,{prefix:this.options.routing?.prefix,version:this.options.routing?.version}),this.setupComponents(),this.setupErrorHandlers()}setupComponents(){q.init(this.container),q.setupGlobalComponents(this.options)}setupErrorHandlers(){this.hono.notFound(this.options.notFound||M.handle()),this.hono.onError(this.options.onError||f.handle())}resolvePlugin(Q){if(m(Q))return new Q;return Q}async register(Q){let W=await q.registerModule(Q,this.container);for(let X of W)await this.routeManager.registerController(X);return this}static async create(Q,W={}){let X=new d(W),Y=(W.plugins||[]).map((Z)=>X.resolvePlugin(Z));for(let Z of Y)if(Z.beforeModulesRegistered)await Z.beforeModulesRegistered(X,X.hono);await X.register(Q);for(let Z of Y)if(Z.afterModulesRegistered)await Z.afterModulesRegistered(X,X.hono);return{app:X,hono:X.getApp()}}getApp(){return this.hono}getRoutes(){return N.getRoutes()}}function rQ(Q="",W={}){return(X)=>{B.setControllerPath(X,Q),B.setControllerOptions(X,W)}}var eQ=E("get"),QW=E("post"),WW=E("put"),XW=E("delete"),YW=E("patch"),ZW=E("options"),$W=E("all");function qW(Q={}){return(W)=>{B.setModuleOptions(W,Q)}}var jW=_("body",async(Q,W)=>{let X=await W.req.json();return Q?X[Q]:X}),LW=_("param",(Q,W)=>{return Q?W.req.param(Q):W.req.param()}),UW=_("query",(Q,W)=>{return Q?W.req.query(Q):W.req.query()}),GW=_("header",(Q,W)=>{return Q?W.req.header(Q):W.req.header()}),kW=_("request",(Q,W)=>W.req),FW=_("request",(Q,W)=>W.req),VW=_("response",(Q,W)=>W.res),EW=_("response",(Q,W)=>W.res),AW=_("context",(Q,W)=>W),DW=_("context",(Q,W)=>W),OW=_("variable",(Q,W)=>W.get(Q)),HW=_("variable",(Q,W)=>W.get(Q));function KW(){return(Q)=>{B.addService(Q)}}function PW(Q,...W){return(X,Y)=>{if(Y){let Z=X.constructor;q.registerHandler(Q,Z,Y,...W)}else q.registerController(Q,X,...W)}}function fW(...Q){return(W,X)=>{if(X){let Y=W.constructor;q.registerHandler("filter",Y,X,...Q)}else q.registerController("filter",W,...Q)}}function IW(...Q){return(W,X)=>{if(X){let Y=W.constructor;q.registerHandler("guard",Y,X,...Q)}else q.registerController("guard",W,...Q)}}function yW(...Q){return(W,X)=>{if(X){let Y=W.constructor;q.registerHandler("middleware",Y,X,...Q)}else q.registerController("middleware",W,...Q)}}function hW(...Q){return(W,X)=>{if(X){let Y=W.constructor;q.registerHandler("pipe",Y,X,...Q)}else q.registerController("pipe",W,...Q)}}export{SQ as stripEndSlash,v as normalizePath,bQ as isUndefined,TQ as isSymbol,C as isString,NQ as isPlainObject,I as isObject,KQ as isNumber,O as isNil,h as isFunction,RQ as isEmpty,m as isConstructor,_ as createParamDecorator,E as createHttpMethodDecorator,P as createErrorResponse,PQ as addLeadingSlash,HW as Variable,OW as Var,x as VERSION_NEUTRAL,hW as UsePipes,yW as UseMiddleware,IW as UseGuards,fW as UseFilters,PW as UseComponent,KW as Service,N as RouteRegistry,y as RouteManager,EW as Response,VW as Res,FW as Request,kW as Req,UW as Query,WW as Put,QW as Post,YW as Patch,LW as Param,ZW as Options,M as NotFoundHandler,qW as Module,B as MetadataRegistry,GW as Header,eQ as Get,f as ErrorHandler,XW as Delete,AW as Ctx,rQ as Controller,DW as Context,w as Container,q as ComponentManager,jW as Body,d as Application,$W as All};

package/dist/interfaces/controller-options.interface.d.ts

@@ -0,0 +1,17 @@
+import type { VERSION_NEUTRAL } from '../constants';
+/**
+ * Interface for controller configuration options
+ */
+export interface ControllerOptions {
+    /**
+     * API prefix for this controller's routes, overrides global prefix
+     */
+    prefix?: string | null;
+    /**
+     * API version for this controller's routes (e.g. 1 becomes /v1), overrides global version
+     * Set to null to explicitly opt out of versioning even when global version is set
+     * Set to VERSION_NEUTRAL to make routes accessible both with and without version prefix
+     * Set to an array of numbers to make routes available at multiple versions
+     */
+    version?: number | null | typeof VERSION_NEUTRAL | number[];
+}

package/dist/interfaces/di-container.interface.d.ts

@@ -0,0 +1,24 @@
+import type { Constructor } from '../types';
+/**
+ * Interface for dependency injection containers
+ * Defines the contract that DI containers must implement to work with the Honest framework
+ * Handles the creation and management of dependency instances
+ */
+export interface DiContainer {
+    /**
+     * Resolves a dependency from the container
+     * Creates a new instance or returns an existing one based on the container's configuration
+     * @param target - The class constructor to resolve
+     * @returns An instance of the requested class with all dependencies injected
+     * @throws {Error} If the dependency cannot be resolved
+     */
+    resolve<T>(target: Constructor<T>): T;
+    /**
+     * Registers a pre-created instance in the container
+     * Used for singleton instances or mocks in testing
+     * @param target - The class constructor to register the instance for
+     * @param instance - The pre-created instance to use
+     * @throws {Error} If registration fails
+     */
+    register<T>(target: Constructor<T>, instance: T): void;
+}

package/dist/interfaces/error-response.interface.d.ts

@@ -0,0 +1,13 @@
+export interface ErrorResponse {
+    status: number;
+    message: string;
+    timestamp: string;
+    path: string;
+    requestId?: string;
+    code?: string;
+    details?: Record<string, any>;
+    errors?: Array<{
+        property: string;
+        constraints: Record<string, string>;
+    }>;
+}

package/dist/interfaces/filter.interface.d.ts

@@ -0,0 +1,20 @@
+import type { Context } from 'hono';
+import type { Constructor } from '../types';
+/**
+ * Interface for exception filters
+ * Filters handle and transform exceptions thrown during request processing
+ */
+export interface IFilter {
+    /**
+     * Method to catch and handle exceptions
+     * @param exception - The exception that was thrown
+     * @param context - The Hono context object
+     * @returns A Response object or undefined if the exception should be passed to the next filter
+     */
+    catch(exception: Error, context: Context): Promise<Response | undefined> | Response | undefined;
+}
+/**
+ * Type for exception filters
+ * Can be either a class implementing IFilter or an instance of IFilter
+ */
+export type FilterType = Constructor<IFilter> | IFilter;

package/dist/interfaces/guard.interface.d.ts

@@ -0,0 +1,21 @@
+import type { Constructor } from '../types';
+import type { Context } from 'hono';
+/**
+ * Interface defining a guard.
+ * Guards determine whether a request should be handled by the route handler or not.
+ */
+export interface IGuard {
+    /**
+     * Method to implement the guard logic.
+     * Return true to allow the request to proceed, false to deny.
+     *
+     * @param context - The Hono context object
+     * @returns A boolean or Promise<boolean> indicating if the request is allowed
+     */
+    canActivate(context: Context): boolean | Promise<boolean>;
+}
+/**
+ * Type for guard classes
+ * Can be either a constructor of IGuard or an instance of IGuard
+ */
+export type GuardType = Constructor<IGuard> | IGuard;

package/dist/interfaces/honest-options.interface.d.ts

@@ -0,0 +1,78 @@
+import type { Context } from 'hono';
+import type { VERSION_NEUTRAL } from '../constants';
+import type { FilterType, GuardType, MiddlewareType, PipeType, PluginType } from '../interfaces';
+import type { DiContainer } from './di-container.interface';
+/**
+ * Options for configuring the Honest application
+ */
+export interface HonestOptions {
+    /**
+     * Container instance for dependency injection
+     */
+    container?: DiContainer;
+    /**
+     * Hono-specific options
+     */
+    hono?: {
+        /**
+         * Whether to use strict matching for routes
+         */
+        strict?: boolean;
+        /**
+         * Custom router to use
+         */
+        router?: any;
+        /**
+         * Function to extract path from request
+         */
+        getPath?: (request: Request, options?: any) => string;
+    };
+    /**
+     * Global routing options
+     */
+    routing?: {
+        /**
+         * Global API prefix to apply to all routes (e.g. /api)
+         */
+        prefix?: string;
+        /**
+         * Global API version to apply to all routes (e.g. 1 becomes /v1)
+         * Set to VERSION_NEUTRAL to make routes accessible both with and without version prefix
+         * Set to an array of numbers to make routes available at multiple versions
+         */
+        version?: number | typeof VERSION_NEUTRAL | number[];
+    };
+    /**
+     * Global components to apply to all routes
+     */
+    components?: {
+        /**
+         * Global middleware to apply to all routes
+         */
+        middleware?: MiddlewareType[];
+        /**
+         * Global guards to apply to all routes
+         */
+        guards?: GuardType[];
+        /**
+         * Global pipes to apply to all routes
+         */
+        pipes?: PipeType[];
+        /**
+         * Global exception filters to apply to all routes
+         */
+        filters?: FilterType[];
+    };
+    /**
+     * Plugins for extending the application functionality
+     */
+    plugins?: PluginType[];
+    /**
+     * Default exception handler to use when no filter matches
+     */
+    onError?: (error: Error, context: Context) => Response | Promise<Response>;
+    /**
+     * Default not found handler for routes that don't match any pattern
+     */
+    notFound?: (context: Context) => Response | Promise<Response>;
+}

package/dist/interfaces/http-method-options.interface.d.ts

@@ -0,0 +1,13 @@
+import type { VERSION_NEUTRAL } from '../constants';
+/**
+ * Options for HTTP method decorators
+ */
+export interface HttpMethodOptions {
+    /**
+     * API version for this specific route, overrides controller and global version
+     * Set to null to explicitly opt out of versioning
+     * Set to VERSION_NEUTRAL to make the route accessible both with and without version prefix
+     * Set to an array of numbers to make the route available at multiple versions
+     */
+    version?: number | null | typeof VERSION_NEUTRAL | number[];
+}

package/dist/interfaces/index.d.ts

@@ -0,0 +1,14 @@
+export * from './controller-options.interface';
+export * from './di-container.interface';
+export * from './error-response.interface';
+export * from './filter.interface';
+export * from './guard.interface';
+export * from './honest-options.interface';
+export * from './http-method-options.interface';
+export * from './middleware.interface';
+export * from './module-options.interface';
+export * from './parameter-metadata.interface';
+export * from './pipe.interface';
+export * from './plugin.interface';
+export * from './route-definition.interface';
+export * from './route-info.interface';

package/dist/interfaces/middleware.interface.d.ts

@@ -0,0 +1,22 @@
+import type { Context, Next } from 'hono';
+import type { Constructor } from '../types';
+/**
+ * Interface for HTTP middleware components
+ * Middleware can process requests before they reach the route handler
+ * and modify both the request and response
+ */
+export interface IMiddleware {
+    /**
+     * Processes an HTTP request/response
+     * @param c - The Hono context containing request and response information
+     * @param next - Function to call the next middleware in the chain
+     * @returns A Promise that resolves to a Response or void
+     * @throws {Error} If middleware processing fails
+     */
+    use(c: Context, next: Next): Promise<Response | void>;
+}
+/**
+ * Type for middleware implementations
+ * Can be either a class implementing IMiddleware or an instance of IMiddleware
+ */
+export type MiddlewareType = Constructor<IMiddleware> | IMiddleware;

package/dist/interfaces/module-options.interface.d.ts

@@ -0,0 +1,18 @@
+import type { Constructor } from '../types';
+/**
+ * Options for configuring a module
+ */
+export interface ModuleOptions {
+    /**
+     * List of controller classes
+     */
+    controllers?: Constructor[];
+    /**
+     * List of service classes
+     */
+    services?: Constructor[];
+    /**
+     * List of imported modules
+     */
+    imports?: Constructor[];
+}

package/dist/interfaces/parameter-metadata.interface.d.ts

@@ -0,0 +1,27 @@
+import type { Constructor } from '../types';
+import type { Context } from 'hono';
+/**
+ * Metadata for route parameters
+ */
+export interface ParameterMetadata {
+    /**
+     * Parameter index
+     */
+    index: number;
+    /**
+     * Parameter name (body, param, query, etc.)
+     */
+    name: string;
+    /**
+     * Additional parameter data (e.g., param name)
+     */
+    data?: any;
+    /**
+     * Optional factory function to transform the data
+     */
+    factory: (data: any, ctx: Context) => any;
+    /**
+     * The class type of the parameter
+     */
+    metatype?: Constructor<unknown>;
+}

package/dist/interfaces/pipe.interface.d.ts

@@ -0,0 +1,37 @@
+import type { Constructor } from '../types';
+/**
+ * Metadata about an argument being processed by a pipe
+ */
+export interface ArgumentMetadata {
+    /**
+     * The type of argument (body, query, param, or custom)
+     */
+    type: 'body' | 'query' | 'param' | 'custom';
+    /**
+     * The class type of the argument
+     */
+    metatype?: Constructor<unknown>;
+    /**
+     * Additional data about the argument
+     */
+    data?: string;
+}
+/**
+ * Interface for transformation pipes
+ * Pipes transform input data before it reaches the route handler
+ */
+export interface IPipe {
+    /**
+     * Transforms the input value according to the pipe's logic
+     * @param value - The value to transform
+     * @param metadata - Metadata about the argument being transformed
+     * @returns The transformed value, which can be synchronous or asynchronous
+     * @throws {Error} If the transformation fails or validation fails
+     */
+    transform(value: unknown, metadata: ArgumentMetadata): Promise<unknown> | unknown;
+}
+/**
+ * Type for pipe implementations
+ * Can be either a class implementing IPipe or an instance of IPipe
+ */
+export type PipeType = Constructor<IPipe> | IPipe;

package/dist/interfaces/plugin.interface.d.ts

@@ -0,0 +1,31 @@
+import type { Hono } from 'hono';
+import type { Application } from '../application';
+import type { Constructor } from '../types';
+/**
+ * Interface for Honest framework plugins
+ * Plugins can extend the framework's functionality by hooking into
+ * different stages of the application lifecycle
+ */
+export interface IPlugin {
+    /**
+     * Hook that runs before module registration begins
+     * Use this to set up plugin functionality that modules might depend on
+     * @param app - The Honest application instance
+     * @param hono - The underlying Hono application instance
+     * @returns Void or a Promise that resolves to void
+     */
+    beforeModulesRegistered?: (app: Application, hono: Hono) => void | Promise<void>;
+    /**
+     * Hook that runs after all modules have been registered
+     * Use this to perform cleanup or setup that requires all modules to be ready
+     * @param app - The Honest application instance
+     * @param hono - The underlying Hono application instance
+     * @returns Void or a Promise that resolves to void
+     */
+    afterModulesRegistered?: (app: Application, hono: Hono) => void | Promise<void>;
+}
+/**
+ * Type for plugin implementations
+ * Can be either a class implementing IPlugin or an instance of IPlugin
+ */
+export type PluginType = Constructor<IPlugin> | IPlugin;

package/dist/interfaces/route-definition.interface.d.ts

@@ -0,0 +1,30 @@
+import type { VERSION_NEUTRAL } from '../constants';
+import type { ParameterMetadata } from '../interfaces';
+/**
+ * Metadata for defining a route
+ */
+export interface RouteDefinition {
+    /**
+     * Route path
+     */
+    path: string;
+    /**
+     * HTTP method
+     */
+    method: string;
+    /**
+     * Handler method name
+     */
+    handlerName: string | symbol;
+    /**
+     * Parameter metadata for the handler
+     */
+    parameterMetadata: ParameterMetadata[];
+    /**
+     * Route-specific API version, overrides controller and global version
+     * Set to null to explicitly opt out of versioning
+     * Set to VERSION_NEUTRAL to make the route accessible both with and without version prefix
+     * Set to an array of numbers to make the route available at multiple versions
+     */
+    version?: number | null | typeof VERSION_NEUTRAL | number[];
+}

package/dist/interfaces/route-info.interface.d.ts

@@ -0,0 +1,42 @@
+import type { ParameterMetadata } from './parameter-metadata.interface';
+/**
+ * Route information for registered routes
+ */
+export interface RouteInfo {
+    /**
+     * Controller name
+     */
+    controller: string | symbol;
+    /**
+     * Handler method name
+     */
+    handler: string | symbol;
+    /**
+     * HTTP method
+     */
+    method: string;
+    /**
+     * Effective prefix
+     */
+    prefix: string;
+    /**
+     * Effective version
+     */
+    version?: string;
+    /**
+     * Controller route path
+     */
+    route: string;
+    /**
+     * Method path
+     */
+    path: string;
+    /**
+     * Complete path (prefix + version + route + path)
+     */
+    fullPath: string;
+    /**
+     * Parameter metadata for the handler
+     */
+    parameters: ParameterMetadata[];
+}

package/dist/managers/component.manager.d.ts

@@ -0,0 +1,143 @@
+import type { Context, Next } from 'hono';
+import type { ArgumentMetadata, DiContainer, GuardType, IGuard, IPipe, MiddlewareType, PipeType } from '../interfaces';
+import { type ComponentType, type ComponentTypeMap } from '../registries';
+import type { Constructor } from '../types';
+/**
+ * Manager class for handling all component types in the Honest framework
+ * Provides unified management of middleware, guards, pipes, and filters
+ * Handles component registration, resolution, and execution at global, controller, and handler levels
+ * Works with the dependency injection container to resolve component instances
+ */
+export declare class ComponentManager {
+    private static container;
+    /**
+     * Initializes the ComponentManager with a dependency injection container
+     * Must be called before using any other ComponentManager methods
+     * @param container - The dependency injection container to use for resolving components
+     */
+    static init(container: DiContainer): void;
+    /**
+     * Configures global components from application options
+     * Global components are applied to all routes in the application
+     * @param options - Application options containing component configurations
+     * @param options.components - Optional component configuration object
+     * @param options.components.middleware - Optional array of global middleware
+     * @param options.components.guards - Optional array of global guards
+     * @param options.components.pipes - Optional array of global pipes
+     * @param options.components.filters - Optional array of global filters
+     */
+    static setupGlobalComponents(options: {
+        components?: {
+            middleware?: any[];
+            guards?: any[];
+            pipes?: any[];
+            filters?: any[];
+        };
+    }): void;
+    /**
+     * Registers a component at the global level
+     * @param type - The type of component to register
+     * @param components - The component classes or instances to register
+     */
+    static registerGlobal<T extends ComponentType>(type: T, ...components: ComponentTypeMap[T][]): void;
+    /**
+     * Registers a component at the controller level
+     * @param type - The type of component to register
+     * @param controller - The controller class to register the component for
+     * @param components - The component classes or instances to register
+     */
+    static registerController<T extends ComponentType>(type: T, controller: Constructor, ...components: ComponentTypeMap[T][]): void;
+    /**
+     * Registers a component at the handler level
+     * @param type - The type of component to register
+     * @param controller - The controller class
+     * @param handlerName - The handler method name
+     * @param components - The component classes or instances to register
+     */
+    static registerHandler<T extends ComponentType>(type: T, controller: Constructor, handlerName: string | symbol, ...components: ComponentTypeMap[T][]): void;
+    /**
+     * Gets all components of a specific type for a handler
+     * @param type - The type of component to get
+     * @param controller - The controller class
+     * @param handlerName - The handler method name
+     * ..returns An array of component instances
+     */
+    static getComponents<T extends ComponentType>(type: T, controller: Constructor, handlerName: string | symbol): ComponentTypeMap[T][];
+    /**
+     * Resolves middleware classes or instances to middleware functions
+     * @param middlewareItems - The middleware classes or instances to resolve
+     * ..returns An array of middleware functions
+     */
+    static resolveMiddleware(middlewareItems: MiddlewareType[]): ((c: Context, next: Next) => Promise<Response | void>)[];
+    /**
+     * Gets middleware for a specific handler
+     * @param controller - The controller class
+     * @param handlerName - The handler method name
+     * ..returns An array of middleware functions
+     */
+    static getHandlerMiddleware(controller: Constructor, handlerName: string | symbol): ((c: Context, next: Next) => Promise<Response | void>)[];
+    /**
+     * Gets global middleware
+     * ..returns An array of middleware functions
+     */
+    static getGlobalMiddleware(): ((c: Context, next: Next) => Promise<Response | void>)[];
+    /**
+     * Resolves guard classes or instances to guard instances
+     * @param guardItems - The guard classes or instances to resolve
+     * ..returns An array of guard instances
+     */
+    static resolveGuards(guardItems: GuardType[]): IGuard[];
+    /**
+     * Gets guards for a specific handler
+     * @param controller - The controller class
+     * @param handlerName - The handler method name
+     * ..returns An array of guard instances
+     */
+    static getHandlerGuards(controller: Constructor, handlerName: string | symbol): IGuard[];
+    /**
+     * Resolves pipe classes or instances to pipe instances
+     * @param pipeItems - The pipe classes or instances to resolve
+     * ..returns An array of pipe instances
+     */
+    static resolvePipes(pipeItems: PipeType[]): IPipe[];
+    /**
+     * Gets pipes for a specific handler
+     * @param controller - The controller class
+     * @param handlerName - The handler method name
+     * ..returns An array of pipe instances
+     */
+    static getHandlerPipes(controller: Constructor, handlerName: string | symbol): IPipe[];
+    /**
+     * Executes a series of pipes on a value
+     * Pipes are executed in sequence, with each pipe's output feeding into the next pipe
+     * @param value - The initial value to transform
+     * @param metadata - Metadata about the parameter being transformed
+     * @param pipes - Array of pipes to execute
+     * @returns The final transformed value after all pipes have executed
+     * @throws {Error} If any pipe transformation fails
+     */
+    static executePipes(value: any, metadata: ArgumentMetadata, pipes: IPipe[]): Promise<any>;
+    /**
+     * Handles an exception by passing it through registered exception filters
+     * Filters are executed in sequence until one returns a response
+     * @param exception - The error to handle
+     * @param context - The Hono context object
+     * @returns A Response object if a filter handles the exception, undefined otherwise
+     */
+    static handleException(exception: Error, context: Context): Promise<Response | undefined>;
+    /**
+     * Executes a list of exception filters
+     * @param filterItems - The exception filter classes or instances to execute
+     * @param exception - The exception that was thrown
+     * @param context - The Hono context object
+     * ..returns The response from the first filter that handles the exception or undefined if no filter handled it
+     */
+    private static executeFilters;
+    /**
+     * Registers a module and its dependencies with the container
+     * @param moduleClass - The module class to register
+     * @param container - The dependency injection container
+     * @returns An array of controller classes registered from this module
+     */
+    static registerModule(moduleClass: Constructor, container: DiContainer): Promise<Constructor[]>;
+}

package/dist/managers/index.d.ts

@@ -0,0 +1,2 @@
+export * from './component.manager';
+export * from './route.manager';