@kanjijs/core 0.2.0-beta.3 → 0.2.0-beta.30

package/README.md

@@ -14,8 +14,10 @@ It provides the decorators used to define APIs and the internal storage mechanis
 - **`@Use(...middlewares)`**: Registers Hono-compatible middleware for a route or controller.
 - **`@Module({ ... })`**: Defines a module with `imports`, `controllers`, and `providers`.
 - **`@Inject(token)`**: Token-based dependency injection.
+- **`@Body()`, `@Query()`, `@Param()`, `@Headers()`**: Parameter decorators for fine-grained metadata (used by platform adapters).
 
 ### Request Context (AsyncLocalStorage)
+
 Kanjijs Core includes a built-in `kanjijsContext` (based on Node.js AsyncLocalStorage) to track request state globally without prop drilling. It enables access to `requestId` anywhere in the stack.
 
 ```typescript
@@ -24,8 +26,11 @@ const reqId = getRequestId();
 ```
 
 ### Dependency Injection
+
 **KanjijsIoC**: A lightweight, platform-agnostic IoC container embedded in Core. It handles singleton resolution and dependency injection for your modules and controllers.
 
+**Strict Mode Compatible**: The DI container now supports strict Token typing (`Token<T>`) and robustly handles `Function` vs `Constructor` type narrowing, ensuring compatibility with strict TypeScript configurations (`strict: true`).
+
 ### Metadata Storage
 
 We use a `WeakMap`-based `MetadataStorage` singleton to keep the memory footprint minimal and ensure metadata is garbage collected if the controller class is no longer referenced.
@@ -39,8 +44,8 @@ const routes = MetadataStorage.getRoutes(ControllerClass.prototype);
 
 Kanjijs Core defines the standard exceptions used across the framework.
 
