@hono-di/core 0.0.9 → 0.0.15

package/dist/index.d.cts

@@ -1,10 +1,407 @@
-export { All, Body, Catch, Controller, Ctx, CustomDecorator, Delete, FileParam, Files, Get, Global, Head, Header, Headers, HostParam, HttpCode, Inject, Injectable, InjectableOptions, Ip, Module, Next, Optional, Options, Param, Patch, Post, Put, Query, Redirect, Request, Response, RouteDefinition, RouteParamtypes, Session, SetMetadata, UseFilters, UseGuards, UseInterceptors, UsePipes, applyDecorators, assignMetadata, createParamDecorator } from './decorators.cjs';
-export { c as ArgumentMetadata, A as ArgumentsHost, B as BeforeApplicationShutdown, d as CallHandler, C as CanActivate, i as ClassProvider, D as DynamicModule, E as ExceptionFilter, b as ExecutionContext, j as ExistingProvider, F as FactoryProvider, k as ForwardReference, l as HonoDiMiddleware, p as HonoDiModule, H as HttpArgumentsHost, q as IApplication, I as InjectionToken, a as Interceptor, n as MiddlewareConfigProxy, m as MiddlewareConsumer, M as ModuleOptions, e as OnApplicationBootstrap, g as OnApplicationShutdown, f as OnModuleDestroy, O as OnModuleInit, P as PipeTransform, h as Provider, R as RequestMethod, o as RouteInfo, S as Scope, T as Type, V as ValueProvider } from './interfaces-4oTuNIHA.cjs';
-import { ILogger, HonoDiFactory } from './core.cjs';
-export { AppError, BadGatewayException, BadRequestError, BadRequestException, BaseExceptionFilter, ConflictError, ConflictException, Container, ExecutionContextHost, ForbiddenError, ForbiddenException, GatewayTimeoutException, GoneException, HonoDiApplication, HonoDiScanner, HttpException, InternalServerErrorException, METADATA_KEYS, MiddlewareBuilder, MiddlewareConfig, ModuleRef, ModuleRefImpl, NotAcceptableException, NotFoundError, NotFoundException, NotImplementedException, ParseBoolPipe, ParseFloatPipe, ParseIntPipe, PayloadTooLargeException, Reflector, RequestTimeoutException, ServiceUnavailableException, UnauthorizedError, UnauthorizedException, UnprocessableEntityException, UnsupportedMediaTypeException, ValidationPipe, forwardRef } from './core.cjs';
-import 'hono';
+import { I as IApplication, a as InjectionToken, T as Type, S as Scope, E as ExceptionFilter, P as PipeTransform, b as Interceptor, C as CanActivate, F as ForwardReference, c as ExecutionContext, H as HttpArgumentsHost, M as MiddlewareConsumer, d as MiddlewareConfigProxy, R as RouteInfo, A as ArgumentMetadata, e as ArgumentsHost } from './decorators-ClTJ_N9c.cjs';
+export { r as All, ab as BeforeApplicationShutdown, Y as Body, a7 as CallHandler, s as Catch, ae as ClassProvider, am as CleanupHandler, l as Controller, X as Ctx, a1 as CustomDecorator, D as Delete, ai as DynamicModule, ah as ExistingProvider, ag as FactoryProvider, L as FileParam, Q as Files, m as Get, G as Global, q as Head, a3 as Header, $ as Headers, aj as HonoDiMiddleware, ak as HonoDiModule, W as HostParam, a2 as HttpCode, t as Inject, k as Injectable, h as InjectableOptions, V as Ip, j as Module, g as ModuleOptions, N as Next, a9 as OnApplicationBootstrap, ac as OnApplicationShutdown, aa as OnModuleDestroy, a8 as OnModuleInit, u as Optional, O as Options, _ as Param, p as Patch, n as Post, ad as Provider, o as Put, Z as Query, a4 as Redirect, B as Request, f as RequestMethod, J as Response, i as RouteDefinition, al as RouteMetadataCache, y as RouteParamtypes, K as Session, a0 as SetMetadata, U as UseFilters, v as UseGuards, w as UseInterceptors, x as UsePipes, af as ValueProvider, a5 as applyDecorators, z as assignMetadata, a6 as createParamDecorator } from './decorators-ClTJ_N9c.cjs';
+import * as hono from 'hono';
+import { Hono } from 'hono';
+import * as hono_utils_http_status from 'hono/utils/http-status';
 import 'rxjs';
