@ts-kizuna/express 1.49.5

package/LICENSE.MD

@@ -0,0 +1,9 @@
+MIT License
+
+Copyright (c) 2026 Sondre Ørland
+
+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,37 @@
+# @ts-kizuna/express
+
+`@ts-kizuna/express` connects a ts-kizuna API to an Express 5 application. It handles routing, request validation, body parsing, and error formatting, all driven by your contract.
+
+**Requires Express >= 5.**
+
+## Installation
+
+```sh
+pnpm add @ts-kizuna/express express
+```
+
+## Usage
+
+```ts
+import express from 'express';
+import { KizunaServer } from '@ts-kizuna/express';
+import { contract } from './contract';
+import { router } from './router';
+
+const server = new KizunaServer(contract);
+
+const api = server.api({
+    router,
+});
+
+const app = express();
+app.use(express.json());
+
+api.mount(app);
+
+app.listen(3000);
+```
+
+## Documentation
+
+[Express adapter](https://ts-kizuna.com/docs/adapters/express)

package/dist/index.cjs

@@ -0,0 +1,157 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+let express = require("express");
+let node_stream = require("node:stream");
+let _ts_kizuna_core_adapter = require("@ts-kizuna/core/adapter");
+//#region src/server.ts
+/**
+* Write a web `Response` to a node response. Plugins answer in web terms to stay
+* adapter-agnostic, so the translation belongs here.
+*/
+const writeWebResponse = async (response, res) => {
+	if (!(response instanceof globalThis.Response)) return;
+	res.status(response.status);
+	response.headers.forEach((value, name) => res.setHeader(name, value));
+	if (!response.body) {
+		res.end();
+		return;
+	}
+	node_stream.Readable.fromWeb(response.body).pipe(res);
+};
+const adapter = (0, _ts_kizuna_core_adapter.createAdapter)({
+	buildHandlerContext: (adapterRequest, { res }) => ({
+		req: adapterRequest.request,
+		res
+	}),
+	respond: (result, { res, next, formatError }) => {
+		if (result.kind === "handler-error") {
+			next(result.error);
+			return;
+		}
+		if (result.kind === "raw-response") {
+			writeWebResponse(result.response, res);
+			return;
+		}
+		if (res.headersSent) return;
+		if (result.kind === "not-found" || result.kind === "method-not-allowed") {
+			next();
+			return;
+		}
+		const rendered = (0, _ts_kizuna_core_adapter.renderJsonResult)(result, formatError, res.req);
+		for (const [key, value] of Object.entries(rendered.headers)) res.setHeader(key, value);
+		if (rendered.body === void 0) res.status(rendered.status).end();
+		else if (rendered.raw) {
+			const body = rendered.body;
+			res.status(rendered.status).send(typeof body === "string" || Buffer.isBuffer(body) ? body : Buffer.from(body));
+		} else res.status(rendered.status).json(rendered.body);
+	}
+});
+/**
+* Mount a ts-kizuna API onto an Express app.
+*
+* @example
+* api.mount(app);
+*/
+function mountExpress(api, app, options) {
+	const guards = api[_ts_kizuna_core_adapter.GUARDS_META];
+	const schemes = api[_ts_kizuna_core_adapter.SCHEMES_META];
+	const requestContext = api[_ts_kizuna_core_adapter.REQUEST_CONTEXT_META];
+	const pluginExports = (0, _ts_kizuna_core_adapter.pluginExportsOf)(api);
+	const jobsMeta = api[_ts_kizuna_core_adapter.JOBS_META];
+	const jobRunner = (0, _ts_kizuna_core_adapter.jobRunnerFrom)(jobsMeta);
+	const expressRouter = (0, express.Router)();
+	const mountRoute = (routeKey, route, routes, router) => {
+		expressRouter[route.method.toLowerCase()](route.path, (req, _res, next) => {
+			req.kizunaRoute = route;
+			next();
+		}, async (req, res, next) => {
+			const adapterRequest = {
+				request: req,
+				method: req.method,
+				resolution: {
+					kind: "pre-resolved",
+					routeKey,
+					route,
+					params: req.params
+				},
+				query: req.query,
+				headers: req.headers,
+				readBody: () => req.body
+			};
+			await adapter.handle({
+				routes,
+				router,
+				request: adapterRequest,
+				responseContext: {
+					res,
+					next,
+					formatError: options?.formatError
+				},
+				guards,
+				schemes,
+				requestContext,
+				pluginExports,
+				jobs: jobRunner,
+				responseValidation: options?.responseValidation
+			});
+		});
+	};
+	const mountLane = (routes, router) => {
+		for (const { routeKey, route } of adapter.eachRoute(routes, router)) mountRoute(routeKey, route, routes, router);
+	};
+	mountLane(api.routes, api[_ts_kizuna_core_adapter.ROUTER_META]);
+	mountLane((0, _ts_kizuna_core_adapter.pluginRoutesOf)(api), (0, _ts_kizuna_core_adapter.pluginRouterOf)(api));
+	if (jobsMeta) {
+		const routes = (0, _ts_kizuna_core_adapter.jobRoutes)(jobsMeta);
+		const router = (0, _ts_kizuna_core_adapter.jobRouter)(jobsMeta);
+		for (const [routeKey, route] of Object.entries(routes)) mountRoute(routeKey, route, routes, router);
+	}
+	app.use(expressRouter);
+	return expressRouter;
+}
+const createServerSurface = (contract, options) => {
+	(0, _ts_kizuna_core_adapter.warnUnsupportedJobOptions)(contract.jobs, options?.jobTransport);
+	return {
+		guard: (_name, run) => run,
+		requestContext: (_name, run) => run,
+		router: (groupOrRouter, groupRouter) => groupRouter ?? groupOrRouter,
+		jobs: (handlers) => handlers,
+		api: ({ jobs, ...parts }) => {
+			const api = Object.assign((0, _ts_kizuna_core_adapter.assembleApi)(contract, parts), { [_ts_kizuna_core_adapter.JOBS_META]: contract.jobs ? {
+				jobs: contract.jobs,
+				handlers: jobs ?? {},
+				config: contract.jobsConfig,
+				transport: options?.jobTransport,
+				onError: options?.onJobError
+			} : void 0 });
+			return Object.assign(api, { mount: (app, mountOptions) => mountExpress(api, app, mountOptions) });
+		}
+	};
+};
+/**
+* Turn a contract into a server handle: the serving counterpart to `Kizuna`.
+* Keep the instance and use `server.guard` to define guards, `server.router`
+* to write typed handlers, and `server.api` to assemble them.
+*
+* @example
+* const server = new KizunaServer(contract);
+*
+* const requireUser = server.guard('user', ({ bearer, deny }) => {
+*     const session = bearer && sessions.get(bearer.token);
+*     return session ? { userId: session.userId } : deny(401, 'Unauthorized');
+* });
+*
+* export const api = server.api({
+*     router,
+*     guards: {
+*         user: requireUser,
+*     },
+* });
+*/
+var KizunaServer = class {
+	constructor(contract, options) {
+		Object.assign(this, createServerSurface(contract, options));
+	}
+};
+//#endregion
+exports.KizunaServer = KizunaServer;
+exports.mountExpress = mountExpress;

package/dist/index.d.cts

@@ -0,0 +1,193 @@
+import { Request, Response, Router as Router$1 } from "express";
+import { ApiWithRouter, ContractPlugins, ErrorFormatter, GUARDS_META, GuardDenial, GuardDeny, GuardParams, GuardRun, HandlersFromAuth, JOBS_META, Jobs, PluginArgs, PluginImplementations, REQUEST_CONTEXT_META, RequestContextRun, RequestContextValues, RouteDefinition, RouteHandler as RouteHandler$1, Router as Router$2, Routes, SCHEMES_META, ServerOptions } from "@ts-kizuna/core/adapter";
+import { z } from "zod";
+import { Contract, CredentialOf, GuardSuccess, JobHandlers, JobsArg, RequestContextHeaderValues, RequestContextSchema, SecurityScheme, TagOptions } from "@ts-kizuna/core";
+
+//#region src/server.d.ts
+type ExpressApi<R extends Routes = Routes> = ApiWithRouter<R> & {
+  readonly [GUARDS_META]?: unknown;
+  readonly [SCHEMES_META]?: unknown;
+  readonly [REQUEST_CONTEXT_META]?: unknown;
+  readonly [JOBS_META]?: unknown;
+  /**
+   * Register every contract route on an Express app or router.
+   */
+  mount: (app: AppLike, options?: ExpressOptions) => Router$1;
+};
+/**
+ * The Express request and response passed to each handler.
+ */
+interface ExpressHandlerContext {
+  req: Request;
+  res: Response;
+}
+/**
+ * The handler for a single route, typed against its contract definition.
+ */
+type RouteHandler<R extends RouteDefinition> = RouteHandler$1<R, ExpressHandlerContext>;
+/**
+ * The handler tree for a contract or route group, typed against it. Routes
+ * secured by the contract's `auth` map additionally receive each required
+ * identity's context in their handler args, under `auth`, keyed by the identity's name.
+ */
+type Router<C> = C extends Contract<infer R, infer _Tags, infer _Codes, infer Schemes, infer Auth, infer RequestContext, infer Plugins, infer J> ? HandlersFromAuth<R, ExpressHandlerContext & RequestContextValues<RequestContext> & PluginArgs<Plugins> & JobsArg<J>, Schemes, Auth> : C extends Routes ? Router$2<C, ExpressHandlerContext> : never;
+/**
+ * The handler for each of a contract's scheduled jobs, typed against it. Each
+ * receives only the job's `input`, so the same handler can be run in process.
+ */
+type JobsRouter<C> = C extends Contract<infer _R, infer _Tags, infer _Codes, infer _Schemes, infer _Auth, infer _RequestContext, infer _Plugins, infer J> ? JobHandlers<J> : never;
+/**
+ * The handlers for a group named on the contract, or for a bare route group.
+ * Both forms resolve through one signature: a second candidate of the same
+ * arity costs zero-argument handlers their contextual type.
+ */
+type GroupRouter<Source, GroupOrRoutes> = GroupOrRoutes extends string ? Router<Source>[Extract<GroupOrRoutes, keyof Router<Source>>] : Router<GroupOrRoutes>;
+declare global {
+  namespace Express {
+    interface Request {
+      kizunaRoute?: RouteDefinition;
+    }
+  }
+}
+interface ExpressOptions {
+  /**
+   * Validate handler return values against the route's response schemas.
+   * Mismatches surface as 500 errors. Enable in development.
+   *
+   * @default false
+   */
+  responseValidation?: boolean;
+  /**
+   * Reshape error (status >= 400) response bytes before they are sent. See
+   * {@link ErrorFormatter}.
+   */
+  formatError?: ErrorFormatter<Request>;
+}
+/**
+ * A guard per identity, keyed by name. Each receives the handler context, a
+ * `deny` helper, and the matched route's required scopes, and returns that
+ * identity's {@link GuardSuccess} (its context and access fields) or a `deny(...)`
+ * result. Keying by name lets each guard's return be typed against its own
+ * identity, so access values narrow without an annotation. An
+ * authentication-only identity (no context, no access) returns nothing on
+ * success, or `deny(...)`.
+ */
+type GuardFns<Schemes extends Record<string, SecurityScheme>, Params> = { [Name in keyof Schemes]: (args: ExpressHandlerContext & CredentialOf<Schemes[Name]> & {
+  params: Params;
+  deny: GuardDeny;
+  scopes: string[];
+}) => [keyof GuardSuccess<Schemes[Name]>] extends [never] ? void | GuardDenial | Promise<void | GuardDenial> : GuardSuccess<Schemes[Name]> | GuardDenial | Promise<GuardSuccess<Schemes[Name]> | GuardDenial> };
+/**
+ * One guard per identity declared on the contract.
+ */
+type GuardsForSchemes<Schemes extends Record<string, SecurityScheme>> = { [Name in keyof Schemes]: GuardRun<ExpressHandlerContext> };
+/**
+ * The resolver functions for the request context schemas declared on `kizuna`,
+ * keyed by name. Each runs on every route and returns its schema's value.
+ */
+type RequestResolverFns<RequestContext extends Record<string, RequestContextSchema>> = { [Name in keyof RequestContext]: (args: ExpressHandlerContext & {
+  params: Record<string, string>;
+  headers: RequestContextHeaderValues<RequestContext[Name]>;
+}) => z.output<RequestContext[Name]['context']> | Promise<z.output<RequestContext[Name]['context']>> };
+interface AppLike {
+  use: (router: Router$1) => unknown;
+}
+/**
+ * Mount a ts-kizuna API onto an Express app.
+ *
+ * @example
+ * api.mount(app);
+ */
+declare function mountExpress(api: ExpressApi, app: AppLike, options?: ExpressOptions): Router$1;
+type ServerContract<R extends Routes, Schemes extends Record<string, SecurityScheme>, Auth, RequestContext extends Record<string, RequestContextSchema>, Plugins extends ContractPlugins, J extends Jobs = Jobs> = Contract<R, Record<string, TagOptions>, string, Schemes, Auth, RequestContext, Plugins, J>;
+interface Server<R extends Routes, Schemes extends Record<string, SecurityScheme>, Auth, RequestContext extends Record<string, RequestContextSchema>, Plugins extends ContractPlugins, J extends Jobs = Jobs> {
+  /**
+   * Define a guard for one of the contract's identities. It runs before the
+   * handlers of every route whose `auth` entry requires the identity, and
+   * receives the credential its method extracted (`bearer`, `apiKey`, or
+   * `basic`, `null` when absent). Return the identity's context and access
+   * fields to allow the request, or call `deny(status, detail)`.
+   */
+  guard<const Name extends Extract<keyof Schemes, string>>(name: Name, run: GuardFns<Schemes, GuardParams<R, Auth, Name>>[Name]): GuardRun<ExpressHandlerContext>;
+  /**
+   * Define a request context resolver declared on the contract. It runs on
+   * every route, public ones included, and never denies.
+   */
+  requestContext<const Name extends Extract<keyof RequestContext, string>>(name: Name, run: RequestResolverFns<RequestContext>[Name]): RequestContextRun<ExpressHandlerContext>;
+  /**
+   * Write typed handlers for the contract or one of its route groups.
+   */
+  router: {
+    <const GroupOrRoutes extends Extract<keyof Router<ServerContract<R, Schemes, Auth, RequestContext, Plugins, J>>, string> | Routes>(group: GroupOrRoutes, router: GroupRouter<ServerContract<R, Schemes, Auth, RequestContext, Plugins, J>, GroupOrRoutes>): GroupRouter<ServerContract<R, Schemes, Auth, RequestContext, Plugins, J>, GroupOrRoutes>;
+    (router: Router<ServerContract<R, Schemes, Auth, RequestContext, Plugins, J>>): Router<ServerContract<R, Schemes, Auth, RequestContext, Plugins, J>>;
+  };
+  /**
+   * Write a handler for each of the contract's jobs.
+   *
+   * Pass a `transport` to say where a queued job goes. Without one, `queue`
+   * runs the job in this process and it is lost on a crash.
+   *
+   * @example
+   * export const jobs = server.jobs({
+   *     sendDigests: async () => ({
+   *         status: 200,
+   *         body: {
+   *             sent: await sendPendingDigests(),
+   *         },
+   *     }),
+   * });
+   */
+  jobs(handlers: JobsRouter<ServerContract<R, Schemes, Auth, RequestContext, Plugins, J>>): JobsRouter<ServerContract<R, Schemes, Auth, RequestContext, Plugins, J>>;
+  /**
+   * Assemble the router, guards, and job handlers into the api object.
+   */
+  api(options: {
+    router: Router<ServerContract<R, Schemes, Auth, RequestContext, Plugins, J>>;
+  } & (string extends keyof Schemes ? {
+    guards?: undefined;
+  } : {
+    guards: NoInfer<GuardsForSchemes<Schemes>>;
+  }) & (string extends keyof J ? {
+    jobs?: undefined;
+  } : {
+    jobs: NoInfer<JobsRouter<ServerContract<R, Schemes, Auth, RequestContext, Plugins, J>>>;
+  }) & (string extends keyof RequestContext ? {
+    requestContext?: undefined;
+  } : {
+    requestContext: NoInfer<{ [Name in keyof RequestContext]: RequestContextRun<ExpressHandlerContext> }>;
+  }) & (string extends keyof Plugins ? {
+    plugins?: undefined;
+  } : {
+    plugins: PluginImplementations<Plugins, ExpressHandlerContext>;
+  })): ExpressApi<R>;
+}
+/**
+ * Turn a contract into a server handle: the serving counterpart to `Kizuna`.
+ * Keep the instance and use `server.guard` to define guards, `server.router`
+ * to write typed handlers, and `server.api` to assemble them.
+ *
+ * @example
+ * const server = new KizunaServer(contract);
+ *
+ * const requireUser = server.guard('user', ({ bearer, deny }) => {
+ *     const session = bearer && sessions.get(bearer.token);
+ *     return session ? { userId: session.userId } : deny(401, 'Unauthorized');
+ * });
+ *
+ * export const api = server.api({
+ *     router,
+ *     guards: {
+ *         user: requireUser,
+ *     },
+ * });
+ */
+declare class KizunaServer<const R extends Routes, Schemes extends Record<string, SecurityScheme>, Auth, RequestContext extends Record<string, RequestContextSchema>, Plugins extends ContractPlugins, J extends Jobs = Jobs> implements Server<R, Schemes, Auth, RequestContext, Plugins, J> {
+  readonly guard: Server<R, Schemes, Auth, RequestContext, Plugins, J>['guard'];
+  readonly requestContext: Server<R, Schemes, Auth, RequestContext, Plugins, J>['requestContext'];
+  readonly router: Server<R, Schemes, Auth, RequestContext, Plugins, J>['router'];
+  readonly jobs: Server<R, Schemes, Auth, RequestContext, Plugins, J>['jobs'];
+  readonly api: Server<R, Schemes, Auth, RequestContext, Plugins, J>['api'];
+  constructor(contract: ServerContract<R, Schemes, Auth, RequestContext, Plugins, J>, options?: ServerOptions);
+}
+//#endregion
+export { AppLike, ExpressApi, ExpressHandlerContext, ExpressOptions, JobsRouter, KizunaServer, RouteHandler, Router, Server, mountExpress };

package/dist/index.d.mts

@@ -0,0 +1,193 @@
+import { Request, Response, Router as Router$1 } from "express";
+import { ApiWithRouter, ContractPlugins, ErrorFormatter, GUARDS_META, GuardDenial, GuardDeny, GuardParams, GuardRun, HandlersFromAuth, JOBS_META, Jobs, PluginArgs, PluginImplementations, REQUEST_CONTEXT_META, RequestContextRun, RequestContextValues, RouteDefinition, RouteHandler as RouteHandler$1, Router as Router$2, Routes, SCHEMES_META, ServerOptions } from "@ts-kizuna/core/adapter";
+import { z } from "zod";
+import { Contract, CredentialOf, GuardSuccess, JobHandlers, JobsArg, RequestContextHeaderValues, RequestContextSchema, SecurityScheme, TagOptions } from "@ts-kizuna/core";
+
+//#region src/server.d.ts
+type ExpressApi<R extends Routes = Routes> = ApiWithRouter<R> & {
+  readonly [GUARDS_META]?: unknown;
+  readonly [SCHEMES_META]?: unknown;
+  readonly [REQUEST_CONTEXT_META]?: unknown;
+  readonly [JOBS_META]?: unknown;
+  /**
+   * Register every contract route on an Express app or router.
+   */
+  mount: (app: AppLike, options?: ExpressOptions) => Router$1;
+};
+/**
+ * The Express request and response passed to each handler.
+ */
+interface ExpressHandlerContext {
+  req: Request;
+  res: Response;
+}
+/**
+ * The handler for a single route, typed against its contract definition.
+ */
+type RouteHandler<R extends RouteDefinition> = RouteHandler$1<R, ExpressHandlerContext>;
+/**
+ * The handler tree for a contract or route group, typed against it. Routes
+ * secured by the contract's `auth` map additionally receive each required
+ * identity's context in their handler args, under `auth`, keyed by the identity's name.
+ */
+type Router<C> = C extends Contract<infer R, infer _Tags, infer _Codes, infer Schemes, infer Auth, infer RequestContext, infer Plugins, infer J> ? HandlersFromAuth<R, ExpressHandlerContext & RequestContextValues<RequestContext> & PluginArgs<Plugins> & JobsArg<J>, Schemes, Auth> : C extends Routes ? Router$2<C, ExpressHandlerContext> : never;
+/**
+ * The handler for each of a contract's scheduled jobs, typed against it. Each
+ * receives only the job's `input`, so the same handler can be run in process.
+ */
+type JobsRouter<C> = C extends Contract<infer _R, infer _Tags, infer _Codes, infer _Schemes, infer _Auth, infer _RequestContext, infer _Plugins, infer J> ? JobHandlers<J> : never;
+/**
+ * The handlers for a group named on the contract, or for a bare route group.
+ * Both forms resolve through one signature: a second candidate of the same
+ * arity costs zero-argument handlers their contextual type.
+ */
+type GroupRouter<Source, GroupOrRoutes> = GroupOrRoutes extends string ? Router<Source>[Extract<GroupOrRoutes, keyof Router<Source>>] : Router<GroupOrRoutes>;
+declare global {
+  namespace Express {
+    interface Request {
+      kizunaRoute?: RouteDefinition;
+    }
+  }
+}
+interface ExpressOptions {
+  /**
+   * Validate handler return values against the route's response schemas.
+   * Mismatches surface as 500 errors. Enable in development.
+   *
+   * @default false
+   */
+  responseValidation?: boolean;
+  /**
+   * Reshape error (status >= 400) response bytes before they are sent. See
+   * {@link ErrorFormatter}.
+   */
+  formatError?: ErrorFormatter<Request>;
+}
+/**
+ * A guard per identity, keyed by name. Each receives the handler context, a
+ * `deny` helper, and the matched route's required scopes, and returns that
+ * identity's {@link GuardSuccess} (its context and access fields) or a `deny(...)`
+ * result. Keying by name lets each guard's return be typed against its own
+ * identity, so access values narrow without an annotation. An
+ * authentication-only identity (no context, no access) returns nothing on
+ * success, or `deny(...)`.
+ */
+type GuardFns<Schemes extends Record<string, SecurityScheme>, Params> = { [Name in keyof Schemes]: (args: ExpressHandlerContext & CredentialOf<Schemes[Name]> & {
+  params: Params;
+  deny: GuardDeny;
+  scopes: string[];
+}) => [keyof GuardSuccess<Schemes[Name]>] extends [never] ? void | GuardDenial | Promise<void | GuardDenial> : GuardSuccess<Schemes[Name]> | GuardDenial | Promise<GuardSuccess<Schemes[Name]> | GuardDenial> };
+/**
+ * One guard per identity declared on the contract.
+ */
+type GuardsForSchemes<Schemes extends Record<string, SecurityScheme>> = { [Name in keyof Schemes]: GuardRun<ExpressHandlerContext> };
+/**
+ * The resolver functions for the request context schemas declared on `kizuna`,
+ * keyed by name. Each runs on every route and returns its schema's value.
+ */
+type RequestResolverFns<RequestContext extends Record<string, RequestContextSchema>> = { [Name in keyof RequestContext]: (args: ExpressHandlerContext & {
+  params: Record<string, string>;
+  headers: RequestContextHeaderValues<RequestContext[Name]>;
+}) => z.output<RequestContext[Name]['context']> | Promise<z.output<RequestContext[Name]['context']>> };
+interface AppLike {
+  use: (router: Router$1) => unknown;
+}
+/**
+ * Mount a ts-kizuna API onto an Express app.
+ *
+ * @example
+ * api.mount(app);
+ */
+declare function mountExpress(api: ExpressApi, app: AppLike, options?: ExpressOptions): Router$1;
+type ServerContract<R extends Routes, Schemes extends Record<string, SecurityScheme>, Auth, RequestContext extends Record<string, RequestContextSchema>, Plugins extends ContractPlugins, J extends Jobs = Jobs> = Contract<R, Record<string, TagOptions>, string, Schemes, Auth, RequestContext, Plugins, J>;
+interface Server<R extends Routes, Schemes extends Record<string, SecurityScheme>, Auth, RequestContext extends Record<string, RequestContextSchema>, Plugins extends ContractPlugins, J extends Jobs = Jobs> {
+  /**
+   * Define a guard for one of the contract's identities. It runs before the
+   * handlers of every route whose `auth` entry requires the identity, and
+   * receives the credential its method extracted (`bearer`, `apiKey`, or
+   * `basic`, `null` when absent). Return the identity's context and access
+   * fields to allow the request, or call `deny(status, detail)`.
+   */
+  guard<const Name extends Extract<keyof Schemes, string>>(name: Name, run: GuardFns<Schemes, GuardParams<R, Auth, Name>>[Name]): GuardRun<ExpressHandlerContext>;
+  /**
+   * Define a request context resolver declared on the contract. It runs on
+   * every route, public ones included, and never denies.
+   */
+  requestContext<const Name extends Extract<keyof RequestContext, string>>(name: Name, run: RequestResolverFns<RequestContext>[Name]): RequestContextRun<ExpressHandlerContext>;
+  /**
+   * Write typed handlers for the contract or one of its route groups.
+   */
+  router: {
+    <const GroupOrRoutes extends Extract<keyof Router<ServerContract<R, Schemes, Auth, RequestContext, Plugins, J>>, string> | Routes>(group: GroupOrRoutes, router: GroupRouter<ServerContract<R, Schemes, Auth, RequestContext, Plugins, J>, GroupOrRoutes>): GroupRouter<ServerContract<R, Schemes, Auth, RequestContext, Plugins, J>, GroupOrRoutes>;
+    (router: Router<ServerContract<R, Schemes, Auth, RequestContext, Plugins, J>>): Router<ServerContract<R, Schemes, Auth, RequestContext, Plugins, J>>;
+  };
+  /**
+   * Write a handler for each of the contract's jobs.
+   *
+   * Pass a `transport` to say where a queued job goes. Without one, `queue`
+   * runs the job in this process and it is lost on a crash.
+   *
+   * @example
+   * export const jobs = server.jobs({
+   *     sendDigests: async () => ({
+   *         status: 200,
+   *         body: {
+   *             sent: await sendPendingDigests(),
+   *         },
+   *     }),
+   * });
+   */
+  jobs(handlers: JobsRouter<ServerContract<R, Schemes, Auth, RequestContext, Plugins, J>>): JobsRouter<ServerContract<R, Schemes, Auth, RequestContext, Plugins, J>>;
+  /**
+   * Assemble the router, guards, and job handlers into the api object.
+   */
+  api(options: {
+    router: Router<ServerContract<R, Schemes, Auth, RequestContext, Plugins, J>>;
+  } & (string extends keyof Schemes ? {
+    guards?: undefined;
+  } : {
+    guards: NoInfer<GuardsForSchemes<Schemes>>;
+  }) & (string extends keyof J ? {
+    jobs?: undefined;
+  } : {
+    jobs: NoInfer<JobsRouter<ServerContract<R, Schemes, Auth, RequestContext, Plugins, J>>>;
+  }) & (string extends keyof RequestContext ? {
+    requestContext?: undefined;
+  } : {
+    requestContext: NoInfer<{ [Name in keyof RequestContext]: RequestContextRun<ExpressHandlerContext> }>;
+  }) & (string extends keyof Plugins ? {
+    plugins?: undefined;
+  } : {
+    plugins: PluginImplementations<Plugins, ExpressHandlerContext>;
+  })): ExpressApi<R>;
+}
+/**
+ * Turn a contract into a server handle: the serving counterpart to `Kizuna`.
+ * Keep the instance and use `server.guard` to define guards, `server.router`
+ * to write typed handlers, and `server.api` to assemble them.
+ *
+ * @example
+ * const server = new KizunaServer(contract);
+ *
+ * const requireUser = server.guard('user', ({ bearer, deny }) => {
+ *     const session = bearer && sessions.get(bearer.token);
+ *     return session ? { userId: session.userId } : deny(401, 'Unauthorized');
+ * });
+ *
+ * export const api = server.api({
+ *     router,
+ *     guards: {
+ *         user: requireUser,
+ *     },
+ * });
+ */
+declare class KizunaServer<const R extends Routes, Schemes extends Record<string, SecurityScheme>, Auth, RequestContext extends Record<string, RequestContextSchema>, Plugins extends ContractPlugins, J extends Jobs = Jobs> implements Server<R, Schemes, Auth, RequestContext, Plugins, J> {
+  readonly guard: Server<R, Schemes, Auth, RequestContext, Plugins, J>['guard'];
+  readonly requestContext: Server<R, Schemes, Auth, RequestContext, Plugins, J>['requestContext'];
+  readonly router: Server<R, Schemes, Auth, RequestContext, Plugins, J>['router'];
+  readonly jobs: Server<R, Schemes, Auth, RequestContext, Plugins, J>['jobs'];
+  readonly api: Server<R, Schemes, Auth, RequestContext, Plugins, J>['api'];
+  constructor(contract: ServerContract<R, Schemes, Auth, RequestContext, Plugins, J>, options?: ServerOptions);
+}
+//#endregion
+export { AppLike, ExpressApi, ExpressHandlerContext, ExpressOptions, JobsRouter, KizunaServer, RouteHandler, Router, Server, mountExpress };

package/dist/index.mjs

@@ -0,0 +1,155 @@
+import { Router } from "express";
+import { Readable } from "node:stream";
+import { GUARDS_META, JOBS_META, REQUEST_CONTEXT_META, ROUTER_META, SCHEMES_META, assembleApi, createAdapter, jobRouter, jobRoutes, jobRunnerFrom, pluginExportsOf, pluginRouterOf, pluginRoutesOf, renderJsonResult, warnUnsupportedJobOptions } from "@ts-kizuna/core/adapter";
+//#region src/server.ts
+/**
+* Write a web `Response` to a node response. Plugins answer in web terms to stay
+* adapter-agnostic, so the translation belongs here.
+*/
+const writeWebResponse = async (response, res) => {
+	if (!(response instanceof globalThis.Response)) return;
+	res.status(response.status);
+	response.headers.forEach((value, name) => res.setHeader(name, value));
+	if (!response.body) {
+		res.end();
+		return;
+	}
+	Readable.fromWeb(response.body).pipe(res);
+};
+const adapter = createAdapter({
+	buildHandlerContext: (adapterRequest, { res }) => ({
+		req: adapterRequest.request,
+		res
+	}),
+	respond: (result, { res, next, formatError }) => {
+		if (result.kind === "handler-error") {
+			next(result.error);
+			return;
+		}
+		if (result.kind === "raw-response") {
+			writeWebResponse(result.response, res);
+			return;
+		}
+		if (res.headersSent) return;
+		if (result.kind === "not-found" || result.kind === "method-not-allowed") {
+			next();
+			return;
+		}
+		const rendered = renderJsonResult(result, formatError, res.req);
+		for (const [key, value] of Object.entries(rendered.headers)) res.setHeader(key, value);
+		if (rendered.body === void 0) res.status(rendered.status).end();
+		else if (rendered.raw) {
+			const body = rendered.body;
+			res.status(rendered.status).send(typeof body === "string" || Buffer.isBuffer(body) ? body : Buffer.from(body));
+		} else res.status(rendered.status).json(rendered.body);
+	}
+});
+/**
+* Mount a ts-kizuna API onto an Express app.
+*
+* @example
+* api.mount(app);
+*/
+function mountExpress(api, app, options) {
+	const guards = api[GUARDS_META];
+	const schemes = api[SCHEMES_META];
+	const requestContext = api[REQUEST_CONTEXT_META];
+	const pluginExports = pluginExportsOf(api);
+	const jobsMeta = api[JOBS_META];
+	const jobRunner = jobRunnerFrom(jobsMeta);
+	const expressRouter = Router();
+	const mountRoute = (routeKey, route, routes, router) => {
+		expressRouter[route.method.toLowerCase()](route.path, (req, _res, next) => {
+			req.kizunaRoute = route;
+			next();
+		}, async (req, res, next) => {
+			const adapterRequest = {
+				request: req,
+				method: req.method,
+				resolution: {
+					kind: "pre-resolved",
+					routeKey,
+					route,
+					params: req.params
+				},
+				query: req.query,
+				headers: req.headers,
+				readBody: () => req.body
+			};
+			await adapter.handle({
+				routes,
+				router,
+				request: adapterRequest,
+				responseContext: {
+					res,
+					next,
+					formatError: options?.formatError
+				},
+				guards,
+				schemes,
+				requestContext,
+				pluginExports,
+				jobs: jobRunner,
+				responseValidation: options?.responseValidation
+			});
+		});
+	};
+	const mountLane = (routes, router) => {
+		for (const { routeKey, route } of adapter.eachRoute(routes, router)) mountRoute(routeKey, route, routes, router);
+	};
+	mountLane(api.routes, api[ROUTER_META]);
+	mountLane(pluginRoutesOf(api), pluginRouterOf(api));
+	if (jobsMeta) {
+		const routes = jobRoutes(jobsMeta);
+		const router = jobRouter(jobsMeta);
+		for (const [routeKey, route] of Object.entries(routes)) mountRoute(routeKey, route, routes, router);
+	}
+	app.use(expressRouter);
+	return expressRouter;
+}
+const createServerSurface = (contract, options) => {
+	warnUnsupportedJobOptions(contract.jobs, options?.jobTransport);
+	return {
+		guard: (_name, run) => run,
+		requestContext: (_name, run) => run,
+		router: (groupOrRouter, groupRouter) => groupRouter ?? groupOrRouter,
+		jobs: (handlers) => handlers,
+		api: ({ jobs, ...parts }) => {
+			const api = Object.assign(assembleApi(contract, parts), { [JOBS_META]: contract.jobs ? {
+				jobs: contract.jobs,
+				handlers: jobs ?? {},
+				config: contract.jobsConfig,
+				transport: options?.jobTransport,
+				onError: options?.onJobError
+			} : void 0 });
+			return Object.assign(api, { mount: (app, mountOptions) => mountExpress(api, app, mountOptions) });
+		}
+	};
+};
+/**
+* Turn a contract into a server handle: the serving counterpart to `Kizuna`.
+* Keep the instance and use `server.guard` to define guards, `server.router`
+* to write typed handlers, and `server.api` to assemble them.
+*
+* @example
+* const server = new KizunaServer(contract);
+*
+* const requireUser = server.guard('user', ({ bearer, deny }) => {
+*     const session = bearer && sessions.get(bearer.token);
+*     return session ? { userId: session.userId } : deny(401, 'Unauthorized');
+* });
+*
+* export const api = server.api({
+*     router,
+*     guards: {
+*         user: requireUser,
+*     },
+* });
+*/
+var KizunaServer = class {
+	constructor(contract, options) {
+		Object.assign(this, createServerSurface(contract, options));
+	}
+};
+//#endregion
+export { KizunaServer, mountExpress };

package/package.json

@@ -0,0 +1,74 @@
+{
+  "name": "@ts-kizuna/express",
+  "version": "1.49.5",
+  "description": "Express adapter for ts-kizuna",
+  "keywords": [
+    "ts-kizuna",
+    "typescript",
+    "zod",
+    "openapi",
+    "contract-first",
+    "type-safe",
+    "rest",
+    "api",
+    "express",
+    "adapter",
+    "server"
+  ],
+  "license": "MIT",
+  "homepage": "https://ts-kizuna.com/docs/adapters/express",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ts-kizuna/kizuna.git",
+    "directory": "packages/express"
+  },
+  "bugs": "https://github.com/ts-kizuna/kizuna/issues",
+  "type": "module",
+  "sideEffects": false,
+  "engines": {
+    "node": ">=24"
+  },
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.mts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.mts",
+        "default": "./dist/index.mjs"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      }
+    }
+  },
+  "kizuna": {
+    "entries": {
+      ".": "server"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "peerDependencies": {
+    "express": "^5.0.0",
+    "zod": "^4.0.0",
+    "@ts-kizuna/core": "1.49.5"
+  },
+  "devDependencies": {
+    "@types/express": "^5.0.0",
+    "express": "^5.0.0",
+    "tsdown": "^0.21.0",
+    "typescript": "^5.6.3",
+    "zod": "^4.0.0",
+    "@ts-kizuna/core": "1.49.5"
+  },
+  "scripts": {
+    "build": "tsdown src/index.ts --format esm,cjs --dts --clean --external @ts-kizuna/core --external express --external zod",
+    "typecheck": "tsc --noEmit"
+  }
+}