honovajs 0.0.1

package/README.md

@@ -0,0 +1,366 @@
+# Honova
+
+Nest-like framework for Cloudflare Workers built on top of Hono.
+
+Honova provides a module system, decorators, dependency injection, route metadata, request-aware lifecycle, and typed database middleware so you can build structured APIs on the edge without bringing a full Node-centric runtime.
+
+## Status
+
+- Package version: `0.0.1`
+- Runtime target: Cloudflare Workers (also works anywhere Hono runs)
+- Module format: ESM
+
+## Feature Checklist
+
+### Core Framework
+
+- [x] `@Module()` with `controllers`, `providers`, and `imports`
+- [x] `@Controller()` with route prefixing
+- [x] HTTP method decorators: `@Get`, `@Post`, `@Put`, `@Patch`, `@Delete`, `@Options`, `@Head`
+- [x] Dependency Injection container
+- [x] `@Injectable()` scopes (`singleton`, `request`, `transient`)
+- [x] `@Inject()` token-based constructor injection
+- [x] Provider auto-inference by constructor parameter name
+- [x] Request-aware provider resolution (`resolveWithContext`)
+- [x] `OnModuleInit` lifecycle hook (sync)
+- [x] Global middleware registration
+- [x] Controller-level and route-level middleware via `@UseMiddleware`
+- [x] Built-in `not_found` and `internal_error` JSON responses
+
+### Security and Observability
+
+- [x] CORS integration (`hono/cors`)
+- [x] Optional secure headers (`hono/secure-headers`)
+- [x] Request ID propagation (`x-request-id` by default)
+- [x] Access logs with log level control (`debug`, `info`, `warn`, `error`)
+- [x] Header redaction in debug logs
+
+### Authentication Middleware
+
+- [x] Bearer auth middleware (`UseBearerAuth`, `BearerAuth`)
+- [x] API key middleware (`UseApiKey`, `ApiKeyAuth`)
+- [x] Auth principal injection into context (`c.set("auth", principal)`)
+- [x] Overrideable auth error handling
+
+### Database Layer
+
+- [x] `defineDatabase()` typed config helper
+- [x] `DatabaseManager` with per-request lifecycle
+- [x] Single and multi-connection support
+- [x] `defaultConnection` enforcement for multi-DB setups
+- [x] URL resolution from static URL, env binding, or async resolver
+- [x] Eager connection initialization
+- [x] Connection cleanup hooks
+- [x] Context bindings: `c.db`, `c.get("db")`, `c.get("dbConnections")`
+- [x] Adapter helpers: Drizzle, Prisma, MongoDB (`createMongoDbAdapter`) with legacy alias (`createMondelAdapter`)
+
+### Tests
+
+- [x] DI behavior tests
+- [x] Provider validation tests (`@Injectable` required)
+- [x] Lifecycle behavior tests (`onModuleInit` with request context)
+- [x] Database manager and middleware tests
+
+### Planned / Missing Features
+
+- [x] Request-scoped and transient instance caching semantics validated by tests
+- [ ] Async `onModuleInit` support in runtime
+- [ ] Validation pipes and DTO validation layer
+- [ ] Guard/interceptor abstraction (Nest-style)
+- [ ] Exception filter abstraction
+- [ ] First-class OpenAPI/Swagger generation
+- [ ] CLI scaffolding (`create-honova-app`, generators)
+- [ ] Official Cloudflare starter templates (D1, KV, R2 examples)
+- [ ] More auth primitives (JWT helper, role/permission guard, session middleware)
+- [ ] E2E test suite with Worker runtime integration
+- [ ] Benchmark/performance suite and guidance
+- [ ] Complete API docs website
+
+## Installation
+
+```bash
+npm i honovajs
+```
+
+```bash
+pnpm add honovajs
+```
+
+```bash
+yarn add honovajs
+```
+
+```bash
+bun add honovajs
+```
+
+## Quick Start
+
+```ts
+import { Controller, Get, Injectable, Module, createApp } from "honovajs";
+
+@Injectable()
+class HealthService {
+  getStatus() {
+    return { ok: true };
+  }
+}
+
+@Controller("/health")
+class HealthController {
+  constructor(private readonly healthService: HealthService) {}
+
+  @Get("/")
+  handle(): Response {
+    return Response.json(this.healthService.getStatus());
+  }
+}
+
+@Module({
+  controllers: [HealthController],
+  providers: [HealthService],
+})
+class AppModule {}
+
+const app = createApp({ basePath: "/api" });
+app.registerModule(AppModule);
+
+export default {
+  fetch: app.fetch,
+};
+```
+
+## Core Concepts
+
+### Modules
+
+`@Module()` organizes app boundaries:
+
+- `controllers`: classes that expose HTTP handlers
+- `providers`: services managed by the DI container
+- `imports`: other modules to compose features
+
+All providers listed in `providers` must have `@Injectable()`.
+
+### Controllers and Routes
+
+`@Controller("/prefix")` defines a route prefix. Route handlers are defined with HTTP decorators.
+
+```ts
+@Controller("/users")
+class UserController {
+  @Get("/")
+  list() {
+    return Response.json([]);
+  }
+}
+```
+
+### Dependency Injection
+
+Providers are resolved through the container. Constructor dependencies can be resolved by:
+
+- explicit token with `@Inject(token)`
+- inferred class token by constructor parameter name
+
+Strict DI mode is enabled by default and throws on unresolved dependencies.
+
+Provider scopes:
+
+- `singleton`: one instance per app container
+- `request`: one instance per request context (reused within the same request)
+- `transient`: new instance on each resolution
+
+### Lifecycle: `OnModuleInit`
+
+A provider can implement `onModuleInit(context?)`.
+
+Current runtime behavior:
+
+- It runs when the provider is resolved for the first time.
+- For singleton providers, it runs once per app instance.
+- Request context is passed when the provider is resolved during a request.
+- It must be synchronous in `0.0.1`.
+
+## Middleware
+
+### Global Middleware
+
+```ts
+const app = createApp({
+  globalMiddlewares: [async (c, next) => { await next(); }],
+});
+```
+
+### Decorator Middleware
+
+```ts
+import { Controller, Get, UseMiddleware } from "honovajs";
+
+const requireHeader = async (c: any, next: any) => {
+  if (!c.req.header("x-trace")) {
+    return c.json({ error: "missing x-trace" }, 400);
+  }
+  await next();
+};
+
+@UseMiddleware(requireHeader)
+@Controller("/demo")
+class DemoController {
+  @Get("/")
+  handle() {
+    return Response.json({ ok: true });
+  }
+}
+```
+
+## Security and Observability
+
+Configure at app creation:
+
+```ts
+const app = createApp({
+  security: {
+    cors: { origin: ["https://app.example.com"] },
+    secureHeaders: true,
+  },
+  observability: {
+    requestIdHeader: "x-request-id",
+    enableAccessLogs: true,
+    logLevel: "info",
+    redactHeaders: ["authorization", "cookie", "x-api-key"],
+  },
+});
+```
+
+## Authentication
+
+### Bearer Token
+
+```ts
+import { Controller, Get, UseBearerAuth } from "honovajs";
+
+@UseBearerAuth({
+  verify: async (token) => (token === "valid-token" ? { id: "user_1" } : null),
+})
+@Controller("/me")
+class MeController {
+  @Get("/")
+  handle() {
+    return Response.json({ ok: true });
+  }
+}
+```
+
+### API Key
+
+```ts
+import { Controller, Get, UseApiKey } from "honovajs";
+
+@UseApiKey({
+  header: "x-api-key",
+  verify: async (key) => (key === "secret" ? { id: "service_1" } : null),
+})
+@Controller("/internal")
+class InternalController {
+  @Get("/")
+  handle() {
+    return Response.json({ ok: true });
+  }
+}
+```
+
+## Database Integration
+
+### Define Connections
+
+```ts
+import { createDbManagerMiddleware, defineDatabase } from "honovajs";
+
+type Env = { DATABASE_URL: string; ANALYTICS_URL: string };
+
+const database = defineDatabase<Env>()({
+  lifecycle: { strategy: "request" }, // default
+  defaultConnection: "main",
+  connections: [
+    {
+      connectionName: "main",
+      adapter: {
+        name: "custom",
+        connect: async ({ url }) => ({ url }),
+      },
+      urlFromEnv: "DATABASE_URL",
+      // default connection is always initialized per request
+    },
+    {
+      connectionName: "analytics",
+      adapter: {
+        name: "custom",
+        connect: async ({ url }) => ({ url }),
+      },
+      urlFromEnv: "ANALYTICS_URL",
+      eager: true, // optional; initialize this non-default connection on every request
+    },
+  ],
+});
+
+const app = createApp<Env>({
+  database,
+});
+```
+
+Inside handlers:
+
+- `c.db` points to the default connection and also exposes named connections.
+- `c.get("dbConnections")` returns all named connections.
+- Non-default connections are lazy by default (`eager: false`).
+- `lifecycle.strategy` defaults to `"request"` (cleanup after each request). Use `"manual"` only when you intentionally manage connection lifecycle yourself.
+
+## Cloudflare Workers Deployment
+
+Honova exposes `app.fetch`, so Worker export is direct:
+
+```ts
+export default {
+  fetch: app.fetch,
+};
+```
+
+Use your standard Worker workflow with Wrangler:
+
+```bash
+npm run build
+wrangler deploy
+```
+
+## API Surface
+
+Main exports include:
+
+- App/runtime: `createApp`, `Application`
+- Decorators: `Module`, `Controller`, `Injectable`, `Inject`, `UseMiddleware`, HTTP method decorators
+- DI helper: `inject`
+- Database: `defineDatabase`, `DatabaseManager`, `createDbManagerMiddleware`, `createDrizzleAdapter`, `createPrismaAdapter`, `createMongoDbAdapter` (legacy `createMondelAdapter`), helpers from `database/types`
+- Auth middleware: `UseBearerAuth`, `BearerAuth`, `UseApiKey`, `ApiKeyAuth`
+
+## Development Scripts
+
+```bash
+npm run typecheck
+npm run test
+npm run build
+```
+
+## Publish Checklist (npm)
+
+- [x] Version set to `0.0.1`
+- [x] ESM build output in `dist/`
+- [x] Type declarations emitted
+- [x] Package `files` restricted to `dist`
+- [x] `prepublishOnly` runs typecheck + tests + build
+- [ ] npm organization metadata (`repository`, `bugs`, `homepage`) if needed
+- [ ] `npm publish --access public`
+
+## License
+
+MIT

