@kabyeon/nexusjs 0.6.5

package/dist/core/application.d.ts

@@ -0,0 +1,77 @@
+/**
+ * Application.
+ *
+ * The Application is the user-facing entry point: it owns the DI container,
+ * the HTTP server, and the view engine. Typical bootstrap:
+ *
+ * ```ts
+ * const app = await new Application(AppModule).bootstrap();
+ * await app.listen(3000);
+ * ```
+ *
+ * The class is intentionally small — every feature (DI, HTTP, ORM, view)
+ * is a separate concern with its own module. Application composes them.
+ */
+import "reflect-metadata";
+import { ApplicationContainer } from "./di/container.js";
+import { NexusServer, type NexusServerOptions } from "./http/server.js";
+import type { ViewAdapter } from "../view/types.js";
+import type { Type } from "./di/tokens.js";
+import { Inertia, type InertiaConfig } from "../view/inertia/index.js";
+export interface ApplicationOptions extends NexusServerOptions {
+    /** Default view adapter. Defaults to Rendu. */
+    viewAdapter?: ViewAdapter;
+    /** Inertia configuration. If supplied, `app.inertia` is initialized. */
+    inertia?: InertiaConfig;
+}
+export declare class Application {
+    readonly container: ApplicationContainer;
+    readonly server: NexusServer;
+    /** Inertia adapter (or `null` if not configured). Always defined after ctor. */
+    readonly inertia: Inertia | null;
+    private viewAdapter;
+    constructor(rootModule: Type<any>, options?: ApplicationOptions);
+    /** Try to load nx.config.ts and apply runtime-relevant settings. */
+    private tryLoadNxConfig;
+    /** Replace the default view adapter. */
+    setViewAdapter(adapter: ViewAdapter): this;
+    /**
+     * Set the directories to search when a controller returns
+     * `{ view: 'about.html' }`. Defaults to `[]` (no file-based
+     * views; controllers must pass inline template source).
+     *
+     * The Application auto-loads nx.config.ts at construction time, so if
+     * you already set viewPaths there, no explicit call is needed.
+     * This method exists to override the config-file value at runtime.
+     *
+     * Typical setup in nx.config.ts (auto-detected):
+     *
+     *   export default {
+     *     view: 'rendu',
+     *     viewPaths: 'resources/views',
+     *   };
+     *
+     * After this, `@Get('/about') return { view: 'about.html', data }`
+     * loads `views/about.html` from disk instead of treating the
+     * string as inline template source.
+     *
+     * Edge-only runtimes (Cloudflare Workers) should leave this
+     * empty and pass inline template strings.
+     */
+    setViewPaths(path: string): this;
+    /** Render a view using the configured adapter. */
+    render(view: string, data?: Record<string, any>): Promise<string>;
+    /**
+     * Convenience: start the server using the auto-detected runtime adapter.
+     */
+    listen(port?: number): Promise<any>;
+    /**
+     * For Cloudflare / Workers: return the fetch handler.
+     */
+    get fetch(): (req: Request, env?: any, ctx?: any) => Promise<Response>;
+    /**
+     * Static factory that mirrors the typical `bootstrap()` pattern.
+     */
+    static bootstrap(rootModule: Type<any>, options?: ApplicationOptions): Application;
+}
+//# sourceMappingURL=application.d.ts.map

package/dist/core/application.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"application.d.ts","sourceRoot":"","sources":["../../src/core/application.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,OAAO,kBAAkB,CAAC;AAC1B,OAAO,EAAE,oBAAoB,EAAE,MAAM,mBAAmB,CAAC;AAEzD,OAAO,EAAE,WAAW,EAAE,KAAK,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AACxE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAGpD,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,gBAAgB,CAAC;AAC3C,OAAO,EAAE,OAAO,EAAE,KAAK,aAAa,EAAE,MAAM,0BAA0B,CAAC;AAEvE,MAAM,WAAW,kBAAmB,SAAQ,kBAAkB;IAC7D,+CAA+C;IAC/C,WAAW,CAAC,EAAE,WAAW,CAAC;IAC1B,wEAAwE;IACxE,OAAO,CAAC,EAAE,aAAa,CAAC;CACxB;AAED,qBAAa,WAAW;IACvB,QAAQ,CAAC,SAAS,EAAE,oBAAoB,CAAC;IACzC,QAAQ,CAAC,MAAM,EAAE,WAAW,CAAC;IAC7B,gFAAgF;IAChF,QAAQ,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAAC;IACjC,OAAO,CAAC,WAAW,CAAc;gBAErB,UAAU,EAAE,IAAI,CAAC,GAAG,CAAC,EAAE,OAAO,GAAE,kBAAuB;IAmDnE,oEAAoE;IACpE,OAAO,CAAC,eAAe;IAiBvB,wCAAwC;IACxC,cAAc,CAAC,OAAO,EAAE,WAAW,GAAG,IAAI;IAK1C;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;IAKhC,kDAAkD;IAC5C,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,GAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAI3E;;OAEG;IACG,MAAM,CAAC,IAAI,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,GAAG,CAAC;IAOzC;;OAEG;IACH,IAAI,KAAK,8DAER;IAED;;OAEG;IACH,MAAM,CAAC,SAAS,CACf,UAAU,EAAE,IAAI,CAAC,GAAG,CAAC,EACrB,OAAO,CAAC,EAAE,kBAAkB,GAC1B,WAAW;CAGd"}

