stratal 0.0.13 → 0.0.15

package/dist/middleware-iRhNjsPH.mjs

@@ -0,0 +1,362 @@
+import { i as Transient } from "./decorate-D5j-d9_z.mjs";
+import { o as ROUTE_METADATA_KEYS, t as RouterContext } from "./router-context-BLn4PrRG.mjs";
+//#region src/middleware/middleware-consumer.ts
+/**
+* Builder for configuring middleware routes and exclusions
+*
+* Provides fluent API for specifying where middleware should apply.
+*/
+var MiddlewareBuilderImpl = class {
+	middlewares;
+	excludedRoutes = [];
+	consumer;
+	constructor(middlewares, consumer) {
+		this.middlewares = middlewares;
+		this.consumer = consumer;
+	}
+	/**
+	* Exclude specific routes from middleware
+	*
+	* @param routes - Routes to exclude (path strings or RouteInfo objects)
+	* @returns this for method chaining
+	*
+	* @example
+	* ```typescript
+	* consumer
+	*   .apply(AuthMiddleware)
+	*   .exclude('/health', { path: '/api/public', method: 'get' })
+	*   .forRoutes('*')
+	* ```
+	*/
+	exclude(...routes) {
+		for (const route of routes) if (typeof route === "string") this.excludedRoutes.push({ path: route });
+		else this.excludedRoutes.push(route);
+		return this;
+	}
+	/**
+	* Apply middleware to specified routes
+	*
+	* This method finalizes the configuration and registers it with the consumer.
+	*
+	* @param targets - Controller classes, RouteInfo objects, or '*' for global
+	*
+	* @example
+	* ```typescript
+	* // Apply to all routes
+	* consumer.apply(LoggingMiddleware).forRoutes('*')
+	*
+	* // Apply to specific controllers
+	* consumer.apply(CorsMiddleware).forRoutes(ApiController, WebhooksController)
+	*
+	* // Apply to specific paths
+	* consumer.apply(RateLimitMiddleware).forRoutes(
+	*   { path: '/api/v1/auth', method: 'post' }
+	* )
+	* ```
+	*/
+	forRoutes(...targets) {
+		const entry = {
+			middlewares: this.middlewares,
+			excludes: this.excludedRoutes,
+			routes: targets
+		};
+		this.consumer.addEntry(entry);
+	}
+};
+/**
+* Consumer for configuring middleware in modules
+*
+* Provides fluent API for registering middleware with route targeting.
+* Used by modules implementing MiddlewareConfigurable interface.
+*
+* @example
+* ```typescript
+* @Module({ providers: [...] })
+* export class AppModule implements MiddlewareConfigurable {
+*   configure(consumer: MiddlewareConsumer): void {
+*     // Global logging middleware (excludes health check)
+*     consumer
+*       .apply(LoggingMiddleware)
+*       .exclude('/health')
+*       .forRoutes('*')
+*
+*     // CORS middleware for specific controllers
+*     consumer
+*       .apply(CorsMiddleware)
+*       .forRoutes(ApiController, WebhooksController)
+*
+*     // Rate limiting for auth endpoints
+*     consumer
+*       .apply(RateLimitMiddleware)
+*       .forRoutes({ path: '/api/v1/auth/*', method: 'post' })
+*   }
+* }
+* ```
+*/
+var MiddlewareConsumerImpl = class {
+	entries = [];
+	/**
+	* Start configuring middleware
+	*
+	* @param middlewares - Middleware classes to apply
+	* @returns Builder for configuring routes and exclusions
+	*/
+	apply(...middlewares) {
+		return new MiddlewareBuilderImpl(middlewares, this);
+	}
+	/**
+	* Add a configuration entry (called by builder)
+	* @internal
+	*/
+	addEntry(entry) {
+		this.entries.push(entry);
+	}
+	/**
+	* Get all configured middleware entries
+	*/
+	getEntries() {
+		return this.entries;
+	}
+};
+/**
+* Create a new middleware consumer instance
+*/
+function createMiddlewareConsumer() {
+	return new MiddlewareConsumerImpl();
+}
+//#endregion
+//#region src/router/decorators/controller.decorator.ts
+const CONTROLLER_ROUTE_KEY = ROUTE_METADATA_KEYS.CONTROLLER_ROUTE;
+/**
+* Base controller decorator for route registration
+*
+* This is the core controller decorator that handles:
+* - Transient scope registration (request-scoped)
+* - Route metadata storage
+* - Controller options (tags, security schemes, hideFromDocs)
+*
+* @param route - Base route for this controller (e.g., '/api/v1/users')
+* @param options - Optional configuration (tags, security schemes, hideFromDocs)
+*
+* @example
+* ```typescript
+* import { Controller } from 'stratal/router'
+*
+* @Controller('/api/v1/users', { tags: ['Users'] })
+* export class UsersController implements IController {
+*   // All routes accessible
+* }
+* ```
+*/
+function Controller(route, options) {
+	return function(target) {
+		Transient()(target);
+		Reflect.defineMetadata(CONTROLLER_ROUTE_KEY, route, target);
+		if (options) Reflect.defineMetadata(ROUTE_METADATA_KEYS.CONTROLLER_OPTIONS, options, target);
+		return target;
+	};
+}
+/**
+* Get the route from controller class metadata
+*
+* @param target - Controller class or instance
+* @returns Route string or undefined if not set
+*/
+function getControllerRoute(target) {
+	const metadataTarget = typeof target === "function" ? target : target.constructor;
+	return Reflect.getMetadata(CONTROLLER_ROUTE_KEY, metadataTarget);
+}
+/**
+* Get the options from controller class metadata
+*
+* @param target - Controller class or instance
+* @returns Controller options or undefined if not set
+*/
+function getControllerOptions(target) {
+	const metadataTarget = typeof target === "function" ? target : target.constructor;
+	return Reflect.getMetadata(ROUTE_METADATA_KEYS.CONTROLLER_OPTIONS, metadataTarget);
+}
+/**
+* Get the version from controller class metadata
+*
+* @param target - Controller class or instance
+* @returns Version string, array, VERSION_NEUTRAL symbol, or undefined if not set
+*/
+function getControllerVersion(target) {
+	return getControllerOptions(target)?.version;
+}
+//#endregion
+//#region src/middleware/middleware-configuration.service.ts
+/**
+* Service for applying middleware configurations to Hono app
+*
+* Processes MiddlewareConfigEntry[] from modules and registers
+* appropriate middleware handlers with route matching.
+*/
+var MiddlewareConfigurationService = class {
+	constructor(logger, versioningOptions = null) {
+		this.logger = logger;
+		this.versioningOptions = versioningOptions;
+	}
+	/**
+	* Apply middleware configurations to the Hono app
+	*
+	* @param app - Hono application instance
+	* @param configs - Middleware configuration entries from modules
+	* @param controllers - All registered controller classes (for route resolution)
+	* @param container - DI container for resolving middleware instances
+	*/
+	applyMiddlewares(app, configs, controllers, container) {
+		for (const config of configs) this.applyMiddlewareConfig(app, config, controllers, container);
+	}
+	/**
+	* Apply a single middleware configuration entry
+	*/
+	applyMiddlewareConfig(app, config, controllers, container) {
+		const { middlewares, excludes, routes } = config;
+		const routePatterns = this.resolveRoutePatterns(routes, controllers);
+		this.logger.debug("Applying middleware configuration", {
+			middlewares: middlewares.map((m) => m.name),
+			routes: routePatterns,
+			excludes
+		});
+		for (const pattern of routePatterns) this.registerMiddlewareForPattern(app, middlewares, pattern, excludes, container);
+	}
+	/**
+	* Resolve route targets into concrete route patterns
+	*/
+	resolveRoutePatterns(targets, _controllers) {
+		const patterns = [];
+		for (const target of targets) if (target === "*") patterns.push({ path: "*" });
+		else if (typeof target === "function") {
+			const route = getControllerRoute(target);
+			if (route) {
+				patterns.push({ path: `${route}/*` });
+				patterns.push({ path: route });
+			} else this.logger.warn("Controller has no route metadata", { controller: target.name });
+		} else if (!this.versioningOptions || !target.version) patterns.push(target);
+		else {
+			const resolved = this.resolveVersionedRouteInfo(target);
+			patterns.push(...resolved);
+		}
+		return patterns;
+	}
+	/**
+	* Resolve a RouteInfo with version into versioned path(s).
+	* If versioning is disabled or no version is specified, returns the RouteInfo as-is.
+	*/
+	resolveVersionedRouteInfo(routeInfo) {
+		if (!this.versioningOptions || !routeInfo.version) return [routeInfo];
+		const prefix = this.versioningOptions.prefix ?? "v";
+		const versions = Array.isArray(routeInfo.version) ? routeInfo.version : [routeInfo.version];
+		const results = [];
+		for (const v of versions) {
+			const versionedPath = `/${prefix}${v}${routeInfo.path}`;
+			results.push({
+				path: versionedPath,
+				method: routeInfo.method
+			});
+			results.push({
+				path: `${versionedPath}/*`,
+				method: routeInfo.method
+			});
+		}
+		return results;
+	}
+	/**
+	* Register middleware handlers for a specific route pattern
+	*/
+	registerMiddlewareForPattern(app, middlewares, pattern, excludes, container) {
+		const path = pattern.path;
+		const methods = pattern.method ? Array.isArray(pattern.method) ? pattern.method : [pattern.method] : void 0;
+		const handler = this.createMiddlewareHandler(middlewares, excludes, container);
+		if (methods && methods.length > 0) for (const method of methods) this.registerForMethod(app, method, path, handler);
+		else app.use(path, handler);
+	}
+	/**
+	* Register handler for a specific HTTP method
+	*/
+	registerForMethod(app, method, path, handler) {
+		switch (method) {
+			case "get":
+				app.get(path, handler);
+				break;
+			case "post":
+				app.post(path, handler);
+				break;
+			case "put":
+				app.put(path, handler);
+				break;
+			case "delete":
+				app.delete(path, handler);
+				break;
+			case "patch":
+				app.patch(path, handler);
+				break;
+			default: app.use(path, handler);
+		}
+	}
+	/**
+	* Create a middleware handler function that executes the middleware chain
+	*/
+	createMiddlewareHandler(middlewares, excludes, container) {
+		return async (c, next) => {
+			const requestPath = c.req.path;
+			const requestMethod = c.req.method.toLowerCase();
+			if (this.isExcluded(requestPath, requestMethod, excludes)) {
+				await next();
+				return;
+			}
+			const ctx = new RouterContext(c);
+			await this.executeMiddlewareChain(middlewares, ctx, container, next);
+		};
+	}
+	/**
+	* Check if a request matches any exclusion pattern
+	*/
+	isExcluded(requestPath, requestMethod, excludes) {
+		for (const exclude of excludes) if (this.matchesRoute(requestPath, requestMethod, exclude)) return true;
+		return false;
+	}
+	/**
+	* Check if request matches a route pattern
+	*/
+	matchesRoute(requestPath, requestMethod, route) {
+		if (route.method) {
+			if (!(Array.isArray(route.method) ? route.method : [route.method]).includes(requestMethod)) return false;
+		}
+		return this.matchesPath(requestPath, route.path);
+	}
+	/**
+	* Match request path against pattern
+	* Supports wildcards: /api/* matches /api/users, /api/v1/users
+	*/
+	matchesPath(requestPath, pattern) {
+		if (pattern === requestPath) return true;
+		if (pattern === "*") return true;
+		if (pattern.endsWith("/*")) {
+			const prefix = pattern.slice(0, -2);
+			return requestPath === prefix || requestPath.startsWith(prefix + "/");
+		}
+		const regexPattern = pattern.replace(/:[^/]+/g, "[^/]+").replace(/\*/g, ".*");
+		return new RegExp(`^${regexPattern}$`).test(requestPath);
+	}
+	/**
+	* Execute middleware chain in order
+	*/
+	async executeMiddlewareChain(middlewares, ctx, container, finalNext) {
+		let chain = finalNext;
+		for (let i = middlewares.length - 1; i >= 0; i--) {
+			const MiddlewareClass = middlewares[i];
+			const currentNext = chain;
+			chain = async () => {
+				await ctx.getContainer().resolve(MiddlewareClass).handle(ctx, currentNext);
+			};
+		}
+		await chain();
+	}
+};
+//#endregion
+export { getControllerVersion as a, getControllerRoute as i, Controller as n, MiddlewareConsumerImpl as o, getControllerOptions as r, createMiddlewareConsumer as s, MiddlewareConfigurationService as t };
+
+//# sourceMappingURL=middleware-iRhNjsPH.mjs.map