package/dist/adapters/db/drizzle.d.ts

@@ -0,0 +1,7 @@
+import type { DatabaseAdapter } from "../../database/manager";
+export interface DrizzleAdapterOptions<TClient> {
+    connect: (url: string) => Promise<TClient> | TClient;
+    disconnect?: (client: TClient) => Promise<void> | void;
+}
+export declare function createDrizzleAdapter<Env extends Record<string, unknown>, TClient>(options: DrizzleAdapterOptions<TClient>): DatabaseAdapter<Env, TClient, unknown>;
+//# sourceMappingURL=drizzle.d.ts.map

package/dist/adapters/db/drizzle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"drizzle.d.ts","sourceRoot":"","sources":["../../../src/adapters/db/drizzle.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAE9D,MAAM,WAAW,qBAAqB,CAAC,OAAO;IAC5C,OAAO,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC,OAAO,CAAC,GAAG,OAAO,CAAC;IACrD,UAAU,CAAC,EAAE,CAAC,MAAM,EAAE,OAAO,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;CACxD;AAED,wBAAgB,oBAAoB,CAClC,GAAG,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACnC,OAAO,EAEP,OAAO,EAAE,qBAAqB,CAAC,OAAO,CAAC,GACtC,eAAe,CAAC,GAAG,EAAE,OAAO,EAAE,OAAO,CAAC,CAMxC"}

