stratal 0.0.13 → 0.0.14

package/dist/module-Dvzm4dhS.mjs

@@ -0,0 +1,331 @@
+import { S as ApplicationError, b as ERROR_CODES, s as Scope } from "./errors-BRJgVd5-.mjs";
+import { a as isListener } from "./events-CQyvSyrQ.mjs";
+import { s as createMiddlewareConsumer } from "./middleware-B3tx1u1K.mjs";
+import { instancePerContainerCachingFactory, registry } from "tsyringe";
+//#region src/module/errors/invalid-module-provider.error.ts
+/**
+* InvalidModuleProviderError
+*
+* Thrown when a module provider configuration is invalid.
+* This indicates a misconfiguration in the @Module decorator providers array.
+*/
+var InvalidModuleProviderError = class extends ApplicationError {
+	constructor(provider) {
+		super("errors.invalidModuleProvider", ERROR_CODES.SYSTEM.INVALID_MODULE_PROVIDER, { provider: JSON.stringify(provider) });
+	}
+};
+//#endregion
+//#region src/module/module.decorator.ts
+const MODULE_OPTIONS_KEY = Symbol.for("stratal:module:options");
+/**
+* `@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 {}
+* ```
+*/
+function Module(options) {
+	return (target) => {
+		Reflect.defineMetadata(MODULE_OPTIONS_KEY, options, target);
+		const registryEntries = buildRegistryEntries(options.providers ?? []);
+		if (registryEntries.length > 0) registry(registryEntries)(target);
+		return target;
+	};
+}
+/**
+* Get module options from decorated class
+*/
+function getModuleOptions(target) {
+	return Reflect.getMetadata(MODULE_OPTIONS_KEY, target);
+}
+/**
+* Check if a class is decorated with `@Module`
+*/
+function isModuleClass(target) {
+	return typeof target === "function" && Reflect.hasMetadata(MODULE_OPTIONS_KEY, target);
+}
+/**
+* Convert our Provider types to tsyringe registry format
+*
+* Maps provider scope to tsyringe's lifecycle option.
+* Scope enum values map directly to Lifecycle enum values.
+*/
+function buildRegistryEntries(providers) {
+	return providers.map((provider) => {
+		if (typeof provider === "function") return {
+			token: provider,
+			useClass: provider
+		};
+		if ("useClass" in provider) return {
+			token: provider.provide,
+			useClass: provider.useClass,
+			options: provider.scope !== void 0 ? { lifecycle: provider.scope } : void 0
+		};
+		if ("useValue" in provider) return {
+			token: provider.provide,
+			useValue: provider.useValue
+		};
+		if ("useFactory" in provider) {
+			const { provide, useFactory, inject = [] } = provider;
+			return {
+				token: provide,
+				useFactory: instancePerContainerCachingFactory((dependencyContainer) => {
+					return useFactory(...inject.map((token) => dependencyContainer.resolve(token)));
+				})
+			};
+		}
+		if ("useExisting" in provider) return {
+			token: provider.provide,
+			useToken: provider.useExisting
+		};
+		throw new InvalidModuleProviderError(provider);
+	});
+}
+//#endregion
+//#region src/module/module-registry.ts
+/**
+* Module Registry
+*
+* Manages module lifecycle for the @Module decorator pattern.
+* Simplified for tsyringe's flat container model:
+* - Imports are traversed for registration (organization only)
+* - Modules registered in declaration order
+* - Lifecycle hooks: onInitialize, onShutdown
+*/
+/**
+* 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()
+* ```
+*/
+var ModuleRegistry = class {
+	modules = [];
+	registeredClasses = /* @__PURE__ */ new Set();
+	initialized = false;
+	allControllers = [];
+	allConsumers = [];
+	allJobs = [];
+	allListeners = [];
+	allMiddlewareConfigs = [];
+	constructor(container, logger) {
+		this.container = container;
+		this.logger = logger;
+	}
+	/**
+	* Register a module (static or dynamic)
+	*
+	* @param moduleOrDynamic - Module class decorated with `@Module` or DynamicModule from configure()
+	*/
+	register(moduleOrDynamic) {
+		const { moduleClass, options } = this.resolveModule(moduleOrDynamic);
+		const isDynamic = this.isDynamicModule(moduleOrDynamic);
+		if (this.registeredClasses.has(moduleClass)) {
+			if (isDynamic) {
+				this.logger.debug(`Module ${moduleClass.name} already registered, registering DynamicModule providers`);
+				for (const provider of options.providers ?? []) this.registerProvider(provider);
+			} else this.logger.debug(`Module ${moduleClass.name} already registered, skipping`);
+			return;
+		}
+		this.registeredClasses.add(moduleClass);
+		this.logger.info(`Registering module: ${moduleClass.name}`);
+		for (const ImportedModule of options.imports ?? []) this.register(ImportedModule);
+		for (const provider of options.providers ?? []) this.registerProvider(provider);
+		for (const controller of options.controllers ?? []) {
+			this.container.register(controller);
+			this.allControllers.push(controller);
+		}
+		for (const consumer of options.consumers ?? []) {
+			this.container.register(consumer, Scope.Singleton);
+			this.allConsumers.push(consumer);
+			this.logger.info(`Collected consumer: ${consumer.name}`, { queueCount: this.allConsumers.length });
+		}
+		for (const job of options.jobs ?? []) {
+			this.container.register(job, Scope.Singleton);
+			this.allJobs.push(job);
+		}
+		this.modules.push({
+			moduleClass,
+			options,
+			instance: null
+		});
+	}
+	/**
+	* Register multiple modules in order
+	*/
+	registerAll(modules) {
+		for (const module of modules) this.register(module);
+	}
+	/**
+	* Initialize all modules (call configure and onInitialize hooks)
+	*/
+	async initialize() {
+		if (this.initialized) return;
+		this.logger.info("Initializing modules...");
+		const context = {
+			container: this.container,
+			logger: this.logger
+		};
+		for (const registered of this.modules) {
+			const instance = new registered.moduleClass();
+			registered.instance = instance;
+			if (this.hasMiddlewareConfigurable(instance)) {
+				this.logger.debug(`Configuring middleware for: ${registered.moduleClass.name}`);
+				const consumer = createMiddlewareConsumer();
+				instance.configure(consumer);
+				const entries = consumer.getEntries();
+				this.allMiddlewareConfigs.push(...entries);
+				this.logger.debug(`Collected ${entries.length} middleware config(s) from ${registered.moduleClass.name}`);
+			}
+			if (this.hasOnInitialize(instance)) {
+				this.logger.info(`Initializing: ${registered.moduleClass.name}`);
+				await instance.onInitialize(context);
+			}
+		}
+		this.initialized = true;
+		this.logger.info("All modules initialized");
+	}
+	/**
+	* Get all controllers registered from all modules
+	*/
+	getAllControllers() {
+		return this.allControllers;
+	}
+	/**
+	* Get all consumers registered from all modules
+	*/
+	getAllConsumers() {
+		return this.allConsumers;
+	}
+	/**
+	* Get all jobs registered from all modules
+	*/
+	getAllJobs() {
+		return this.allJobs;
+	}
+	/**
+	* Get all listeners registered from all modules
+	*/
+	getAllListeners() {
+		return this.allListeners;
+	}
+	/**
+	* Get all middleware configurations from all modules
+	*/
+	getAllMiddlewareConfigs() {
+		return this.allMiddlewareConfigs;
+	}
+	/**
+	* Shutdown all modules (call onShutdown hooks in reverse order)
+	*/
+	async shutdown() {
+		this.logger.info("Shutting down modules...");
+		const context = {
+			container: this.container,
+			logger: this.logger
+		};
+		const reversed = [...this.modules].reverse();
+		for (const { moduleClass, instance } of reversed) if (instance && this.hasOnShutdown(instance)) try {
+			await instance.onShutdown(context);
+		} catch (error) {
+			this.logger.error(`Error shutting down ${moduleClass.name}:`, error);
+		}
+		this.logger.info("All modules shut down");
+	}
+	/**
+	* Type guard for MiddlewareConfigurable
+	*/
+	hasMiddlewareConfigurable(instance) {
+		return typeof instance === "object" && instance !== null && "configure" in instance && typeof instance.configure === "function";
+	}
+	/**
+	* Type guard for OnInitialize
+	*/
+	hasOnInitialize(instance) {
+		return typeof instance === "object" && instance !== null && "onInitialize" in instance && typeof instance.onInitialize === "function";
+	}
+	/**
+	* Type guard for OnShutdown
+	*/
+	hasOnShutdown(instance) {
+		return typeof instance === "object" && instance !== null && "onShutdown" in instance && typeof instance.onShutdown === "function";
+	}
+	/**
+	* 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.
+	*/
+	resolveModule(moduleOrDynamic) {
+		if (this.isDynamicModule(moduleOrDynamic)) {
+			const { module: moduleClass, ...dynamicRest } = moduleOrDynamic;
+			const decoratorOptions = getModuleOptions(moduleClass) ?? {};
+			return {
+				moduleClass,
+				options: {
+					...decoratorOptions,
+					...dynamicRest,
+					providers: [...decoratorOptions.providers ?? [], ...dynamicRest.providers ?? []],
+					imports: [...decoratorOptions.imports ?? []]
+				}
+			};
+		}
+		const moduleClass = moduleOrDynamic;
+		return {
+			moduleClass,
+			options: getModuleOptions(moduleClass) ?? {}
+		};
+	}
+	/**
+	* Type guard for DynamicModule
+	*/
+	isDynamicModule(value) {
+		return typeof value === "object" && value !== null && "module" in value && typeof value.module === "function";
+	}
+	/**
+	* Register a single provider in the container
+	*/
+	registerProvider(provider) {
+		if (typeof provider === "function") {
+			this.container.register(provider);
+			this.collectIfListener(provider);
+		} else if ("useClass" in provider) {
+			this.container.register(provider.provide, provider.useClass, provider.scope);
+			this.collectIfListener(provider.useClass);
+		} else if ("useValue" in provider) this.container.registerValue(provider.provide, provider.useValue);
+		else if ("useFactory" in provider) {
+			const { provide, useFactory, inject = [] } = provider;
+			this.container.getTsyringeContainer().register(provide, { useFactory: instancePerContainerCachingFactory((dependencyContainer) => {
+				return useFactory(...inject.map((token) => dependencyContainer.resolve(token)));
+			}) });
+		} else if ("useExisting" in provider) this.container.registerExisting(provider.provide, provider.useExisting);
+	}
+	/**
+	* Check if a class is a `@Listener()` and collect it for auto-wiring
+	*/
+	collectIfListener(providerClass) {
+		if (isListener(providerClass)) {
+			this.container.register(providerClass, providerClass, Scope.Singleton);
+			this.allListeners.push(providerClass);
+			this.logger.debug(`Collected listener: ${providerClass.name}`);
+		}
+	}
+};
+//#endregion
+export { isModuleClass as a, getModuleOptions as i, MODULE_OPTIONS_KEY as n, Module as r, ModuleRegistry as t };
+
+//# sourceMappingURL=module-Dvzm4dhS.mjs.map