package/dist/middleware-iRhNjsPH.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"middleware-iRhNjsPH.mjs","names":[],"sources":["../src/middleware/middleware-consumer.ts","../src/router/decorators/controller.decorator.ts","../src/middleware/middleware-configuration.service.ts"],"sourcesContent":["import type { Middleware } from '../router/middleware.interface'\nimport type { Constructor } from '../types'\nimport type {\n  MiddlewareConfigEntry,\n  MiddlewareConsumer as IMiddlewareConsumer,\n  MiddlewareBuilder as IMiddlewareBuilder,\n  MiddlewareRouteTarget,\n  RouteInfo,\n} from './types'\n\n/**\n * Builder for configuring middleware routes and exclusions\n *\n * Provides fluent API for specifying where middleware should apply.\n */\nclass MiddlewareBuilderImpl implements IMiddlewareBuilder {\n  private middlewares: Constructor<Middleware>[]\n  private excludedRoutes: RouteInfo[] = []\n  private consumer: MiddlewareConsumerImpl\n\n  constructor(\n    middlewares: Constructor<Middleware>[],\n    consumer: MiddlewareConsumerImpl\n  ) {\n    this.middlewares = middlewares\n    this.consumer = consumer\n  }\n\n  /**\n   * Exclude specific routes from middleware\n   *\n   * @param routes - Routes to exclude (path strings or RouteInfo objects)\n   * @returns this for method chaining\n   *\n   * @example\n   * ```typescript\n   * consumer\n   *   .apply(AuthMiddleware)\n   *   .exclude('/health', { path: '/api/public', method: 'get' })\n   *   .forRoutes('*')\n   * ```\n   */\n  exclude(...routes: (string | RouteInfo)[]): this {\n    for (const route of routes) {\n      if (typeof route === 'string') {\n        this.excludedRoutes.push({ path: route })\n      } else {\n        this.excludedRoutes.push(route)\n      }\n    }\n    return this\n  }\n\n  /**\n   * Apply middleware to specified routes\n   *\n   * This method finalizes the configuration and registers it with the consumer.\n   *\n   * @param targets - Controller classes, RouteInfo objects, or '*' for global\n   *\n   * @example\n   * ```typescript\n   * // Apply to all routes\n   * consumer.apply(LoggingMiddleware).forRoutes('*')\n   *\n   * // Apply to specific controllers\n   * consumer.apply(CorsMiddleware).forRoutes(ApiController, WebhooksController)\n   *\n   * // Apply to specific paths\n   * consumer.apply(RateLimitMiddleware).forRoutes(\n   *   { path: '/api/v1/auth', method: 'post' }\n   * )\n   * ```\n   */\n  forRoutes(...targets: MiddlewareRouteTarget[]): void {\n    const entry: MiddlewareConfigEntry = {\n      middlewares: this.middlewares,\n      excludes: this.excludedRoutes,\n      routes: targets,\n    }\n    this.consumer.addEntry(entry)\n  }\n}\n\n/**\n * Consumer for configuring middleware in modules\n *\n * Provides fluent API for registering middleware with route targeting.\n * Used by modules implementing MiddlewareConfigurable interface.\n *\n * @example\n * ```typescript\n * @Module({ providers: [...] })\n * export class AppModule implements MiddlewareConfigurable {\n *   configure(consumer: MiddlewareConsumer): void {\n *     // Global logging middleware (excludes health check)\n *     consumer\n *       .apply(LoggingMiddleware)\n *       .exclude('/health')\n *       .forRoutes('*')\n *\n *     // CORS middleware for specific controllers\n *     consumer\n *       .apply(CorsMiddleware)\n *       .forRoutes(ApiController, WebhooksController)\n *\n *     // Rate limiting for auth endpoints\n *     consumer\n *       .apply(RateLimitMiddleware)\n *       .forRoutes({ path: '/api/v1/auth/*', method: 'post' })\n *   }\n * }\n * ```\n */\nexport class MiddlewareConsumerImpl implements IMiddlewareConsumer {\n  private entries: MiddlewareConfigEntry[] = []\n\n  /**\n   * Start configuring middleware\n   *\n   * @param middlewares - Middleware classes to apply\n   * @returns Builder for configuring routes and exclusions\n   */\n  apply(...middlewares: Constructor<Middleware>[]): IMiddlewareBuilder {\n    return new MiddlewareBuilderImpl(middlewares, this)\n  }\n\n  /**\n   * Add a configuration entry (called by builder)\n   * @internal\n   */\n  addEntry(entry: MiddlewareConfigEntry): void {\n    this.entries.push(entry)\n  }\n\n  /**\n   * Get all configured middleware entries\n   */\n  getEntries(): MiddlewareConfigEntry[] {\n    return this.entries\n  }\n}\n\n/**\n * Create a new middleware consumer instance\n */\nexport function createMiddlewareConsumer(): IMiddlewareConsumer {\n  return new MiddlewareConsumerImpl()\n}\n","import { Transient } from '../../di/decorators'\nimport { type Constructor } from '../../types'\nimport { ROUTE_METADATA_KEYS } from '../constants'\nimport { type ControllerOptions } from '../types'\n\nconst CONTROLLER_ROUTE_KEY = ROUTE_METADATA_KEYS.CONTROLLER_ROUTE\n\n/**\n * Base controller decorator for route registration\n *\n * This is the core controller decorator that handles:\n * - Transient scope registration (request-scoped)\n * - Route metadata storage\n * - Controller options (tags, security schemes, hideFromDocs)\n *\n * @param route - Base route for this controller (e.g., '/api/v1/users')\n * @param options - Optional configuration (tags, security schemes, hideFromDocs)\n *\n * @example\n * ```typescript\n * import { Controller } from 'stratal/router'\n *\n * @Controller('/api/v1/users', { tags: ['Users'] })\n * export class UsersController implements IController {\n *   // All routes accessible\n * }\n * ```\n */\nexport function Controller(route: string, options?: ControllerOptions) {\n  return function <T extends Constructor>(target: T) {\n    // Wrap @Transient (handles @injectable and scope metadata)\n    Transient()(target)\n\n    // Store route metadata on the class\n    Reflect.defineMetadata(CONTROLLER_ROUTE_KEY, route, target)\n\n    // Store options metadata if provided\n    if (options) {\n      Reflect.defineMetadata(ROUTE_METADATA_KEYS.CONTROLLER_OPTIONS, options, target)\n    }\n\n    return target\n  }\n}\n\n/**\n * Get the route from controller class metadata\n *\n * @param target - Controller class or instance\n * @returns Route string or undefined if not set\n */\nexport function getControllerRoute(target: object): string | undefined {\n  // Check if target is a class constructor (function) or an instance\n  // If class, get metadata from it directly; if instance, get from constructor\n  const metadataTarget = typeof target === 'function' ? target : (target as { constructor: object }).constructor\n  return Reflect.getMetadata(CONTROLLER_ROUTE_KEY, metadataTarget) as string | undefined\n}\n\n/**\n * Get the options from controller class metadata\n *\n * @param target - Controller class or instance\n * @returns Controller options or undefined if not set\n */\nexport function getControllerOptions(target: object): ControllerOptions | undefined {\n  const metadataTarget = typeof target === 'function' ? target : (target as { constructor: object }).constructor\n  return Reflect.getMetadata(ROUTE_METADATA_KEYS.CONTROLLER_OPTIONS, metadataTarget) as ControllerOptions | undefined\n}\n\n/**\n * Get the version from controller class metadata\n *\n * @param target - Controller class or instance\n * @returns Version string, array, VERSION_NEUTRAL symbol, or undefined if not set\n */\nexport function getControllerVersion(target: object): ControllerOptions['version'] {\n  const options = getControllerOptions(target)\n  return options?.version\n}\n","import type { Context } from 'hono'\nimport type { OpenAPIHono } from '../i18n/validation'\nimport type { Container } from '../di'\nimport type { LoggerService } from '../logger'\nimport type { IController } from '../router/controller'\nimport { getControllerRoute } from '../router/decorators/controller.decorator'\nimport type { Middleware } from '../router/middleware.interface'\nimport { RouterContext } from '../router/router-context'\nimport type { HttpMethod, RouterEnv, VersioningOptions } from '../router/types'\nimport type { Constructor } from '../types'\nimport type { MiddlewareConfigEntry, RouteInfo } from './types'\n\n/**\n * Service for applying middleware configurations to Hono app\n *\n * Processes MiddlewareConfigEntry[] from modules and registers\n * appropriate middleware handlers with route matching.\n */\nexport class MiddlewareConfigurationService {\n  constructor(\n    private readonly logger: LoggerService,\n    private readonly versioningOptions: VersioningOptions | null = null,\n  ) { }\n\n  /**\n   * Apply middleware configurations to the Hono app\n   *\n   * @param app - Hono application instance\n   * @param configs - Middleware configuration entries from modules\n   * @param controllers - All registered controller classes (for route resolution)\n   * @param container - DI container for resolving middleware instances\n   */\n  applyMiddlewares(\n    app: OpenAPIHono<RouterEnv>,\n    configs: MiddlewareConfigEntry[],\n    controllers: Constructor<IController>[],\n    container: Container\n  ): void {\n    for (const config of configs) {\n      this.applyMiddlewareConfig(app, config, controllers, container)\n    }\n  }\n\n  /**\n   * Apply a single middleware configuration entry\n   */\n  private applyMiddlewareConfig(\n    app: OpenAPIHono<RouterEnv>,\n    config: MiddlewareConfigEntry,\n    controllers: Constructor<IController>[],\n    container: Container\n  ): void {\n    const { middlewares, excludes, routes } = config\n\n    // Resolve route patterns from targets\n    const routePatterns = this.resolveRoutePatterns(routes, controllers)\n\n    // Log the configuration for debugging\n    this.logger.debug('Applying middleware configuration', {\n      middlewares: middlewares.map(m => m.name),\n      routes: routePatterns,\n      excludes: excludes,\n    })\n\n    // Apply middleware to each route pattern\n    for (const pattern of routePatterns) {\n      this.registerMiddlewareForPattern(app, middlewares, pattern, excludes, container)\n    }\n  }\n\n  /**\n   * Resolve route targets into concrete route patterns\n   */\n  private resolveRoutePatterns(\n    targets: (Constructor<IController> | RouteInfo | '*')[],\n    _controllers: Constructor<IController>[]\n  ): RouteInfo[] {\n    const patterns: RouteInfo[] = []\n\n    for (const target of targets) {\n      if (target === '*') {\n        // Global middleware - apply to all routes\n        patterns.push({ path: '*' })\n      } else if (typeof target === 'function') {\n        // Controller class - get its route from metadata\n        const route = getControllerRoute(target)\n        if (route) {\n          // Add wildcard for all paths under this controller\n          patterns.push({ path: `${route}/*` })\n          // Also match the exact path\n          patterns.push({ path: route })\n        } else {\n          this.logger.warn('Controller has no route metadata', { controller: target.name })\n        }\n      } else {\n        // RouteInfo object - resolve version if present\n        if (!this.versioningOptions || !target.version) {\n          // Fast path: no versioning or no version on target — push directly\n          patterns.push(target)\n        } else {\n          const resolved = this.resolveVersionedRouteInfo(target)\n          patterns.push(...resolved)\n        }\n      }\n    }\n\n    return patterns\n  }\n\n  /**\n   * Resolve a RouteInfo with version into versioned path(s).\n   * If versioning is disabled or no version is specified, returns the RouteInfo as-is.\n   */\n  private resolveVersionedRouteInfo(routeInfo: RouteInfo): RouteInfo[] {\n    if (!this.versioningOptions || !routeInfo.version) {\n      return [routeInfo]\n    }\n\n    const prefix = this.versioningOptions.prefix ?? 'v'\n    const versions = Array.isArray(routeInfo.version) ? routeInfo.version : [routeInfo.version]\n    const results: RouteInfo[] = []\n\n    for (const v of versions) {\n      const versionedPath = `/${prefix}${v}${routeInfo.path}`\n      // Add exact path match\n      results.push({ path: versionedPath, method: routeInfo.method })\n      // Add wildcard match for sub-paths\n      results.push({ path: `${versionedPath}/*`, method: routeInfo.method })\n    }\n\n    return results\n  }\n\n  /**\n   * Register middleware handlers for a specific route pattern\n   */\n  private registerMiddlewareForPattern(\n    app: OpenAPIHono<RouterEnv>,\n    middlewares: Constructor<Middleware>[],\n    pattern: RouteInfo,\n    excludes: RouteInfo[],\n    container: Container\n  ): void {\n    const path = pattern.path\n    const methods = pattern.method\n      ? (Array.isArray(pattern.method) ? pattern.method : [pattern.method])\n      : undefined\n\n    // Create the middleware handler\n    const handler = this.createMiddlewareHandler(middlewares, excludes, container)\n\n    // Register with Hono\n    if (methods && methods.length > 0) {\n      // Method-specific registration\n      for (const method of methods) {\n        this.registerForMethod(app, method, path, handler)\n      }\n    } else {\n      // All methods\n      app.use(path, handler)\n    }\n  }\n\n  /**\n   * Register handler for a specific HTTP method\n   */\n  private registerForMethod(\n    app: OpenAPIHono<RouterEnv>,\n    method: HttpMethod,\n    path: string,\n    handler: (c: Context<RouterEnv>, next: () => Promise<void>) => Promise<void>\n  ): void {\n    switch (method) {\n      case 'get':\n        app.get(path, handler)\n        break\n      case 'post':\n        app.post(path, handler)\n        break\n      case 'put':\n        app.put(path, handler)\n        break\n      case 'delete':\n        app.delete(path, handler)\n        break\n      case 'patch':\n        app.patch(path, handler)\n        break\n      default:\n        app.use(path, handler)\n    }\n  }\n\n  /**\n   * Create a middleware handler function that executes the middleware chain\n   */\n  private createMiddlewareHandler(\n    middlewares: Constructor<Middleware>[],\n    excludes: RouteInfo[],\n    container: Container\n  ): (c: Context<RouterEnv>, next: () => Promise<void>) => Promise<void> {\n    return async (c, next) => {\n      const requestPath = c.req.path\n      const requestMethod = c.req.method.toLowerCase() as HttpMethod\n\n      // Check if this request should be excluded\n      if (this.isExcluded(requestPath, requestMethod, excludes)) {\n        await next()\n        return\n      }\n\n      // Create RouterContext for middleware\n      const ctx = new RouterContext(c)\n\n      // Execute middleware chain\n      await this.executeMiddlewareChain(middlewares, ctx, container, next)\n    }\n  }\n\n  /**\n   * Check if a request matches any exclusion pattern\n   */\n  private isExcluded(\n    requestPath: string,\n    requestMethod: HttpMethod,\n    excludes: RouteInfo[]\n  ): boolean {\n    for (const exclude of excludes) {\n      if (this.matchesRoute(requestPath, requestMethod, exclude)) {\n        return true\n      }\n    }\n    return false\n  }\n\n  /**\n   * Check if request matches a route pattern\n   */\n  private matchesRoute(\n    requestPath: string,\n    requestMethod: HttpMethod,\n    route: RouteInfo\n  ): boolean {\n    // Check method match (if specified)\n    if (route.method) {\n      const methods = Array.isArray(route.method) ? route.method : [route.method]\n      if (!methods.includes(requestMethod)) {\n        return false\n      }\n    }\n\n    // Check path match\n    return this.matchesPath(requestPath, route.path)\n  }\n\n  /**\n   * Match request path against pattern\n   * Supports wildcards: /api/* matches /api/users, /api/v1/users\n   */\n  private matchesPath(requestPath: string, pattern: string): boolean {\n    // Exact match\n    if (pattern === requestPath) {\n      return true\n    }\n\n    // Global wildcard\n    if (pattern === '*') {\n      return true\n    }\n\n    // Wildcard pattern (e.g., /api/*)\n    if (pattern.endsWith('/*')) {\n      const prefix = pattern.slice(0, -2)\n      return requestPath === prefix || requestPath.startsWith(prefix + '/')\n    }\n\n    // Path parameter pattern (e.g., /api/users/:id)\n    // Convert to regex for matching\n    const regexPattern = pattern\n      .replace(/:[^/]+/g, '[^/]+') // Replace :param with regex\n      .replace(/\\*/g, '.*') // Replace * with regex\n    const regex = new RegExp(`^${regexPattern}$`)\n    return regex.test(requestPath)\n  }\n\n  /**\n   * Execute middleware chain in order\n   */\n  private async executeMiddlewareChain(\n    middlewares: Constructor<Middleware>[],\n    ctx: RouterContext,\n    container: Container,\n    finalNext: () => Promise<void>\n  ): Promise<void> {\n    // Build middleware chain from end to start\n    let chain = finalNext\n\n    for (let i = middlewares.length - 1; i >= 0; i--) {\n      const MiddlewareClass = middlewares[i]\n      const currentNext = chain\n\n      chain = async () => {\n        // Resolve middleware from request-scoped container\n        const requestContainer = ctx.getContainer()\n        const middleware = requestContainer.resolve<Middleware>(MiddlewareClass)\n        await middleware.handle(ctx, currentNext)\n      }\n    }\n\n    // Execute the chain\n    await chain()\n  }\n}\n"],"mappings":"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"}