package/dist/adapters/db/drizzle.js

@@ -0,0 +1,8 @@
+export function createDrizzleAdapter(options) {
+    return {
+        name: "drizzle",
+        connect: async ({ url }) => options.connect(url),
+        disconnect: options.disconnect,
+    };
+}
+//# sourceMappingURL=drizzle.js.map

package/dist/adapters/db/drizzle.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"drizzle.js","sourceRoot":"","sources":["../../../src/adapters/db/drizzle.ts"],"names":[],"mappings":"AAOA,MAAM,UAAU,oBAAoB,CAIlC,OAAuC;IAEvC,OAAO;QACL,IAAI,EAAE,SAAS;QACf,OAAO,EAAE,KAAK,EAAE,EAAE,GAAG,EAAE,EAAE,EAAE,CAAC,OAAO,CAAC,OAAO,CAAC,GAAG,CAAC;QAChD,UAAU,EAAE,OAAO,CAAC,UAAU;KAC/B,CAAC;AACJ,CAAC"}

package/dist/adapters/db/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./drizzle";
+export * from "./mongodb";
+export * from "./mondel";
+export * from "./prisma";
+//# sourceMappingURL=index.d.ts.map

package/dist/adapters/db/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/adapters/db/index.ts"],"names":[],"mappings":"AAAA,cAAc,WAAW,CAAC;AAC1B,cAAc,WAAW,CAAC;AAC1B,cAAc,UAAU,CAAC;AACzB,cAAc,UAAU,CAAC"}