package/dist/core/constants.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Metadata keys used by reflect-metadata for storing decorator data.
+ *
+ * These constants are the contract between decorators and the framework
+ * core (DI container, router, validator).
+ */
+export declare const METADATA_KEY: {
+    /** Marks a class as a Nest-style controller, stores route prefix. */
+    readonly CONTROLLER: "nexus:controller";
+    /** Marks a class as an injectable provider. */
+    readonly INJECTABLE: "nexus:injectable";
+    /** Marks a class as a repository. */
+    readonly REPOSITORY: "nexus:repository";
+    /** Marks a class as a module. Stores module options. */
+    readonly MODULE: "nexus:module";
+    /** HTTP method routes registered on a controller (Get/Post/...). */
+    readonly ROUTES: "nexus:routes";
+    /** Method parameter type metadata (body/query/param/headers/ctx). */
+    readonly PARAMS: "nexus:params";
+    /** Validation schema per method (Zod schema or class). */
+    readonly VALIDATE: "nexus:validate";
+    /** Class-level design:paramtypes (built-in). */
+    readonly PARAMTYPES: "design:paramtypes";
+    /** Class-level design:type (built-in). */
+    readonly TYPE: "design:type";
+    /** Class-level design:returntype (built-in). */
+    readonly RETURNTYPE: "design:returntype";
+    /** Provider token to inject for a parameter (for custom tokens). */
+    readonly INJECT: "nexus:inject";
+};
+export type MetadataKey = (typeof METADATA_KEY)[keyof typeof METADATA_KEY];
+/** Available parameter decorator locations. */
+export declare const PARAM_TYPES: {
+    readonly REQUEST: 0;
+    readonly RESPONSE: 1;
+    readonly NEXT: 2;
+    readonly BODY: 3;
+    readonly QUERY: 4;
+    readonly PARAM: 5;
+    readonly HEADERS: 6;
+    readonly CTX: 7;
+    readonly USER: 8;
+};
+export type ParamType = (typeof PARAM_TYPES)[keyof typeof PARAM_TYPES];
+/** HTTP methods supported by the router. */
+export declare const HTTP_METHODS: readonly ["GET", "POST", "PUT", "DELETE", "PATCH", "OPTIONS", "HEAD"];
+export type HttpMethod = (typeof HTTP_METHODS)[number];
+//# sourceMappingURL=constants.d.ts.map

package/dist/core/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../src/core/constants.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,eAAO,MAAM,YAAY;IACxB,qEAAqE;;IAGrE,+CAA+C;;IAG/C,qCAAqC;;IAGrC,wDAAwD;;IAGxD,oEAAoE;;IAGpE,qEAAqE;;IAGrE,0DAA0D;;IAG1D,gDAAgD;;IAGhD,0CAA0C;;IAG1C,gDAAgD;;IAGhD,oEAAoE;;CAE3D,CAAC;AAEX,MAAM,MAAM,WAAW,GAAG,CAAC,OAAO,YAAY,CAAC,CAAC,MAAM,OAAO,YAAY,CAAC,CAAC;AAE3E,+CAA+C;AAC/C,eAAO,MAAM,WAAW;;;;;;;;;;CAUd,CAAC;AAEX,MAAM,MAAM,SAAS,GAAG,CAAC,OAAO,WAAW,CAAC,CAAC,MAAM,OAAO,WAAW,CAAC,CAAC;AAEvE,4CAA4C;AAC5C,eAAO,MAAM,YAAY,uEAQf,CAAC;AACX,MAAM,MAAM,UAAU,GAAG,CAAC,OAAO,YAAY,CAAC,CAAC,MAAM,CAAC,CAAC"}

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

@@ -0,0 +1,21 @@
+/**
+ * @Controller decorator.
+ *
+ * Marks a class as a controller and registers a route prefix.
+ * Routes inside the controller class are decorated with @Get/@Post/etc.
+ *
+ * @example
+ * ```ts
+ * @Controller('/users')
+ * class UserController {
+ *   @Get('/')
+ *   list() { ... }
+ * }
+ * ```
+ */
+import "reflect-metadata";
+import type { ControllerMetadata } from "../di/tokens.js";
+export declare function Controller(prefix?: string): ClassDecorator;
+export declare function getControllerMetadata(target: any): ControllerMetadata;
+export declare function isController(target: any): boolean;
+//# sourceMappingURL=controller.d.ts.map

package/dist/core/decorators/controller.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"controller.d.ts","sourceRoot":"","sources":["../../../src/core/decorators/controller.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,OAAO,kBAAkB,CAAC;AAE1B,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AAE1D,wBAAgB,UAAU,CAAC,MAAM,GAAE,MAAY,GAAG,cAAc,CAM/D;AAED,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,GAAG,GAAG,kBAAkB,CAIrE;AAED,wBAAgB,YAAY,CAAC,MAAM,EAAE,GAAG,GAAG,OAAO,CAEjD"}

