srvx 0.10.0 → 0.11.0

package/dist/adapters/node.mjs

@@ -1,14 +1,10 @@
-import { t as lazyInherit } from "../_chunks/_inherit.mjs";
-import { t as FastURL } from "../_chunks/_url.mjs";
-import { a as resolveTLSOptions, i as resolvePortAndHost, n as fmtURL, r as printListening, t as createWaitUntil } from "../_chunks/_utils.mjs";
+import { n as lazyInherit, t as FastURL } from "../_chunks/_url.mjs";
+import { a as resolveTLSOptions, i as resolvePortAndHost, n as fmtURL, r as printListening, t as createWaitUntil } from "../_chunks/_utils2.mjs";
 import { n as gracefulShutdownPlugin, r as wrapFetch, t as errorPlugin } from "../_chunks/_plugins.mjs";
-import { n as NodeResponse, t as callNodeHandler } from "../_chunks/call.mjs";
 import nodeHTTP, { IncomingMessage, ServerResponse } from "node:http";
 import { Duplex, Readable } from "node:stream";
 import nodeHTTPS from "node:https";
 import nodeHTTP2 from "node:http2";
-
-//#region src/adapters/_node/send.ts
 async function sendNodeResponse(nodeRes, webRes) {
 	if (!webRes) {
 		nodeRes.statusCode = 500;
@@ -66,9 +62,6 @@ function streamBody(stream, nodeRes) {
 		nodeRes.off("error", streamCancel);
 	});
 }