package/dist/module-Dvzm4dhS.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"module-Dvzm4dhS.mjs","names":[],"sources":["../src/module/errors/invalid-module-provider.error.ts","../src/module/module.decorator.ts","../src/module/module-registry.ts"],"sourcesContent":["import { ApplicationError, ERROR_CODES } from '../../errors'\n\n/**\n * InvalidModuleProviderError\n *\n * Thrown when a module provider configuration is invalid.\n * This indicates a misconfiguration in the @Module decorator providers array.\n */\nexport class InvalidModuleProviderError extends ApplicationError {\n  constructor(provider: unknown) {\n    super(\n      'errors.invalidModuleProvider',\n      ERROR_CODES.SYSTEM.INVALID_MODULE_PROVIDER,\n      { provider: JSON.stringify(provider) }\n    )\n  }\n}\n","/**\n * Module Decorator\n *\n * NestJS-style @Module decorator for defining modules with providers, controllers, etc.\n * Encapsulates tsyringe's @registry decorator for auto-registration.\n */\n\nimport type { DependencyContainer, Provider as TsyringeProvider } from 'tsyringe'\nimport { instancePerContainerCachingFactory, type Lifecycle, registry } from 'tsyringe'\nimport type InjectionToken from 'tsyringe/dist/typings/providers/injection-token'\nimport type RegistrationOptions from 'tsyringe/dist/typings/types/registration-options'\nimport type { Constructor } from '../types'\nimport { InvalidModuleProviderError } from './errors'\nimport type { ModuleOptions, Provider } from './types'\n\nexport const MODULE_OPTIONS_KEY = Symbol.for('stratal:module:options')\n\n/**\n * Tsyringe registry entry format\n */\ntype RegistryEntry = {\n  token: InjectionToken\n  options?: RegistrationOptions\n} & TsyringeProvider\n\n/**\n * `@Module` decorator - defines a module with imports, providers, controllers, consumers, jobs\n *\n * Uses tsyringe's `@registry` internally to auto-register providers when module is imported.\n *\n * @example\n * ```typescript\n * @Module({\n *   imports: [OtherModule],\n *   providers: [MyService, MyRepository],\n *   controllers: [MyController],\n * })\n * export class MyModule {}\n * ```\n */\nexport function Module(options: ModuleOptions) {\n  return <TFunction extends abstract new (...args: never[]) => unknown>(target: TFunction): TFunction => {\n    // Store module options for runtime access\n    Reflect.defineMetadata(MODULE_OPTIONS_KEY, options, target)\n\n    // Build tsyringe registry entries from providers\n    const registryEntries = buildRegistryEntries(options.providers ?? [])\n\n    // Apply tsyringe @registry decorator (encapsulated)\n    if (registryEntries.length > 0) {\n      registry(registryEntries)(target)\n    }\n\n    return target\n  }\n}\n\n/**\n * Get module options from decorated class\n */\nexport function getModuleOptions(target: Constructor): ModuleOptions | undefined {\n  return Reflect.getMetadata(MODULE_OPTIONS_KEY, target) as ModuleOptions | undefined\n}\n\n/**\n * Check if a class is decorated with `@Module`\n */\nexport function isModuleClass(target: unknown): target is Constructor {\n  return (\n    typeof target === 'function' &&\n    Reflect.hasMetadata(MODULE_OPTIONS_KEY, target)\n  )\n}\n\n/**\n * Convert our Provider types to tsyringe registry format\n *\n * Maps provider scope to tsyringe's lifecycle option.\n * Scope enum values map directly to Lifecycle enum values.\n */\nfunction buildRegistryEntries(providers: Provider[]): RegistryEntry[] {\n  return providers.map((provider): RegistryEntry => {\n    // Class-only provider - transient by default\n    if (typeof provider === 'function') {\n      return {\n        token: provider as InjectionToken,\n        useClass: provider,\n      }\n    }\n\n    // ClassProvider with optional scope\n    if ('useClass' in provider) {\n      return {\n        token: provider.provide as InjectionToken,\n        useClass: provider.useClass,\n        options: provider.scope !== undefined\n          ? { lifecycle: provider.scope as unknown as Lifecycle }\n          : undefined,\n      }\n    }\n\n    // ValueProvider - no scope needed (values are inherently singleton)\n    if ('useValue' in provider) {\n      return {\n        token: provider.provide as InjectionToken,\n        useValue: provider.useValue,\n      }\n    }\n\n    // FactoryProvider - use instancePerContainerCachingFactory to:\n    // 1. Get the actual container at resolution time (global vs request)\n    // 2. Cache result per container\n    if ('useFactory' in provider) {\n      const { provide, useFactory, inject = [] } = provider\n      return {\n        token: provide as InjectionToken,\n        useFactory: instancePerContainerCachingFactory((dependencyContainer: DependencyContainer): object => {\n          const deps = inject.map((token) => dependencyContainer.resolve(token))\n          return useFactory(...deps) as object\n        }),\n      }\n    }\n\n    // ExistingProvider - alias to another token (uses tsyringe's useToken)\n    if ('useExisting' in provider) {\n      return {\n        token: provider.provide as InjectionToken,\n        useToken: provider.useExisting as InjectionToken,\n      }\n    }\n\n    // Fallback (should not reach here with proper types)\n    throw new InvalidModuleProviderError(provider)\n  })\n}\n","/**\n * Module Registry\n *\n * Manages module lifecycle for the @Module decorator pattern.\n * Simplified for tsyringe's flat container model:\n * - Imports are traversed for registration (organization only)\n * - Modules registered in declaration order\n * - Lifecycle hooks: onInitialize, onShutdown\n */\n\nimport { instancePerContainerCachingFactory } from 'tsyringe'\nimport type { Container } from '../di/container'\nimport { Scope } from '../di/types'\nimport { isListener } from '../events'\nimport type { LoggerService } from '../logger'\nimport {\n  createMiddlewareConsumer,\n  type MiddlewareConfigEntry,\n  type MiddlewareConfigurable,\n} from '../middleware'\nimport type { Constructor } from '../types'\nimport { getModuleOptions } from './module.decorator'\nimport type {\n  DynamicModule,\n  ModuleClass,\n  ModuleContext,\n  ModuleOptions,\n  OnInitialize,\n  OnShutdown,\n  Provider,\n} from './types'\n\n\ninterface RegisteredModule {\n  moduleClass: Constructor\n  options: ModuleOptions\n  instance: object | null\n}\n\n/**\n * ModuleRegistry - manages module lifecycle\n *\n * @example\n * ```typescript\n * const registry = new ModuleRegistry(container, logger)\n * registry.register(AppModule)  // Traverses imports recursively\n * await registry.initialize()\n * // ... application running ...\n * await registry.shutdown()\n * ```\n */\nexport class ModuleRegistry {\n  private modules: RegisteredModule[] = []\n  private registeredClasses = new Set<Constructor>()\n  private initialized = false\n\n  // Collected items from all modules for Application to use\n  private allControllers: Constructor[] = []\n  private allConsumers: Constructor[] = []\n  private allJobs: Constructor[] = []\n  private allListeners: Constructor[] = []\n  private allMiddlewareConfigs: MiddlewareConfigEntry[] = []\n\n  constructor(\n    private readonly container: Container,\n    private readonly logger: LoggerService\n  ) { }\n\n  /**\n   * Register a module (static or dynamic)\n   *\n   * @param moduleOrDynamic - Module class decorated with `@Module` or DynamicModule from configure()\n   */\n  register(moduleOrDynamic: ModuleClass | DynamicModule): void {\n    const { moduleClass, options } = this.resolveModule(moduleOrDynamic)\n    const isDynamic = this.isDynamicModule(moduleOrDynamic)\n\n    // Check for duplicate registration\n    if (this.registeredClasses.has(moduleClass)) {\n      // For DynamicModules: Still register the additional providers\n      // This allows forRoot() to add configuration even if base module is registered\n      if (isDynamic) {\n        this.logger.debug(`Module ${moduleClass.name} already registered, registering DynamicModule providers`)\n        for (const provider of options.providers ?? []) {\n          this.registerProvider(provider)\n        }\n      } else {\n        this.logger.debug(`Module ${moduleClass.name} already registered, skipping`)\n      }\n      return\n    }\n\n    this.registeredClasses.add(moduleClass)\n    this.logger.info(`Registering module: ${moduleClass.name}`)\n\n    // First, register imported modules recursively\n    for (const ImportedModule of options.imports ?? []) {\n      this.register(ImportedModule)\n    }\n\n    // Register providers in container\n    for (const provider of options.providers ?? []) {\n      this.registerProvider(provider)\n    }\n\n    // Register controllers and collect them\n    for (const controller of options.controllers ?? []) {\n      this.container.register(controller)\n      this.allControllers.push(controller)\n    }\n\n    // Register consumers as singletons by default and collect them\n    for (const consumer of options.consumers ?? []) {\n      this.container.register(consumer, Scope.Singleton)\n      this.allConsumers.push(consumer)\n      this.logger.info(`Collected consumer: ${consumer.name}`, { queueCount: this.allConsumers.length })\n    }\n\n    // Register jobs as singletons by default and collect them\n    for (const job of options.jobs ?? []) {\n      this.container.register(job, Scope.Singleton)\n      this.allJobs.push(job)\n    }\n\n    this.modules.push({ moduleClass, options, instance: null })\n  }\n\n  /**\n   * Register multiple modules in order\n   */\n  registerAll(modules: (ModuleClass | DynamicModule)[]): void {\n    for (const module of modules) {\n      this.register(module)\n    }\n  }\n\n  /**\n   * Initialize all modules (call configure and onInitialize hooks)\n   */\n  async initialize(): Promise<void> {\n    if (this.initialized) return\n\n    this.logger.info('Initializing modules...')\n\n    const context: ModuleContext = {\n      container: this.container,\n      logger: this.logger,\n    }\n\n    for (const registered of this.modules) {\n      // Instantiate module class\n      const instance = new registered.moduleClass()\n      registered.instance = instance\n\n      // Call configure() for middleware configuration if implemented\n      if (this.hasMiddlewareConfigurable(instance)) {\n        this.logger.debug(`Configuring middleware for: ${registered.moduleClass.name}`)\n        const consumer = createMiddlewareConsumer()\n        instance.configure(consumer)\n        const entries = consumer.getEntries()\n        this.allMiddlewareConfigs.push(...entries)\n        this.logger.debug(`Collected ${entries.length} middleware config(s) from ${registered.moduleClass.name}`)\n      }\n\n      // Call onInitialize if implemented\n      if (this.hasOnInitialize(instance)) {\n        this.logger.info(`Initializing: ${registered.moduleClass.name}`)\n        await instance.onInitialize(context)\n      }\n    }\n\n    this.initialized = true\n    this.logger.info('All modules initialized')\n  }\n\n  /**\n   * Get all controllers registered from all modules\n   */\n  getAllControllers(): Constructor[] {\n    return this.allControllers\n  }\n\n  /**\n   * Get all consumers registered from all modules\n   */\n  getAllConsumers(): Constructor[] {\n    return this.allConsumers\n  }\n\n  /**\n   * Get all jobs registered from all modules\n   */\n  getAllJobs(): Constructor[] {\n    return this.allJobs\n  }\n\n  /**\n   * Get all listeners registered from all modules\n   */\n  getAllListeners(): Constructor[] {\n    return this.allListeners\n  }\n\n  /**\n   * Get all middleware configurations from all modules\n   */\n  getAllMiddlewareConfigs(): MiddlewareConfigEntry[] {\n    return this.allMiddlewareConfigs\n  }\n\n  /**\n   * Shutdown all modules (call onShutdown hooks in reverse order)\n   */\n  async shutdown(): Promise<void> {\n    this.logger.info('Shutting down modules...')\n\n    const context: ModuleContext = {\n      container: this.container,\n      logger: this.logger,\n    }\n\n    // Reverse order for shutdown\n    const reversed = [...this.modules].reverse()\n\n    for (const { moduleClass, instance } of reversed) {\n      if (instance && this.hasOnShutdown(instance)) {\n        try {\n          await instance.onShutdown(context)\n        } catch (error) {\n          this.logger.error(`Error shutting down ${moduleClass.name}:`, error as Error)\n        }\n      }\n    }\n\n    this.logger.info('All modules shut down')\n  }\n\n  /**\n   * Type guard for MiddlewareConfigurable\n   */\n  private hasMiddlewareConfigurable(instance: unknown): instance is MiddlewareConfigurable {\n    return (\n      typeof instance === 'object' &&\n      instance !== null &&\n      'configure' in instance &&\n      typeof (instance as MiddlewareConfigurable).configure === 'function'\n    )\n  }\n\n  /**\n   * Type guard for OnInitialize\n   */\n  private hasOnInitialize(instance: unknown): instance is OnInitialize {\n    return (\n      typeof instance === 'object' &&\n      instance !== null &&\n      'onInitialize' in instance &&\n      typeof (instance as OnInitialize).onInitialize === 'function'\n    )\n  }\n\n  /**\n   * Type guard for OnShutdown\n   */\n  private hasOnShutdown(instance: unknown): instance is OnShutdown {\n    return (\n      typeof instance === 'object' &&\n      instance !== null &&\n      'onShutdown' in instance &&\n      typeof (instance as OnShutdown).onShutdown === 'function'\n    )\n  }\n\n  /**\n   * Resolve module class and options from static or dynamic module\n   *\n   * For DynamicModules, merges the decorator metadata (consumers, controllers, jobs)\n   * with the DynamicModule options (providers, imports). This ensures modules using\n   * forRoot/forRootAsync patterns still have their decorator-defined consumers registered.\n   */\n  private resolveModule(moduleOrDynamic: ModuleClass | DynamicModule): {\n    moduleClass: Constructor\n    options: ModuleOptions\n  } {\n    // DynamicModule (from forRoot/forRootAsync) - has module property\n    if (this.isDynamicModule(moduleOrDynamic)) {\n      const { module: moduleClass, ...dynamicRest } = moduleOrDynamic\n\n      // Get decorator options and merge with dynamic options\n      // This ensures consumers/controllers/jobs from @Module decorator are included\n      const decoratorOptions = getModuleOptions(moduleClass) ?? {}\n      const mergedOptions: ModuleOptions = {\n        ...decoratorOptions,\n        ...dynamicRest,\n        // Merge arrays: decorator providers first, then dynamic providers\n        providers: [...(decoratorOptions.providers ?? []), ...(dynamicRest.providers ?? [])],\n        imports: [...(decoratorOptions.imports ?? [])],\n      }\n\n      return { moduleClass: moduleClass, options: mergedOptions }\n    }\n\n    // Static module (decorated with @Module)\n    const moduleClass = moduleOrDynamic as Constructor\n    const options = getModuleOptions(moduleClass) ?? {}\n    return { moduleClass, options }\n  }\n\n  /**\n   * Type guard for DynamicModule\n   */\n  private isDynamicModule(value: unknown): value is DynamicModule {\n    return (\n      typeof value === 'object' &&\n      value !== null &&\n      'module' in value && // Required property for dynamic modules\n      typeof (value as DynamicModule).module === 'function'\n    )\n  }\n\n  /**\n   * Register a single provider in the container\n   */\n  private registerProvider(provider: Provider): void {\n    if (typeof provider === 'function') {\n      // Class-only provider - transient by default\n      this.container.register(provider as Constructor)\n      this.collectIfListener(provider as Constructor)\n    } else if ('useClass' in provider) {\n      // ClassProvider with optional scope\n      this.container.register(provider.provide, provider.useClass as Constructor, provider.scope)\n      this.collectIfListener(provider.useClass as Constructor)\n    } else if ('useValue' in provider) {\n      // ValueProvider - no scope needed (values are inherently singleton)\n      this.container.registerValue(provider.provide, provider.useValue)\n    } else if ('useFactory' in provider) {\n      // FactoryProvider - use instancePerContainerCachingFactory to:\n      // 1. Get the actual container at resolution time (global vs request)\n      // 2. Cache result per container\n      const { provide, useFactory, inject = [] } = provider\n      this.container.getTsyringeContainer().register(provide, {\n        useFactory: instancePerContainerCachingFactory((dependencyContainer) => {\n          const deps = inject.map((token) => dependencyContainer.resolve(token))\n          return useFactory(...deps)\n        })\n      })\n    } else if ('useExisting' in provider) {\n      // ExistingProvider - alias to another token\n      this.container.registerExisting(provider.provide, provider.useExisting)\n    }\n  }\n\n  /**\n   * Check if a class is a `@Listener()` and collect it for auto-wiring\n   */\n  private collectIfListener(providerClass: Constructor): void {\n    if (isListener(providerClass)) {\n      // Re-register as singleton so the same instance is used across all event registrations\n      this.container.register(providerClass, providerClass, Scope.Singleton)\n      this.allListeners.push(providerClass)\n      this.logger.debug(`Collected listener: ${providerClass.name}`)\n    }\n  }\n}\n"],"mappings":"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"}

