@znight/http 0.0.0-stage → 0.1.0

package/dist/express.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"express.mjs","names":[],"sources":["../src/adapters/express.ts"],"sourcesContent":["/**\n * `@znight/http/express`: serves Znight routes with [Express](https://expressjs.com) 5 (optional\n * peer dependency `express`). Routes are mounted on a dedicated router, after the middleware of the\n * application you pass. `inject()` uses the optional peer `light-my-request`.\n */\nimport type { IncomingMessage, ServerResponse } from 'node:http'\nimport type {\n  AdapterCloseOptions,\n  AdapterRoute,\n  FallbackHandler,\n  HttpAdapter,\n  HttpServerAddress,\n  InjectRequest,\n  InjectResponse,\n  InjectStreamRequest,\n  InjectStreamResponse,\n} from '../adapter.ts'\n\nimport { createServer, type Server } from 'node:http'\nimport express, { type Express, type NextFunction, type Request, type Response, type Router } from 'express'\n\nimport { toRegExpSource } from '../path.ts'\nimport { ConnectionTracker, closeServer, nodeAdapterRequest, writeNodeFailure, writeNodeReply } from './node-io.ts'\nimport { bufferInjectStream, injectNodeStream, serverAddress } from './shared.ts'\n\n/** Options of {@link expressAdapter}. */\nexport interface ExpressAdapterOptions {\n  /**\n   * An existing application: its middleware (CORS, helmet, sessions...) runs before the Znight\n   * routes. Do not add body parsers for Znight routes: Znight reads bodies itself.\n   */\n  readonly app?: Express\n  /**\n   * The server to listen with (e.g. `https.createServer({ key, cert })`): the adapter adds its\n   * `request` listener. Default: a new `http.createServer()`.\n   */\n  readonly server?: Server\n}\n\n/** The Express adapter. */\nexport interface ExpressAdapter extends HttpAdapter {\n  readonly name: 'express'\n  /** The Express application. */\n  readonly app: Express\n  /** The router holding the Znight routes (mounted on {@link app}). */\n  readonly router: Router\n  /** The HTTP server, once listening. */\n  readonly server: Server | undefined\n}\n\n/**\n * Creates an Express adapter.\n *\n * ```ts\n * import { expressAdapter } from '@znight/http/express'\n *\n * const app = express()\n * app.use(cors())\n * HttpPlugin.configure({ adapter: expressAdapter({ app }) })\n * ```\n */\nexport function expressAdapter(options: ExpressAdapterOptions = {}): ExpressAdapter {\n  return new ExpressHttpAdapter(options)\n}\n\ntype Method = 'get' | 'head' | 'post' | 'put' | 'patch' | 'delete' | 'options'\n\nclass ExpressHttpAdapter implements ExpressAdapter {\n  readonly name = 'express' as const\n  readonly app: Express\n  readonly router: Router\n  #fallback: FallbackHandler | undefined\n  #mounted = false\n  #server: Server | undefined\n  #tracker: ConnectionTracker | undefined\n  #closing: Promise<void> | undefined\n\n  readonly #givenServer: Server | undefined\n\n  constructor(options: ExpressAdapterOptions) {\n    this.#givenServer = options.server\n    if (options.app === undefined) {\n      this.app = express()\n      this.app.disable('x-powered-by')\n    } else {\n      this.app = options.app\n    }\n    this.router = express.Router({ caseSensitive: true, strict: true })\n  }\n\n  get server(): Server | undefined {\n    return this.#server\n  }\n\n  registerRoute(route: AdapterRoute): void {\n    const handler = route.handler\n    // anchored regular expressions without capture groups: Express decodes nothing, Znight extracts parameters\n    this.router[route.method.toLowerCase() as Method](new RegExp(toRegExpSource(route.path)), (request, response) => {\n      handler(adapterRequest(request, response)).then(\n        reply => writeNodeReply(response, reply),\n        () => writeNodeFailure(response),\n      )\n    })\n  }\n\n  setFallbackHandler(handler: FallbackHandler): void {\n    this.#fallback = handler\n  }\n\n  #mount(): void {\n    if (this.#mounted) return\n    this.#mounted = true\n    // Express answers unmatched OPTIONS requests itself (200): route them to the Znight fallback\n    this.router.options(/^.*$/, (request: Request, response: Response) =>\n      this.#dispatchFallback(request, response, undefined),\n    )\n    this.app.use(this.router)\n    this.app.use((request: Request, response: Response) => this.#dispatchFallback(request, response, undefined))\n    this.app.use((error: unknown, request: Request, response: Response, _next: NextFunction) =>\n      this.#dispatchFallback(request, response, error),\n    )\n  }\n\n  #dispatchFallback(request: Request, response: Response, error: unknown): void {\n    if (this.#fallback === undefined) {\n      writeNodeFailure(response)\n      return\n    }\n    this.#fallback(adapterRequest(request, response), error).then(\n      reply => writeNodeReply(response, reply),\n      () => writeNodeFailure(response),\n    )\n  }\n\n  readonly #listener = (request: IncomingMessage, response: ServerResponse): void => {\n    this.app(request as Request, response as Response)\n  }\n\n  async listen(port: number, host: string): Promise<HttpServerAddress> {\n    this.#mount()\n    const server = this.#givenServer ?? createServer()\n    if (!server.listeners('request').includes(this.#listener)) server.on('request', this.#listener)\n    this.#server = server\n    this.#tracker ??= new ConnectionTracker(server)\n    this.#closing = undefined\n    await new Promise<void>((resolve, reject) => {\n      const onError = (error: Error): void => reject(error)\n      server.once('error', onError)\n      server.listen(port, host, () => {\n        server.off('error', onError)\n        resolve()\n      })\n    })\n    const address = server.address()\n    if (address === null || typeof address === 'string') return serverAddress(host, port)\n    return serverAddress(address.address, address.port, address.family)\n  }\n\n  close(options: AdapterCloseOptions = {}): Promise<void> {\n    const server = this.#server\n    const tracker = this.#tracker\n    if (server === undefined || tracker === undefined) return Promise.resolve()\n    this.#closing = closeServer(server, tracker, this.#closing, options.force === true)\n    return this.#closing\n  }\n\n  inject(request: InjectRequest): Promise<InjectResponse> {\n    return bufferInjectStream(stream => this.injectStream(stream), request)\n  }\n\n  injectStream(request: InjectStreamRequest): Promise<InjectStreamResponse> {\n    this.#mount()\n    return injectNodeStream('express', this.#injectListener as (req: never, res: never) => void, request)\n  }\n\n  /**\n   * Express replaces the prototype of `req`/`res` with its own, which drops the overrides of the\n   * light-my-request fakes (payload capture, body streaming): pin them as own properties first.\n   */\n  readonly #injectListener = (request: IncomingMessage, response: ServerResponse): void => {\n    pinPrototype(request)\n    pinPrototype(response)\n    this.#listener(request, response)\n  }\n}\n\nfunction pinPrototype(target: object): void {\n  const prototype: unknown = Object.getPrototypeOf(target)\n  if (prototype === null || typeof prototype !== 'object') return\n  for (const key of Object.getOwnPropertyNames(prototype)) {\n    if (key === 'constructor' || Object.hasOwn(target, key)) continue\n    const descriptor = Object.getOwnPropertyDescriptor(prototype, key)\n    if (typeof descriptor?.value === 'function') {\n      Object.defineProperty(target, key, { value: descriptor.value, writable: true, configurable: true })\n    }\n  }\n}\n\nfunction adapterRequest(request: Request, response: Response): ReturnType<typeof nodeAdapterRequest> {\n  return nodeAdapterRequest(request, response, { url: request.originalUrl ?? request.url, ip: request.ip })\n}\n"],"mappings":";;;;;;;;;;;;;;;;AA6DA,SAAgB,eAAe,UAAiC,CAAC,GAAmB;CAClF,OAAO,IAAI,mBAAmB,OAAO;AACvC;AAIA,IAAM,qBAAN,MAAmD;CACjD,OAAgB;CAChB;CACA;CACA;CACA,WAAW;CACX;CACA;CACA;CAEA;CAEA,YAAY,SAAgC;EAC1C,KAAK,eAAe,QAAQ;EAC5B,IAAI,QAAQ,QAAQ,KAAA,GAAW;GAC7B,KAAK,MAAM,QAAQ;GACnB,KAAK,IAAI,QAAQ,cAAc;EACjC,OACE,KAAK,MAAM,QAAQ;EAErB,KAAK,SAAS,QAAQ,OAAO;GAAE,eAAe;GAAM,QAAQ;EAAK,CAAC;CACpE;CAEA,IAAI,SAA6B;EAC/B,OAAO,KAAK;CACd;CAEA,cAAc,OAA2B;EACvC,MAAM,UAAU,MAAM;EAEtB,KAAK,OAAO,MAAM,OAAO,YAAY,EAAY,CAAC,IAAI,OAAO,eAAe,MAAM,IAAI,CAAC,IAAI,SAAS,aAAa;GAC/G,QAAQ,eAAe,SAAS,QAAQ,CAAC,CAAC,CAAC,MACzC,UAAS,eAAe,UAAU,KAAK,SACjC,iBAAiB,QAAQ,CACjC;EACF,CAAC;CACH;CAEA,mBAAmB,SAAgC;EACjD,KAAK,YAAY;CACnB;CAEA,SAAe;EACb,IAAI,KAAK,UAAU;EACnB,KAAK,WAAW;EAEhB,KAAK,OAAO,QAAQ,SAAS,SAAkB,aAC7C,KAAK,kBAAkB,SAAS,UAAU,KAAA,CAAS,CACrD;EACA,KAAK,IAAI,IAAI,KAAK,MAAM;EACxB,KAAK,IAAI,KAAK,SAAkB,aAAuB,KAAK,kBAAkB,SAAS,UAAU,KAAA,CAAS,CAAC;EAC3G,KAAK,IAAI,KAAK,OAAgB,SAAkB,UAAoB,UAClE,KAAK,kBAAkB,SAAS,UAAU,KAAK,CACjD;CACF;CAEA,kBAAkB,SAAkB,UAAoB,OAAsB;EAC5E,IAAI,KAAK,cAAc,KAAA,GAAW;GAChC,iBAAiB,QAAQ;GACzB;EACF;EACA,KAAK,UAAU,eAAe,SAAS,QAAQ,GAAG,KAAK,CAAC,CAAC,MACvD,UAAS,eAAe,UAAU,KAAK,SACjC,iBAAiB,QAAQ,CACjC;CACF;CAEA,aAAsB,SAA0B,aAAmC;EACjF,KAAK,IAAI,SAAoB,QAAoB;CACnD;CAEA,MAAM,OAAO,MAAc,MAA0C;EACnE,KAAK,OAAO;EACZ,MAAM,SAAS,KAAK,gBAAgB,aAAa;EACjD,IAAI,CAAC,OAAO,UAAU,SAAS,CAAC,CAAC,SAAS,KAAK,SAAS,GAAG,OAAO,GAAG,WAAW,KAAK,SAAS;EAC9F,KAAK,UAAU;EACf,KAAK,aAAa,IAAI,kBAAkB,MAAM;EAC9C,KAAK,WAAW,KAAA;EAChB,MAAM,IAAI,SAAe,SAAS,WAAW;GAC3C,MAAM,WAAW,UAAuB,OAAO,KAAK;GACpD,OAAO,KAAK,SAAS,OAAO;GAC5B,OAAO,OAAO,MAAM,YAAY;IAC9B,OAAO,IAAI,SAAS,OAAO;IAC3B,QAAQ;GACV,CAAC;EACH,CAAC;EACD,MAAM,UAAU,OAAO,QAAQ;EAC/B,IAAI,YAAY,QAAQ,OAAO,YAAY,UAAU,OAAO,cAAc,MAAM,IAAI;EACpF,OAAO,cAAc,QAAQ,SAAS,QAAQ,MAAM,QAAQ,MAAM;CACpE;CAEA,MAAM,UAA+B,CAAC,GAAkB;EACtD,MAAM,SAAS,KAAK;EACpB,MAAM,UAAU,KAAK;EACrB,IAAI,WAAW,KAAA,KAAa,YAAY,KAAA,GAAW,OAAO,QAAQ,QAAQ;EAC1E,KAAK,WAAW,YAAY,QAAQ,SAAS,KAAK,UAAU,QAAQ,UAAU,IAAI;EAClF,OAAO,KAAK;CACd;CAEA,OAAO,SAAiD;EACtD,OAAO,oBAAmB,WAAU,KAAK,aAAa,MAAM,GAAG,OAAO;CACxE;CAEA,aAAa,SAA6D;EACxE,KAAK,OAAO;EACZ,OAAO,iBAAiB,WAAW,KAAK,iBAAqD,OAAO;CACtG;;;;;CAMA,mBAA4B,SAA0B,aAAmC;EACvF,aAAa,OAAO;EACpB,aAAa,QAAQ;EACrB,KAAK,UAAU,SAAS,QAAQ;CAClC;AACF;AAEA,SAAS,aAAa,QAAsB;CAC1C,MAAM,YAAqB,OAAO,eAAe,MAAM;CACvD,IAAI,cAAc,QAAQ,OAAO,cAAc,UAAU;CACzD,KAAK,MAAM,OAAO,OAAO,oBAAoB,SAAS,GAAG;EACvD,IAAI,QAAQ,iBAAiB,OAAO,OAAO,QAAQ,GAAG,GAAG;EACzD,MAAM,aAAa,OAAO,yBAAyB,WAAW,GAAG;EACjE,IAAI,OAAO,YAAY,UAAU,YAC/B,OAAO,eAAe,QAAQ,KAAK;GAAE,OAAO,WAAW;GAAO,UAAU;GAAM,cAAc;EAAK,CAAC;CAEtG;AACF;AAEA,SAAS,eAAe,SAAkB,UAA2D;CACnG,OAAO,mBAAmB,SAAS,UAAU;EAAE,KAAK,QAAQ,eAAe,QAAQ;EAAK,IAAI,QAAQ;CAAG,CAAC;AAC1G"}