package/dist/adapters/db/index.js

@@ -0,0 +1,5 @@
+export * from "./drizzle";
+export * from "./mongodb";
+export * from "./mondel";
+export * from "./prisma";
+//# sourceMappingURL=index.js.map

package/dist/adapters/db/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/adapters/db/index.ts"],"names":[],"mappings":"AAAA,cAAc,WAAW,CAAC;AAC1B,cAAc,WAAW,CAAC;AAC1B,cAAc,UAAU,CAAC;AACzB,cAAc,UAAU,CAAC"}

package/dist/adapters/db/mondel.d.ts

@@ -0,0 +1,2 @@
+export { type MongoDbAdapterOptions as MondelAdapterOptions, createMongoDbAdapter as createMondelAdapter, } from "./mongodb";
+//# sourceMappingURL=mondel.d.ts.map

package/dist/adapters/db/mondel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mondel.d.ts","sourceRoot":"","sources":["../../../src/adapters/db/mondel.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,qBAAqB,IAAI,oBAAoB,EAClD,oBAAoB,IAAI,mBAAmB,GAC5C,MAAM,WAAW,CAAC"}

package/dist/adapters/db/mondel.js

@@ -0,0 +1,2 @@
+export { createMongoDbAdapter as createMondelAdapter, } from "./mongodb";
+//# sourceMappingURL=mondel.js.map

package/dist/adapters/db/mondel.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mondel.js","sourceRoot":"","sources":["../../../src/adapters/db/mondel.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,oBAAoB,IAAI,mBAAmB,GAC5C,MAAM,WAAW,CAAC"}

package/dist/adapters/db/mongodb.d.ts

@@ -0,0 +1,7 @@
+import type { DatabaseAdapter } from "../../database/manager";
+export interface MongoDbAdapterOptions<TClient, TConnectOptions> {
+    connect: (url: string, options: TConnectOptions) => Promise<TClient> | TClient;
+    disconnect?: (client: TClient) => Promise<void> | void;
+}
+export declare function createMongoDbAdapter<Env extends Record<string, unknown>, TClient, TConnectOptions>(adapterOptions: MongoDbAdapterOptions<TClient, TConnectOptions>): DatabaseAdapter<Env, TClient, TConnectOptions>;
+//# sourceMappingURL=mongodb.d.ts.map