-import 'hono/utils/http-status';
+
+declare const METADATA_KEYS: {
+    MODULE: symbol;
+    GLOBAL: symbol;
+    CONTROLLER: symbol;
+    FLUSH_ROLES: symbol;
+    OPTS: symbol;
+    PARAMS: symbol;
+    ROUTES: symbol;
+    FILTER_CATCH: symbol;
+    FILTER_EXCEPTION: symbol;
+    USE_FILTERS: symbol;
+    USE_PIPES: symbol;
+    USE_GUARDS: symbol;
+    USE_INTERCEPTORS: symbol;
+    ROUTE_ARGS_METADATA: symbol;
+    INJECTIONS: symbol;
+    OPTIONAL: symbol;
+    SCOPE: symbol;
+    METHOD_INJECTIONS: symbol;
+    METHOD_OPTIONAL: symbol;
+    PROPERTY_DEPS: symbol;
+    HTTP_CODE: symbol;
+    HEADERS: symbol;
+    REDIRECT: symbol;
+};
+
+/**
+ * Factory class for creating Hono DI applications
+ *
+ * @remarks
+ * This is the main entry point for bootstrapping a Hono DI application.
+ * It handles module scanning, dependency resolution, and application initialization.
+ *
+ * @example
+ * Basic usage:
+ * ```typescript
+ * @Module({
+ *   controllers: [AppController],
+ *   providers: [AppService]
+ * })
+ * class AppModule {}
+ *
+ * const app = await HonoDiFactory.create(AppModule);
+ * ```
+ *
+ * @example
+ * With custom Hono instance:
+ * ```typescript
+ * const hono = new Hono();
+ * const app = await HonoDiFactory.create(AppModule, hono);
+ * ```
+ *
+ * @example
+ * With manual initialization:
+ * ```typescript
+ * const app = await HonoDiFactory.create(AppModule, { autoInit: false });
+ * app.setGlobalPrefix('api/v1');
+ * await app.init();
+ * ```
+ *
+ * @public
+ */
+declare class HonoDiFactory {
+    private static logger;
+    /**
+     * Creates and bootstraps a Hono DI application
+     *
+     * @param rootModule - The root module class decorated with @Module
+     * @param appOrOptions - Optional Hono instance or configuration options
+     * @param appOrOptions.app - Custom Hono instance to use
+     * @param appOrOptions.autoInit - Whether to automatically initialize the app (default: true)
+     *
+     * @returns Promise resolving to the initialized application instance
+     *
+     * @throws {Error} If module scanning fails
+     * @throws {Error} If circular dependencies are detected
+     * @throws {Error} If required dependencies cannot be resolved
+     *
+     * @remarks
+     * The creation process includes:
+     * 1. Module scanning and dependency graph building
+     * 2. Scope bubbling optimization (REQUEST-scoped propagation)
+     * 3. Singleton provider instantiation
+     * 4. Lifecycle hook execution (OnModuleInit, OnApplicationBootstrap)
+     * 5. Route registration and middleware setup
+     *
+     * @public
+     */
+    static create(rootModule: any, appOrOptions?: Hono | {
+        app?: Hono;
+        autoInit?: boolean;
+    }): Promise<IApplication>;
+    private static applyScopeBubbling;
+    private static instantiateProviders;
+    private static callLifecycleHook;
+}
+
+declare class ContextId {
+    readonly id: string;
+    constructor();
+}
+
+declare class InstanceWrapper<T = any> {
+    readonly id: string;
+    readonly token: InjectionToken;
+    readonly name?: string;
+    metatype?: Type<T> | Function;
+    scope: Scope;
+    host?: Module;
+    inject?: InjectionToken[];
+    isOptional?: boolean[];
+    properties?: {
+        key: string | symbol;
+        token: InjectionToken;
+        isOptional?: boolean;
+    }[];
+    instance?: T;
+    private readonly instancesPerContext;
+    isResolved: boolean;
+    isPending: boolean;
+    isAlias: boolean;
+    useFactory?: Function;
+    useValue?: any;
+    useExisting?: any;
+    constructor(metadata: Partial<InstanceWrapper<T>> & {
+        token: InjectionToken;
+    });
+    getInstanceByContextId(contextId: ContextId): T | undefined;
+    setInstanceByContextId(contextId: ContextId, instance: T): void;
+    addCtorMetadata(index: number, token: InjectionToken): void;
+    cleanup(contextId?: ContextId): void;
+}
+
+declare class Module {
+    readonly metatype: Type<any>;
+    readonly token: string;
+    private readonly _providers;
+    private readonly _imports;
+    private readonly _exports;
+    private readonly _controllers;
+    constructor(metatype: Type<any>, token: string);
+    get providers(): Map<InjectionToken, InstanceWrapper<any>>;
+    get imports(): Set<Module>;
+    get exports(): Set<InjectionToken>;
+    get controllers(): Map<InjectionToken, InstanceWrapper<any>>;
+    addProvider(provider: InstanceWrapper): void;
+    addController(controller: InstanceWrapper): void;
+    addImport(module: Module): void;
+    addExport(token: InjectionToken): void;
+    hasProvider(token: InjectionToken): boolean;
+    getProvider(token: InjectionToken): InstanceWrapper | undefined;
+}
+
+declare class Container {
+    private readonly modules;
+    private readonly globalModules;
+    addModule(moduleMeta: Type<any>, token: string): Module;
+    addGlobalModule(module: Module): void;
+    getGlobalModules(): Set<Module>;
+    getModuleByToken(token: string): Module | undefined;
+    getModules(): Map<string, Module>;
+}
+
+declare class Injector {
+    private readonly container?;
+    constructor(container?: Container | undefined);
+    resolveConstructorParams<T>(wrapper: InstanceWrapper<T>, module: Module, inject: InjectionToken[], callback: (args: any[]) => void, // not used directly in this async flow but kept for structure if needed
+    contextId?: ContextId, inquire?: InstanceWrapper[], parentInquire?: InstanceWrapper[]): Promise<any[]>;
+    resolveSingleParam<T>(token: InjectionToken, targetModule: Module, contextId: ContextId, inquire: InstanceWrapper[], isOptional?: boolean): Promise<T | undefined>;
+    private lookupProvider;
+    loadInstance<T>(wrapper: InstanceWrapper<T>, contextId: ContextId, inquire?: InstanceWrapper[]): Promise<T>;
+}
+
+declare class Scanner {
+    private readonly container;
+    constructor(container: Container);
+    private readonly logger;
+    scan(module: Type<any>): Promise<void>;
+    private scanModule;
+    private insertProvider;
+    private insertController;
+    scanDependencies(wrapper: InstanceWrapper): void;
+}
+
+declare abstract class ModuleRef {
+    abstract get<TInput = any, TResult = TInput>(typeOrToken: Type<TInput> | string | symbol, options?: {
+        strict: boolean;
+    }): TResult;
+    abstract resolve<TInput = any, TResult = TInput>(typeOrToken: Type<TInput> | string | symbol, contextId?: ContextId, options?: {
+        strict: boolean;
+    }): Promise<TResult>;
+    abstract create<TInput = any>(type: Type<TInput>, contextId?: ContextId): Promise<TInput>;
+}
+declare class ModuleRefImpl extends ModuleRef {
+    private readonly container;
+    private readonly injector;
+    private readonly moduleRef;
+    constructor(container: Container, injector: Injector, moduleRef: Module);
+    get<TInput = any, TResult = TInput>(typeOrToken: Type<TInput> | string | symbol, options?: {
+        strict: boolean;
+    }): TResult;
+    resolve<TInput = any, TResult = TInput>(typeOrToken: Type<TInput> | string | symbol, contextId?: ContextId, options?: {
+        strict: boolean;
+    }): Promise<TResult>;
+    create<TInput = any>(type: Type<TInput>, contextId?: ContextId): Promise<TInput>;
+}
+
+/**
+ * The main application class for Hono DI
+ *
+ * @remarks
+ * This class manages the application lifecycle, route registration, middleware,
+ * and dependency injection container. It wraps a Hono instance and adds DI capabilities.
+ *
+ * @example
+ * ```typescript
+ * const app = await HonoDiFactory.create(AppModule);
+ * app.useGlobalGuards(new AuthGuard());
+ * app.setGlobalPrefix('api');
+ * await app.listen({ port: 3000 });
+ * ```
+ *
+ * @public
+ */
+declare class Application implements IApplication {
+    private readonly app;
+    private readonly container;
+    private readonly injector;
+    private globalFilters;
+    private globalPipes;
+    private globalGuards;
+    private globalInterceptors;
+    private readonly scanner;
+    private readonly contextManager;
+    private readonly lifecycleManager;
+    private readonly argumentResolver;
+    private readonly exceptionHandler;
+    private readonly middlewareHandler;
+    private readonly UNSAFE_PROPERTIES;
+    private readonly routeCache;
+    constructor(app: Hono, container: Container, injector: Injector);
+    /**
+     * Registers global exception filters
+     *
+     * @param filters - Exception filter instances or classes
+     * @returns This application instance for chaining
+     *
+     * @example
+     * ```typescript
+     * app.useGlobalFilters(new HttpExceptionFilter());
+     * ```
+     *
+     * @public
+     */
+    useGlobalFilters(...filters: ExceptionFilter[]): this;
+    /**
+     * Registers global pipes for request transformation/validation
+     *
+     * @param pipes - Pipe instances or classes
+     * @returns This application instance for chaining
+     *
+     * @example
+     * ```typescript
+     * app.useGlobalPipes(new ValidationPipe());
+     * ```
+     *
+     * @public
+     */
+    useGlobalPipes(...pipes: PipeTransform[]): this;
+    /**
+     * Registers global interceptors for request/response manipulation
+     *
+     * @param interceptors - Interceptor instances or classes
+     * @returns This application instance for chaining
+     *
+     * @example
+     * ```typescript
+     * app.useGlobalInterceptors(new LoggingInterceptor());
+     * ```
+     *
+     * @public
+     */
+    useGlobalInterceptors(...interceptors: Interceptor[]): this;
+    /**
+     * Registers global guards for route protection
+     *
+     * @param guards - Guard instances or classes
+     * @returns This application instance for chaining
+     *
+     * @example
+     * ```typescript
+     * app.useGlobalGuards(new AuthGuard());
+     * ```
+     *
+     * @public
+     */
+    useGlobalGuards(...guards: CanActivate[]): this;
+    private globalPrefix;
+    /**
+     * Sets a global prefix for all routes
+     *
+     * @param prefix - URL prefix (e.g., 'api' or 'api/v1')
+     * @returns This application instance for chaining
+     *
+     * @remarks
+     * Must be called before init() if using autoInit: true.
+     * Use autoInit: false in HonoDiFactory.create() to set prefix before initialization.
+     *
+     * @example
+     * ```typescript
+     * app.setGlobalPrefix('api/v1');
+     * // All routes will be prefixed with /api/v1
+     * ```
+     *
+     * @public
+     */
+    setGlobalPrefix(prefix: string): this;
+    getGlobalPrefix(): string;
+    private readonly logger;
+    private isInitialized;
+    /**
+     * Initializes the application by registering all routes and middleware
+     *
+     * @returns Promise resolving to this application instance
+     *
+     * @remarks
+     * Called automatically unless autoInit: false is specified in HonoDiFactory.create().
+     * Handles:
+     * - Middleware registration
+     * - Controller and route registration
+     * - Lifecycle hook execution (OnApplicationBootstrap)
+     *
+     * @public
+     */
+    init(): Promise<this>;
+    listen(port: number | string, callback?: () => void): Promise<any>;
+    private callLifecycleHook;
+    private registerControllersFromContainer;
+    private registerControllerRoutes;
+    private resolveContextItems;
+    private resolveArgs;
+    private runGuards;
+    private resolveArgsFromCache;
+    private initializeMiddleware;
+    private isRouteMatch;
+    private isRouteExcluded;
+    private combinePaths;
+    getHttpAdapter(): any;
+    get<TInput = any, TResult = TInput>(typeOrToken: Type<TInput> | string | symbol, options?: {
+        strict?: boolean;
+    }): TResult;
+    close(): Promise<void>;
+    private cleanupContext;
+    getGlobalFilters(): ExceptionFilter<any>[];
+    getGlobalPipes(): PipeTransform<any, any>[];
+    getGlobalGuards(): CanActivate[];
+    getGlobalInterceptors(): Interceptor<any, any>[];
+    getContainer(): Container;
+}
+
+declare function forwardRef(fn: () => Type<any>): ForwardReference;
+
+declare class ExecutionContextHost implements ExecutionContext {
+    private readonly args;
+    private readonly constructorRef;
+    private readonly handler;
+    private readonly context;
+    private readonly next?;
+    constructor(args: any[], constructorRef: Type<any>, handler: Function);
+    getClass<T = any>(): Type<T>;
+    getHandler(): Function;
+    getArgs<T extends Array<any> = any[]>(): T;
+    getType<TContext extends string = 'http'>(): TContext;
+    switchToHttp(): HttpArgumentsHost;
+}
+
+declare class MiddlewareBuilder implements MiddlewareConsumer {
+    private readonly module?;
+    private readonly configs;
+    constructor(module?: Module | undefined);
+    apply(...middleware: (Type<any> | Function)[]): MiddlewareConfigProxy;
+    addConfig(middleware: any[], routes: (string | Type<any> | RouteInfo)[], excludes?: (string | RouteInfo)[]): void;
+    getConfigs(): MiddlewareConfig[];
+}
+interface MiddlewareConfig {
+    middleware: any[];
+    routes: (string | Type<any> | RouteInfo)[];
+    excludes: (string | RouteInfo)[];
+    module?: Module;
+}
+
+interface ILogger {
+    info(message: string, ...meta: any[]): void;
+    error(message: string, ...meta: any[]): void;
+    warn(message: string, ...meta: any[]): void;
+    debug(message: string, ...meta: any[]): void;
+}
 
 declare class Logger implements ILogger {
     private static lastTimestamp?;
@@ -27,6 +424,122 @@ declare class Logger implements ILogger {
     private static getColorByLevel;
 }
 
+declare class Reflector {
+    get<TResult = any, TKey = any>(metadataKey: TKey, target: Type<any> | Function): TResult;
+    getAllAndOverride<TResult = any, TKey = any>(metadataKey: TKey, targets: (Type<any> | Function)[]): TResult;
+    getAllAndMerge<TResult = any[], TKey = any>(metadataKey: TKey, targets: (Type<any> | Function)[]): TResult;
+}
+
+declare class HttpException extends Error {
+    private readonly response;
+    private readonly status;
+    constructor(response: string | object, status: number);
+    getResponse(): string | object;
+    getStatus(): number;
+    static createBody(message: object | string | any, error: string, statusCode: number): any;
+}
+
+declare class BadRequestException extends HttpException {
+    constructor(message?: string | object | any, error?: string);
+}
+declare class UnauthorizedException extends HttpException {
+    constructor(message?: string | object | any, error?: string);
+}
+declare class NotFoundException extends HttpException {
+    constructor(message?: string | object | any, error?: string);
+}
+declare class ForbiddenException extends HttpException {
+    constructor(message?: string | object | any, error?: string);
+}
+declare class NotAcceptableException extends HttpException {
+    constructor(message?: string | object | any, error?: string);
+}
+declare class RequestTimeoutException extends HttpException {
+    constructor(message?: string | object | any, error?: string);
+}
+declare class ConflictException extends HttpException {
+    constructor(message?: string | object | any, error?: string);
+}
+declare class GoneException extends HttpException {
+    constructor(message?: string | object | any, error?: string);
+}
+declare class PayloadTooLargeException extends HttpException {
+    constructor(message?: string | object | any, error?: string);
+}
+declare class UnsupportedMediaTypeException extends HttpException {
+    constructor(message?: string | object | any, error?: string);
+}
+declare class UnprocessableEntityException extends HttpException {
+    constructor(message?: string | object | any, error?: string);
+}
+declare class InternalServerErrorException extends HttpException {
+    constructor(message?: string | object | any, error?: string);
+}
+declare class NotImplementedException extends HttpException {
+    constructor(message?: string | object | any, error?: string);
+}
+declare class BadGatewayException extends HttpException {
+    constructor(message?: string | object | any, error?: string);
+}
+declare class ServiceUnavailableException extends HttpException {
+    constructor(message?: string | object | any, error?: string);
+}
+declare class GatewayTimeoutException extends HttpException {
+    constructor(message?: string | object | any, error?: string);
+}
+
+declare class ParseIntPipe implements PipeTransform<string, number> {
+    transform(value: string, metadata: ArgumentMetadata): number;
+}
+declare class ParseFloatPipe implements PipeTransform<string, number> {
+    transform(value: string, metadata: ArgumentMetadata): number;
+}
+declare class ParseBoolPipe implements PipeTransform<string | boolean, boolean> {
+    transform(value: string | boolean, metadata: ArgumentMetadata): boolean;
+}
+declare class ValidationPipe implements PipeTransform<any> {
+    transform(value: any, metadata: ArgumentMetadata): any;
+}
+
+declare class AppError extends Error {
+    statusCode: number;
+    message: string;
+    isOperational: boolean;
+    constructor(statusCode: number, message: string, isOperational?: boolean);
+}
+declare class NotFoundError extends AppError {
+    constructor(message?: string);
+}
+declare class BadRequestError extends AppError {
+    constructor(message?: string);
+}
+declare class UnauthorizedError extends AppError {
+    constructor(message?: string);
+}
+declare class ForbiddenError extends AppError {
+    constructor(message?: string);
+}
+declare class ConflictError extends AppError {
+    constructor(message?: string);
+}
+
+declare class BaseExceptionFilter implements ExceptionFilter {
+    catch(exception: unknown, host: ArgumentsHost): (Response & hono.TypedResponse<string, hono_utils_http_status.ContentfulStatusCode, "json">) | (Response & hono.TypedResponse<{
+        statusCode: number;
+        message: string;
+        cause: string;
+    }, hono_utils_http_status.ContentfulStatusCode, "json">) | (Response & hono.TypedResponse<{
+        statusCode: number;
+        message: string;
+        error: string;
+    }, hono_utils_http_status.ContentfulStatusCode, "json">);
+}
+
+/**
+ * @module @hono-di/core
+ * Main entry point for Hono DI framework
+ */
+
 declare const HonoDi: typeof HonoDiFactory;
 
-export { HonoDi, HonoDiFactory, ILogger, Logger };
+export { AppError, Application, ArgumentMetadata, ArgumentsHost, BadGatewayException, BadRequestError, BadRequestException, BaseExceptionFilter, CanActivate, ConflictError, ConflictException, Container, ExceptionFilter, ExecutionContext, ExecutionContextHost, ForbiddenError, ForbiddenException, ForwardReference, GatewayTimeoutException, GoneException, HonoDi, HonoDiFactory, HttpArgumentsHost, HttpException, IApplication, type ILogger, InjectionToken, Interceptor, InternalServerErrorException, Logger, METADATA_KEYS, MiddlewareBuilder, type MiddlewareConfig, MiddlewareConfigProxy, MiddlewareConsumer, ModuleRef, ModuleRefImpl, NotAcceptableException, NotFoundError, NotFoundException, NotImplementedException, ParseBoolPipe, ParseFloatPipe, ParseIntPipe, PayloadTooLargeException, PipeTransform, Reflector, RequestTimeoutException, RouteInfo, Scanner, Scope, ServiceUnavailableException, Type, UnauthorizedError, UnauthorizedException, UnprocessableEntityException, UnsupportedMediaTypeException, ValidationPipe, forwardRef };