package/dist/fastify.d.mts

@@ -0,0 +1,33 @@
+import { s as HttpAdapter } from "./adapter-CGSceVEN.mjs";
+import { FastifyInstance, FastifyServerOptions } from "fastify";
+/** Options of {@link fastifyAdapter}. */
+export interface FastifyAdapterOptions {
+  /**
+   * An existing instance (with your plugins and hooks). Znight registers its routes in an
+   * encapsulated child context (its own body handling and 404 handler) and closes the instance on
+   * shutdown. Malformed URLs are then answered by Fastify's `frameworkErrors` handler.
+   */
+  readonly instance?: FastifyInstance;
+  /**
+   * Options of the instance created when `instance` is absent. Znight sets `exposeHeadRoutes: false`
+   * (HEAD is served by Znight), a `maxParamLength` of 8 KiB and a `frameworkErrors` handler.
+   */
+  readonly options?: FastifyServerOptions;
+}
+/** The Fastify adapter. */
+export interface FastifyAdapter extends HttpAdapter {
+  readonly name: "fastify";
+  /** The Fastify instance. */
+  readonly instance: FastifyInstance;
+}
+/**
+ * Creates a Fastify adapter.
+ *
+ * ```ts
+ * import { fastifyAdapter } from '@znight/http/fastify'
+ *
+ * HttpPlugin.configure({ adapter: fastifyAdapter({ options: { trustProxy: true } }) })
+ * ```
+ */
+export declare function fastifyAdapter(options?: FastifyAdapterOptions): FastifyAdapter;
+//# sourceMappingURL=fastify.d.mts.map