-
-//#endregion
-//#region src/adapters/_node/url.ts
 var NodeRequestURL = class extends FastURL {
 	#req;
 	constructor({ req }) {
@@ -96,9 +89,6 @@ var NodeRequestURL = class extends FastURL {
 		this.#req.url = this._url.pathname + this._url.search;
 	}
 };
-
-//#endregion
-//#region src/adapters/_node/headers.ts
 const NodeRequestHeaders = /* @__PURE__ */ (() => {
 	const NativeHeaders = globalThis.Headers;
 	class Headers {
@@ -160,9 +150,6 @@ const NodeRequestHeaders = /* @__PURE__ */ (() => {
 	Object.setPrototypeOf(Headers.prototype, NativeHeaders.prototype);
 	return Headers;
 })();
-
-//#endregion
-//#region src/adapters/_node/request.ts
 const NodeRequest = /* @__PURE__ */ (() => {
 	const NativeRequest = globalThis.Request;
 	class Request {
@@ -210,7 +197,6 @@ const NodeRequest = /* @__PURE__ */ (() => {
 				const { req, res } = this.runtime.node;
 				const abortController = this.#abortController;
 				const abort = (err) => abortController.abort?.(err);
-				req.once("error", abort);
 				if (res) res.once("close", () => {
 					const reqError = req.errored;
 					if (reqError) abort(reqError);
@@ -262,13 +248,6 @@ const NodeRequest = /* @__PURE__ */ (() => {
 	Object.setPrototypeOf(Request.prototype, NativeRequest.prototype);
 	return Request;
 })();
-/**
-* Undici uses an incompatible Request constructor depending on private property accessors.
-*
-* This utility, patches global Request to support `new Request(req)` in Node.js.
-*
-* Alternatively you can use `new Request(req._request || req)` instead of patching global Request.
-*/
 function patchGlobalRequest() {
 	const NativeRequest = globalThis[Symbol.for("srvx.nativeRequest")] ??= globalThis.Request;
 	const PatchedRequest = class Request extends NativeRequest {
@@ -286,6 +265,7 @@ function patchGlobalRequest() {
 	return PatchedRequest;
 }
 function readBody(req) {
+	if ("rawBody" in req && Buffer.isBuffer(req.rawBody)) return Promise.resolve(req.rawBody);
 	return new Promise((resolve, reject) => {
 		const chunks = [];
 		const onData = (chunk) => {
@@ -302,35 +282,106 @@ function readBody(req) {
 		req.on("data", onData).once("end", onEnd).once("error", onError);
 	});
 }
-
-//#endregion
-//#region src/adapters/_node/web/incoming.ts
-var WebIncomingMessage = class extends IncomingMessage {
-	constructor(req, socket) {
-		super(socket);
-		this.method = req.method;
-		const url = req._url ??= new FastURL(req.url);
-		this.url = url.pathname + url.search;
-		for (const [key, value] of req.headers.entries()) this.headers[key.toLowerCase()] = value;
-		if (req.method !== "GET" && req.method !== "HEAD" && !this.headers["content-length"] && !this.headers["transfer-encoding"]) this.headers["transfer-encoding"] = "chunked";
-		const onData = (chunk) => {
-			this.push(chunk);
-		};
-		socket.on("data", onData);
-		socket.once("end", () => {
-			this.emit("end");
-			this.off("data", onData);
-		});
+const NodeResponse = /* @__PURE__ */ (() => {
+	const NativeResponse = globalThis.Response;
+	const STATUS_CODES = globalThis.process?.getBuiltinModule?.("node:http")?.STATUS_CODES || {};
+	class NodeResponse {
+		#body;
+		#init;
+		#headers;
+		#response;
+		constructor(body, init) {
+			this.#body = body;
+			this.#init = init;
+		}
+		static [Symbol.hasInstance](val) {
+			return val instanceof NativeResponse;
+		}
+		get status() {
+			return this.#response?.status || this.#init?.status || 200;
+		}
+		get statusText() {
+			return this.#response?.statusText || this.#init?.statusText || STATUS_CODES[this.status] || "";
+		}
+		get headers() {
+			if (this.#response) return this.#response.headers;
+			if (this.#headers) return this.#headers;
+			const initHeaders = this.#init?.headers;
+			return this.#headers = initHeaders instanceof Headers ? initHeaders : new Headers(initHeaders);
+		}
+		get ok() {
+			if (this.#response) return this.#response.ok;
+			const status = this.status;
+			return status >= 200 && status < 300;
+		}
+		get _response() {
+			if (this.#response) return this.#response;
+			this.#response = new NativeResponse(this.#body, this.#headers ? {
+				...this.#init,
+				headers: this.#headers
+			} : this.#init);
+			this.#init = void 0;
+			this.#headers = void 0;
+			this.#body = void 0;
+			return this.#response;
+		}
+		_toNodeResponse() {
+			const status = this.status;
+			const statusText = this.statusText;
+			let body;
+			let contentType;
+			let contentLength;
+			if (this.#response) body = this.#response.body;
+			else if (this.#body) if (this.#body instanceof ReadableStream) body = this.#body;
+			else if (typeof this.#body === "string") {
+				body = this.#body;
+				contentType = "text/plain; charset=UTF-8";
+				contentLength = Buffer.byteLength(this.#body);
+			} else if (this.#body instanceof ArrayBuffer) {
+				body = Buffer.from(this.#body);
+				contentLength = this.#body.byteLength;
+			} else if (this.#body instanceof Uint8Array) {
+				body = this.#body;
+				contentLength = this.#body.byteLength;
+			} else if (this.#body instanceof DataView) {
+				body = Buffer.from(this.#body.buffer);
+				contentLength = this.#body.byteLength;
+			} else if (this.#body instanceof Blob) {
+				body = this.#body.stream();
+				contentType = this.#body.type;
+				contentLength = this.#body.size;
+			} else if (typeof this.#body.pipe === "function") body = this.#body;
+			else body = this._response.body;
+			const headers = [];
+			const initHeaders = this.#init?.headers;
+			const headerEntries = this.#response?.headers || this.#headers || (initHeaders ? Array.isArray(initHeaders) ? initHeaders : initHeaders?.entries ? initHeaders.entries() : Object.entries(initHeaders).map(([k, v]) => [k.toLowerCase(), v]) : void 0);
+			let hasContentTypeHeader;
+			let hasContentLength;
+			if (headerEntries) for (const [key, value] of headerEntries) {
+				if (Array.isArray(value)) for (const v of value) headers.push([key, v]);
+				else headers.push([key, value]);
+				if (key === "content-type") hasContentTypeHeader = true;
+				else if (key === "content-length") hasContentLength = true;
+			}
+			if (contentType && !hasContentTypeHeader) headers.push(["content-type", contentType]);
+			if (contentLength && !hasContentLength) headers.push(["content-length", String(contentLength)]);
+			this.#init = void 0;
+			this.#headers = void 0;
+			this.#response = void 0;
+			this.#body = void 0;
+			return {
+				status,
+				statusText,
+				headers,
+				body
+			};
+		}
 	}
-};
-
-//#endregion
-//#region src/adapters/_node/web/socket.ts
-/**
-* Events:
-* - Readable (req from client): readable => data => end (push(null)) => error => close
-* - Writable (res to client): pipe => unpipe => drain => finish (end called) => error => close
-*/
+	lazyInherit(NodeResponse.prototype, NativeResponse.prototype, "_response");
+	Object.setPrototypeOf(NodeResponse, NativeResponse);
+	Object.setPrototypeOf(NodeResponse.prototype, NativeResponse.prototype);
+	return NodeResponse;
+})();
 var WebRequestSocket = class extends Duplex {
 	_httpMessage;
 	autoSelectFamilyAttemptedAddresses = [];
@@ -446,9 +497,67 @@ var WebRequestSocket = class extends Duplex {
 		cb(err ?? void 0);
 	}
 };
-
-//#endregion
-//#region src/adapters/_node/web/response.ts
+var WebIncomingMessage = class extends IncomingMessage {
+	constructor(req, socket) {
+		super(socket);
+		this.method = req.method;
+		const url = req._url ??= new FastURL(req.url);
+		this.url = url.pathname + url.search;
+		for (const [key, value] of req.headers.entries()) this.headers[key.toLowerCase()] = value;
+		if (req.method !== "GET" && req.method !== "HEAD" && !this.headers["content-length"] && !this.headers["transfer-encoding"]) this.headers["transfer-encoding"] = "chunked";
+		const onData = (chunk) => {
+			this.push(chunk);
+		};
+		socket.on("data", onData);
+		socket.once("end", () => {
+			this.emit("end");
+			this.off("data", onData);
+		});
+	}
+};
+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) {
+				const headerEntries = [];
+				const rawHeaders = nodeRes.getHeaders();
+				for (const [name, value] of Object.entries(rawHeaders)) if (Array.isArray(value)) for (const v of value) headerEntries.push([name, v]);
+				else if (value) headerEntries.push([name, String(value)]);
+				_headers = new Headers(headerEntries);
+			}
+			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) => {
+				stream.once("end", () => resolve(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);
+		}
+	});
+}
 var WebServerResponse = class extends ServerResponse {
 	#socket;
 	constructor(req, socket) {
@@ -487,20 +596,6 @@ var WebServerResponse = class extends ServerResponse {
 		});
 	}
 };
-
-//#endregion
-//#region src/adapters/_node/web/fetch.ts
-/**
-* Calls a Node.js HTTP Request handler with a Fetch API Request object and returns a Response object.
-*
-* If the web Request contains an existing Node.js req/res pair (indicating it originated from a Node.js server from srvx/node), it will be called directly.
-*
-* Otherwise, new Node.js IncomingMessage and ServerResponse objects are created and linked to a custom Duplex stream that bridges the Fetch API streams with Node.js streams.
-*
-* The handler is invoked with these objects, and the response is constructed from the ServerResponse once it is finished.
-*
-* @experimental Behavior might be unstable.
-*/
 async function fetchNodeHandler(handler, req) {
 	const nodeRuntime = req.runtime?.node;
 	if (nodeRuntime && nodeRuntime.req && nodeRuntime.res) return await callNodeHandler(handler, req);
@@ -521,12 +616,6 @@ async function fetchNodeHandler(handler, req) {
 		});
 	}
 }
-
-//#endregion
-//#region src/adapters/_node/adapter.ts
-/**
-* Converts a Fetch API handler to a Node.js HTTP handler.
-*/
 function toNodeHandler(handler) {
 	if (handler.__nodeHandler) return handler.__nodeHandler;
 	function convertedNodeHandler(nodeReq, nodeRes) {
@@ -540,11 +629,6 @@ function toNodeHandler(handler) {
 	assignFnName(convertedNodeHandler, handler, " (converted to Node handler)");
 	return convertedNodeHandler;
 }
-/**
-* Converts a Node.js HTTP handler into a Fetch API handler.
-*
-* @experimental Behavior might be unstable and won't work in Bun and Deno currently (tracker: https://github.com/h3js/srvx/issues/132)
-*/
 function toFetchHandler(handler) {
 	if (handler.__fetchHandler) return handler.__fetchHandler;
 	function convertedNodeHandler(req) {
@@ -559,9 +643,6 @@ function assignFnName(target, source, suffix) {
 		Object.defineProperty(target, "name", { value: `${source.name}${suffix}` });
 	} catch {}
 }
-
-//#endregion
-//#region src/adapters/node.ts
 function serve(options) {
 	return new NodeServer(options);
 }
@@ -641,12 +722,10 @@ var NodeServer = class {
 	async close(closeAll) {
 		await Promise.all([this.#wait.wait(), new Promise((resolve, reject) => {
 			const server = this.node?.server;
-			if (!server) return resolve();
+			if (!server || !server.listening) return resolve();
 			if (closeAll && "closeAllConnections" in server) server.closeAllConnections();
 			server.close((error) => error ? reject(error) : resolve());
 		})]);
 	}
 };
-
-//#endregion
-export { NodeResponse as FastResponse, NodeResponse, FastURL, NodeRequest, fetchNodeHandler, patchGlobalRequest, sendNodeResponse, serve, toFetchHandler, toNodeHandler };
+export { NodeResponse as FastResponse, NodeResponse, FastURL, NodeRequest, fetchNodeHandler, patchGlobalRequest, sendNodeResponse, serve, toFetchHandler, toNodeHandler };

package/dist/adapters/service-worker.d.mts

@@ -1,4 +1,4 @@
-import { g as Server, x as ServerRequest, y as ServerOptions } from "../_chunks/types.mjs";
+import { Server, ServerOptions, ServerRequest } from "../types.mjs";
 
 //#region src/adapters/service-worker.d.ts
 declare const FastURL: typeof globalThis.URL;

package/dist/adapters/service-worker.mjs

@@ -1,10 +1,8 @@
 import { r as wrapFetch, t as errorPlugin } from "../_chunks/_plugins.mjs";
-
-//#region src/adapters/service-worker.ts
 const FastURL = URL;
 const FastResponse = Response;
 const isBrowserWindow = typeof window !== "undefined" && typeof navigator !== "undefined";
-const isServiceWorker = /* @__PURE__ */ (() => typeof self !== "undefined" && "skipWaiting" in self)();
+const isServiceWorker = typeof self !== "undefined" && "skipWaiting" in self;
 function serve(options) {
 	return new ServiceWorkerServer(options);
 }
@@ -75,6 +73,4 @@ var ServiceWorkerServer = class {
 		} else if (isServiceWorker) await self.registration.unregister();
 	}
 };
-
-//#endregion
-export { FastResponse, FastURL, serve };
+export { FastResponse, FastURL, serve };

package/dist/cli.d.mts

@@ -1,17 +1,52 @@
+import { t as LoadOptions } from "./_chunks/loader.mjs";
 import { Server } from "srvx";
 
-//#region src/cli.d.ts
-declare function main(mainOpts: MainOpts): Promise<void>;
+//#region src/cli/types.d.ts
 declare global {
-  var __srvx_version__: string | undefined;
-  var __srvx__: Server;
-  var __srvx_listen_cb__: () => void;
+  var __srvx__: Server | undefined;
 }
-type MainOpts = {
-  command: string;
-  docs: string;
-  issues: string;
+type MainOptions = CLIOptions & {
+  args?: string[];
+  usage?: {
+    command?: string;
+    docs?: string;
+    issues?: string;
+  };
 };
-declare function usage(mainOpts: MainOpts): string;
+/**
+* CLI options for srvx command
+*/
+type CLIOptions = {
+  /** CLI mode: "serve" to start a server, "fetch" to make HTTP requests */mode?: "serve" | "fetch"; /** Show help message */
+  help?: boolean; /** Show server and runtime versions */
+  version?: boolean; /** Working directory for resolving entry file */
+  dir?: string; /** Server entry file to use */
+  entry?: string; /** Run in production mode (no watch, no debug) */
+  prod?: boolean; /** Serve static files from the specified directory (default: "public") */
+  static?: string; /** ES module to preload */
+  import?: string; /** Host to bind to (default: all interfaces) */
+  hostname?: string; /** (alias to hostname) */
+  host?: string; /** Port to listen on (default: "3000") */
+  port?: string; /** Enable TLS (HTTPS/HTTP2) */
+  tls?: boolean; /** TLS certificate file */
+  cert?: string; /** TLS private key file */
+  key?: string; /** URL or path to fetch */
+  url?: string; /** HTTP method (default: "GET", or "POST" if body is provided) */
+  method?: string; /** Request headers (format: "Name: Value", can be used multiple times) */
+  header?: string[]; /** Show request and response headers */
+  verbose?: boolean; /** Request body (use "@-" for stdin, "@file" for file) */
+  data?: string;
+};
+//#endregion
+//#region src/cli/main.d.ts
+declare function main(mainOpts: MainOptions): Promise<void>;
+//#endregion
+//#region src/cli/fetch.d.ts
+declare function cliFetch(cliOpts: CLIOptions & LoadOptions & {
+  loader?: LoadOptions;
+  stdin?: typeof process.stdin;
+  stdout?: typeof process.stdout;
+  stderr?: typeof process.stderr;
+}): Promise<Response>;
 //#endregion
-export { main, usage };
+export { type CLIOptions, type MainOptions, cliFetch, main };