package/dist/core/decorators/http-methods.d.ts

@@ -0,0 +1,33 @@
+/**
+ * HTTP method decorators.
+ *
+ * `@Get`, `@Post`, `@Put`, `@Delete`, `@Patch`, `@Options`, `@Head` mark a
+ * controller method as a route handler. The path argument is appended to
+ * the controller's prefix.
+ *
+ * @example
+ * ```ts
+ * @Controller('/users')
+ * class UserController {
+ *   @Get('/')
+ *   list() {}
+ *
+ *   @Post('/')
+ *   create(@Body() body: CreateUserDto) {}
+ * }
+ * ```
+ */
+import "reflect-metadata";
+import { HTTP_METHODS } from "../constants.js";
+import type { RouteMetadata } from "../di/tokens.js";
+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;
+export declare const Options: (path?: string) => MethodDecorator;
+export declare const Head: (path?: string) => MethodDecorator;
+export declare function getRoutes(target: any): RouteMetadata[];
+export { HTTP_METHODS };
+export type { RouteMetadata };
+//# sourceMappingURL=http-methods.d.ts.map

package/dist/core/decorators/http-methods.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"http-methods.d.ts","sourceRoot":"","sources":["../../../src/core/decorators/http-methods.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AACH,OAAO,kBAAkB,CAAC;AAC1B,OAAO,EAAE,YAAY,EAAiC,MAAM,iBAAiB,CAAC;AAC9E,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AA2BrD,eAAO,MAAM,GAAG,GAAI,OAAM,MAAY,oBAA6B,CAAC;AACpE,eAAO,MAAM,IAAI,GAAI,OAAM,MAAY,oBAA8B,CAAC;AACtE,eAAO,MAAM,GAAG,GAAI,OAAM,MAAY,oBAA6B,CAAC;AACpE,eAAO,MAAM,MAAM,GAAI,OAAM,MAAY,oBAAgC,CAAC;AAC1E,eAAO,MAAM,KAAK,GAAI,OAAM,MAAY,oBAA+B,CAAC;AACxE,eAAO,MAAM,OAAO,GAAI,OAAM,MAAY,oBAAiC,CAAC;AAC5E,eAAO,MAAM,IAAI,GAAI,OAAM,MAAY,oBAA8B,CAAC;AAEtE,wBAAgB,SAAS,CAAC,MAAM,EAAE,GAAG,GAAG,aAAa,EAAE,CAEtD;AAED,OAAO,EAAE,YAAY,EAAE,CAAC;AACxB,YAAY,EAAE,aAAa,EAAE,CAAC"}

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

@@ -0,0 +1,12 @@
+/**
+ * Convenience barrel for all decorators.
+ */
+export * from "./module.js";
+export * from "./controller.js";
+export * from "./injectable.js";
+export * from "./http-methods.js";
+export * from "./params.js";
+export * from "./validate.js";
+export * from "./repository.js";
+export * from "./metadata.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/core/decorators/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/core/decorators/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,cAAc,aAAa,CAAC;AAC5B,cAAc,iBAAiB,CAAC;AAChC,cAAc,iBAAiB,CAAC;AAChC,cAAc,mBAAmB,CAAC;AAClC,cAAc,aAAa,CAAC;AAC5B,cAAc,eAAe,CAAC;AAC9B,cAAc,iBAAiB,CAAC;AAChC,cAAc,eAAe,CAAC"}

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

@@ -0,0 +1,42 @@
+/**
+ * @Injectable decorator.
+ *
+ * Marks a class as available for DI. The container uses reflect-metadata's
+ * `design:paramtypes` to read constructor parameter types and resolve them
+ * automatically.
+ *
+ * @example
+ * ```ts
+ * @Injectable()
+ * class UserService {
+ *   constructor(private repo: UserRepository) {}
+ * }
+ *
+ * @Injectable({ scope: 'request' })
+ * class RequestContext {
+ *   constructor(@Inject(REQUEST) private req: any) {}
+ * }
+ * ```
+ */
+import "reflect-metadata";
+export interface InjectableOptions {
+    scope?: "singleton" | "request" | "transient";
+}
+export declare function Injectable(options?: InjectableOptions): ClassDecorator;
+export declare function isInjectable(target: any): boolean;
+/**
+ * Read the scope declared on a class via `@Injectable({ scope })`.
+ * Returns undefined when no scope is declared (defaults to singleton).
+ */
+export declare function getScope(target: any): "singleton" | "request" | "transient" | undefined;
+/**
+ * Mark a parameter as resolved by a specific token instead of its declared
+ * type. Useful for interfaces, abstract classes, or string tokens.
+ *
+ * @example
+ * ```ts
+ * constructor(@Inject('CONFIG') private config: AppConfig) {}
+ * ```
+ */
+export declare function Inject<T = any>(token: any): ParameterDecorator;
+//# sourceMappingURL=injectable.d.ts.map

