@katajs/core 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Yaseer A. Okino
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,110 @@
+# @katajs/core
+
+The runtime for [katajs](https://github.com/ookino/katajs) — an opinionated framework for [Hono](https://hono.dev) on [Cloudflare Workers](https://developers.cloudflare.com/workers/).
+
+```bash
+pnpm add @katajs/core hono zod @hono/zod-validator
+```
+
+## What you get
+
+- `defineModule` — declare a unit of code (provides + requires + routes)
+- `createApp` — boot a Hono app from a list of modules with validated dependencies
+- Per-request DI container with lazy resolution and cycle detection
+- `AppError` + `errorMapper` — typed domain errors → HTTP responses
+- `validate({ body, query, param })` — Zod validation that preserves Hono RPC types
+- `inspectModules` — static graph inspection (Mermaid + HTML)
+- `@katajs/core/testing` — `makeTestContainer` for unit tests
+
+## A minimal example
+
+```ts
+import { Hono } from 'hono';
+import { createApp, defineModule, validate } from '@katajs/core';
+import { z } from 'zod';
+
+// 1. Declare a module
+const greetingModule = defineModule({
+  name: 'greeting',
+  provides: {
+    greeter: () => ({ greet: (name: string) => `hello, ${name}` }),
+  },
+  requires: [] as const,
+  routes: new Hono().get(
+    '/:name',
+    ...validate({ param: z.object({ name: z.string() }) }),
+    (c) => {
+      const { name } = c.req.valid('param');
+      return c.json({ msg: c.var.resolve('greeter').greet(name) });
+    },
+  ),
+  prefix: '/hello',
+});
+
+// 2. Tell the Registry about it (in src/types.d.ts)
+declare module '@katajs/core' {
+  interface Registry {
+    greeter: { greet: (name: string) => string };
+  }
+}
+
+// 3. Boot the app
+const { app } = createApp({
+  bindings: {} as { /* your Cloudflare bindings */ },
+  modules: [greetingModule],
+  routes: (base) => base.route(greetingModule.prefix, greetingModule.routes),
+});
+
+export default app;
+export type AppType = typeof app;
+```
+
+## Public API
+
+```ts
+// Modules
+export { defineModule } from '@katajs/core';
+export type { Module, RoutedModule, ServiceOnlyModule } from '@katajs/core';
+
+// App
+export { createApp } from '@katajs/core';
+export type { AppConfig, BaseApp } from '@katajs/core';
+
+// Middleware
+export { defineMiddleware } from '@katajs/core';
+export type { DbAdapter, RequestVariables } from '@katajs/core';
+
+// Errors
+export { AppError, ValidationError, errorMapper } from '@katajs/core';
+
+// Validation
+export { validate } from '@katajs/core';
+
+// Devtools
+export { inspectModules } from '@katajs/core';
+
+// Augmentable interfaces
+export type { Registry, AppEnv, AppDb, RegistryKey } from '@katajs/core';
+
+// Testing helpers
+export { makeTestContainer } from '@katajs/core/testing';
+```
+
+## Documentation
+
+- [Concepts: intro](https://github.com/ookino/katajs/blob/main/docs/concepts/intro.md)
+- [Concepts: modules](https://github.com/ookino/katajs/blob/main/docs/concepts/modules.md)
+- [Concepts: container](https://github.com/ookino/katajs/blob/main/docs/concepts/container.md)
+- [Concepts: registry](https://github.com/ookino/katajs/blob/main/docs/concepts/registry.md)
+- [Concepts: routes](https://github.com/ookino/katajs/blob/main/docs/concepts/routes.md)
+- [Concepts: validation](https://github.com/ookino/katajs/blob/main/docs/concepts/validation.md)
+- [Concepts: errors](https://github.com/ookino/katajs/blob/main/docs/concepts/errors.md)
+- [Concepts: transactions](https://github.com/ookino/katajs/blob/main/docs/concepts/transactions.md)
+- [Concepts: testing](https://github.com/ookino/katajs/blob/main/docs/concepts/testing.md)
+- [Concepts: devtools](https://github.com/ookino/katajs/blob/main/docs/concepts/devtools.md)
+- [Concepts: architecture](https://github.com/ookino/katajs/blob/main/docs/concepts/architecture.md)
+- [Showcase example](https://github.com/ookino/katajs/tree/main/examples/showcase)
+
+## License
+
+[MIT](./LICENSE) © Yaseer A. Okino

package/dist/index.d.ts

@@ -0,0 +1,408 @@
+import { Hono, MiddlewareHandler, Context } from 'hono';
+import { P as ProvidesMap, R as RequiresList, C as ConsumerSpec, M as ModuleContainer, S as ServiceFactory, a as RequestContainer, Q as QueuesRegistry, b as QueueDeclaration } from './types-B_SUwInq.js';
+export { A as AppDb, c as AppEnv, B as BaseContainer, d as ConsumerBatchHandler, e as ConsumerHandler, f as MergeProvides, g as MessageSchema, h as Registry, i as RegistryKey, j as ResolveOf, k as ResolveProvides, l as ResolvedProvides, m as SendBatchOptions, n as SendOptions, T as TransactionalContainer, o as TypedQueue, V as ValidatedBatch, p as ValidatedMessage } from './types-B_SUwInq.js';
+import { zValidator } from '@hono/zod-validator';
+import { ZodSchema } from 'zod';
+
+type AnyHono = Hono<any, any, any>;
+/**
+ * A services-only module: defines the registry contributions and dependency
+ * graph for a feature, but mounts no HTTP routes. Use for cross-cutting
+ * concerns like an `events` recorder or an `audit` logger that other modules
+ * fan out into. Optionally carries a queue `consumer` so a services-only
+ * module can also process queue messages (notifications, indexing, etc.).
+ */
+type ServiceOnlyModule<Provides extends ProvidesMap = ProvidesMap, Requires extends RequiresList = RequiresList> = {
+    readonly name: string;
+    readonly provides: Provides;
+    readonly requires: Requires;
+    readonly consumer?: ConsumerSpec<any>;
+};
+/**
+ * A routed module: services + HTTP routes mounted at a fixed prefix. The
+ * routes and prefix are co-required — they always come as a pair. May also
+ * carry a queue `consumer` for modules that own both an HTTP surface and a
+ * queue handler (e.g., an `orders` module with CRUD routes plus a consumer
+ * that processes order events).
+ */
+type RoutedModule<Provides extends ProvidesMap = ProvidesMap, Requires extends RequiresList = RequiresList, Routes extends AnyHono = AnyHono, Prefix extends string = string> = ServiceOnlyModule<Provides, Requires> & {
+    readonly routes: Routes;
+    readonly prefix: Prefix;
+};
+/** Either kind. Used internally by `createApp` and the boot validation. */
+type Module<Provides extends ProvidesMap = ProvidesMap, Requires extends RequiresList = RequiresList> = ServiceOnlyModule<Provides, Requires> | RoutedModule<Provides, Requires>;
+/** Map of service keys to their resolved (return) types. */
+type ProvidesReturns<P extends Record<string, unknown>> = {
+    readonly [K in keyof P]: ServiceFactory<P[K]>;
+};
+type DefineSpecBase<PReturns extends Record<string, unknown>, Requires extends RequiresList> = {
+    readonly name: string;
+    readonly provides: {
+        readonly [K in keyof PReturns]: (c: ModuleContainer<PReturns, Requires[number]>) => PReturns[K];
+    };
+    readonly requires: Requires;
+    readonly consumer?: ConsumerSpec<any>;
+};
+/**
+ * Declare a feature module. Returns either a `RoutedModule` (when `routes`
+ * and `prefix` are provided) or a `ServiceOnlyModule` (when they aren't).
+ * The two-overload signature means TypeScript can prove at the type level
+ * that `routedModule.routes` is non-optional — no `!` at the call site.
+ *
+ * DX caveat: in a module with exactly one factory in `provides`,
+ * TypeScript's self-referential inference of `PReturns` weakens — `c.resolve`
+ * may not reject undeclared keys at compile time inside that lone factory.
+ * The runtime boot-time checks (§10) still catch every error.
+ */
+declare function defineModule<PReturns extends Record<string, unknown>, Requires extends RequiresList, Routes extends AnyHono, Prefix extends string>(spec: DefineSpecBase<PReturns, Requires> & {
+    readonly routes: Routes;
+    readonly prefix: Prefix;
+}): RoutedModule<ProvidesReturns<PReturns>, Requires, Routes, Prefix>;
+declare function defineModule<PReturns extends Record<string, unknown>, Requires extends RequiresList>(spec: DefineSpecBase<PReturns, Requires>): ServiceOnlyModule<ProvidesReturns<PReturns>, Requires>;
+
+/**
+ * Hono Variables shape contributed by katajs's container middleware.
+ *
+ * `resolve`, `withTransaction`, and `queues` are convenience handles mounted
+ * directly on `c.var` so route handlers can write
+ * `c.var.resolve('postService')` and `c.var.queues.orders.send(...)` without
+ * digging into `c.var.container`.
+ */
+type RequestVariables = {
+    container: RequestContainer;
+    requestId: string;
+    resolve: RequestContainer['resolve'];
+    withTransaction: RequestContainer['withTransaction'];
+    queues: QueuesRegistry;
+};
+/**
+ * Adapter contract for the database layer. `create` is called once per request
+ * to produce the per-request client; `runTransaction` (optional) runs a callback
+ * inside a transaction with a transaction-bound client (`txDb`).
+ *
+ * The `db` and `txDb` types are intentionally loose (`any`) at the adapter
+ * boundary because, e.g., Drizzle's `DrizzleClient` and `DrizzleTx` are
+ * different types with the same query API. User code should rely on the
+ * augmented `AppDb` interface to type `c.db`, treating the client and tx as
+ * interchangeable for repository code (per spec §6.4).
+ */
+type DbAdapter = {
+    create(env: unknown): unknown;
+    runTransaction?<T>(db: any, fn: (txDb: any) => Promise<T>): Promise<T>;
+};
+/**
+ * Typed-identity helper for user-defined middleware. Lets the user write
+ * `c.var.container` (and the shortcuts) without authoring the env generics inline.
+ */
+declare function defineMiddleware<Env extends {
+    Variables: RequestVariables;
+} = {
+    Variables: RequestVariables;
+}>(handler: MiddlewareHandler<Env>): MiddlewareHandler<Env>;
+
+type ErrorContext = {
+    c: Context;
+    requestId: string;
+};
+/**
+ * Base class for every domain error in user code.
+ *
+ * - `super(message)` is the *internal* message — for logs and stack traces.
+ * - `publicMessage` is what the client sees.
+ * - `publicPayload` is optional structured data merged into the response body.
+ */
+declare abstract class AppError extends Error {
+    abstract readonly status: number;
+    abstract readonly code: string;
+    abstract readonly publicMessage: string;
+    /**
+     * Optional structured payload merged into the response body. Subclasses may
+     * override as either a property or a getter.
+     */
+    get publicPayload(): Record<string, unknown> | undefined;
+    constructor(message: string);
+}
+type ValidationIssue = {
+    path: (string | number)[];
+    message: string;
+};
+declare class ValidationError extends AppError {
+    readonly issues: ValidationIssue[];
+    readonly status = 400;
+    readonly code = "validation_failed";
+    readonly publicMessage = "Request validation failed";
+    constructor(issues: ValidationIssue[]);
+    get publicPayload(): Record<string, unknown>;
+}
+type ErrorMapperOptions = {
+    /** Hook invoked for unhandled (non-AppError) errors. Use to log to Sentry, etc. */
+    onUnhandled?: (err: unknown, ctx: ErrorContext) => void;
+};
+type ErrorMapperHandler = (err: Error, c: Context) => Response | Promise<Response>;
+/**
+ * Build a Hono `onError` handler that renders thrown errors as JSON.
+ *
+ * - `AppError` subclasses → `{error, message, ...publicPayload, requestId}` at the error's status.
+ * - Other errors → safe 500 with `requestId`; `onUnhandled` invoked with the original error.
+ *
+ * Wired automatically by `createApp` via `app.onError(errorMapper(opts))`.
+ */
+declare function errorMapper(opts?: ErrorMapperOptions): ErrorMapperHandler;
+
+/**
+ * Helper for defining a queue consumer with full contextual typing on the
+ * `handle` / `handleBatch` parameters. Drives contextual typing for the
+ * inner functions so `message.body` is inferred from the schema instead of
+ * widening to `unknown`.
+ *
+ *   export const ordersConsumer = defineConsumer({
+ *     queue: 'ORDER_QUEUE',
+ *     schema: OrderEventSchema,
+ *     async handle(message, c) {
+ *       message.body;  // typed as z.infer<typeof OrderEventSchema>
+ *     },
+ *   });
+ */
+declare function defineConsumer<TBody>(spec: ConsumerSpec<TBody>): ConsumerSpec<TBody>;
+/**
+ * Cloudflare Queues `Message<Body>` shape, duck-typed to avoid a hard dep on
+ * `@cloudflare/workers-types`. Only the fields the framework consumes are
+ * declared.
+ */
+type RawMessage<Body = unknown> = {
+    readonly id: string;
+    readonly timestamp: Date;
+    readonly body: Body;
+    readonly attempts: number;
+    ack(): void;
+    retry(options?: {
+        delaySeconds?: number;
+    }): void;
+};
+type RawBatch<Body = unknown> = {
+    readonly queue: string;
+    readonly messages: readonly RawMessage<Body>[];
+    ackAll(): void;
+    retryAll(options?: {
+        delaySeconds?: number;
+    }): void;
+};
+/** Public Worker `queue` handler signature. */
+type QueueHandler = (batch: RawBatch, env: unknown, ctx: unknown) => Promise<void>;
+type QueueErrorContext = {
+    readonly queue: string;
+    readonly messageId?: string;
+    readonly attempts?: number;
+};
+type QueueErrorMapperOptions = {
+    /** Hook invoked when a handler throws. Use for Sentry / Logflare / etc. */
+    onUnhandled?: (err: unknown, ctx: QueueErrorContext) => void;
+};
+type BuildQueueHandlerConfig = {
+    readonly modules: readonly Module[];
+    readonly registry: ReadonlyMap<string, ServiceFactory<unknown>>;
+    readonly db: DbAdapter;
+    readonly errorMapper?: QueueErrorMapperOptions;
+    /** Override `crypto.randomUUID` for deterministic tests. Used as fallback when message has no `id`. */
+    readonly generateRequestId?: () => string;
+};
+
+/** Base Hono app produced by `createApp` (middleware + onError, no routes mounted). */
+type BaseApp = Hono<{
+    Variables: RequestVariables;
+}>;
+type AppConfig<Modules extends readonly Module[] = readonly Module[], ChainResult extends Hono<any, any, any> = BaseApp> = {
+    /**
+     * Type-only marker for the bindings shape (Cloudflare env). Pass `{} as YourBindings`.
+     * v0.1 doesn't propagate bindings to the Hono generic — augment `AppEnv` if you need it.
+     */
+    bindings?: unknown;
+    /** The DB adapter (e.g., `drizzleAdapter()`). */
+    db: DbAdapter;
+    /** Modules to compose. Order doesn't affect behaviour but is the boot validation order. */
+    modules: Modules;
+    /**
+     * User middleware that runs after the container middleware and before any
+     * route handler. Use this for cross-cutting concerns like logging or auth
+     * gates. The error handler is wired automatically via `app.onError`.
+     */
+    middleware?: MiddlewareHandler[];
+    /** Options for the auto-wired errorMapper. Pass `onUnhandled` to log to Sentry, etc. */
+    errorMapper?: ErrorMapperOptions;
+    /**
+     * Options for the queue-side error mapper. Distinct from the HTTP `errorMapper`
+     * because queue failures don't render an HTTP response — they retry or DLQ.
+     * Pass `onUnhandled` to log queue handler failures to Sentry / Logflare / etc.
+     */
+    queueErrorMapper?: QueueErrorMapperOptions;
+    /** Override `crypto.randomUUID` for deterministic tests. */
+    generateRequestId?: () => string;
+    /**
+     * Producer manifest. Each entry registers a queue this app sends to,
+     * surfaced as a typed wrapper at `c.var.queues.<name>.send(body)`.
+     * Validates body against the schema before delegating to the underlying
+     * Cloudflare binding.
+     *
+     *   queues: {
+     *     orders: { binding: 'ORDER_QUEUE', schema: OrderEventSchema },
+     *   }
+     *
+     * Independent of consumer modules — the consumer can live in this app
+     * (single-Worker), in `apps/worker` (monorepo), or be external entirely.
+     */
+    queues?: Record<string, QueueDeclaration>;
+    /**
+     * Define the app's HTTP surface. Receives the framework-prepared base app
+     * (with container middleware + error mapper already wired) and returns the
+     * fully chained app. The chain happens via Hono's native `.route()` /
+     * `.get()` / `.post()` etc., so Hono RPC end-to-end types are preserved.
+     *
+     *   routes: (base) => base
+     *     .get('/health', (c) => c.json({ ok: true }))
+     *     .route(postsModule.prefix, postsModule.routes)
+     *
+     * Omit this option to get the bare base app back; you can then chain
+     * routes externally (the original two-step pattern).
+     */
+    routes?: (base: BaseApp) => ChainResult;
+};
+/**
+ * Compose modules into a Hono app. Performs three boot-time checks (per spec §10.2):
+ *   1. No duplicate `provides` keys across modules.
+ *   2. Every key in any module's `requires` is provided by some module.
+ *   3. No module dependency cycles.
+ *
+ * Throws with a self-explanatory message on any failure (per spec §10.4).
+ *
+ *   const { app } = createApp({
+ *     db: drizzleAdapter({ schema }),
+ *     modules: [eventsModule, auditModule, postsModule],
+ *     routes: (base) => base
+ *       .get('/health', (c) => c.json({ ok: true }))
+ *       .route(postsModule.prefix, postsModule.routes),
+ *   });
+ *   export type AppType = typeof app; // RPC types preserved
+ *   export default app;
+ */
+declare function createApp<const Modules extends readonly Module[], ChainResult extends Hono<any, any, any> = BaseApp>(config: AppConfig<Modules, ChainResult>): {
+    app: ChainResult;
+    modules: Modules;
+    /**
+     * Cloudflare Queues handler. Defined when at least one module declares a
+     * `consumer:` field; `undefined` otherwise. Wire it into the Worker default
+     * export alongside `fetch` to consume queue messages:
+     *
+     *   export default { fetch: app.fetch, queue };
+     */
+    queue: QueueHandler | undefined;
+};
+
+type V<T extends ZodSchema | undefined, Target extends 'json' | 'query' | 'param'> = T extends ZodSchema ? [ReturnType<typeof zValidator<T, Target, any, string>>] : [];
+/**
+ * Validate `body`, `query`, and/or `param` against Zod schemas.
+ *
+ * Returns a tuple of Hono middlewares that the user spreads into a route.
+ * Each middleware preserves Hono RPC's typed surface so `c.req.valid('json' |
+ * 'query' | 'param')` is correctly typed in handlers downstream.
+ *
+ *   app.post('/posts',
+ *     ...validate({ body: CreatePostSchema, param: PostIdParam }),
+ *     async (c) => {
+ *       const body = c.req.valid('json');   // typed as z.infer<typeof CreatePostSchema>
+ *       const params = c.req.valid('param'); // typed as z.infer<typeof PostIdParam>
+ *     }
+ *   );
+ *
+ * On validation failure, throws a `ValidationError` (rendered as 400 by the
+ * `errorMapper` middleware).
+ */
+declare function validate<TBody extends ZodSchema | undefined = undefined, TQuery extends ZodSchema | undefined = undefined, TParam extends ZodSchema | undefined = undefined>(opts: {
+    body?: TBody;
+    query?: TQuery;
+    param?: TParam;
+}): [...V<TBody, 'json'>, ...V<TQuery, 'query'>, ...V<TParam, 'param'>];
+
+/**
+ * Static snapshot of a module's contribution to the app graph. Doesn't
+ * carry runtime state — purely shape data extracted from the user's
+ * `defineModule(...)` calls.
+ */
+type GraphModule = {
+    name: string;
+    provides: string[];
+    requires: string[];
+    prefix?: string;
+    hasRoutes: boolean;
+    /** Present when the module declares `consumer:` — points at a queue binding. */
+    consumer?: GraphConsumer;
+};
+/** Queue consumer attached to a module. */
+type GraphConsumer = {
+    /** wrangler binding name for the queue this module consumes. */
+    queue: string;
+    /** Optional dead-letter binding name. */
+    dlq?: string;
+};
+/**
+ * Producer manifest entry from `createApp({ queues })`. Producers are app-level
+ * (not module-level) so they're inspected separately from modules.
+ */
+type GraphProducer = {
+    /** The key under `queues:` (also the wrapper name on `c.var.queues.<name>`). */
+    name: string;
+    /** wrangler binding name (e.g. 'ORDER_QUEUE'). */
+    binding: string;
+};
+/** Directed dependency edge: `from` requires service `via`, which `to` provides. */
+type GraphEdge = {
+    from: string;
+    to: string;
+    via: string;
+};
+/** Flattened HTTP route, prefixed with its owning module's mount path. */
+type GraphRoute = {
+    method: string;
+    path: string;
+    module: string;
+};
+type Inspection = {
+    modules: GraphModule[];
+    edges: GraphEdge[];
+    routes: GraphRoute[];
+    /** App-level producer manifests, optional. Empty array when no producers passed. */
+    producers: GraphProducer[];
+    /** A `graph TD` Mermaid source string suitable for embedding in markdown or HTML. */
+    mermaid(): string;
+    /** Pretty-printed JSON for piping to other tooling. */
+    json(): string;
+    /** Self-contained HTML page that renders the graph + tables in a browser. */
+    html(opts?: HtmlOptions): string;
+};
+type InspectOptions = {
+    /**
+     * App-level producer manifests, normally the contents of `createApp({ queues })`.
+     * Each entry maps a producer name to its wrangler binding. Pass-through to the
+     * Inspection's `producers` array so devtools can render producer/consumer pairs.
+     */
+    producers?: Record<string, {
+        binding: string;
+    }>;
+};
+type HtmlOptions = {
+    /** Title shown at the top of the page. Default: "katajs — module graph". */
+    title?: string;
+};
+/**
+ * Inspect a list of modules and return everything needed to render the app's
+ * structure (graph, dependency edges, route table) without booting the app.
+ *
+ * Pure / synchronous — safe to call at build time. Use the returned `.html()`
+ * to write a self-contained snapshot file, or `.mermaid()` to embed in docs.
+ *
+ * TODO(Shape B): when we build the live devtools server, it will read the
+ * same `Inspection` shape from a `__katajs/graph` debug endpoint and render
+ * with an interactive Cytoscape canvas instead of a Mermaid snapshot.
+ */
+declare function inspectModules(modules: readonly Module[], options?: InspectOptions): Inspection;
+
+export { type AnyHono, type AppConfig, AppError, type BaseApp, type BuildQueueHandlerConfig, ConsumerSpec, type DbAdapter, type ErrorContext, type ErrorMapperHandler, type ErrorMapperOptions, type GraphConsumer, type GraphEdge, type GraphModule, type GraphProducer, type GraphRoute, type HtmlOptions, type InspectOptions, type Inspection, type Module, ModuleContainer, ProvidesMap, QueueDeclaration, type QueueErrorContext, type QueueErrorMapperOptions, type QueueHandler, QueuesRegistry, RequestContainer, type RequestVariables, RequiresList, type RoutedModule, ServiceFactory, type ServiceOnlyModule, ValidationError, type ValidationIssue, createApp, defineConsumer, defineMiddleware, defineModule, errorMapper, inspectModules, validate };