package/dist/adapters/db/mongodb.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mongodb.d.ts","sourceRoot":"","sources":["../../../src/adapters/db/mongodb.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAE9D,MAAM,WAAW,qBAAqB,CAAC,OAAO,EAAE,eAAe;IAC7D,OAAO,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,eAAe,KAAK,OAAO,CAAC,OAAO,CAAC,GAAG,OAAO,CAAC;IAC/E,UAAU,CAAC,EAAE,CAAC,MAAM,EAAE,OAAO,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;CACxD;AAED,wBAAgB,oBAAoB,CAClC,GAAG,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACnC,OAAO,EACP,eAAe,EAEf,cAAc,EAAE,qBAAqB,CAAC,OAAO,EAAE,eAAe,CAAC,GAC9D,eAAe,CAAC,GAAG,EAAE,OAAO,EAAE,eAAe,CAAC,CAMhD"}

package/dist/adapters/db/mongodb.js

@@ -0,0 +1,8 @@
+export function createMongoDbAdapter(adapterOptions) {
+    return {
+        name: "mongodb",
+        connect: async ({ url, options }) => adapterOptions.connect(url, options),
+        disconnect: adapterOptions.disconnect,
+    };
+}
+//# sourceMappingURL=mongodb.js.map

package/dist/adapters/db/mongodb.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mongodb.js","sourceRoot":"","sources":["../../../src/adapters/db/mongodb.ts"],"names":[],"mappings":"AAOA,MAAM,UAAU,oBAAoB,CAKlC,cAA+D;IAE/D,OAAO;QACL,IAAI,EAAE,SAAS;QACf,OAAO,EAAE,KAAK,EAAE,EAAE,GAAG,EAAE,OAAO,EAAE,EAAE,EAAE,CAAC,cAAc,CAAC,OAAO,CAAC,GAAG,EAAE,OAAO,CAAC;QACzE,UAAU,EAAE,cAAc,CAAC,UAAU;KACtC,CAAC;AACJ,CAAC"}

package/dist/adapters/db/prisma.d.ts

@@ -0,0 +1,9 @@
+import type { DatabaseAdapter } from "../../database/manager";
+export interface PrismaAdapterOptions<TClient> {
+    connect: (url: string) => Promise<TClient> | TClient;
+    disconnect?: (client: TClient) => Promise<void> | void;
+}
+export declare function createPrismaAdapter<Env extends Record<string, unknown>, TClient extends {
+    $disconnect?: () => Promise<void> | void;
+}>(options: PrismaAdapterOptions<TClient>): DatabaseAdapter<Env, TClient, unknown>;
+//# sourceMappingURL=prisma.d.ts.map

package/dist/adapters/db/prisma.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prisma.d.ts","sourceRoot":"","sources":["../../../src/adapters/db/prisma.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAE9D,MAAM,WAAW,oBAAoB,CAAC,OAAO;IAC3C,OAAO,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC,OAAO,CAAC,GAAG,OAAO,CAAC;IACrD,UAAU,CAAC,EAAE,CAAC,MAAM,EAAE,OAAO,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;CACxD;AAED,wBAAgB,mBAAmB,CACjC,GAAG,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACnC,OAAO,SAAS;IAAE,WAAW,CAAC,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAA;CAAE,EAE5D,OAAO,EAAE,oBAAoB,CAAC,OAAO,CAAC,GACrC,eAAe,CAAC,GAAG,EAAE,OAAO,EAAE,OAAO,CAAC,CAexC"}

package/dist/adapters/db/prisma.js