package/dist/core/decorators/injectable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"injectable.d.ts","sourceRoot":"","sources":["../../../src/core/decorators/injectable.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,OAAO,kBAAkB,CAAC;AAG1B,MAAM,WAAW,iBAAiB;IACjC,KAAK,CAAC,EAAE,WAAW,GAAG,SAAS,GAAG,WAAW,CAAC;CAC9C;AAED,wBAAgB,UAAU,CAAC,OAAO,GAAE,iBAAsB,GAAG,cAAc,CAW1E;AAED,wBAAgB,YAAY,CAAC,MAAM,EAAE,GAAG,GAAG,OAAO,CAEjD;AAED;;;GAGG;AACH,wBAAgB,QAAQ,CACvB,MAAM,EAAE,GAAG,GACT,WAAW,GAAG,SAAS,GAAG,WAAW,GAAG,SAAS,CAEnD;AAED;;;;;;;;GAQG;AACH,wBAAgB,MAAM,CAAC,CAAC,GAAG,GAAG,EAAE,KAAK,EAAE,GAAG,GAAG,kBAAkB,CAW9D"}

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

@@ -0,0 +1,7 @@
+/**
+ * Reflect-metadata helper. Centralizes the keys the framework uses so
+ * decorator files stay clean.
+ */
+export { METADATA_KEY, PARAM_TYPES, HTTP_METHODS } from "../constants.js";
+export type { MetadataKey, ParamType, HttpMethod } from "../constants.js";
+//# sourceMappingURL=metadata.d.ts.map

package/dist/core/decorators/metadata.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"metadata.d.ts","sourceRoot":"","sources":["../../../src/core/decorators/metadata.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,EAAE,YAAY,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAC1E,YAAY,EAAE,WAAW,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC"}

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

@@ -0,0 +1,23 @@
+/**
+ * @Module decorator.
+ *
+ * Marks a class as a Nest-style module: a logical grouping of
+ * controllers and providers with explicit imports/exports.
+ *
+ * @example
+ * ```ts
+ * @Module({
+ *   imports: [UserModule],
+ *   controllers: [UserController],
+ *   providers: [UserService],
+ *   exports: [UserService],
+ * })
+ * class AppModule {}
+ * ```
+ */
+import "reflect-metadata";
+import type { ModuleOptions, Type } from "../di/tokens.js";
+export declare function Module(options?: ModuleOptions): ClassDecorator;
+/** Read the @Module options from a class. */
+export declare function getModuleOptions(target: Type<any>): ModuleOptions;
+//# sourceMappingURL=module.d.ts.map

package/dist/core/decorators/module.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"module.d.ts","sourceRoot":"","sources":["../../../src/core/decorators/module.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AACH,OAAO,kBAAkB,CAAC;AAE1B,OAAO,KAAK,EAAE,aAAa,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAC;AAE3D,wBAAgB,MAAM,CAAC,OAAO,GAAE,aAAkB,GAAG,cAAc,CAIlE;AAED,6CAA6C;AAC7C,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,IAAI,CAAC,GAAG,CAAC,GAAG,aAAa,CAEjE"}

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

@@ -0,0 +1,33 @@
+/**
+ * Parameter decorators.
+ *
+ * These mark a controller method argument as a source of request data:
+ *   - `@Req()`        → Hono context
+ *   - `@Res()`        → Response helper
+ *   - `@Next()`       → next() callback (for middleware-style handlers)
+ *   - `@Body()`       → request body (parsed)
+ *   - `@Query('key')` → a single query param, or full query object
+ *   - `@Param('key')` → a single path param, or full params object
+ *   - `@Headers('k')` → a single header, or full headers object
+ *   - `@Ctx()`        → Hono context (alias for @Req)
+ *   - `@User()`       → authenticated user (resolved via auth provider)
+ *
+ * The metadata is read by the router at mount time to build the
+ * handler invocation list.
+ */
+import "reflect-metadata";
+import { PARAM_TYPES } from "../constants.js";
+import type { ParamMetadata } from "../di/tokens.js";
+export declare function createParamDecorator(type: number, data?: string | object): ParameterDecorator;
+export declare const Req: () => ParameterDecorator;
+export declare const Res: () => ParameterDecorator;
+export declare const Next: () => ParameterDecorator;
+export declare const Body: (key?: string) => ParameterDecorator;
+export declare const Query: (key?: string) => ParameterDecorator;
+export declare const Param: (key?: string) => ParameterDecorator;
+export declare const Headers: (key?: string) => ParameterDecorator;
+export declare const Ctx: () => ParameterDecorator;
+export declare const User: () => ParameterDecorator;
+export declare function getParamMetadata(target: any, propertyKey: string | symbol): ParamMetadata[];
+export { PARAM_TYPES };
+//# sourceMappingURL=params.d.ts.map