package/dist/fastify.mjs

@@ -0,0 +1,191 @@
+import { N as discardStream, _ as lightStreamResponse, a as nodeBodyStream, c as readNodeBody, d as writeNodeReply, f as bufferInjectStream, g as lightInjectOptions, l as withNativeCookies, o as normalizeNodeHeaders, r as isEncrypted, s as onResponseAbort, t as ConnectionTracker, y as serverAddress } from "./node-io-BY1ZDLRQ.mjs";
+import { toFastifyPath } from "./path.mjs";
+import { Readable } from "node:stream";
+import Fastify from "fastify";
+// src/adapters/fastify.ts
+/**
+* Creates a Fastify adapter.
+*
+* ```ts
+* import { fastifyAdapter } from '@znight/http/fastify'
+*
+* HttpPlugin.configure({ adapter: fastifyAdapter({ options: { trustProxy: true } }) })
+* ```
+*/
+function fastifyAdapter(options = {}) {
+	return new FastifyHttpAdapter(options);
+}
+const MAX_PARAM_LENGTH = 8192;
+/** `content-type` headers hidden from Fastify (see `#register`), by request. */
+const HIDDEN_CONTENT_TYPES = /* @__PURE__ */ new WeakMap();
+var FastifyHttpAdapter = class {
+	name = "fastify";
+	instance;
+	#routes = [];
+	#tracker;
+	#fallback;
+	#ready;
+	#closing;
+	constructor(options) {
+		if (options.instance === void 0) {
+			const serverOptions = options.options ?? {};
+			this.instance = Fastify({
+				exposeHeadRoutes: false,
+				frameworkErrors: (error, request, reply) => {
+					this.#reply(reply, this.#dispatchFallback(request, reply, error)).catch(() => void 0);
+				},
+				...serverOptions,
+				routerOptions: {
+					maxParamLength: MAX_PARAM_LENGTH,
+					...serverOptions.routerOptions
+				}
+			});
+		} else this.instance = options.instance;
+		this.#tracker = new ConnectionTracker(this.instance.server);
+	}
+	registerRoute(route) {
+		if (this.#ready !== void 0) throw new Error("fastifyAdapter: routes must be registered before listen()/inject()");
+		this.#routes.push(route);
+	}
+	setFallbackHandler(handler) {
+		this.#fallback = handler;
+	}
+	#prepare() {
+		this.#ready ??= this.#register();
+		return this.#ready;
+	}
+	async #register() {
+		const routes = this.#routes;
+		await this.instance.register((child, _options, done) => {
+			child.removeAllContentTypeParsers();
+			child.addContentTypeParser("*", (_request, _payload, done) => done(null, void 0));
+			child.addHook("onRequest", (request, _reply, done) => {
+				const contentType = request.headers["content-type"];
+				if (contentType !== void 0 && request.mediaType === void 0) {
+					HIDDEN_CONTENT_TYPES.set(request.raw, contentType);
+					delete request.raw.headers["content-type"];
+				}
+				done();
+			});
+			for (const route of routes) {
+				const handler = route.handler;
+				child.route({
+					method: route.method,
+					url: toFastifyPath(route.path),
+					exposeHeadRoute: false,
+					handler: (request, reply) => this.#reply(reply, handler(adapterRequest(request, reply)))
+				});
+			}
+			child.setNotFoundHandler((request, reply) => this.#reply(reply, this.#dispatchFallback(request, reply, void 0)));
+			child.setErrorHandler((error, request, reply) => this.#reply(reply, this.#dispatchFallback(request, reply, error)));
+			done();
+		});
+		await this.instance.ready();
+	}
+	#dispatchFallback(request, reply, error) {
+		if (this.#fallback === void 0) return Promise.reject(error ?? /* @__PURE__ */ new Error("No fallback handler"));
+		return this.#fallback(adapterRequest(request, void 0, reply), error);
+	}
+	async #reply(reply, pending) {
+		let result;
+		try {
+			result = await pending;
+		} catch {
+			result = {
+				status: 500,
+				headers: { "content-type": "application/json; charset=utf-8" },
+				body: new TextEncoder().encode("{\"statusCode\":500,\"error\":\"Internal Server Error\"}")
+			};
+		}
+		if (result.raw === true || reply.sent || reply.raw.destroyed) {
+			discardStream(result.body instanceof ReadableStream ? result.body : null);
+			return reply;
+		}
+		if (result.eventStream === true) {
+			const native = lowerCaseHeaders(reply.getHeaders());
+			const headers = {
+				...native,
+				...withNativeCookies(native["set-cookie"], result.headers)
+			};
+			reply.hijack();
+			writeNodeReply(reply.raw, {
+				...result,
+				headers
+			});
+			return reply;
+		}
+		reply.code(result.status);
+		for (const name of Object.keys(result.headers)) reply.header(name, result.headers[name]);
+		const body = result.body;
+		if (body === null) return reply.send();
+		if (body instanceof Uint8Array) return reply.send(Buffer.from(body.buffer, body.byteOffset, body.byteLength));
+		const stream = body instanceof Blob ? body.stream() : body;
+		return reply.send(Readable.fromWeb(stream));
+	}
+	async listen(port, host) {
+		await this.#prepare();
+		this.#closing = void 0;
+		await this.instance.listen({
+			port,
+			host
+		});
+		const address = this.instance.server.address();
+		if (address === null || typeof address === "string") return serverAddress(host, port);
+		return serverAddress(address.address, address.port, address.family);
+	}
+	close(options = {}) {
+		if (this.#closing === void 0) {
+			this.#tracker.closeIdle();
+			this.#closing = this.instance.close();
+		}
+		if (options.force === true) {
+			this.instance.server.closeAllConnections?.();
+			this.#tracker.destroyAll();
+		}
+		return this.#closing;
+	}
+	inject(request) {
+		return bufferInjectStream((stream) => this.injectStream(stream), request);
+	}
+	async injectStream(request) {
+		await this.#prepare();
+		const options = await lightInjectOptions(request);
+		const response = await this.instance.inject.call(this.instance, options);
+		return lightStreamResponse(response, request.signal);
+	}
+};
+function lowerCaseHeaders(headers) {
+	const result = {};
+	for (const [name, value] of Object.entries(headers)) if (value !== void 0) result[name.toLowerCase()] = typeof value === "object" ? [...value] : String(value);
+	return result;
+}
+function adapterRequest(request, reply, response = reply) {
+	const hidden = HIDDEN_CONTENT_TYPES.get(request.raw);
+	if (hidden !== void 0) {
+		HIDDEN_CONTENT_TYPES.delete(request.raw);
+		request.raw.headers["content-type"] = hidden;
+	}
+	let body;
+	return {
+		method: request.raw.method ?? request.method,
+		url: request.raw.url ?? request.url,
+		headers: normalizeNodeHeaders(request.headers),
+		ip: request.ip,
+		remoteAddress: request.raw.socket?.remoteAddress,
+		encrypted: isEncrypted(request.raw),
+		raw: request,
+		rawResponse: reply,
+		readBody: (limit) => {
+			body ??= readNodeBody(request.raw, limit);
+			return body;
+		},
+		streamBody: (limit) => nodeBodyStream(request.raw, limit),
+		rawStatus: () => reply?.statusCode,
+		onAbort: (listener) => {
+			if (response !== void 0) onResponseAbort(response.raw, listener);
+		}
+	};
+}
+export { fastifyAdapter };
+
+//# sourceMappingURL=fastify.mjs.map