@@ -0,0 +1,16 @@
+export function createPrismaAdapter(options) {
+    return {
+        name: "prisma",
+        connect: async ({ url }) => options.connect(url),
+        disconnect: async (client) => {
+            if (options.disconnect) {
+                await options.disconnect(client);
+                return;
+            }
+            if (typeof client.$disconnect === "function") {
+                await client.$disconnect();
+            }
+        },
+    };
+}
+//# sourceMappingURL=prisma.js.map

package/dist/adapters/db/prisma.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"prisma.js","sourceRoot":"","sources":["../../../src/adapters/db/prisma.ts"],"names":[],"mappings":"AAOA,MAAM,UAAU,mBAAmB,CAIjC,OAAsC;IAEtC,OAAO;QACL,IAAI,EAAE,QAAQ;QACd,OAAO,EAAE,KAAK,EAAE,EAAE,GAAG,EAAE,EAAE,EAAE,CAAC,OAAO,CAAC,OAAO,CAAC,GAAG,CAAC;QAChD,UAAU,EAAE,KAAK,EAAE,MAAM,EAAE,EAAE;YAC3B,IAAI,OAAO,CAAC,UAAU,EAAE,CAAC;gBACvB,MAAM,OAAO,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC;gBACjC,OAAO;YACT,CAAC;YAED,IAAI,OAAO,MAAM,CAAC,WAAW,KAAK,UAAU,EAAE,CAAC;gBAC7C,MAAM,MAAM,CAAC,WAAW,EAAE,CAAC;YAC7B,CAAC;QACH,CAAC;KACF,CAAC;AACJ,CAAC"}

package/dist/core/application.d.ts