package/dist/core/decorators/params.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"params.d.ts","sourceRoot":"","sources":["../../../src/core/decorators/params.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AACH,OAAO,kBAAkB,CAAC;AAC1B,OAAO,EAAgB,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAC5D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAErD,wBAAgB,oBAAoB,CACnC,IAAI,EAAE,MAAM,EACZ,IAAI,CAAC,EAAE,MAAM,GAAG,MAAM,GACpB,kBAAkB,CA8BpB;AAED,eAAO,MAAM,GAAG,0BAAkD,CAAC;AACnE,eAAO,MAAM,GAAG,0BAAmD,CAAC;AACpE,eAAO,MAAM,IAAI,0BAA+C,CAAC;AACjE,eAAO,MAAM,IAAI,GAAI,MAAM,MAAM,uBACW,CAAC;AAC7C,eAAO,MAAM,KAAK,GAAI,MAAM,MAAM,uBACW,CAAC;AAC9C,eAAO,MAAM,KAAK,GAAI,MAAM,MAAM,uBACW,CAAC;AAC9C,eAAO,MAAM,OAAO,GAAI,MAAM,MAAM,uBACW,CAAC;AAChD,eAAO,MAAM,GAAG,0BAA8C,CAAC;AAC/D,eAAO,MAAM,IAAI,0BAA+C,CAAC;AAEjE,wBAAgB,gBAAgB,CAC/B,MAAM,EAAE,GAAG,EACX,WAAW,EAAE,MAAM,GAAG,MAAM,GAC1B,aAAa,EAAE,CAEjB;AAED,OAAO,EAAE,WAAW,EAAE,CAAC"}

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

@@ -0,0 +1,24 @@
+/**
+ * @Repository decorator.
+ *
+ * Marks a class as a Spring-style repository. Repositories are normal
+ * `@Injectable()` classes; the decorator is a marker so the framework
+ * can register them with a database adapter (Drizzle/Prisma) and emit
+ * a friendly error if you forget to wire one.
+ *
+ * @example
+ * ```ts
+ * @Repository()
+ * class UserRepository {
+ *   findAll() { return db.select().from(users); }
+ * }
+ * ```
+ */
+import "reflect-metadata";
+import type { InjectionToken } from "../di/tokens.js";
+export declare function Repository(entityToken?: InjectionToken<any>): ClassDecorator;
+export declare function getRepositoryMetadata(target: any): {
+    entity?: InjectionToken<any>;
+} | undefined;
+export declare function isRepository(target: any): boolean;
+//# sourceMappingURL=repository.d.ts.map

package/dist/core/decorators/repository.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"repository.d.ts","sourceRoot":"","sources":["../../../src/core/decorators/repository.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AACH,OAAO,kBAAkB,CAAC;AAE1B,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAEtD,wBAAgB,UAAU,CAAC,WAAW,CAAC,EAAE,cAAc,CAAC,GAAG,CAAC,GAAG,cAAc,CAS5E;AAED,wBAAgB,qBAAqB,CACpC,MAAM,EAAE,GAAG,GACT;IAAE,MAAM,CAAC,EAAE,cAAc,CAAC,GAAG,CAAC,CAAA;CAAE,GAAG,SAAS,CAE9C;AAED,wBAAgB,YAAY,CAAC,MAAM,EAAE,GAAG,GAAG,OAAO,CAEjD"}

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

@@ -0,0 +1,21 @@
+/**
+ * @Validate decorator.
+ *
+ * Attaches Zod schemas (or class validators) to a route handler. Each
+ * schema is run against the corresponding request part before the handler
+ * executes; failed validation throws or returns a 400 response.
+ *
+ * @example
+ * ```ts
+ * const UserSchema = z.object({ name: z.string(), email: z.email() });
+ *
+ * @Post('/')
+ * @Validate({ body: UserSchema })
+ * create(@Body() body: z.infer<typeof UserSchema>) { ... }
+ * ```
+ */
+import "reflect-metadata";
+import type { ValidationMetadata } from "../di/tokens.js";
+export declare function Validate(options: ValidationMetadata): MethodDecorator;
+export declare function getValidationMetadata(target: any, propertyKey: string | symbol): ValidationMetadata | undefined;
+//# sourceMappingURL=validate.d.ts.map

package/dist/core/decorators/validate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate.d.ts","sourceRoot":"","sources":["../../../src/core/decorators/validate.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AACH,OAAO,kBAAkB,CAAC;AAE1B,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AAE1D,wBAAgB,QAAQ,CAAC,OAAO,EAAE,kBAAkB,GAAG,eAAe,CAarE;AAED,wBAAgB,qBAAqB,CACpC,MAAM,EAAE,GAAG,EACX,WAAW,EAAE,MAAM,GAAG,MAAM,GAC1B,kBAAkB,GAAG,SAAS,CAEhC"}

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