package/dist/fastify.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"fastify.mjs","names":[],"sources":["../src/adapters/fastify.ts"],"sourcesContent":["/**\n * `@znight/http/fastify`: serves Znight routes with [Fastify](https://fastify.dev) 5 (optional\n * peer dependency `fastify`). Routing uses Fastify's router; body parsing, validation and\n * serialisation stay Znight's, so responses are identical to the other adapters.\n */\nimport type {\n  AdapterCloseOptions,\n  AdapterHandler,\n  AdapterReply,\n  AdapterRequest,\n  AdapterRoute,\n  FallbackHandler,\n  HttpAdapter,\n  HttpServerAddress,\n  InjectRequest,\n  InjectResponse,\n  InjectStreamRequest,\n  InjectStreamResponse,\n} from '../adapter.ts'\n\nimport { Readable } from 'node:stream'\nimport Fastify, {\n  type FastifyInstance,\n  type FastifyReply,\n  type FastifyRequest,\n  type FastifyServerOptions,\n} from 'fastify'\n\nimport { toFastifyPath } from '../path.ts'\nimport { discardStream } from '../stream.ts'\nimport {\n  ConnectionTracker,\n  isEncrypted,\n  nodeBodyStream,\n  normalizeNodeHeaders,\n  onResponseAbort,\n  readNodeBody,\n  withNativeCookies,\n  writeNodeReply,\n} from './node-io.ts'\nimport {\n  bufferInjectStream,\n  type LightInjectOptions,\n  lightInjectOptions,\n  lightStreamResponse,\n  serverAddress,\n} from './shared.ts'\n\n/** Options of {@link fastifyAdapter}. */\nexport interface FastifyAdapterOptions {\n  /**\n   * An existing instance (with your plugins and hooks). Znight registers its routes in an\n   * encapsulated child context (its own body handling and 404 handler) and closes the instance on\n   * shutdown. Malformed URLs are then answered by Fastify's `frameworkErrors` handler.\n   */\n  readonly instance?: FastifyInstance\n  /**\n   * Options of the instance created when `instance` is absent. Znight sets `exposeHeadRoutes: false`\n   * (HEAD is served by Znight), a `maxParamLength` of 8 KiB and a `frameworkErrors` handler.\n   */\n  readonly options?: FastifyServerOptions\n}\n\n/** The Fastify adapter. */\nexport interface FastifyAdapter extends HttpAdapter {\n  readonly name: 'fastify'\n  /** The Fastify instance. */\n  readonly instance: FastifyInstance\n}\n\n/**\n * Creates a Fastify adapter.\n *\n * ```ts\n * import { fastifyAdapter } from '@znight/http/fastify'\n *\n * HttpPlugin.configure({ adapter: fastifyAdapter({ options: { trustProxy: true } }) })\n * ```\n */\nexport function fastifyAdapter(options: FastifyAdapterOptions = {}): FastifyAdapter {\n  return new FastifyHttpAdapter(options)\n}\n\nconst MAX_PARAM_LENGTH = 8192\n\n/** `content-type` headers hidden from Fastify (see `#register`), by request. */\nconst HIDDEN_CONTENT_TYPES = new WeakMap<object, string>()\n\nclass FastifyHttpAdapter implements FastifyAdapter {\n  readonly name = 'fastify' as const\n  readonly instance: FastifyInstance\n  readonly #routes: AdapterRoute[] = []\n  readonly #tracker: ConnectionTracker\n  #fallback: FallbackHandler | undefined\n  #ready: Promise<void> | undefined\n  #closing: Promise<void> | undefined\n\n  constructor(options: FastifyAdapterOptions) {\n    if (options.instance === undefined) {\n      const serverOptions = options.options ?? {}\n      this.instance = Fastify({\n        exposeHeadRoutes: false,\n        frameworkErrors: (error, request, reply) => {\n          this.#reply(reply, this.#dispatchFallback(request, reply, error)).catch(() => undefined)\n        },\n        ...serverOptions,\n        routerOptions: { maxParamLength: MAX_PARAM_LENGTH, ...serverOptions.routerOptions },\n      })\n    } else {\n      this.instance = options.instance\n    }\n    this.#tracker = new ConnectionTracker(this.instance.server)\n  }\n\n  registerRoute(route: AdapterRoute): void {\n    if (this.#ready !== undefined) throw new Error('fastifyAdapter: routes must be registered before listen()/inject()')\n    this.#routes.push(route)\n  }\n\n  setFallbackHandler(handler: FallbackHandler): void {\n    this.#fallback = handler\n  }\n\n  #prepare(): Promise<void> {\n    this.#ready ??= this.#register()\n    return this.#ready\n  }\n\n  async #register(): Promise<void> {\n    const routes = this.#routes\n    await this.instance.register((child, _options, done) => {\n      // Znight reads and parses bodies itself: accept every content type without consuming it\n      child.removeAllContentTypeParsers()\n      child.addContentTypeParser('*', (_request, _payload, done) => done(null, undefined))\n      // Fastify answers 415 to a content type it cannot parse (`foo`, an empty one) before the route\n      // runs: hide such a header from Fastify (Znight reads it, and parses the body as bytes)\n      child.addHook('onRequest', (request, _reply, done) => {\n        const contentType = request.headers['content-type']\n        if (contentType !== undefined && request.mediaType === undefined) {\n          HIDDEN_CONTENT_TYPES.set(request.raw, contentType)\n          delete request.raw.headers['content-type']\n        }\n        done()\n      })\n      for (const route of routes) {\n        const handler = route.handler\n        child.route({\n          method: route.method,\n          url: toFastifyPath(route.path),\n          exposeHeadRoute: false,\n          handler: (request, reply) => this.#reply(reply, handler(adapterRequest(request, reply))),\n        })\n      }\n      child.setNotFoundHandler((request, reply) =>\n        this.#reply(reply, this.#dispatchFallback(request, reply, undefined)),\n      )\n      child.setErrorHandler((error, request, reply) =>\n        this.#reply(reply, this.#dispatchFallback(request, reply, error)),\n      )\n      done()\n    })\n    await this.instance.ready()\n  }\n\n  #dispatchFallback(request: FastifyRequest, reply: FastifyReply, error: unknown): Promise<AdapterReply> {\n    if (this.#fallback === undefined) return Promise.reject(error ?? new Error('No fallback handler'))\n    return this.#fallback(adapterRequest(request, undefined, reply), error)\n  }\n\n  async #reply(reply: FastifyReply, pending: ReturnType<AdapterHandler>): Promise<FastifyReply> {\n    let result: AdapterReply\n    try {\n      result = await pending\n    } catch {\n      result = {\n        status: 500,\n        headers: { 'content-type': 'application/json; charset=utf-8' },\n        body: new TextEncoder().encode('{\"statusCode\":500,\"error\":\"Internal Server Error\"}'),\n      }\n    }\n    if (result.raw === true || reply.sent || reply.raw.destroyed) {\n      discardStream(result.body instanceof ReadableStream ? result.body : null)\n      return reply\n    }\n    if (result.eventStream === true) {\n      // no onSend hook (compression, ETag...) may rewrite an event stream: write it on the raw\n      // response, with the headers Fastify hooks already set (`onRequest`...) under the plugin's,\n      // and their cookies before the plugin's (as reply.header('set-cookie') does on the other path)\n      const native = lowerCaseHeaders(reply.getHeaders())\n      const headers = { ...native, ...withNativeCookies(native['set-cookie'], result.headers) }\n      reply.hijack()\n      void writeNodeReply(reply.raw, { ...result, headers })\n      return reply\n    }\n    reply.code(result.status)\n    for (const name of Object.keys(result.headers)) reply.header(name, result.headers[name])\n    const body = result.body\n    if (body === null) return reply.send()\n    if (body instanceof Uint8Array) return reply.send(Buffer.from(body.buffer, body.byteOffset, body.byteLength))\n    const stream = body instanceof Blob ? body.stream() : body\n    return reply.send(Readable.fromWeb(stream as import('node:stream/web').ReadableStream))\n  }\n\n  async listen(port: number, host: string): Promise<HttpServerAddress> {\n    await this.#prepare()\n    this.#closing = undefined\n    await this.instance.listen({ port, host })\n    const address = this.instance.server.address()\n    if (address === null || typeof address === 'string') return serverAddress(host, port)\n    return serverAddress(address.address, address.port, address.family)\n  }\n\n  close(options: AdapterCloseOptions = {}): Promise<void> {\n    if (this.#closing === undefined) {\n      this.#tracker.closeIdle()\n      this.#closing = this.instance.close()\n    }\n    if (options.force === true) {\n      this.instance.server.closeAllConnections?.()\n      this.#tracker.destroyAll()\n    }\n    return this.#closing\n  }\n\n  inject(request: InjectRequest): Promise<InjectResponse> {\n    return bufferInjectStream(stream => this.injectStream(stream), request)\n  }\n\n  async injectStream(request: InjectStreamRequest): Promise<InjectStreamResponse> {\n    await this.#prepare()\n    const options: LightInjectOptions = await lightInjectOptions(request)\n    // Fastify forwards the options to light-my-request (`payloadAsStream`)\n    const inject = this.instance.inject as unknown as (options: LightInjectOptions) => Promise<unknown>\n    const response = await inject.call(this.instance, options)\n    return lightStreamResponse(response as Parameters<typeof lightStreamResponse>[0], request.signal)\n  }\n}\n\nfunction lowerCaseHeaders(\n  headers: Readonly<Record<string, string | number | readonly string[] | undefined>>,\n): Record<string, string | string[]> {\n  const result: Record<string, string | string[]> = {}\n  for (const [name, value] of Object.entries(headers)) {\n    if (value !== undefined) result[name.toLowerCase()] = typeof value === 'object' ? [...value] : String(value)\n  }\n  return result\n}\n\nfunction adapterRequest(\n  request: FastifyRequest,\n  reply: FastifyReply | undefined,\n  response: FastifyReply | undefined = reply,\n): AdapterRequest {\n  const hidden = HIDDEN_CONTENT_TYPES.get(request.raw)\n  if (hidden !== undefined) {\n    // Fastify is done with the content type: restore it (for Znight and `@Req()`)\n    HIDDEN_CONTENT_TYPES.delete(request.raw)\n    request.raw.headers['content-type'] = hidden\n  }\n  let body: Promise<Uint8Array> | undefined\n  return {\n    method: request.raw.method ?? request.method,\n    url: request.raw.url ?? request.url,\n    headers: normalizeNodeHeaders(request.headers),\n    ip: request.ip,\n    remoteAddress: request.raw.socket?.remoteAddress,\n    encrypted: isEncrypted(request.raw),\n    raw: request,\n    rawResponse: reply,\n    readBody: (limit: number): Promise<Uint8Array> => {\n      body ??= readNodeBody(request.raw, limit)\n      return body\n    },\n    streamBody: (limit: number): ReadableStream<Uint8Array> => nodeBodyStream(request.raw, limit),\n    rawStatus: (): number | undefined => reply?.statusCode,\n    onAbort: (listener: () => void): void => {\n      if (response !== undefined) onResponseAbort(response.raw, listener)\n    },\n  }\n}\n"],"mappings":"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"}