--   **`HttpException`**: Base class for HTTP errors.
--   **`ExceptionFilter`**: Interface for implementing custom exception filters.
+- **`HttpException`**: Base class for HTTP errors.
+- **`ExceptionFilter`**: Interface for implementing custom exception filters.
 
 ```typescript
 import { HttpException } from "@kanjijs/core";

package/dist/context.d.ts

@@ -0,0 +1,8 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+export interface RequestContext {
+    requestId: string;
+    [key: string]// biome-ignore lint/suspicious/noExplicitAny: Suppressed
+: any;
+}
+export declare const kanjijsContext: AsyncLocalStorage<RequestContext>;
+export declare function getRequestId(): string | undefined;

package/dist/contracts/src/index.d.ts

@@ -0,0 +1,27 @@
+export type SchemaLike = unknown;
+export interface ContractRequestSpec<T = SchemaLike> {
+    params?: T;
+    query?: T;
+    headers?: T;
+    cookies?: T;
+    body?: T;
+}
+export interface ContractResponseSpec<T = SchemaLike> {
+    [status: number]: T;
+}
+export interface ContractSpec<T = SchemaLike> {
+    request?: ContractRequestSpec<T>;
+    response?: ContractResponseSpec<T>;
+}
+export interface ValidatorAdapter<S = SchemaLike> {
+    parse<O = unknown>(schema: S, data: unknown): Promise<{
+        success: true;
+        data: O;
+    } | {
+        success: false;
+        issues: unknown[];
+    }>;
+}
+export declare class Contract {
+    static json<T = SchemaLike>(spec: ContractRequestSpec<T>): ContractSpec<T>;
+}

package/dist/core/src/context.d.ts

@@ -0,0 +1,7 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+export interface RequestContext {
+    requestId: string;
+    [key: string]: any;
+}
+export declare const kanjijsContext: AsyncLocalStorage<RequestContext>;
+export declare function getRequestId(): string | undefined;

package/dist/core/src/decorators.d.ts

@@ -0,0 +1,34 @@
+import type { ContractSpec } from "@kanjijs/contracts";
+import { type ModuleMetadata, type Token } from "./metadata";
+/**
+ * @Module({ controllers: [...] })
+ */
+export declare function Module(metadata: ModuleMetadata): ClassDecorator;
+/**
+ * @Contract({ ... })
+ */
+export declare function Contract(spec: ContractSpec): MethodDecorator;
+/**
+ * @Controller('/users')
+ */
+export declare function Controller(prefix?: string): ClassDecorator;
+export declare function Injectable(): ClassDecorator;
+export declare const Get: (path?: string) => MethodDecorator;
+export declare const Post: (path?: string) => MethodDecorator;
+export declare const Put: (path?: string) => MethodDecorator;
+export declare const Delete: (path?: string) => MethodDecorator;
+export declare const Patch: (path?: string) => MethodDecorator;
+/**
+ * @Inject("DATABASE_CLIENT")
+ */
+export declare function Inject(token: Token<unknown>): ParameterDecorator;
+/**
+ * @Use(middleware1, middleware2)
+ * Attaches middlewares to a controller or method.
+ */
+export declare function Use(...middlewares: unknown[]): MethodDecorator & ClassDecorator;
+export declare const Body: (data?: string) => ParameterDecorator;
+export declare const Query: (data?: string) => ParameterDecorator;
+export declare const Param: (data?: string) => ParameterDecorator;
+export declare const Headers: (data?: string) => ParameterDecorator;
+export declare const Ctx: (data?: string) => ParameterDecorator;

package/dist/core/src/di/container.d.ts

@@ -0,0 +1,26 @@
+import { type Constructor, type Token } from "../metadata";
+import "reflect-metadata";
+export declare class KanjijsIoC {
+    private static providers;
+    static register<T>(target: Constructor<T>): void;
+    static register<T>(token: Token<T>, provider: {
+        useValue?: T;
+        useClass?: Constructor<T>;
+    }): void;
+    static resolve<T>(target: Token<T>): T;
+    static clear(): void;
+}
+/**
+ * V2 STRICT CONTAINER
+ * Instance-based, no auto-registration, explicit visibility.
+ */
+export declare class Container {
+    private providers;
+    register<T>(token: Token<T>, provider: {
+        useValue?: T;
+        useClass?: Constructor<T>;
+        useFactory?: (...args: unknown[]) => T;
+        inject?: Array<Token<unknown>>;
+    }): void;
+    resolve<T>(token: Token<T>): T;
+}

package/dist/core/src/di/module-compiler.d.ts

@@ -0,0 +1,12 @@
+import { type Constructor } from "../metadata";
+import { Container } from "./container";
+export declare class ModuleCompiler {
+    private nodes;
+    private globalExportedTokens;
+    compile(rootModule: Constructor): Container;
+    private scan;
+    private processProviders;
+    private validate;
+    private checkDependencies;
+    private registerProviders;
+}

package/dist/core/src/exceptions/exception.filter.d.ts

@@ -0,0 +1,3 @@
+export interface ExceptionFilter<T = any, C = any> {
+    catch(exception: T, context: C): void | Promise<void> | any;
+}

package/dist/core/src/exceptions/http.exception.d.ts

@@ -0,0 +1,7 @@
+export declare class HttpException extends Error {
+    readonly response: string | object;
+    readonly status: number;
+    constructor(response: string | object, status: number);
+    getResponse(): string | object;
+    getStatus(): number;
+}

package/dist/core/src/index.d.ts

@@ -0,0 +1,9 @@
+export type { ContractRequestSpec, ContractResponseSpec, ContractSpec, SchemaLike, ValidatorAdapter, } from "@kanjijs/contracts";
+export * from "./context";
+export * from "./decorators";
+export * from "./di/container";
+export * from "./di/module-compiler";
+export * from "./exceptions/exception.filter";
+export * from "./exceptions/http.exception";
+export * from "./metadata";
+export declare const GLOBAL_MIDDLEWARE_TOKEN: unique symbol;

package/dist/core/src/metadata.d.ts

@@ -0,0 +1,64 @@
+import type { ContractSpec } from "@kanjijs/contracts";
+import "reflect-metadata";
+export type Constructor<T = unknown> = new (...args: unknown[]) => T;
+export type HttpMethod = "GET" | "POST" | "PUT" | "DELETE" | "PATCH";
+export type RouteParamType = "BODY" | "QUERY" | "PARAM" | "HEADERS" | "CONTEXT";
+export interface RouteParamMetadata {
+    index: number;
+    type: RouteParamType;
+    data?: string;
+}
+export interface RouteMetadata {
+    method: HttpMethod;
+    path: string;
+    contract?: ContractSpec;
+    middlewares?: unknown[];
+    params?: RouteParamMetadata[];
+}
+export interface ControllerMetadata {
+    prefix: string;
+    middlewares?: unknown[];
+}
+export type Token<T = unknown> = string | symbol | Constructor<T>;
+export type Provider<T = unknown> = Constructor<T> | {
+    provide: Token<T>;
+    useValue: T;
+} | {
+    provide: Token<T>;
+    useClass: Constructor<T>;
+} | {
+    provide: Token<T>;
+    useFactory: (...args: unknown[]) => T | Promise<T>;
+    inject?: Token[];
+};
+export interface DynamicModule {
+    module: Constructor;
+    providers?: Provider[];
+    imports?: Array<Constructor | DynamicModule>;
+    exports?: Token[];
+    global?: boolean;
+}
+export interface ModuleMetadata {
+    controllers?: Constructor[];
+    providers?: Provider[];
+    imports?: Array<Constructor | DynamicModule>;
+    exports?: Token[];
+    global?: boolean;
+}
+export interface IMetadataStorage {
+    addRoute(target: object, methodName: string, meta: RouteMetadata): void;
+    addContract(target: object, methodName: string, contract: ContractSpec): void;
+    addMiddleware(target: object, middleware: unknown, methodName?: string): void;
+    getRoutes(target: object): Map<string, RouteMetadata> | undefined;
+    setController(target: object, meta: ControllerMetadata): void;
+    getController(target: object): ControllerMetadata | undefined;
+    defineModule(target: object, meta: ModuleMetadata): void;
+    getModule(target: object): ModuleMetadata | undefined;
+    addInjection(target: object, index: number, token: Token<unknown>): void;
+    getInjections(target: object): Map<number, Token<unknown>> | undefined;
+    addRouteParam(target: object, methodName: string, param: RouteParamMetadata): void;
+}
+declare global {
+    var KANJI_METADATA_STORAGE: IMetadataStorage | undefined;
+}
+export declare const MetadataStorage: IMetadataStorage;

package/dist/decorators.d.ts

@@ -0,0 +1,36 @@
+import type { ContractSpec } from "@kanjijs/contracts";
+import { type ModuleMetadata } from "./metadata";
+/**
+ * @Module({ controllers: [...] })
+ */
+export declare function Module(metadata: ModuleMetadata): ClassDecorator;
+/**
+ * @Contract({ ... })
+ */
+export declare function Contract(spec: ContractSpec): MethodDecorator;
+/**
+ * @Controller('/users')
+ */
+export declare function Controller(prefix?: string): ClassDecorator;
+export declare function Injectable(): ClassDecorator;
+export declare const Get: (path?: string) => MethodDecorator;
+export declare const Post: (path?: string) => MethodDecorator;
+export declare const Put: (path?: string) => MethodDecorator;
+export declare const Delete: (path?: string) => MethodDecorator;
+export declare const Patch: (path?: string) => MethodDecorator;
+/**
+ * @Inject("DATABASE_CLIENT")
+ */
+export declare function Inject(token// biome-ignore lint/suspicious/noExplicitAny: Suppressed
+: any): ParameterDecorator;
+/**
+ * @Use(middleware1, middleware2)
+ * Attaches middlewares to a controller or method.
+ */
+export declare function Use(...middlewares// biome-ignore lint/suspicious/noExplicitAny: Suppressed
+: any[]): MethodDecorator & ClassDecorator;
+export declare const Body: (data?: string) => ParameterDecorator;
+export declare const Query: (data?: string) => ParameterDecorator;
+export declare const Param: (data?: string) => ParameterDecorator;
+export declare const Headers: (data?: string) => ParameterDecorator;
+export declare const Ctx: (data?: string) => ParameterDecorator;

package/dist/di/container.d.ts

@@ -0,0 +1,31 @@
+import { type Constructor } from "../metadata";
+import "reflect-metadata";
+export declare class KanjijsIoC {
+    private static providers;
+    static register<T>(target: Constructor<T>): void;
+    static register(token// biome-ignore lint/suspicious/noExplicitAny: Suppressed
+: any, provider: {
+        useValue?// biome-ignore lint/suspicious/noExplicitAny: Suppressed
+: any;
+        useClass?: Constructor;
+    }): void;
+    static resolve<T>(target: Constructor<T> | any): T;
+    static clear(): void;
+}
+/**
+ * V2 STRICT CONTAINER
+ * Instance-based, no auto-registration, explicit visibility.
+ */
+export declare class Container {
+    private providers;
+    register(token// biome-ignore lint/suspicious/noExplicitAny: Suppressed
+: any, provider: {
+        useValue?// biome-ignore lint/suspicious/noExplicitAny: Suppressed
+: any;
+        useClass?: Constructor;
+        useFactory?: Function;
+        inject?// biome-ignore lint/suspicious/noExplicitAny: Suppressed
+: any[];
+    }): void;
+    resolve<T>(token: Constructor<T> | any): T;
+}

package/dist/di/module-compiler.d.ts

@@ -0,0 +1,11 @@
+import { type Constructor } from "../metadata";
+import { Container } from "./container";
+export declare class ModuleCompiler {
+    private nodes;
+    private globalExportedTokens;
+    compile(rootModule: Constructor): Container;
+    private scan;
+    private processProviders;
+    private validate;
+    private checkDependencies;
+}

package/dist/exceptions/exception.filter.d.ts

@@ -0,0 +1,3 @@
+export interface ExceptionFilter<T = any, C = any> {
+    catch(exception: T, context: C): void | Promise<void> | any;
+}

package/dist/exceptions/http.exception.d.ts

@@ -0,0 +1,7 @@
+export declare class HttpException extends Error {
+    readonly response: string | object;
+    readonly status: number;
+    constructor(response: string | object, status: number);
+    getResponse(): string | object;
+    getStatus(): number;
+}

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+export * from "./decorators";
+export * from "./metadata";
+export * from "./di/container";
+export * from "./context";
+export * from "./exceptions/http.exception";
+export * from "./exceptions/exception.filter";
+export * from "./di/module-compiler";
+export * from "@kanjijs/contracts";
+export declare const GLOBAL_MIDDLEWARE_TOKEN: unique symbol;

package/dist/index.js

@@ -1013,75 +1013,95 @@ var require_Reflect = __commonJS(() => {
   })(Reflect2 || (Reflect2 = {}));
 });
 
+// src/context.ts
+import { AsyncLocalStorage } from "async_hooks";
+var kanjijsContext = new AsyncLocalStorage;
+function getRequestId() {
+  return kanjijsContext.getStore()?.requestId;
+}
 // src/metadata.ts
 var import_reflect_metadata = __toESM(require_Reflect(), 1);
 var methodMetadataStore = new WeakMap;
 var controllerMetadataStore = new WeakMap;
 var moduleMetadataStore = new WeakMap;
 var injectionMetadataStore = new WeakMap;
-var MetadataStorage = {
-  addRoute(target, methodName, meta) {
-    let methods = methodMetadataStore.get(target);
-    if (!methods) {
-      methods = new Map;
-      methodMetadataStore.set(target, methods);
-    }
-    const existing = methods.get(methodName) || {};
-    methods.set(methodName, { ...existing, ...meta });
-  },
-  addContract(target, methodName, contract) {
-    let methods = methodMetadataStore.get(target);
-    if (!methods) {
-      methods = new Map;
-      methodMetadataStore.set(target, methods);
-    }
-    const existing = methods.get(methodName) || {};
-    existing.contract = contract;
-    methods.set(methodName, existing);
-  },
-  addMiddleware(target, middleware, methodName) {
-    if (methodName) {
+var globalStore = globalThis;
+if (!globalStore.KANJI_METADATA_STORAGE) {
+  globalStore.KANJI_METADATA_STORAGE = {
+    addRoute(target, methodName, meta) {
       let methods = methodMetadataStore.get(target);
       if (!methods) {
         methods = new Map;
         methodMetadataStore.set(target, methods);
       }
       const existing = methods.get(methodName) || {};
-      existing.middlewares = [...existing.middlewares || [], middleware];
+      methods.set(methodName, { ...existing, ...meta });
+    },
+    addContract(target, methodName, contract) {
+      let methods = methodMetadataStore.get(target);
+      if (!methods) {
+        methods = new Map;
+        methodMetadataStore.set(target, methods);
+      }
+      const existing = methods.get(methodName) || {};
+      existing.contract = contract;
       methods.set(methodName, existing);
-    } else {
-      const existing = controllerMetadataStore.get(target) || { prefix: "/" };
-      existing.middlewares = [...existing.middlewares || [], middleware];
-      controllerMetadataStore.set(target, existing);
-    }
-  },
-  getRoutes(target) {
-    return methodMetadataStore.get(target);
-  },
-  setController(target, meta) {
-    controllerMetadataStore.set(target, meta);
-  },
-  getController(target) {
-    return controllerMetadataStore.get(target);
-  },
-  defineModule(target, meta) {
-    moduleMetadataStore.set(target, meta);
-  },
-  getModule(target) {
-    return moduleMetadataStore.get(target);
-  },
-  addInjection(target, index, token) {
-    let injections = injectionMetadataStore.get(target);
-    if (!injections) {
-      injections = new Map;
-      injectionMetadataStore.set(target, injections);
+    },
+    addRouteParam(target, methodName, param) {
+      let methods = methodMetadataStore.get(target);
+      if (!methods) {
+        methods = new Map;
+        methodMetadataStore.set(target, methods);
+      }
+      const existing = methods.get(methodName) || {};
+      existing.params = [...existing.params || [], param];
+      methods.set(methodName, existing);
+    },
+    addMiddleware(target, middleware, methodName) {
+      if (methodName) {
+        let methods = methodMetadataStore.get(target);
+        if (!methods) {
+          methods = new Map;
+          methodMetadataStore.set(target, methods);
+        }
+        const existing = methods.get(methodName) || {};
+        existing.middlewares = [...existing.middlewares || [], middleware];
+        methods.set(methodName, existing);
+      } else {
+        const existing = controllerMetadataStore.get(target) || { prefix: "/" };
+        existing.middlewares = [...existing.middlewares || [], middleware];
+        controllerMetadataStore.set(target, existing);
+      }
+    },
+    getRoutes(target) {
+      return methodMetadataStore.get(target);
+    },
+    setController(target, meta) {
+      controllerMetadataStore.set(target, meta);
+    },
+    getController(target) {
+      return controllerMetadataStore.get(target);
+    },
+    defineModule(target, meta) {
+      moduleMetadataStore.set(target, meta);
+    },
+    getModule(target) {
+      return moduleMetadataStore.get(target);
+    },
+    addInjection(target, index, token) {
+      let injections = injectionMetadataStore.get(target);
+      if (!injections) {
+        injections = new Map;
+        injectionMetadataStore.set(target, injections);
+      }
+      injections.set(index, token);
+    },
+    getInjections(target) {
+      return injectionMetadataStore.get(target);
     }
-    injections.set(index, token);
-  },
-  getInjections(target) {
-    return injectionMetadataStore.get(target);
-  }
-};
+  };
+}
+var MetadataStorage = globalStore.KANJI_METADATA_STORAGE;
 
 // src/decorators.ts
 function Module(metadata) {
@@ -1100,7 +1120,7 @@ function Controller(prefix = "") {
   };
 }
 function Injectable() {
-  return (target) => {};
+  return (_target) => {};
 }
 function createMethodDecorator(method) {
   return (path = "/") => {
@@ -1118,12 +1138,12 @@ var Put = createMethodDecorator("PUT");
 var Delete = createMethodDecorator("DELETE");
 var Patch = createMethodDecorator("PATCH");
 function Inject(token) {
-  return (target, propertyKey, parameterIndex) => {
+  return (target, _propertyKey, parameterIndex) => {
     MetadataStorage.addInjection(target, parameterIndex, token);
   };
 }
 function Use(...middlewares) {
-  return (target, propertyKey, descriptor) => {
+  return (target, propertyKey, _descriptor) => {
     if (propertyKey) {
       for (const m of middlewares) {
         MetadataStorage.addMiddleware(target, m, propertyKey);
@@ -1135,6 +1155,24 @@ function Use(...middlewares) {
     }
   };
 }
+function createParamDecorator(type) {
+  return (data) => {
+    return (target, propertyKey, parameterIndex) => {
+      if (propertyKey) {
+        MetadataStorage.addRouteParam(target, propertyKey, {
+          index: parameterIndex,
+          type,
+          data
+        });
+      }
+    };
+  };
+}
+var Body = createParamDecorator("BODY");
+var Query = createParamDecorator("QUERY");
+var Param = createParamDecorator("PARAM");
+var Headers = createParamDecorator("HEADERS");
+var Ctx = createParamDecorator("CONTEXT");
 // src/di/container.ts
 var import_reflect_metadata2 = __toESM(require_Reflect(), 1);
 
@@ -1143,43 +1181,48 @@ class KanjijsIoC {
   static register(tokenOrTarget, provider) {
     if (provider) {
       if ("useValue" in provider) {
-        this.providers.set(tokenOrTarget, { useValue: provider.useValue });
+        KanjijsIoC.providers.set(tokenOrTarget, { useValue: provider.useValue });
       } else if ("useClass" in provider) {
-        this.providers.set(tokenOrTarget, { useClass: provider.useClass });
+        KanjijsIoC.providers.set(tokenOrTarget, { useClass: provider.useClass });
       }
     } else {
-      this.providers.set(tokenOrTarget, { useClass: tokenOrTarget });
+      KanjijsIoC.providers.set(tokenOrTarget, {
+        useClass: tokenOrTarget
+      });
     }
   }
   static resolve(target) {
-    let provider = this.providers.get(target);
+    let provider = KanjijsIoC.providers.get(target);
     if (!provider && typeof target === "function") {
       provider = { useClass: target };
-      this.providers.set(target, provider);
+      KanjijsIoC.providers.set(target, provider);
     }
     if (!provider) {
-      throw new Error(`Provider not found for token: ${target?.name || target}`);
+      const targetName2 = typeof target === "function" ? target.name ?? "anonymous" : String(target);
+      throw new Error(`Provider not found for token: ${targetName2}`);
     }
     if (provider.instance) {
       return provider.instance;
     }
-    console.log(`[DI] Creating NEW instance for ${target?.name || String(target)}`);
+    const targetName = typeof target === "function" ? target.name ?? "anonymous" : String(target);
+    console.log(`[DI] Creating NEW instance for ${targetName}`);
     if (provider.useValue !== undefined) {
       provider.instance = provider.useValue;
     } else if (provider.useClass) {
       const ConcreteClass = provider.useClass;
       const paramTypes = Reflect.getMetadata("design:paramtypes", ConcreteClass) || [];
       const injectionTokens = MetadataStorage.getInjections(ConcreteClass) || new Map;
-      const injections = paramTypes.map((token, index) => {
+      const injections = paramTypes.map((paramToken, index) => {
         const overrideToken = injectionTokens.get(index);
-        return KanjijsIoC.resolve(overrideToken || token);
+        const resolvedToken = overrideToken || paramToken;
+        return KanjijsIoC.resolve(resolvedToken);
       });
       provider.instance = new ConcreteClass(...injections);
     }
     return provider.instance;
   }
   static clear() {
-    this.providers.clear();
+    KanjijsIoC.providers.clear();
   }
 }
 
@@ -1191,7 +1234,8 @@ class Container {
   resolve(token) {
     const provider = this.providers.get(token);
     if (!provider) {
-      throw new Error(`[DI] Provider not found for token: ${token?.name || String(token)}`);
+      const tokenName = typeof token === "function" ? token.name ?? "anonymous" : String(token);
+      throw new Error(`[DI] Provider not found for token: ${tokenName}`);
     }
     if (provider.instance) {
       return provider.instance;
@@ -1204,7 +1248,8 @@ class Container {
       const injectionTokens = MetadataStorage.getInjections(ConcreteClass) || new Map;
       const injections = paramTypes.map((paramToken, index) => {
         const overrideToken = injectionTokens.get(index);
-        return this.resolve(overrideToken || paramToken);
+        const resolvedToken = overrideToken || paramToken;
+        return this.resolve(resolvedToken);
       });
       provider.instance = new ConcreteClass(...injections);
     } else if (provider.useFactory) {
@@ -1214,29 +1259,6 @@ class Container {
     return provider.instance;
   }
 }
-// src/context.ts
-import { AsyncLocalStorage } from "async_hooks";
-var kanjijsContext = new AsyncLocalStorage;
-function getRequestId() {
-  return kanjijsContext.getStore()?.requestId;
-}
-// src/exceptions/http.exception.ts
-class HttpException extends Error {
-  response;
-  status;
-  constructor(response, status) {
-    super(typeof response === "string" ? response : JSON.stringify(response));
-    this.response = response;
-    this.status = status;
-    this.name = "HttpException";
-  }
-  getResponse() {
-    return this.response;
-  }
-  getStatus() {
-    return this.status;
-  }
-}
 // src/di/module-compiler.ts
 class ModuleCompiler {
   nodes = new Map;
@@ -1245,11 +1267,11 @@ class ModuleCompiler {
     this.scan(rootModule);
     this.validate();
     const container = new Container;
-    for (const node of this.nodes.values()) {
-      for (const [token, provider] of node.providers) {
-        container.register(token, provider);
-      }
+    const rootNode = this.nodes.get(rootModule);
+    if (!rootNode) {
+      return container;
     }
+    this.registerProviders(rootNode, container, new Set);
     return container;
   }
   scan(target) {
@@ -1266,20 +1288,20 @@ class ModuleCompiler {
     };
     this.nodes.set(moduleClass, node);
     const meta = MetadataStorage.getModule(moduleClass) || {};
-    const dynamicMeta = "module" in target ? target : {};
-    const allProviders = [...meta.providers || [], ...dynamicMeta.providers || []];
+    const dynamicMeta = "module" in target ? target : undefined;
+    const allProviders = [...meta.providers || [], ...dynamicMeta?.providers || []];
     this.processProviders(node, allProviders);
-    const allExports = [...meta.exports || [], ...dynamicMeta.exports || []];
+    const allExports = [...meta.exports || [], ...dynamicMeta?.exports || []];
     for (const token of allExports) {
       node.exports.add(token);
     }
-    if (meta.global || dynamicMeta.global) {
+    if (meta.global || dynamicMeta?.global) {
       node.isGlobal = true;
       for (const token of node.exports) {
         this.globalExportedTokens.add(token);
       }
     }
-    const allImports = [...meta.imports || [], ...dynamicMeta.imports || []];
+    const allImports = [...meta.imports || [], ...dynamicMeta?.imports || []];
     for (const imp of allImports) {
       const importedNode = this.scan(imp);
       node.imports.add(importedNode);
@@ -1318,7 +1340,7 @@ class ModuleCompiler {
       for (const globalToken of this.globalExportedTokens) {
         visibleTokens.add(globalToken);
       }
-      for (const [token, provider] of node.providers) {
+      for (const [_token, provider] of node.providers) {
         this.checkDependencies(provider, visibleTokens, node.module.name);
       }
     }
@@ -1331,18 +1353,50 @@ class ModuleCompiler {
       targetName = clazz.name;
       const paramTypes = Reflect.getMetadata("design:paramtypes", clazz) || [];
       const injectionTokens = MetadataStorage.getInjections(clazz) || new Map;
-      dependencies = paramTypes.map((t, i) => injectionTokens.get(i) || t);
-    } else if ("useFactory" in provider && provider.useFactory) {
-      targetName = provider.provide?.name || String(provider.provide);
+      dependencies = paramTypes.map((paramType, index) => {
+        const overrideToken = injectionTokens.get(index);
+        return overrideToken || paramType;
+      });
+    } else if ("useFactory" in provider) {
+      targetName = typeof provider.provide === "function" ? provider.provide.name ?? "anonymous" : String(provider.provide);
       dependencies = provider.inject || [];
     }
     for (const dep of dependencies) {
       if (!visibleTokens.has(dep)) {
-        const depName = dep?.name || String(dep);
+        const depName = typeof dep === "function" ? dep.name ?? "anonymous" : String(dep);
         throw new Error(`[Kanjijs] strict-di-error: Provider '${targetName}' in Module '${moduleName}' ` + `depends on '${depName}', but it is not visible. ` + `Make sure it is imported and exported by the source module.`);
       }
     }
   }
+  registerProviders(node, container, visited) {
+    if (visited.has(node))
+      return;
+    visited.add(node);
+    for (const imp of node.imports) {
+      this.registerProviders(imp, container, visited);
+    }
+    for (const [token, provider] of node.providers) {
+      const { provide: _provide, ...definition } = provider;
+      container.register(token, definition);
+    }
+  }
+}
+// src/exceptions/http.exception.ts
+class HttpException extends Error {
+  response;
+  status;
+  constructor(response, status) {
+    super(typeof response === "string" ? response : JSON.stringify(response));
+    this.response = response;
+    this.status = status;
+    this.name = "HttpException";
+  }
+  getResponse() {
+    return this.response;
+  }
+  getStatus() {
+    return this.status;
+  }
 }
 
 // src/index.ts
@@ -1351,9 +1405,11 @@ export {
   kanjijsContext,
   getRequestId,
   Use,
+  Query,
   Put,
   Post,
   Patch,
+  Param,
   ModuleCompiler,
   Module,
   MetadataStorage,
@@ -1361,10 +1417,13 @@ export {
   Injectable,
   Inject,
   HttpException,
+  Headers,
   Get,
   GLOBAL_MIDDLEWARE_TOKEN,
   Delete,
+  Ctx,
   Controller,
   Contract,
-  Container
+  Container,
+  Body
 };

package/dist/metadata.d.ts

@@ -0,0 +1,70 @@
+import type { ContractSpec } from "@kanjijs/contracts";
+import "reflect-metadata";
+export type Constructor<T = any> = new (...args// biome-ignore lint/suspicious/noExplicitAny: Suppressed
+: any[]) => T;
+export type HttpMethod = "GET" | "POST" | "PUT" | "DELETE" | "PATCH";
+export type RouteParamType = "BODY" | "QUERY" | "PARAM" | "HEADERS" | "CONTEXT";
+export interface RouteParamMetadata {
+    index: number;
+    type: RouteParamType;
+    data?: string;
+}
+export interface RouteMetadata {
+    method: HttpMethod;
+    path: string;
+    contract?: ContractSpec;
+    middlewares?// biome-ignore lint/suspicious/noExplicitAny: Suppressed
+: any[];
+    params?: RouteParamMetadata[];
+}
+export interface ControllerMetadata {
+    prefix: string;
+    middlewares?// biome-ignore lint/suspicious/noExplicitAny: Suppressed
+: any[];
+}
+export type Token<T = any> = string | symbol | Constructor<T>;
+export type Provider<T = any> = Constructor<T> | {
+    provide: Token<T>;
+    useValue: T;
+} | {
+    provide: Token<T>;
+    useClass: Constructor<T>;
+} | {
+    provide: Token<T>;
+    useFactory: (...args// biome-ignore lint/suspicious/noExplicitAny: Suppressed
+: any[]) => T | Promise<T>;
+    inject?: Token[];
+};
+export interface DynamicModule {
+    module: Constructor;
+    providers?: Provider[];
+    imports?: Array<Constructor | DynamicModule>;
+    exports?: Token[];
+    global?: boolean;
+}
+export interface ModuleMetadata {
+    controllers?: Constructor[];
+    providers?: Provider[];
+    imports?: Array<Constructor | DynamicModule>;
+    exports?: Token[];
+    global?: boolean;
+}
+export interface IMetadataStorage {
+    addRoute(target: object, methodName: string, meta: RouteMetadata): void;
+    addContract(target: object, methodName: string, contract: ContractSpec): void;
+    addMiddleware(target: object, middleware// biome-ignore lint/suspicious/noExplicitAny: Suppressed
+: any, methodName?: string): void;
+    getRoutes(target: object): Map<string, RouteMetadata> | undefined;
+    setController(target: object, meta: ControllerMetadata): void;
+    getController(target: object): ControllerMetadata | undefined;
+    defineModule(target: object, meta: ModuleMetadata): void;
+    getModule(target: object): ModuleMetadata | undefined;
+    addInjection(target: object, index: number, token// biome-ignore lint/suspicious/noExplicitAny: Suppressed
+: any): void;
+    getInjections(target: object): Map<number, any> | undefined;
+    addRouteParam(target: object, methodName: string, param: RouteParamMetadata): void;
+}
+declare global {
+    var KANJI_METADATA_STORAGE: IMetadataStorage | undefined;
+}
+export declare const MetadataStorage: IMetadataStorage;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kanjijs/core",
-  "version": "0.2.0-beta.3",
+  "version": "0.2.0-beta.30",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -10,12 +10,12 @@
     "LICENSE"
   ],
   "scripts": {
-    "build": "bun build src/index.ts --outdir dist --target bun",
+    "build": "bun build src/index.ts --outdir dist --target bun && bunx tsc --emitDeclarationOnly --declaration --outDir dist",
     "test": "bun test"
   },
   "dependencies": {
-    "@kanjijs/common": "^0.2.0-beta.3",
-    "@kanjijs/contracts": "^0.2.0-beta.3",
+    "@kanjijs/common": "^0.2.0-beta.30",
+    "@kanjijs/contracts": "^0.2.0-beta.30",
     "reflect-metadata": "^0.2.0"
   },
   "devDependencies": {