srvx 0.8.4 → 0.8.6

package/README.md

@@ -52,9 +52,12 @@ $ bunx --bun srvx
 | Example          | Source                                                                                     | Try                                                                  |
 | ---------------- | ------------------------------------------------------------------------------------------ | -------------------------------------------------------------------- |
 | `elysia`         | [examples/elysia](https://github.com/h3js/srvx/tree/main/examples/elysia/)                 | `npx giget gh:h3js/srvx/examples/elysia srvx-elysia`                 |
+| `express`        | [examples/express](https://github.com/h3js/srvx/tree/main/examples/express/)               | `npx giget gh:h3js/srvx/examples/express srvx-express`               |
 | `h3`             | [examples/h3](https://github.com/h3js/srvx/tree/main/examples/h3/)                         | `npx giget gh:h3js/srvx/examples/h3 srvx-h3`                         |
 | `hello-world`    | [examples/hello-world](https://github.com/h3js/srvx/tree/main/examples/hello-world/)       | `npx giget gh:h3js/srvx/examples/hello-world srvx-hello-world`       |
 | `hono`           | [examples/hono](https://github.com/h3js/srvx/tree/main/examples/hono/)                     | `npx giget gh:h3js/srvx/examples/hono srvx-hono`                     |
+| `jsx`            | [examples/jsx](https://github.com/h3js/srvx/tree/main/examples/jsx/)                       | `npx giget gh:h3js/srvx/examples/jsx srvx-jsx`                       |
+| `node-handler`   | [examples/node-handler](https://github.com/h3js/srvx/tree/main/examples/node-handler/)     | `npx giget gh:h3js/srvx/examples/node-handler srvx-node-handler`     |
 | `service-worker` | [examples/service-worker](https://github.com/h3js/srvx/tree/main/examples/service-worker/) | `npx giget gh:h3js/srvx/examples/service-worker srvx-service-worker` |
 | `websocket`      | [examples/websocket](https://github.com/h3js/srvx/tree/main/examples/websocket/)           | `npx giget gh:h3js/srvx/examples/websocket srvx-websocket`           |
 

package/dist/_chunks/_utils.cli-B2YzwlOv.mjs

@@ -0,0 +1,31 @@
+//#region src/_utils.cli.ts
+const noColor = globalThis.process?.env?.NO_COLOR === "1" || globalThis.process?.env?.TERM === "dumb";
+const resets = {
+	1: 22,
+	31: 39,
+	32: 39,
+	33: 39,
+	34: 39,
+	35: 39,
+	36: 39,
+	90: 39
+};
+const _c = (c) => (text) => {
+	if (noColor) return text;
+	const off = resets[c] ?? 0;
+	return `\u001B[${c}m${text}\u001B[${off}m`;
+};
+const Colors = {
+	bold: _c(1),
+	red: _c(31),
+	green: _c(32),
+	yellow: _c(33),
+	blue: _c(34),
+	magenta: _c(35),
+	cyan: _c(36),
+	gray: _c(90),
+	url: (title, url) => noColor ? `[${title}](${url})` : `\u001B]8;;${url}\u001B\\${title}\u001B]8;;\u001B\\`
+};
+
+//#endregion
+export { Colors };

package/dist/_chunks/call-CKpEER8U.mjs

@@ -0,0 +1,43 @@
+import { NodeResponse, NodeResponseHeaders } from "./response-Ca-wGejU.mjs";
+
+//#region src/adapters/_node/call.ts
+function callNodeHandler(handler, req) {
+	const isMiddleware = handler.length > 2;
+	const nodeCtx = req.runtime?.node;
+	if (!nodeCtx || !nodeCtx.req || !nodeCtx.res) throw new Error("Node.js runtime context is not available.");
+	const { req: nodeReq, res: nodeRes } = nodeCtx;
+	let _headers;
+	const webRes = new NodeResponse(void 0, {
+		get status() {
+			return nodeRes.statusCode;
+		},
+		get statusText() {
+			return nodeRes.statusMessage;
+		},
+		get headers() {
+			if (!_headers) _headers = new NodeResponseHeaders(nodeCtx);
+			return _headers;
+		}
+	});
+	return new Promise((resolve, reject) => {
+		nodeRes.once("close", () => resolve(webRes));
+		nodeRes.once("finish", () => resolve(webRes));
+		nodeRes.once("error", (error) => reject(error));
+		let streamPromise;
+		nodeRes.once("pipe", (stream) => {
+			streamPromise = new Promise((resolve$1) => {
+				stream.once("end", () => resolve$1(webRes));
+				stream.once("error", (error) => reject(error));
+			});
+		});
+		try {
+			if (isMiddleware) Promise.resolve(handler(nodeReq, nodeRes, (error) => error ? reject(error) : streamPromise || resolve(webRes))).catch((error) => reject(error));
+			else Promise.resolve(handler(nodeReq, nodeRes)).then(() => streamPromise || webRes);
+		} catch (error) {
+			reject(error);
+		}
+	});
+}
+
+//#endregion
+export { callNodeHandler };

package/dist/_chunks/response-Ca-wGejU.mjs

@@ -0,0 +1,358 @@
+import { splitSetCookieString } from "cookie-es";
+
+//#region src/adapters/_node/_common.ts
+const kNodeInspect = /* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom");
+
+//#endregion
+//#region src/adapters/_node/headers.ts
+const NodeRequestHeaders = /* @__PURE__ */ (() => {
+	const _Headers = class Headers$1 {
+		_node;
+		constructor(nodeCtx) {
+			this._node = nodeCtx;
+		}
+		append(name, value) {
+			name = validateHeader(name);
+			const _headers = this._node.req.headers;
+			const _current = _headers[name];
+			if (_current) if (Array.isArray(_current)) _current.push(value);
+			else _headers[name] = [_current, value];
+			else _headers[name] = value;
+		}
+		delete(name) {
+			name = validateHeader(name);
+			this._node.req.headers[name] = void 0;
+		}
+		get(name) {
+			name = validateHeader(name);
+			const rawValue = this._node.req.headers[name];
+			if (rawValue === void 0) return null;
+			return _normalizeValue(this._node.req.headers[name]);
+		}
+		getSetCookie() {
+			const setCookie = this._node.req.headers["set-cookie"];
+			if (!setCookie || setCookie.length === 0) return [];
+			return splitSetCookieString(setCookie);
+		}
+		has(name) {
+			name = validateHeader(name);
+			return !!this._node.req.headers[name];
+		}
+		set(name, value) {
+			name = validateHeader(name);
+			this._node.req.headers[name] = value;
+		}
+		get count() {
+			throw new Error("Method not implemented.");
+		}
+		getAll(_name) {
+			throw new Error("Method not implemented.");
+		}
+		toJSON() {
+			const _headers = this._node.req.headers;
+			const result = {};
+			for (const key in _headers) if (_headers[key]) result[key] = _normalizeValue(_headers[key]);
+			return result;
+		}
+		forEach(cb, thisArg) {
+			const _headers = this._node.req.headers;
+			for (const key in _headers) if (_headers[key]) cb.call(thisArg, _normalizeValue(_headers[key]), key, this);
+		}
+		*entries() {
+			const headers = this._node.req.headers;
+			const isHttp2 = this._node.req.httpVersion === "2.0";
+			for (const key in headers) if (!isHttp2 || key[0] !== ":") yield [key, _normalizeValue(headers[key])];
+		}
+		*keys() {
+			const keys = Object.keys(this._node.req.headers);
+			for (const key of keys) yield key;
+		}
+		*values() {
+			const values = Object.values(this._node.req.headers);
+			for (const value of values) yield _normalizeValue(value);
+		}
+		[Symbol.iterator]() {
+			return this.entries()[Symbol.iterator]();
+		}
+		get [Symbol.toStringTag]() {
+			return "Headers";
+		}
+		[kNodeInspect]() {
+			return Object.fromEntries(this.entries());
+		}
+	};
+	Object.setPrototypeOf(_Headers.prototype, globalThis.Headers.prototype);
+	return _Headers;
+})();
+const NodeResponseHeaders = /* @__PURE__ */ (() => {
+	const _Headers = class Headers$1 {
+		_node;
+		constructor(nodeCtx) {
+			this._node = nodeCtx;
+		}
+		append(name, value) {
+			this._node.res.appendHeader(name, value);
+		}
+		delete(name) {
+			this._node.res.removeHeader(name);
+		}
+		get(name) {
+			const rawValue = this._node.res.getHeader(name);
+			if (rawValue === void 0) return null;
+			return _normalizeValue(rawValue);
+		}
+		getSetCookie() {
+			const setCookie = _normalizeValue(this._node.res.getHeader("set-cookie"));
+			if (!setCookie) return [];
+			return splitSetCookieString(setCookie);
+		}
+		has(name) {
+			return this._node.res.hasHeader(name);
+		}
+		set(name, value) {
+			this._node.res.setHeader(name, value);
+		}
+		get count() {
+			throw new Error("Method not implemented.");
+		}
+		getAll(_name) {
+			throw new Error("Method not implemented.");
+		}
+		toJSON() {
+			const _headers = this._node.res.getHeaders();
+			const result = {};
+			for (const key in _headers) if (_headers[key]) result[key] = _normalizeValue(_headers[key]);
+			return result;
+		}
+		forEach(cb, thisArg) {
+			const _headers = this._node.res.getHeaders();
+			for (const key in _headers) if (_headers[key]) cb.call(thisArg, _normalizeValue(_headers[key]), key, this);
+		}
+		*entries() {
+			const _headers = this._node.res.getHeaders();
+			for (const key in _headers) yield [key, _normalizeValue(_headers[key])];
+		}
+		*keys() {
+			const keys = this._node.res.getHeaderNames();
+			for (const key of keys) yield key;
+		}
+		*values() {
+			const values = Object.values(this._node.res.getHeaders());
+			for (const value of values) yield _normalizeValue(value);
+		}
+		[Symbol.iterator]() {
+			return this.entries()[Symbol.iterator]();
+		}
+		get [Symbol.toStringTag]() {
+			return "Headers";
+		}
+		[kNodeInspect]() {
+			return Object.fromEntries(this.entries());
+		}
+	};
+	Object.setPrototypeOf(_Headers.prototype, globalThis.Headers.prototype);
+	return _Headers;
+})();
+function _normalizeValue(value) {
+	if (Array.isArray(value)) return value.join(", ");
+	return typeof value === "string" ? value : String(value ?? "");
+}
+function validateHeader(name) {
+	if (name[0] === ":") throw new TypeError(`${JSON.stringify(name)} is an invalid header name.`);
+	return name.toLowerCase();
+}
+
+//#endregion
+//#region src/adapters/_node/response.ts
+/**
+* Fast Response for Node.js runtime
+*
+* It is faster because in most cases it doesn't create a full Response instance.
+*/
+const NodeResponse = /* @__PURE__ */ (() => {
+	const CONTENT_TYPE = "content-type";
+	const JSON_TYPE = "application/json";
+	const JSON_HEADER = [[CONTENT_TYPE, JSON_TYPE]];
+	const _Response = class Response {
+		#body;
+		#init;
+		constructor(body, init) {
+			this.#body = body;
+			this.#init = init;
+		}
+		static json(data, init) {
+			if (init?.headers) {
+				if (!init.headers[CONTENT_TYPE]) {
+					const initHeaders = new Headers(init.headers);
+					if (!initHeaders.has(CONTENT_TYPE)) initHeaders.set(CONTENT_TYPE, JSON_TYPE);
+					init = {
+						...init,
+						headers: initHeaders
+					};
+				}
+			} else {
+				init = init ? { ...init } : {};
+				init.headers = JSON_HEADER;
+			}
+			return new _Response(JSON.stringify(data), init);
+		}
+		static error() {
+			return globalThis.Response.error();
+		}
+		static redirect(url, status) {
+			return globalThis.Response.redirect(url, status);
+		}
+		/**
+		* Prepare Node.js response object
+		*/
+		nodeResponse() {
+			const status = this.#init?.status ?? 200;
+			const statusText = this.#init?.statusText ?? "";
+			const headers = [];
+			const headersInit = this.#init?.headers;
+			if (this.#headersObj) for (const [key, value] of this.#headersObj) if (key === "set-cookie") for (const setCookie of splitSetCookieString(value)) headers.push(["set-cookie", setCookie]);
+			else headers.push([key, value]);
+			else if (headersInit) {
+				const headerEntries = Array.isArray(headersInit) ? headersInit : headersInit.entries ? headersInit.entries() : Object.entries(headersInit);
+				for (const [key, value] of headerEntries) if (key === "set-cookie") for (const setCookie of splitSetCookieString(value)) headers.push(["set-cookie", setCookie]);
+				else headers.push([key, value]);
+			}
+			const bodyInit = this.#body;
+			let body;
+			if (bodyInit) if (typeof bodyInit === "string") body = bodyInit;
+			else if (bodyInit instanceof ReadableStream) body = bodyInit;
+			else if (bodyInit instanceof ArrayBuffer) body = Buffer.from(bodyInit);
+			else if (bodyInit instanceof Uint8Array) body = Buffer.from(bodyInit);
+			else if (bodyInit instanceof DataView) body = Buffer.from(bodyInit.buffer);
+			else if (bodyInit instanceof Blob) {
+				body = bodyInit.stream();
+				if (bodyInit.type) headers.push(["content-type", bodyInit.type]);
+			} else if (typeof bodyInit.pipe === "function") body = bodyInit;
+			else {
+				const res = new globalThis.Response(bodyInit);
+				body = res.body;
+				for (const [key, value] of res.headers) headers.push([key, value]);
+			}
+			this.#body = void 0;
+			this.#init = void 0;
+			this.#headersObj = void 0;
+			this.#responseObj = void 0;
+			return {
+				status,
+				statusText,
+				headers,
+				body
+			};
+		}
+		/** Lazy initialized response instance */
+		#responseObj;
+		/** Lazy initialized headers instance */
+		#headersObj;
+		clone() {
+			if (this.#responseObj) return this.#responseObj.clone();
+			if (this.#headersObj) return new _Response(this.#body, {
+				...this.#init,
+				headers: this.#headersObj
+			});
+			return new _Response(this.#body, this.#init);
+		}
+		get #response() {
+			if (!this.#responseObj) {
+				this.#responseObj = this.#headersObj ? new globalThis.Response(this.#body, {
+					...this.#init,
+					headers: this.#headersObj
+				}) : new globalThis.Response(this.#body, this.#init);
+				this.#body = void 0;
+				this.#init = void 0;
+				this.#headersObj = void 0;
+			}
+			return this.#responseObj;
+		}
+		get headers() {
+			if (this.#responseObj) return this.#responseObj.headers;
+			if (!this.#headersObj) this.#headersObj = new Headers(this.#init?.headers);
+			return this.#headersObj;
+		}
+		get ok() {
+			if (this.#responseObj) return this.#responseObj.ok;
+			const status = this.#init?.status ?? 200;
+			return status >= 200 && status < 300;
+		}
+		get redirected() {
+			if (this.#responseObj) return this.#responseObj.redirected;
+			return false;
+		}
+		get status() {
+			if (this.#responseObj) return this.#responseObj.status;
+			return this.#init?.status ?? 200;
+		}
+		get statusText() {
+			if (this.#responseObj) return this.#responseObj.statusText;
+			return this.#init?.statusText ?? "";
+		}
+		get type() {
+			if (this.#responseObj) return this.#responseObj.type;
+			return "default";
+		}
+		get url() {
+			if (this.#responseObj) return this.#responseObj.url;
+			return "";
+		}
+		#fastBody(as) {
+			const bodyInit = this.#body;
+			if (bodyInit === null || bodyInit === void 0) return null;
+			if (bodyInit instanceof as) return bodyInit;
+			return false;
+		}
+		get body() {
+			if (this.#responseObj) return this.#responseObj.body;
+			const fastBody = this.#fastBody(ReadableStream);
+			if (fastBody !== false) return fastBody;
+			return this.#response.body;
+		}
+		get bodyUsed() {
+			if (this.#responseObj) return this.#responseObj.bodyUsed;
+			return false;
+		}
+		arrayBuffer() {
+			if (this.#responseObj) return this.#responseObj.arrayBuffer();
+			const fastBody = this.#fastBody(ArrayBuffer);
+			if (fastBody !== false) return Promise.resolve(fastBody || new ArrayBuffer(0));
+			return this.#response.arrayBuffer();
+		}
+		blob() {
+			if (this.#responseObj) return this.#responseObj.blob();
+			const fastBody = this.#fastBody(Blob);
+			if (fastBody !== false) return Promise.resolve(fastBody || new Blob());
+			return this.#response.blob();
+		}
+		bytes() {
+			if (this.#responseObj) return this.#responseObj.bytes();
+			const fastBody = this.#fastBody(Uint8Array);
+			if (fastBody !== false) return Promise.resolve(fastBody || new Uint8Array());
+			return this.#response.bytes();
+		}
+		formData() {
+			if (this.#responseObj) return this.#responseObj.formData();
+			const fastBody = this.#fastBody(FormData);
+			if (fastBody !== false) return Promise.resolve(fastBody || new FormData());
+			return this.#response.formData();
+		}
+		text() {
+			if (this.#responseObj) return this.#responseObj.text();
+			const bodyInit = this.#body;
+			if (bodyInit === null || bodyInit === void 0) return Promise.resolve("");
+			if (typeof bodyInit === "string") return Promise.resolve(bodyInit);
+			return this.#response.text();
+		}
+		json() {
+			if (this.#responseObj) return this.#responseObj.json();
+			return this.text().then((text) => JSON.parse(text));
+		}
+	};
+	Object.setPrototypeOf(_Response.prototype, globalThis.Response.prototype);
+	return _Response;
+})();
+
+//#endregion
+export { NodeRequestHeaders, NodeResponse, NodeResponseHeaders, kNodeInspect };

package/dist/_chunks/{types-GwbH0R0m.d.mts → types-BXtbU5Z8.d.mts}

@@ -250,6 +250,7 @@ type DenoFetchHandler = (request: Request, info?: Deno.ServeHandlerInfo<Deno.Net
 type NodeServerRequest = NodeHttp$1.IncomingMessage | NodeHttp2.Http2ServerRequest;
 type NodeServerResponse = NodeHttp$1.ServerResponse | NodeHttp2.Http2ServerResponse;
 type NodeHttpHandler = (req: NodeServerRequest, res: NodeServerResponse) => void | Promise<void>;
+type NodeHTTPMiddleware = (req: NodeServerRequest, res: NodeServerResponse, next: (error?: Error) => void) => unknown | Promise<unknown>;
 type CloudflareFetchHandler = CF.ExportedHandlerFetchHandler;
 //#endregion
-export { BunFetchHandler, CloudflareFetchHandler, DenoFetchHandler, ErrorHandler, FastResponse, FastURL, FetchHandler, NodeHttpHandler, NodeServerRequest, NodeServerResponse, Server, ServerHandler, ServerMiddleware, ServerOptions, ServerPlugin, ServerRequest, ServerRuntimeContext, serve };
+export { BunFetchHandler, CloudflareFetchHandler, DenoFetchHandler, ErrorHandler, FastResponse, FastURL, FetchHandler, NodeHTTPMiddleware, NodeHttpHandler, NodeServerRequest, NodeServerResponse, Server, ServerHandler, ServerMiddleware, ServerOptions, ServerPlugin, ServerRequest, ServerRuntimeContext, serve };

package/dist/adapters/bun.d.mts

@@ -1,5 +1,5 @@
-import { BunFetchHandler, Server, ServerOptions } from "../_chunks/types-GwbH0R0m.mjs";
-import { FastURL$2 as FastURL } from "../_chunks/_url-Bu46KnwC.mjs";
+import { BunFetchHandler, Server, ServerOptions } from "../_chunks/types-BXtbU5Z8.mjs";
+import { FastURL$2 as FastURL } from "../_chunks/_url-D8u5OAto.mjs";
 import * as bun from "bun";
 
 //#region src/adapters/bun.d.ts

package/dist/adapters/cloudflare.d.mts

@@ -1,4 +1,4 @@
-import { Server, ServerOptions } from "../_chunks/types-GwbH0R0m.mjs";
+import { Server, ServerOptions } from "../_chunks/types-BXtbU5Z8.mjs";
 import * as CF from "@cloudflare/workers-types";
 
 //#region src/adapters/cloudflare.d.ts

package/dist/adapters/cloudflare.mjs

@@ -1,5 +1,5 @@
 import { wrapFetch } from "../_chunks/_middleware-BvRR7B4M.mjs";
-import { errorPlugin } from "../_chunks/_plugins-CbGQstxC.mjs";
+import { errorPlugin } from "../_chunks/_plugins-DOhVIkXu.mjs";
 
 //#region src/adapters/cloudflare.ts
 const FastURL = URL;

package/dist/adapters/deno.d.mts

@@ -1,5 +1,5 @@
-import { DenoFetchHandler, Server, ServerOptions } from "../_chunks/types-GwbH0R0m.mjs";
-import { FastURL$2 as FastURL } from "../_chunks/_url-Bu46KnwC.mjs";
+import { DenoFetchHandler, Server, ServerOptions } from "../_chunks/types-BXtbU5Z8.mjs";
+import { FastURL$2 as FastURL } from "../_chunks/_url-D8u5OAto.mjs";
 
 //#region src/adapters/deno.d.ts
 declare const FastResponse: typeof globalThis.Response;

package/dist/adapters/generic.d.mts

@@ -1,4 +1,4 @@
-import { Server, ServerOptions } from "../_chunks/types-GwbH0R0m.mjs";
+import { Server, ServerOptions } from "../_chunks/types-BXtbU5Z8.mjs";
 
 //#region src/adapters/generic.d.ts
 declare const FastURL: typeof globalThis.URL;

package/dist/adapters/generic.mjs

@@ -1,6 +1,6 @@
 import { createWaitUntil } from "../_chunks/_utils-DRF_4b_y.mjs";
 import { wrapFetch } from "../_chunks/_middleware-BvRR7B4M.mjs";
-import { errorPlugin } from "../_chunks/_plugins-CbGQstxC.mjs";
+import { errorPlugin } from "../_chunks/_plugins-DOhVIkXu.mjs";
 
 //#region src/adapters/generic.ts
 const FastURL = URL;

package/dist/adapters/node.d.mts

@@ -1,5 +1,5 @@
-import { FetchHandler, NodeHttpHandler, NodeServerRequest, NodeServerResponse, Server, ServerOptions, ServerRequest } from "../_chunks/types-GwbH0R0m.mjs";
-import { FastURL$2 as FastURL } from "../_chunks/_url-Bu46KnwC.mjs";
+import { FetchHandler, NodeHttpHandler, NodeServerRequest, NodeServerResponse, Server, ServerOptions, ServerRequest } from "../_chunks/types-BXtbU5Z8.mjs";
+import { FastURL$2 as FastURL } from "../_chunks/_url-D8u5OAto.mjs";
 import NodeHttp from "node:http";
 import { Readable } from "node:stream";
 
@@ -39,7 +39,7 @@ declare const NodeResponse: {
       status: number;
       statusText: string;
       headers: NodeHttp.OutgoingHttpHeader[];
-      body: string | Buffer | Uint8Array | DataView | ReadableStream<Uint8Array> | Readable | undefined | null;
+      body: string | Buffer | Uint8Array | DataView | ReadableStream | Readable | undefined | null;
     };
   };
 };