package/dist/openapi/index.d.mts

@@ -0,0 +1,202 @@
+import { Ct as IController, Nt as RouterEnv, it as DynamicModule, nt as AsyncModuleOptions } from "../index-C9bIk5tt.mjs";
+import { t as Constructor } from "../types-JUIHSW_a.mjs";
+import { r as PathItemObject, t as OpenAPIHono } from "../index-Dl4RvzNp.mjs";
+import { MiddlewareHandler } from "hono/types";
+
+//#region src/openapi/types.d.ts
+/**
+ * OpenAPI Info section configuration
+ */
+interface OpenAPIInfo {
+  title: string;
+  version: string;
+  description?: string;
+}
+/**
+ * Context passed to a custom OpenAPI UI renderer
+ */
+interface OpenAPIUIContext {
+  specUrl: string;
+  title: string;
+}
+/**
+ * Custom UI renderer function
+ * Returns a Hono middleware handler that serves the docs UI
+ */
+type OpenAPIUIRenderer = (context: OpenAPIUIContext) => MiddlewareHandler<RouterEnv>;
+/**
+ * Options for the docs UI
+ */
+interface OpenAPIUIOptions {
+  /** Path for docs UI (default: '/api/docs') */
+  path?: string;
+  /** Custom UI renderer (default: swagger UI) */
+  renderer?: OpenAPIUIRenderer;
+}
+/**
+ * Static module configuration (provided via forRoot)
+ */
+interface OpenAPIModuleOptions {
+  /** Path for OpenAPI JSON spec (default: '/api/openapi.json') */
+  jsonPath?: string;
+  /** Default info section for spec */
+  info?: OpenAPIInfo;
+  /** Security schemes definition */
+  securitySchemes?: Record<string, object>;
+  /** Docs UI configuration. Set to false to disable. (default: swagger UI at /api/docs) */
+  ui?: OpenAPIUIOptions | false;
+}
+/**
+ * Route filter function type
+ * Returns true to include route, false to exclude
+ */
+type RouteFilterFn = (path: string, pathItem: PathItemObject) => boolean;
+/**
+ * Runtime configuration override (set via middleware)
+ */
+interface OpenAPIConfigOverride {
+  /** Override info section */
+  info?: Partial<OpenAPIInfo>;
+  /** Custom route filter (returns true to include, false to exclude) */
+  routeFilter?: RouteFilterFn;
+}
+/**
+ * Effective configuration after merging base options with overrides
+ */
+interface OpenAPIEffectiveConfig {
+  jsonPath: string;
+  info: OpenAPIInfo;
+  securitySchemes?: Record<string, object>;
+  routeFilter?: RouteFilterFn;
+  ui?: OpenAPIUIOptions | false;
+}
+/**
+ * OpenAPI config service interface
+ */
+interface IOpenAPIConfigService {
+  /**
+   * Override config for this request
+   * Can be called multiple times; overrides are merged in order
+   */
+  override(config: OpenAPIConfigOverride): void;
+  /**
+   * Get effective config (base merged with all overrides)
+   */
+  getEffectiveConfig(): OpenAPIEffectiveConfig;
+}
+//#endregion
+//#region src/openapi/openapi.module.d.ts
+declare class OpenAPIModule {
+  /**
+   * Configure OpenAPI module with static options
+   *
+   * @param options - OpenAPI configuration (paths, info, security schemes)
+   * @returns DynamicModule with options provider
+   */
+  static forRoot(options?: OpenAPIModuleOptions): DynamicModule;
+  static forRootAsync(options: AsyncModuleOptions<OpenAPIModuleOptions>): DynamicModule;
+}
+//#endregion
+//#region src/openapi/openapi.tokens.d.ts
+/**
+ * OpenAPI Module DI Tokens
+ */
+declare const OPENAPI_TOKENS: {
+  /** Static options provided via forRoot() */readonly Options: symbol; /** Request-scoped config service that supports runtime overrides */
+  readonly ConfigService: symbol; /** OpenAPI service that generates specs and serves endpoints */
+  readonly OpenAPIService: symbol;
+};
+//#endregion
+//#region src/openapi/services/openapi-config.service.d.ts
+/**
+ * OpenAPI Config Service
+ *
+ * Request-scoped service that manages OpenAPI configuration for the current request.
+ * Supports runtime overrides via middleware while preserving base configuration.
+ *
+ * @example
+ * ```typescript
+ * // In middleware (e.g., RouteAccessMiddleware)
+ * constructor(
+ *   @inject(OPENAPI_TOKENS.ConfigService) private openAPIConfig: IOpenAPIConfigService
+ * ) {}
+ *
+ * async handle(ctx, next) {
+ *   this.openAPIConfig.override({
+ *     info: { title: 'Custom API' },
+ *     routeFilter: (path) => shouldInclude(path)
+ *   })
+ *   await next()
+ * }
+ * ```
+ */
+declare class OpenAPIConfigService implements IOpenAPIConfigService {
+  private baseOptions?;
+  private overrides;
+  constructor(baseOptions?: OpenAPIModuleOptions | undefined);
+  /**
+   * Add configuration override for this request
+   * Overrides are merged in the order they are added
+   */
+  override(config: OpenAPIConfigOverride): void;
+  /**
+   * Get effective configuration (base merged with all overrides)
+   */
+  getEffectiveConfig(): OpenAPIEffectiveConfig;
+  /**
+   * Merge override into effective config
+   * Info is shallow-merged, routeFilter is replaced
+   */
+  private mergeConfig;
+}
+//#endregion
+//#region src/openapi/services/openapi.service.d.ts
+/**
+ * OpenAPI Service
+ *
+ * Generates OpenAPI specifications with support for:
+ * - Runtime configuration via OpenAPIConfigService
+ * - Route filtering via hideFromDocs and custom routeFilter
+ * - i18n support for titles and descriptions
+ * - Security scheme definitions
+ *
+ * Configuration is resolved per-request from OpenAPIConfigService,
+ * allowing middleware to override config based on domain context.
+ */
+declare class OpenAPIService {
+  private configService;
+  private routeInfoMap;
+  constructor(configService: IOpenAPIConfigService);
+  /**
+   * Setup OpenAPI documentation endpoints
+   */
+  setupEndpoints(app: OpenAPIHono<RouterEnv>, controllers: Constructor<IController>[]): void;
+  /**
+   * Get localized security scheme definitions
+   */
+  private getSecuritySchemeDefinitions;
+  /**
+   * Build route info map from controllers
+   * Maps route prefixes to their hideFromDocs flag
+   */
+  private buildRouteInfoMap;
+  /**
+   * Filter OpenAPI paths based on hideFromDocs and custom routeFilter
+   */
+  private filterRoutes;
+  /**
+   * Get route info by matching path against controller routes
+   */
+  private getRouteInfo;
+  /**
+   * Filter unreferenced schemas from OpenAPI spec
+   */
+  private filterSchemas;
+  /**
+   * Recursively collect all schema references from an object
+   */
+  private collectSchemaRefs;
+}
+//#endregion
+export { type IOpenAPIConfigService, OPENAPI_TOKENS, type OpenAPIConfigOverride, OpenAPIConfigService, type OpenAPIEffectiveConfig, type OpenAPIInfo, OpenAPIModule, type OpenAPIModuleOptions, OpenAPIService, type OpenAPIUIContext, type OpenAPIUIOptions, type OpenAPIUIRenderer, type RouteFilterFn };
+//# sourceMappingURL=index.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","names":[],"sources":["../../src/openapi/types.ts","../../src/openapi/openapi.module.ts","../../src/openapi/openapi.tokens.ts","../../src/openapi/services/openapi-config.service.ts","../../src/openapi/services/openapi.service.ts"],"mappings":";;;;;;;;;UAOiB,WAAA;EACf,KAAA;EACA,OAAA;EACA,WAAA;AAAA;;;;UAMe,gBAAA;EACf,OAAA;EACA,KAAA;AAAA;;;AAOF;;KAAY,iBAAA,IAAqB,OAAA,EAAS,gBAAA,KAAqB,iBAAA,CAAkB,SAAA;;;;UAKhE,gBAAA;EAL+D;EAO9E,IAAA;EAP+B;EAS/B,QAAA,GAAW,iBAAA;AAAA;;;AAJb;UAUiB,oBAAA;;EAEf,QAAA;EAVA;EAaA,IAAA,GAAO,WAAA;EAXI;EAcX,eAAA,GAAkB,MAAA;EAdU;EAiB5B,EAAA,GAAK,gBAAA;AAAA;;;;;KAOK,aAAA,IAAiB,IAAA,UAAc,QAAA,EAAU,cAAA;;;;UAKpC,qBAAA;EAff;EAiBA,IAAA,GAAO,OAAA,CAAQ,WAAA;EAdf;EAiBA,WAAA,GAAc,aAAA;AAAA;;AAVhB;;UAgBiB,sBAAA;EACf,QAAA;EACA,IAAA,EAAM,WAAA;EACN,eAAA,GAAkB,MAAA;EAClB,WAAA,GAAc,aAAA;EACd,EAAA,GAAK,gBAAA;AAAA;AAhBP;;;AAAA,UAsBiB,qBAAA;EApBR;;;;EAyBP,QAAA,CAAS,MAAA,EAAQ,qBAAA;EAzBV;;;EA8BP,kBAAA,IAAsB,sBAAA;AAAA;;;cC/BX,aAAA;ED9BiB;AAM9B;;;;;EAN8B,OCqCrB,OAAA,CAAQ,OAAA,GAAS,oBAAA,GAA4B,aAAA;EAAA,OAqB7C,YAAA,CAAa,OAAA,EAAS,kBAAA,CAAmB,oBAAA,IAAwB,aAAA;AAAA;;;;;;cCzF7D,cAAA;wEFII;EAAA;;;;;;;;;;AAAjB;;;;;;;;;AASA;;;;;AASA;;;cGQa,oBAAA,YAAgC,qBAAA;EAAA,QAIqB,WAAA;EAAA,QAHxD,SAAA;cAGwD,WAAA,GAAc,oBAAA;EHZA;;;;EGmB9E,QAAA,CAAS,MAAA,EAAQ,qBAAA;EHnBuE;;AAK1F;EGqBE,kBAAA,CAAA,GAAsB,sBAAA;;;;;UAyBd,WAAA;AAAA;;;;AHrEV;;;;;;;;;AASA;;cIkBa,cAAA;EAAA,QAKD,aAAA;EAAA,QAJF,YAAA;cAIE,aAAA,EAAe,qBAAA;EJdE;;;EIoB3B,cAAA,CAAe,GAAA,EAAK,WAAA,CAAY,SAAA,GAAY,WAAA,EAAa,WAAA,CAAY,WAAA;EJpBR;;;EAAA,QIkGrD,4BAAA;EJlGuB;;;;EAAA,QI6HvB,iBAAA;EJxHO;;;EAAA,QIwIP,YAAA;EJtIR;;;EAAA,QImKQ,YAAA;EJjKoB;AAM9B;;EAN8B,QI+KpB,aAAA;EJpKD;;;EAAA,QIoMC,iBAAA;AAAA"}