@@ -0,0 +1,45 @@
+import { Hono, type MiddlewareHandler } from "hono";
+import { cors } from "hono/cors";
+import { secureHeaders } from "hono/secure-headers";
+import { Container } from "./container/container";
+import { type DbManagerMiddlewareOptions } from "../database/middleware";
+import type { Constructor } from "./types";
+export interface SecurityOptions {
+    cors?: Parameters<typeof cors>[0];
+    secureHeaders?: boolean | Parameters<typeof secureHeaders>[0];
+}
+export interface ObservabilityOptions {
+    requestIdHeader?: string;
+    enableAccessLogs?: boolean;
+    logLevel?: "debug" | "info" | "warn" | "error";
+    redactHeaders?: string[];
+}
+export interface ApplicationOptions<Env extends Record<string, unknown>> {
+    basePath?: string;
+    globalMiddlewares?: MiddlewareHandler[];
+    database?: DbManagerMiddlewareOptions<Env>;
+    security?: SecurityOptions;
+    observability?: ObservabilityOptions;
+    di?: {
+        strict?: boolean;
+    };
+}
+export declare class Application<Env extends Record<string, unknown> = Record<string, unknown>> {
+    private app;
+    private readonly container;
+    private readonly router;
+    private readonly registeredProviders;
+    private readonly registeredControllers;
+    private readonly registeredModules;
+    private readonly moduleResolutionStack;
+    constructor(options?: ApplicationOptions<Env>);
+    registerModule(moduleClass: Constructor): this;
+    use(middleware: MiddlewareHandler): this;
+    getContainer(): Container;
+    getHono(): Hono<{
+        Bindings: Env;
+    }>;
+    fetch: (request: Request, env: Env, ctx: any) => Response | Promise<Response>;
+}
+export declare function createApp<Env extends Record<string, unknown> = Record<string, unknown>>(options?: ApplicationOptions<Env>): Application<Env>;
+//# 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,OAAO,EAAE,IAAI,EAAE,KAAK,iBAAiB,EAAE,MAAM,MAAM,CAAC;AACpD,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AACjC,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAEpD,OAAO,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AAClD,OAAO,EAA6B,KAAK,0BAA0B,EAAE,MAAM,wBAAwB,CAAC;AAEpG,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAG3C,MAAM,WAAW,eAAe;IAC9B,IAAI,CAAC,EAAE,UAAU,CAAC,OAAO,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC;IAClC,aAAa,CAAC,EAAE,OAAO,GAAG,UAAU,CAAC,OAAO,aAAa,CAAC,CAAC,CAAC,CAAC,CAAC;CAC/D;AAED,MAAM,WAAW,oBAAoB;IACnC,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,QAAQ,CAAC,EAAE,OAAO,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC;IAC/C,aAAa,CAAC,EAAE,MAAM,EAAE,CAAC;CAC1B;AAED,MAAM,WAAW,kBAAkB,CAAC,GAAG,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IACrE,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,iBAAiB,CAAC,EAAE,iBAAiB,EAAE,CAAC;IACxC,QAAQ,CAAC,EAAE,0BAA0B,CAAC,GAAG,CAAC,CAAC;IAC3C,QAAQ,CAAC,EAAE,eAAe,CAAC;IAC3B,aAAa,CAAC,EAAE,oBAAoB,CAAC;IACrC,EAAE,CAAC,EAAE;QAAE,MAAM,CAAC,EAAE,OAAO,CAAA;KAAE,CAAC;CAC3B;AA6CD,qBAAa,WAAW,CAAC,GAAG,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IACpF,OAAO,CAAC,GAAG,CAA0B;IACrC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAY;IACtC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAc;IACrC,OAAO,CAAC,QAAQ,CAAC,mBAAmB,CAA0B;IAC9D,OAAO,CAAC,QAAQ,CAAC,qBAAqB,CAA0B;IAChE,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAA0B;IAC5D,OAAO,CAAC,QAAQ,CAAC,qBAAqB,CAAqB;gBAE/C,OAAO,GAAE,kBAAkB,CAAC,GAAG,CAAM;IA0CjD,cAAc,CAAC,WAAW,EAAE,WAAW,GAAG,IAAI;IA2D9C,GAAG,CAAC,UAAU,EAAE,iBAAiB,GAAG,IAAI;IAKxC,YAAY,IAAI,SAAS;IAIzB,OAAO,IAAI,IAAI,CAAC;QAAE,QAAQ,EAAE,GAAG,CAAA;KAAE,CAAC;IAIlC,KAAK,GAAI,SAAS,OAAO,EAAE,KAAK,GAAG,EAAE,KAAK,GAAG,KAAG,QAAQ,GAAG,OAAO,CAAC,QAAQ,CAAC,CAE1E;CACH;AAED,wBAAgB,SAAS,CAAC,GAAG,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACrF,OAAO,GAAE,kBAAkB,CAAC,GAAG,CAAM,GACpC,WAAW,CAAC,GAAG,CAAC,CAElB"}

package/dist/core/application.js