@@ -0,0 +1,70 @@
+/**
+ * Dependency Injection Container.
+ *
+ * The container is the heart of the framework. It:
+ * - Registers providers (classes, values, factories, aliases)
+ * - Resolves dependencies recursively through reflect-metadata
+ * - Manages instance lifecycles (singleton / request / transient)
+ * - Detects circular dependencies and throws helpful errors
+ *
+ * Design notes:
+ * - Modules each have their own container scope, but share the root
+ *   container for global providers. Exports propagate tokens upward.
+ * - The container is lazy: nothing is instantiated until first resolve.
+ */
+import "reflect-metadata";
+import type { InjectionToken, Provider, Type } from "./tokens.js";
+export declare class DIContainer {
+    /** Token -> provider record. */
+    private providers;
+    /** Token -> singleton instance (lazy). */
+    private singletons;
+    /** Token -> "currently resolving" flag for cycle detection. */
+    private resolving;
+    /** Parent container (for hierarchical lookup of exports). */
+    private parent?;
+    constructor(parent?: DIContainer);
+    /** Create a child container (used by modules). */
+    createChild(): DIContainer;
+    /** Register a provider or list of providers. */
+    register(providers: Provider<any> | Provider<any>[]): void;
+    private registerOne;
+    /**
+     * Normalize a provider union into a uniform ProviderRecord.
+     * - Type<...> → useClass equivalent
+     * - { useClass | useValue | useFactory | useExisting } → as-is
+     */
+    private normalizeProvider;
+    /** Read constructor parameter types from a class using reflect-metadata. */
+    private readClassDependencies;
+    /** Read dependencies from a structured provider's `inject` array (factory). */
+    private readProviderDependencies;
+    /**
+     * Resolve a token to an instance. Walks up the parent chain on miss.
+     * Returns undefined when nothing is registered and the token is optional.
+     */
+    resolve<T = any>(token: InjectionToken<T>): T;
+    /** Try to resolve; return undefined instead of throwing when missing. */
+    tryResolve<T = any>(token: InjectionToken<T>): T | undefined;
+    /**
+     * Instantiate a single provider record. Calls itself recursively
+     * for each constructor parameter.
+     */
+    private instantiate;
+    /** Check whether a token is registered locally (does not consult parent). */
+    has(token: InjectionToken<any>): boolean;
+    /** Inspect the registered tokens (debug aid). */
+    list(): string[];
+    private isClass;
+    private tokenName;
+}
+/**
+ * Root application container. Modules created via @Module register their
+ * providers into child containers of this root.
+ */
+export declare class ApplicationContainer extends DIContainer {
+    private moduleContainers;
+    registerModule(moduleClass: Type<any>, container: DIContainer): void;
+    getModuleContainer(moduleClass: Type<any>): DIContainer | undefined;
+}
+//# sourceMappingURL=container.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"container.d.ts","sourceRoot":"","sources":["../../../src/core/di/container.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,OAAO,kBAAkB,CAAC;AAE1B,OAAO,KAAK,EAEX,cAAc,EACd,QAAQ,EAER,IAAI,EAEJ,MAAM,aAAa,CAAC;AAWrB,qBAAa,WAAW;IACvB,gCAAgC;IAChC,OAAO,CAAC,SAAS,CAAkD;IAEnE,0CAA0C;IAC1C,OAAO,CAAC,UAAU,CAAuC;IAEzD,+DAA+D;IAC/D,OAAO,CAAC,SAAS,CAAkC;IAEnD,6DAA6D;IAC7D,OAAO,CAAC,MAAM,CAAC,CAAc;gBAEjB,MAAM,CAAC,EAAE,WAAW;IAIhC,kDAAkD;IAClD,WAAW,IAAI,WAAW;IAI1B,gDAAgD;IAChD,QAAQ,CAAC,SAAS,EAAE,QAAQ,CAAC,GAAG,CAAC,GAAG,QAAQ,CAAC,GAAG,CAAC,EAAE,GAAG,IAAI;IAO1D,OAAO,CAAC,WAAW;IAWnB;;;;OAIG;IACH,OAAO,CAAC,iBAAiB;IA2BzB,4EAA4E;IAC5E,OAAO,CAAC,qBAAqB;IAU7B,+EAA+E;IAC/E,OAAO,CAAC,wBAAwB;IAsBhC;;;OAGG;IACH,OAAO,CAAC,CAAC,GAAG,GAAG,EAAE,KAAK,EAAE,cAAc,CAAC,CAAC,CAAC,GAAG,CAAC;IAyD7C,yEAAyE;IACzE,UAAU,CAAC,CAAC,GAAG,GAAG,EAAE,KAAK,EAAE,cAAc,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,SAAS;IAQ5D;;;OAGG;IACH,OAAO,CAAC,WAAW;IAoGnB,6EAA6E;IAC7E,GAAG,CAAC,KAAK,EAAE,cAAc,CAAC,GAAG,CAAC,GAAG,OAAO;IAIxC,iDAAiD;IACjD,IAAI,IAAI,MAAM,EAAE;IAIhB,OAAO,CAAC,OAAO;IAIf,OAAO,CAAC,SAAS;CAKjB;AAED;;;GAGG;AACH,qBAAa,oBAAqB,SAAQ,WAAW;IACpD,OAAO,CAAC,gBAAgB,CAAqC;IAE7D,cAAc,CAAC,WAAW,EAAE,IAAI,CAAC,GAAG,CAAC,EAAE,SAAS,EAAE,WAAW,GAAG,IAAI;IAIpE,kBAAkB,CAAC,WAAW,EAAE,IAAI,CAAC,GAAG,CAAC,GAAG,WAAW,GAAG,SAAS;CAGnE"}

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