package/dist/hono.d.mts

@@ -0,0 +1,49 @@
+import { s as HttpAdapter } from "./adapter-CGSceVEN.mjs";
+import { Hono } from "hono";
+/** Options of {@link honoAdapter}. */
+export interface HonoAdapterOptions {
+  /**
+   * An existing application: its middleware (`app.use(...)`) runs before the Znight routes. Znight
+   * sets its `notFound` and `onError` handlers.
+   */
+  readonly app?: Hono;
+  /**
+   * Options of `Bun.serve()` on Bun (`tls`, `idleTimeout`, `development`, `error`...); Znight sets
+   * `port`, `hostname` and `fetch`. Ignored on Node.js.
+   */
+  readonly serveOptions?: HonoServeOptions;
+}
+/**
+ * Options of `Bun.serve()` (see the Bun documentation; Bun types are not required). Defaults set by
+ * the adapter: `maxRequestBodySize` unlimited (Znight enforces `bodyLimit` / `@BodyLimit` itself)
+ * and Bun's `idleTimeout` (10 s), lifted while a streamed response is sent.
+ */
+export interface HonoServeOptions {
+  /** Seconds a connection may stay idle (`0`: never closed). Default: 10. */
+  readonly idleTimeout?: number;
+  /** Request bodies above this size are refused by Bun (413). Default: unlimited. */
+  readonly maxRequestBodySize?: number;
+  /** TLS options (`{ key, cert }`). */
+  readonly tls?: unknown;
+  /** Any other `Bun.serve()` option. */
+  readonly [option: string]: unknown;
+}
+/** The Hono adapter. */
+export interface HonoAdapter extends HttpAdapter {
+  readonly name: "hono";
+  /** The Hono application. */
+  readonly app: Hono;
+  /** Fetch handler of the application (`export default { fetch: adapter.fetch }` on edge runtimes). */
+  readonly fetch: (request: Request, env?: unknown) => Response | Promise<Response>;
+}
+/**
+ * Creates a Hono adapter.
+ *
+ * ```ts
+ * import { honoAdapter } from '@znight/http/hono'
+ *
+ * HttpPlugin.configure({ adapter: honoAdapter() })
+ * ```
+ */
+export declare function honoAdapter(options?: HonoAdapterOptions): HonoAdapter;
+//# sourceMappingURL=hono.d.mts.map