package/dist/module/index.d.mts

@@ -0,0 +1,148 @@
+import { $t as Container, _t as MiddlewareConfigEntry, at as ExistingProvider, ct as ModuleClass, dt as OnInitialize, ft as OnShutdown, ht as ValueProvider, it as DynamicModule, lt as ModuleContext, mt as RegistryEntry, nt as AsyncModuleOptions, ot as FactoryProvider, pt as Provider, rt as ClassProvider, st as InjectionToken, ut as ModuleOptions } from "../index-D69rxo8H.mjs";
+import { t as Constructor } from "../types-Cu4jkeiH.mjs";
+import { i as LoggerService } from "../index-Cfkie8JM.mjs";
+
+//#region src/module/module.decorator.d.ts
+declare const MODULE_OPTIONS_KEY: unique symbol;
+/**
+ * `@Module` decorator - defines a module with imports, providers, controllers, consumers, jobs
+ *
+ * Uses tsyringe's `@registry` internally to auto-register providers when module is imported.
+ *
+ * @example
+ * ```typescript
+ * @Module({
+ *   imports: [OtherModule],
+ *   providers: [MyService, MyRepository],
+ *   controllers: [MyController],
+ * })
+ * export class MyModule {}
+ * ```
+ */
+declare function Module(options: ModuleOptions): <TFunction extends abstract new (...args: never[]) => unknown>(target: TFunction) => TFunction;
+/**
+ * Get module options from decorated class
+ */
+declare function getModuleOptions(target: Constructor): ModuleOptions | undefined;
+/**
+ * Check if a class is decorated with `@Module`
+ */
+declare function isModuleClass(target: unknown): target is Constructor;
+//#endregion
+//#region src/module/module-registry.d.ts
+/**
+ * ModuleRegistry - manages module lifecycle
+ *
+ * @example
+ * ```typescript
+ * const registry = new ModuleRegistry(container, logger)
+ * registry.register(AppModule)  // Traverses imports recursively
+ * await registry.initialize()
+ * // ... application running ...
+ * await registry.shutdown()
+ * ```
+ */
+declare class ModuleRegistry {
+  private readonly container;
+  private readonly logger;
+  private modules;
+  private registeredClasses;
+  private initialized;
+  private allControllers;
+  private allConsumers;
+  private allJobs;
+  private allListeners;
+  private allCommands;
+  private allSeeders;
+  private allMiddlewareConfigs;
+  constructor(container: Container, logger: LoggerService);
+  /**
+   * Register a module (static or dynamic)
+   *
+   * @param moduleOrDynamic - Module class decorated with `@Module` or DynamicModule from configure()
+   */
+  register(moduleOrDynamic: ModuleClass | DynamicModule): void;
+  /**
+   * Register multiple modules in order
+   */
+  registerAll(modules: (ModuleClass | DynamicModule)[]): void;
+  /**
+   * Initialize all modules (call configure and onInitialize hooks)
+   */
+  initialize(): Promise<void>;
+  /**
+   * Get all controllers registered from all modules
+   */
+  getAllControllers(): Constructor[];
+  /**
+   * Get all consumers registered from all modules
+   */
+  getAllConsumers(): Constructor[];
+  /**
+   * Get all jobs registered from all modules
+   */
+  getAllJobs(): Constructor[];
+  /**
+   * Get all listeners registered from all modules
+   */
+  getAllListeners(): Constructor[];
+  /**
+   * Get all commands registered from all modules
+   */
+  getAllCommands(): Constructor[];
+  /**
+   * Get all seeders registered from all modules
+   */
+  getAllSeeders(): Constructor[];
+  /**
+   * Get all middleware configurations from all modules
+   */
+  getAllMiddlewareConfigs(): MiddlewareConfigEntry[];
+  /**
+   * Shutdown all modules (call onShutdown hooks in reverse order)
+   */
+  shutdown(): Promise<void>;
+  /**
+   * Type guard for MiddlewareConfigurable
+   */
+  private hasMiddlewareConfigurable;
+  /**
+   * Type guard for OnInitialize
+   */
+  private hasOnInitialize;
+  /**
+   * Type guard for OnShutdown
+   */
+  private hasOnShutdown;
+  /**
+   * Resolve module class and options from static or dynamic module
+   *
+   * For DynamicModules, merges the decorator metadata (consumers, controllers, jobs)
+   * with the DynamicModule options (providers, imports). This ensures modules using
+   * forRoot/forRootAsync patterns still have their decorator-defined consumers registered.
+   */
+  private resolveModule;
+  /**
+   * Type guard for DynamicModule
+   */
+  private isDynamicModule;
+  /**
+   * Register a single provider in the container
+   */
+  private registerProvider;
+  /**
+   * Check if a class is a `Command` and collect it for auto-wiring
+   */
+  private collectIfCommand;
+  /**
+   * Check if a class is a `Seeder` and collect it for auto-wiring
+   */
+  private collectIfSeeder;
+  /**
+   * Check if a class is a `@Listener()` and collect it for auto-wiring
+   */
+  private collectIfListener;
+}
+//#endregion
+export { AsyncModuleOptions, ClassProvider, DynamicModule, ExistingProvider, FactoryProvider, InjectionToken, MODULE_OPTIONS_KEY, Module, ModuleClass, ModuleContext, ModuleOptions, ModuleRegistry, OnInitialize, OnShutdown, Provider, RegistryEntry, ValueProvider, getModuleOptions, isModuleClass };
+//# sourceMappingURL=index.d.mts.map