@@ -0,0 +1,9 @@
+/**
+ * DI barrel exports.
+ */
+export * from "./tokens.js";
+export * from "./container.js";
+export * from "./scanner.js";
+export * from "./request-scope.js";
+export { requestScopeMiddleware } from "./request-middleware.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/core/di/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/core/di/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,cAAc,aAAa,CAAC;AAC5B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,cAAc,CAAC;AAC7B,cAAc,oBAAoB,CAAC;AACnC,OAAO,EAAE,sBAAsB,EAAE,MAAM,yBAAyB,CAAC"}

package/dist/core/di/request-middleware.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Hono middleware that activates a `RequestScope` for the duration
+ * of an HTTP request. The scope is held in `AsyncLocalStorage` and
+ * propagated through the entire async call tree.
+ *
+ *   - At request start: build a new `RequestScope` (with a child
+ *     DI container that inherits from the application's container).
+ *   - Run the rest of the request inside the scope.
+ *   - At request end: the scope (and child container) is dropped,
+ *     so all per-request state is garbage-collected.
+ *
+ * The framework installs this middleware on the Hono app at
+ * `NexusServer.start()` / `Application.listen()` time.
+ */
+import type { MiddlewareHandler } from "hono";
+import { DIContainer } from "./container.js";
+/**
+ * One-time setup: register the `REQUEST` and `REQUEST_SCOPE` tokens
+ * on the root container. The factory reads the active scope on
+ * each resolve, so the same `REQUEST` always points at the
+ * current request regardless of which container resolves it.
+ *
+ * Idempotent — calling it twice is a no-op.
+ */
+export declare function installRequestTokens(root: DIContainer): void;
+/**
+ * Build the request-scope middleware against the given root container.
+ * The root container is the application's `ApplicationContainer` —
+ * the one that holds every singleton provider.
+ *
+ * Call `installRequestTokens(root)` once before the server starts.
+ * (The framework does this for you; you only need to call this
+ * factory directly when wiring a custom Hono app.)
+ */
+export declare function requestScopeMiddleware(root: DIContainer): MiddlewareHandler;
+//# sourceMappingURL=request-middleware.d.ts.map

package/dist/core/di/request-middleware.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"request-middleware.d.ts","sourceRoot":"","sources":["../../../src/core/di/request-middleware.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,MAAM,CAAC;AAC9C,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAQ7C;;;;;;;GAOG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,WAAW,GAAG,IAAI,CAe5D;AAED;;;;;;;;GAQG;AACH,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,WAAW,GAAG,iBAAiB,CAS3E"}

package/dist/core/di/request-scope.d.ts

@@ -0,0 +1,45 @@
+import type { DIContainer } from "./container.js";
+/** The Hono context type. Kept loose to avoid a circular import. */
+export type HonoContext = any;
+/**
+ * Per-request state. Created by the HTTP middleware, lives for the
+ * duration of a single request, and is propagated through the entire
+ * async call tree via `AsyncLocalStorage`.
+ */
+export interface RequestScope {
+    /** Unique id for this request. Useful for log correlation. */
+    readonly id: string;
+    /** The Hono context (c). */
+    context: HonoContext;
+    /** A per-request DI container (singleton container + this scope). */
+    container: DIContainer;
+    /** User-extensible state bag. Modules can stash request-scoped data here. */
+    state: Map<string | symbol, unknown>;
+}
+/** Symbol token: inject the active Hono context. */
+export declare const REQUEST: unique symbol;
+/** Symbol token: inject the entire RequestScope. */
+export declare const REQUEST_SCOPE: unique symbol;
+/** Internal: read/write access to the AsyncLocalStorage slot. */
+export declare const RequestScopeStorage: {
+    /** Get the current scope, or `undefined` if not inside a request. */
+    get(): RequestScope | undefined;
+    /**
+     * Run `fn` inside a new request scope. The scope is propagated
+     * through the async call tree.
+     */
+    run<T>(scope: RequestScope, fn: () => T | Promise<T>): T | Promise<T>;
+    /**
+     * Create a new scope. Used by the HTTP middleware.
+     */
+    create(context: HonoContext, container: DIContainer): RequestScope;
+};
+/** Get the active Hono context, or `undefined` if not in a request. */
+export declare function getRequest<T = HonoContext>(): T | undefined;
+/** Get the active RequestScope, or `undefined`. */
+export declare function getRequestScope(): RequestScope | undefined;
+/** Get a piece of request-scoped state by key. */
+export declare function getRequestState<T = unknown>(key: string | symbol): T | undefined;
+/** Set a piece of request-scoped state. */
+export declare function setRequestState(key: string | symbol, value: unknown): void;
+//# sourceMappingURL=request-scope.d.ts.map

package/dist/core/di/request-scope.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"request-scope.d.ts","sourceRoot":"","sources":["../../../src/core/di/request-scope.ts"],"names":[],"mappings":"AA2BA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAElD,oEAAoE;AACpE,MAAM,MAAM,WAAW,GAAG,GAAG,CAAC;AAE9B;;;;GAIG;AACH,MAAM,WAAW,YAAY;IAC5B,8DAA8D;IAC9D,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,4BAA4B;IAC5B,OAAO,EAAE,WAAW,CAAC;IACrB,qEAAqE;IACrE,SAAS,EAAE,WAAW,CAAC;IACvB,6EAA6E;IAC7E,KAAK,EAAE,GAAG,CAAC,MAAM,GAAG,MAAM,EAAE,OAAO,CAAC,CAAC;CACrC;AAED,oDAAoD;AACpD,eAAO,MAAM,OAAO,eAA8B,CAAC;AAEnD,oDAAoD;AACpD,eAAO,MAAM,aAAa,eAAoC,CAAC;AAS/D,iEAAiE;AACjE,eAAO,MAAM,mBAAmB;IAC/B,qEAAqE;WAC9D,YAAY,GAAG,SAAS;IAG/B;;;OAGG;QACC,CAAC,SAAS,YAAY,MAAM,MAAM,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC;IAGrE;;OAEG;oBACa,WAAW,aAAa,WAAW,GAAG,YAAY;CAQlE,CAAC;AAMF,uEAAuE;AACvE,wBAAgB,UAAU,CAAC,CAAC,GAAG,WAAW,KAAK,CAAC,GAAG,SAAS,CAE3D;AAED,mDAAmD;AACnD,wBAAgB,eAAe,IAAI,YAAY,GAAG,SAAS,CAE1D;AAED,kDAAkD;AAClD,wBAAgB,eAAe,CAAC,CAAC,GAAG,OAAO,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,CAAC,GAAG,SAAS,CAEhF;AAED,2CAA2C;AAC3C,wBAAgB,eAAe,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,IAAI,CAG1E"}