package/dist/openapi/index.mjs

@@ -0,0 +1,11 @@
+import "../errors-BRJgVd5-.mjs";
+import "../logger-Bg-CuidS.mjs";
+import "../module-Dvzm4dhS.mjs";
+import "../events-CQyvSyrQ.mjs";
+import "../middleware-B3tx1u1K.mjs";
+import "../router-context-DlTxpJUG.mjs";
+import "../validation-DA5nptIp.mjs";
+import { I as OpenAPIConfigService, L as OPENAPI_TOKENS, _ as OpenAPIService, g as OpenAPIModule } from "../i18n.module-C9wQr_2k.mjs";
+import "../guards-B5o618bL.mjs";
+import "../gateway-context-D7TFPLi5.mjs";
+export { OPENAPI_TOKENS, OpenAPIConfigService, OpenAPIModule, OpenAPIService };

package/dist/queue/index.d.mts

@@ -0,0 +1,2 @@
+import { _ as QueueNames, a as InjectQueue, b as IQueueConsumer, c as QueueModule, d as SyncQueueProvider, f as CloudflareQueueProvider, g as QueueName, h as IQueueSender, i as QueueToken, l as QueueModuleOptions, m as DispatchMessage, n as QueueBindingNotFoundError, o as QueueRegistry, p as IQueueProvider, r as QUEUE_TOKENS, s as QueueProviderFactory, t as QueueProviderNotSupportedError, u as QueueSender, v as QueueManager, x as QueueMessage, y as ConsumerRegistry } from "../index-zKURVFOC.mjs";
+export { CloudflareQueueProvider, ConsumerRegistry, DispatchMessage, IQueueConsumer, IQueueProvider, IQueueSender, InjectQueue, QUEUE_TOKENS, QueueBindingNotFoundError, QueueManager, QueueMessage, QueueModule, QueueModuleOptions, QueueName, QueueNames, QueueProviderFactory, QueueProviderNotSupportedError, QueueRegistry, QueueSender, QueueToken, SyncQueueProvider };