package/dist/module/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","names":[],"sources":["../../src/module/module.decorator.ts","../../src/module/module-registry.ts"],"mappings":";;;;;cAea,kBAAA;;;AAyBb;;;;;;;;;;;;;iBAAgB,MAAA,CAAO,OAAA,EAAS,aAAA,uCACa,IAAA,uBAA2B,MAAA,EAAQ,SAAA,KAAY,SAAA;;;;iBAmB5E,gBAAA,CAAiB,MAAA,EAAQ,WAAA,GAAc,aAAA;;;;iBAOvC,aAAA,CAAc,MAAA,YAAkB,MAAA,IAAU,WAAA;;;;;;;;;;;;;;;cCd7C,cAAA;EAAA,iBAeQ,SAAA;EAAA,iBACA,MAAA;EAAA,QAfX,OAAA;EAAA,QACA,iBAAA;EAAA,QACA,WAAA;EAAA,QAGA,cAAA;EAAA,QACA,YAAA;EAAA,QACA,OAAA;EAAA,QACA,YAAA;EAAA,QACA,WAAA;EAAA,QACA,UAAA;EAAA,QACA,oBAAA;cAGW,SAAA,EAAW,SAAA,EACX,MAAA,EAAQ,aAAA;EDFwC;;;;;ECUnE,QAAA,CAAS,eAAA,EAAiB,WAAA,GAAc,aAAA;;;;EAyDxC,WAAA,CAAY,OAAA,GAAU,WAAA,GAAc,aAAA;EAjFX;;;EA0FnB,UAAA,CAAA,GAAc,OAAA;EAlEM;;;EAyG1B,iBAAA,CAAA,GAAqB,WAAA;EAvCD;;;EA8CpB,eAAA,CAAA,GAAmB,WAAA;EAcA;;;EAPnB,UAAA,CAAA,GAAc,WAAA;EAmCI;;;EA5BlB,eAAA,CAAA,GAAmB,WAAA;EAtIA;;;EA6InB,cAAA,CAAA,GAAkB,WAAA;EAvJV;;;EA8JR,aAAA,CAAA,GAAiB,WAAA;EA1JT;;;EAiKR,uBAAA,CAAA,GAA2B,qBAAA;EA5JG;;;EAmKxB,QAAA,CAAA,GAAY,OAAA;EA1JlB;;;EAAA,QAqLQ,yBAAA;EA5HR;;;EAAA,QAwIQ,eAAA;EA/HF;;;EAAA,QA2IE,aAAA;EA7FR;;;;;;;EAAA,QA6GQ,aAAA;EAjFR;;;EAAA,QAgHQ,eAAA;EAlGF;;;EAAA,QA8GE,gBAAA;EA3DA;;;EAAA,QA+FA,gBAAA;EAAA;;;EAAA,QAWA,eAAA;EAUiB;;;EAAA,QAAjB,iBAAA;AAAA"}

package/dist/module/index.mjs

@@ -0,0 +1,11 @@
+import "../errors-CtCi1wn6.mjs";
+import "../decorate-D5j-d9_z.mjs";
+import "../logger-BR1-s1Um.mjs";
+import { a as isModuleClass, i as getModuleOptions, n as MODULE_OPTIONS_KEY, r as Module, t as ModuleRegistry } from "../module-BH7t7BGG.mjs";
+import "../events-CXl-o1Ad.mjs";
+import "../command-DG_u5ob2.mjs";
+import "../is-command-MZDCH-0T.mjs";
+import "../is-seeder-BN9Ej1r7.mjs";
+import "../middleware-iRhNjsPH.mjs";
+import "../router-context-BLn4PrRG.mjs";
+export { MODULE_OPTIONS_KEY, Module, ModuleRegistry, getModuleOptions, isModuleClass };