package/dist/core/di/scanner.d.ts

@@ -0,0 +1,36 @@
+import type { ApplicationContainer, DIContainer } from "./container.js";
+import type { Provider, Type } from "./tokens.js";
+interface ScanResult {
+    /** Controllers registered by this module. */
+    controllers: Type[];
+    /** Providers registered locally (classes + non-class providers). */
+    providers: Provider[];
+    /** Tokens exported by this module. */
+    exports: any[];
+    /** Container holding the module's locally-scoped providers. */
+    container: DIContainer;
+}
+export declare class ModuleScanner {
+    private root;
+    private scanned;
+    constructor(root: ApplicationContainer);
+    /**
+     * Scan a module tree starting from `rootModule`, registering all
+     * providers and controllers into the appropriate containers.
+     */
+    scan(rootModule: Type<any>): {
+        root: ScanResult;
+        modules: ScanResult[];
+    };
+    /**
+     * Scan one module. Recurses into its `imports`, then registers its
+     * providers and controllers. Exports are exposed to the parent
+     * container.
+     */
+    private scanModule;
+    private readModuleOptions;
+    /** Get a previously-scanned module's result (debug aid). */
+    get(moduleClass: Type<any>): ScanResult | undefined;
+}
+export {};
+//# sourceMappingURL=scanner.d.ts.map

package/dist/core/di/scanner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scanner.d.ts","sourceRoot":"","sources":["../../../src/core/di/scanner.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,oBAAoB,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AACxE,OAAO,KAAK,EAAiB,QAAQ,EAAE,IAAI,EAAE,MAAM,aAAa,CAAC;AAEjE,UAAU,UAAU;IACnB,6CAA6C;IAC7C,WAAW,EAAE,IAAI,EAAE,CAAC;IACpB,oEAAoE;IACpE,SAAS,EAAE,QAAQ,EAAE,CAAC;IACtB,sCAAsC;IACtC,OAAO,EAAE,GAAG,EAAE,CAAC;IACf,+DAA+D;IAC/D,SAAS,EAAE,WAAW,CAAC;CACvB;AAED,qBAAa,aAAa;IAGb,OAAO,CAAC,IAAI;IAFxB,OAAO,CAAC,OAAO,CAAoC;gBAE/B,IAAI,EAAE,oBAAoB;IAE9C;;;OAGG;IACH,IAAI,CAAC,UAAU,EAAE,IAAI,CAAC,GAAG,CAAC,GAAG;QAAE,IAAI,EAAE,UAAU,CAAC;QAAC,OAAO,EAAE,UAAU,EAAE,CAAA;KAAE;IAMxE;;;;OAIG;IACH,OAAO,CAAC,UAAU;IAiElB,OAAO,CAAC,iBAAiB;IAYzB,4DAA4D;IAC5D,GAAG,CAAC,WAAW,EAAE,IAAI,CAAC,GAAG,CAAC,GAAG,UAAU,GAAG,SAAS;CAGnD"}