package/dist/hono.mjs

@@ -0,0 +1,319 @@
+import { N as discardStream, b as webBodyStream, f as bufferInjectStream, n as closeServer, p as injectFetchStream, s as onResponseAbort, t as ConnectionTracker, v as readWebStream, y as serverAddress } from "./node-io-BY1ZDLRQ.mjs";
+import { r as isBun } from "./utils-DCbu3a4w.mjs";
+import { toHonoPath } from "./path.mjs";
+import { Hono } from "hono";
+// src/adapters/hono.ts
+/**
+* Creates a Hono adapter.
+*
+* ```ts
+* import { honoAdapter } from '@znight/http/hono'
+*
+* HttpPlugin.configure({ adapter: honoAdapter() })
+* ```
+*/
+function honoAdapter(options = {}) {
+	return new HonoHttpAdapter(options);
+}
+/** Default `idleTimeout` of `Bun.serve()`, in seconds. */
+const BUN_IDLE_TIMEOUT = 10;
+/** Response bodies built while serving with `Bun.serve()`, by body (Hono may copy a `Response`, not its body). */
+const BUN_BODIES = /* @__PURE__ */ new WeakMap();
+/** Bindings of injected requests (the remote address the other adapters report for `inject()`). */
+const INJECT_ENV = Object.freeze({ incoming: Object.freeze({ socket: Object.freeze({ remoteAddress: "127.0.0.1" }) }) });
+var HonoHttpAdapter = class {
+	name = "hono";
+	app;
+	#serveOptions;
+	#fallback;
+	#prepared = false;
+	#bun;
+	#node;
+	#tracker;
+	#closing;
+	constructor(options) {
+		this.app = options.app ?? new Hono();
+		this.#serveOptions = options.serveOptions ?? {};
+	}
+	fetch = (request, env) => {
+		this.#prepare();
+		return this.app.fetch(request, env);
+	};
+	registerRoute(route) {
+		const handler = route.handler;
+		const path = toHonoPath(route.path);
+		if (route.method === "HEAD") {
+			this.app.get(path, (c, next) => c.req.raw.method === "HEAD" ? this.#serve(c, handler) : next().then(() => c.res));
+			return;
+		}
+		this.app.on(route.method, path, (c) => this.#serve(c, handler));
+	}
+	setFallbackHandler(handler) {
+		this.#fallback = handler;
+	}
+	#prepare() {
+		if (this.#prepared) return;
+		this.#prepared = true;
+		this.app.notFound((c) => this.#serveFallback(c, void 0));
+		this.app.onError((error, c) => this.#serveFallback(c, error));
+	}
+	async #serve(c, handler) {
+		const request = adapterRequest(c);
+		const reply = this.#fallback !== void 0 && pathOf(request.url) !== pathOf(pathAndQuery(c.req.raw.url)) ? await this.#fallback(request) : await handler(request);
+		return this.#toResponse(c, reply);
+	}
+	async #serveFallback(c, error) {
+		if (this.#fallback === void 0) throw error ?? /* @__PURE__ */ new Error("No fallback handler");
+		return this.#toResponse(c, await this.#fallback(adapterRequest(c), error));
+	}
+	#toResponse(c, reply) {
+		const outgoing = nodeOutgoing(c);
+		if (outgoing !== void 0) {
+			const body = reply.body instanceof ReadableStream ? reply.body : null;
+			if (outgoing.destroyed) {
+				discardStream(body);
+				return toResponse(c, {
+					...reply,
+					body: null
+				});
+			}
+			if (body !== null) outgoing.once("close", () => {
+				if (!outgoing.writableFinished) discardStream(body);
+			});
+			if (reply.eventStream === true && typeof outgoing.setTimeout === "function") outgoing.setTimeout(0);
+		}
+		if (this.#bun === void 0 || !(reply.body instanceof ReadableStream)) return toResponse(c, reply);
+		const reader = reply.body.getReader();
+		let ended = false;
+		let onEnd = () => void 0;
+		const end = () => {
+			if (ended) return;
+			ended = true;
+			onEnd();
+		};
+		const body = new ReadableStream({
+			async pull(controller) {
+				let result;
+				try {
+					result = await reader.read();
+				} catch (error) {
+					end();
+					throw error;
+				}
+				if (result.done) {
+					end();
+					controller.close();
+					return;
+				}
+				controller.enqueue(result.value);
+			},
+			cancel(reason) {
+				end();
+				return reader.cancel(reason);
+			}
+		}, { highWaterMark: 0 });
+		BUN_BODIES.set(body, {
+			blob: reply.blob,
+			onEnd: (callback) => {
+				onEnd = callback;
+			}
+		});
+		return toResponse(c, {
+			...reply,
+			body
+		});
+	}
+	/** The fetch handler given to `Bun.serve()`. */
+	async #bunFetch(request, server, idleTimeout) {
+		const response = await this.app.fetch(request, server);
+		const body = response.body;
+		const served = body === null ? void 0 : BUN_BODIES.get(body);
+		if (body === null || served === void 0) return response;
+		BUN_BODIES.delete(body);
+		if (served.blob !== void 0 && !body.locked) {
+			const native = new Response(served.blob, {
+				status: response.status,
+				statusText: response.statusText,
+				headers: response.headers
+			});
+			setImmediate(() => discardStream(body));
+			return native;
+		}
+		if (idleTimeout > 0 && typeof server.timeout === "function") {
+			server.timeout(request, 0);
+			served.onEnd(() => {
+				try {
+					server.timeout?.(request, idleTimeout);
+				} catch {}
+			});
+		}
+		return response;
+	}
+	async listen(port, host) {
+		this.#prepare();
+		this.#closing = void 0;
+		const bun = globalThis.Bun;
+		if (isBun() && bun !== void 0) {
+			const options = this.#serveOptions;
+			const idleTimeout = typeof options.idleTimeout === "number" ? options.idleTimeout : BUN_IDLE_TIMEOUT;
+			const server = bun.serve({
+				maxRequestBodySize: Number.MAX_SAFE_INTEGER,
+				...options,
+				port,
+				hostname: host,
+				fetch: (request, server) => this.#bunFetch(request, server, idleTimeout)
+			});
+			this.#bun = server;
+			return serverAddress(server.hostname, server.port);
+		}
+		let nodeServer;
+		try {
+			nodeServer = await import("@hono/node-server");
+		} catch (error) {
+			throw new Error("honoAdapter on Node.js requires the optional peer dependency \"@hono/node-server\" (npm i @hono/node-server)", { cause: error });
+		}
+		const server = nodeServer.createAdaptorServer({ fetch: this.app.fetch });
+		this.#node = server;
+		this.#tracker = new ConnectionTracker(server);
+		await new Promise((resolve, reject) => {
+			const onError = (error) => reject(error);
+			server.once("error", onError);
+			server.listen(port, host, () => {
+				server.off("error", onError);
+				resolve();
+			});
+		});
+		const address = server.address();
+		if (address === null || typeof address === "string") return serverAddress(host, port);
+		return serverAddress(address.address, address.port, address.family);
+	}
+	close(options = {}) {
+		const bun = this.#bun;
+		if (bun !== void 0) {
+			if (options.force === true) this.#closing = Promise.resolve(bun.stop(true));
+			else this.#closing ??= Promise.resolve(bun.stop(false));
+			return this.#closing;
+		}
+		const server = this.#node;
+		const tracker = this.#tracker;
+		if (server === void 0 || tracker === void 0) return Promise.resolve();
+		this.#closing = closeServer(server, tracker, this.#closing, options.force === true);
+		return this.#closing;
+	}
+	inject(request) {
+		return bufferInjectStream((stream) => this.injectStream(stream), request);
+	}
+	injectStream(request) {
+		this.#prepare();
+		return injectFetchStream((request) => this.app.request(request, void 0, INJECT_ENV), request);
+	}
+};
+function adapterRequest(c) {
+	const request = c.req.raw;
+	const headers = {};
+	for (const [name, value] of request.headers) headers[name] = value;
+	const incoming = nodeIncoming(c);
+	const address = remoteAddress(c);
+	let body;
+	return {
+		method: request.method,
+		url: pathAndQuery(typeof incoming?.url === "string" && incoming.url !== "" ? incoming.url : request.url),
+		headers,
+		ip: address,
+		remoteAddress: address,
+		encrypted: incoming === void 0 ? request.url.startsWith("https:") : incoming.socket?.encrypted === true,
+		raw: request,
+		rawResponse: c,
+		readBody: (limit) => {
+			body ??= readWebStream(() => request.body, limit, headers["content-length"]);
+			return body;
+		},
+		streamBody: (limit) => webBodyStream(() => request.body, limit, headers["content-length"]),
+		hasBody: () => incoming === void 0 ? request.body !== null : incoming.httpVersionMajor >= 2 && incoming.stream?.endAfterHeaders === false,
+		onAbort: (listener) => {
+			const outgoing = nodeOutgoing(c);
+			if (outgoing !== void 0) {
+				onResponseAbort(outgoing, listener);
+				return;
+			}
+			const signal = request.signal;
+			if (signal.aborted) queueMicrotask(listener);
+			else signal.addEventListener("abort", listener, { once: true });
+		}
+	};
+}
+/** The Node.js response of `@hono/node-server` (`c.env.outgoing`), absent on Bun and for `inject()`. */
+function nodeOutgoing(c) {
+	const outgoing = c.env?.outgoing;
+	return typeof outgoing?.once === "function" ? outgoing : void 0;
+}
+/** The Node.js request of `@hono/node-server` (`c.env.incoming`), absent on Bun and for `inject()`. */
+function nodeIncoming(c) {
+	const incoming = c.env?.incoming;
+	return typeof incoming?.httpVersionMajor === "number" ? incoming : void 0;
+}
+function pathAndQuery(url) {
+	if (url.startsWith("/")) return url;
+	const scheme = url.indexOf("://");
+	const start = url.indexOf("/", scheme === -1 ? 0 : scheme + 3);
+	return start === -1 ? "/" : url.slice(start);
+}
+function pathOf(url) {
+	const query = url.indexOf("?");
+	return query === -1 ? url : url.slice(0, query);
+}
+function remoteAddress(c) {
+	const env = c.env;
+	if (env === void 0 || env === null) return void 0;
+	if (typeof env.requestIP === "function") return env.requestIP(c.req.raw)?.address ?? void 0;
+	return env.incoming?.socket?.remoteAddress;
+}
+function toResponse(c, reply) {
+	if (reply.raw === true) {
+		discardStream(reply.body instanceof ReadableStream ? reply.body : null);
+		return c.res;
+	}
+	const headers = new Headers();
+	try {
+		for (const name of Object.keys(reply.headers)) {
+			const value = reply.headers[name];
+			if (typeof value === "string") headers.set(name, value);
+			else if (value !== void 0) for (const item of value) headers.append(name, item);
+		}
+	} catch {
+		discardStream(reply.body instanceof ReadableStream ? reply.body : null);
+		return new Response("{\"statusCode\":500,\"error\":\"Internal Server Error\"}", {
+			status: 500,
+			headers: { "content-type": "application/json; charset=utf-8" }
+		});
+	}
+	keepContextCookies(c, headers);
+	return new Response(reply.body, {
+		status: reply.status,
+		headers
+	});
+}
+/**
+* Keeps the cookies Hono middleware set before the Znight route (`setCookie(c, ...)`,
+* `c.header('set-cookie', ..., { append: true })`) before the reply's own, like the other adapters.
+* Hono drops the headers of the context when a handler returns its own `Response` (or, when a
+* middleware read `c.res`, replaces the response's cookies with the context's): the reply's cookies
+* are added to the context too, so that both ways end with every cookie, in order.
+*/
+function keepContextCookies(c, headers) {
+	let context;
+	try {
+		context = c.newResponse(null).headers.getSetCookie();
+	} catch {
+		return;
+	}
+	if (context.length === 0) return;
+	const own = headers.getSetCookie();
+	for (const line of own) c.header("set-cookie", line, { append: true });
+	headers.delete("set-cookie");
+	for (const line of context) headers.append("set-cookie", line);
+	for (const line of own) headers.append("set-cookie", line);
+}
+export { honoAdapter };
+
+//# sourceMappingURL=hono.mjs.map