@@ -0,0 +1,138 @@
+import { Hono } from "hono";
+import { cors } from "hono/cors";
+import { secureHeaders } from "hono/secure-headers";
+import { Container } from "./container/container";
+import { createDbManagerMiddleware } from "../database/middleware";
+import { Router } from "./router/router";
+import { getInjectableMetadata, getModuleMetadata } from "./metadata";
+const defaultRedactHeaders = ["authorization", "cookie", "set-cookie", "x-api-key"];
+function createObservabilityMiddleware(options) {
+    const requestIdHeader = options?.requestIdHeader ?? "x-request-id";
+    const accessLogs = options?.enableAccessLogs ?? true;
+    const level = options?.logLevel ?? "info";
+    const redactHeaders = options?.redactHeaders ?? defaultRedactHeaders;
+    return async (c, next) => {
+        const requestId = c.req.header(requestIdHeader) ?? crypto.randomUUID();
+        const start = Date.now();
+        await next();
+        c.res.headers.set(requestIdHeader, requestId);
+        if (!accessLogs) {
+            return;
+        }
+        const status = c.res.status;
+        const line = `[${requestId}] ${c.req.method} ${c.req.path} -> ${status} (${Date.now() - start}ms)`;
+        if (status >= 500) {
+            console.error(line);
+        }
+        else if (status >= 400) {
+            console.warn(line);
+        }
+        else if (level !== "error" && level !== "warn") {
+            console.info(line);
+        }
+        if (level === "debug") {
+            const headers = {};
+            const redacted = new Set(redactHeaders.map((h) => h.toLowerCase()));
+            c.req.raw.headers.forEach((value, key) => {
+                headers[key] = redacted.has(key.toLowerCase()) ? "[REDACTED]" : value;
+            });
+            console.debug(`[${requestId}] request_headers`, headers);
+        }
+    };
+}
+export class Application {
+    constructor(options = {}) {
+        this.registeredProviders = new Set();
+        this.registeredControllers = new Set();
+        this.registeredModules = new Set();
+        this.moduleResolutionStack = [];
+        this.fetch = (request, env, ctx) => {
+            return this.app.fetch(request, env, ctx);
+        };
+        this.app = new Hono({ strict: false });
+        this.container = new Container();
+        this.container.configure({ strict: options.di?.strict ?? true });
+        if (options.basePath) {
+            this.app = this.app.basePath(options.basePath);
+        }
+        this.app.use("*", createObservabilityMiddleware(options.observability));
+        this.app.use("*", cors(options.security?.cors));
+        if (options.security?.secureHeaders) {
+            const settings = typeof options.security.secureHeaders === "boolean"
+                ? undefined
+                : options.security.secureHeaders;
+            this.app.use("*", secureHeaders(settings));
+        }
+        if (options.database) {
+            this.app.use("*", createDbManagerMiddleware(options.database));
+        }
+        for (const middleware of options.globalMiddlewares ?? []) {
+            this.app.use("*", middleware);
+        }
+        this.app.notFound((c) => c.json({ error: { code: "not_found", message: "Route not found" } }, 404));
+        this.app.onError((err, c) => {
+            console.error(err);
+            return c.json({ error: { code: "internal_error", message: "Internal server error" } }, 500);
+        });
+        this.router = new Router(this.app, this.container);
+    }
+    registerModule(moduleClass) {
+        if (this.registeredModules.has(moduleClass)) {
+            return this;
+        }
+        const cycleStartIndex = this.moduleResolutionStack.indexOf(moduleClass);
+        if (cycleStartIndex >= 0) {
+            const cycle = [...this.moduleResolutionStack.slice(cycleStartIndex), moduleClass]
+                .map((moduleToken) => moduleToken.name)
+                .join(" -> ");
+            throw new Error(`Circular module import detected: ${cycle}`);
+        }
+        this.moduleResolutionStack.push(moduleClass);
+        try {
+            const metadata = getModuleMetadata(moduleClass);
+            if (!metadata) {
+                throw new Error(`Class ${moduleClass.name} is not decorated with @Module()`);
+            }
+            for (const imported of metadata.imports ?? []) {
+                this.registerModule(imported);
+            }
+            for (const provider of metadata.providers ?? []) {
+                const injectableMetadata = getInjectableMetadata(provider);
+                if (!injectableMetadata) {
+                    throw new Error(`Provider ${provider.name} in ${moduleClass.name} must be decorated with @Injectable().`);
+                }
+                if (!this.registeredProviders.has(provider)) {
+                    this.container.register(provider);
+                    this.registeredProviders.add(provider);
+                }
+            }
+            for (const controller of metadata.controllers ?? []) {
+                if (this.registeredControllers.has(controller)) {
+                    continue;
+                }
+                this.container.register(controller);
+                this.router.registerController(controller);
+                this.registeredControllers.add(controller);
+            }
+            this.registeredModules.add(moduleClass);
+            return this;
+        }
+        finally {
+            this.moduleResolutionStack.pop();
+        }
+    }
+    use(middleware) {
+        this.app.use("*", middleware);
+        return this;
+    }
+    getContainer() {
+        return this.container;
+    }
+    getHono() {
+        return this.app;
+    }
+}
+export function createApp(options = {}) {
+    return new Application(options);
+}
+//# sourceMappingURL=application.js.map