srvx 0.10.0 → 0.11.0

package/README.md

@@ -41,29 +41,15 @@ $ deno -A npm:srvx
 $ bunx --bun srvx
 ```
 
-👉 **Visit the 📖 [Documentation](https://srvx.h3.dev/) to learn more.**
-
-## Starter Examples
+You can also use `srvx fetch` to directly call your server handler without starting a server:
 
-[➤ Online Playground](https://stackblitz.com/fork/github/h3js/srvx/tree/main/examples/stackblitz?startScript=dev&file=server.mjs)
-
-<!-- automd:examples -->
+```bash
+$ npx srvx fetch /api/users
+```
 
-| 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`               |
-| `fastify`        | [examples/fastify](https://github.com/h3js/srvx/tree/main/examples/fastify/)               | `npx giget gh:h3js/srvx/examples/fastify srvx-fastify`               |
-| `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` |
-| `tracing`        | [examples/tracing](https://github.com/h3js/srvx/tree/main/examples/tracing/)               | `npx giget gh:h3js/srvx/examples/tracing srvx-tracing`               |
-| `websocket`      | [examples/websocket](https://github.com/h3js/srvx/tree/main/examples/websocket/)           | `npx giget gh:h3js/srvx/examples/websocket srvx-websocket`           |
+See [CLI documentation](https://srvx.h3.dev/guide/cli) for more options.
 
-<!-- /automd -->
+👉 **Visit the 📖 [Documentation](https://srvx.h3.dev/) to learn more.**
 
 ## Contribution
 

package/bin/srvx.mjs

@@ -2,7 +2,9 @@
 import { main } from "../dist/cli.mjs";
 
 await main({
-  command: "srvx",
-  docs: "https://srvx.h3.dev",
-  issues: "https://github.com/h3js/srvx/issues",
+  usage: {
+    command: "srvx",
+    docs: "https://srvx.h3.dev",
+    issues: "https://github.com/h3js/srvx/issues",
+  },
 });

package/dist/_chunks/_plugins.mjs

@@ -1,6 +1,4 @@
-import { i as gray, s as red } from "./_color.mjs";
-
-//#region src/_middleware.ts
+import { i as gray, o as red } from "./_utils.mjs";
 function wrapFetch(server) {
 	const fetchHandler = server.options.fetch;
 	const middleware = server.options.middleware || [];
@@ -10,9 +8,6 @@ function callMiddleware(request, fetchHandler, middleware, index) {
 	if (index === middleware.length) return fetchHandler(request);
 	return middleware[index](request, () => callMiddleware(request, fetchHandler, middleware, index + 1));
 }
-
-//#endregion
-//#region src/_plugins.ts
 const errorPlugin = (server) => {
 	const errorHandler = server.options.error;
 	if (!errorHandler) return;
@@ -31,16 +26,26 @@ const gracefulShutdownPlugin = (server) => {
 	const gracefulShutdown = config === true || !config?.gracefulTimeout ? Number.parseInt(process.env.SERVER_SHUTDOWN_TIMEOUT || "") || 3 : config.gracefulTimeout;
 	const forceShutdown = config === true || !config?.forceTimeout ? Number.parseInt(process.env.SERVER_FORCE_SHUTDOWN_TIMEOUT || "") || 5 : config.forceTimeout;
 	let isShuttingDown = false;
+	let forceClose;
 	const shutdown = async () => {
-		if (isShuttingDown) return;
+		if (isShuttingDown) {
+			forceClose?.();
+			return;
+		}
 		isShuttingDown = true;
 		const w = process.stderr.write.bind(process.stderr);
-		w(gray(`\nShutting down server in ${gracefulShutdown}s...`));
+		w(gray(`\nShutting down server in ${gracefulShutdown}s... (press Ctrl+C again to force close)`));
 		let timeout;
 		await Promise.race([server.close().finally(() => {
 			clearTimeout(timeout);
 			w(gray(" Server closed.\n"));
 		}), new Promise((resolve) => {
+			forceClose = () => {
+				clearTimeout(timeout);
+				w(gray("\nForce closing...\n"));
+				server.close(true);
+				resolve();
+			};
 			timeout = setTimeout(() => {
 				w(gray(`\nForce closing connections in ${forceShutdown}s...`));
 				timeout = setTimeout(() => {
@@ -54,6 +59,4 @@ const gracefulShutdownPlugin = (server) => {
 	};
 	for (const sig of ["SIGINT", "SIGTERM"]) globalThis.process.on(sig, shutdown);
 };
-
-//#endregion
-export { gracefulShutdownPlugin as n, wrapFetch as r, errorPlugin as t };
+export { gracefulShutdownPlugin as n, wrapFetch as r, errorPlugin as t };

package/dist/_chunks/_url.mjs

@@ -1,23 +1,33 @@
-import { t as lazyInherit } from "./_inherit.mjs";
-
-//#region src/_url.ts
-/**
-* URL wrapper with fast paths to access to the following props:
-*
-*  - `url.pathname`
-*  - `url.search`
-*  - `url.searchParams`
-*  - `url.protocol`
-*
-* **NOTES:**
-*
-* - It is assumed that the input URL is **already encoded** and formatted from an HTTP request and contains no hash.
-* - Triggering the setters or getters on other props will deoptimize to full URL parsing.
-* - Changes to `searchParams` will be discarded as we don't track them.
-*/
+function lazyInherit(target, source, sourceKey) {
+	for (const key of [...Object.getOwnPropertyNames(source), ...Object.getOwnPropertySymbols(source)]) {
+		if (key === "constructor") continue;
+		const targetDesc = Object.getOwnPropertyDescriptor(target, key);
+		const desc = Object.getOwnPropertyDescriptor(source, key);
+		let modified = false;
+		if (desc.get) {
+			modified = true;
+			desc.get = targetDesc?.get || function() {
+				return this[sourceKey][key];
+			};
+		}
+		if (desc.set) {
+			modified = true;
+			desc.set = targetDesc?.set || function(value) {
+				this[sourceKey][key] = value;
+			};
+		}
+		if (!targetDesc?.value && typeof desc.value === "function") {
+			modified = true;
+			desc.value = function(...args) {
+				return this[sourceKey][key](...args);
+			};
+		}
+		if (modified) Object.defineProperty(target, key, desc);
+	}
+}
 const FastURL = /* @__PURE__ */ (() => {
 	const NativeURL = globalThis.URL;
-	const FastURL$1 = class URL {
+	const FastURL = class URL {
 		#url;
 		#href;
 		#protocol;
@@ -108,11 +118,9 @@ const FastURL = /* @__PURE__ */ (() => {
 			return this.href;
 		}
 	};
-	lazyInherit(FastURL$1.prototype, NativeURL.prototype, "_url");
-	Object.setPrototypeOf(FastURL$1.prototype, NativeURL.prototype);
-	Object.setPrototypeOf(FastURL$1, NativeURL);
-	return FastURL$1;
+	lazyInherit(FastURL.prototype, NativeURL.prototype, "_url");
+	Object.setPrototypeOf(FastURL.prototype, NativeURL.prototype);
+	Object.setPrototypeOf(FastURL, NativeURL);
+	return FastURL;
 })();
-
-//#endregion
-export { FastURL as t };
+export { lazyInherit as n, FastURL as t };

package/dist/_chunks/_utils.mjs

@@ -1,71 +1,14 @@
-//#region src/_utils.ts
-function resolvePortAndHost(opts) {
-	const _port = opts.port ?? globalThis.process?.env.PORT ?? 3e3;
-	const port = typeof _port === "number" ? _port : Number.parseInt(_port, 10);
-	if (port < 0 || port > 65535) throw new RangeError(`Port must be between 0 and 65535 (got "${port}").`);
-	return {
-		port,
-		hostname: opts.hostname ?? globalThis.process?.env.HOST
-	};
-}
-function fmtURL(host, port, secure) {
-	if (!host || !port) return;
-	if (host.includes(":")) host = `[${host}]`;
-	return `http${secure ? "s" : ""}://${host}:${port}/`;
-}
-function printListening(opts, url) {
-	if (!url || (opts.silent ?? globalThis.process?.env?.TEST)) return;
-	const _url = new URL(url);
-	const allInterfaces = _url.hostname === "[::]" || _url.hostname === "0.0.0.0";
-	if (allInterfaces) {
-		_url.hostname = "localhost";
-		url = _url.href;
-	}
-	let listeningOn = `➜ Listening on:`;
-	let additionalInfo = allInterfaces ? " (all interfaces)" : "";
-	if (globalThis.process.stdout?.isTTY) {
-		listeningOn = `\u001B[32m${listeningOn}\u001B[0m`;
-		url = `\u001B[36m${url}\u001B[0m`;
-		additionalInfo = `\u001B[2m${additionalInfo}\u001B[0m`;
-	}
-	console.log(`${listeningOn} ${url}${additionalInfo}`);
-}
-function resolveTLSOptions(opts) {
-	if (!opts.tls || opts.protocol === "http") return;
-	const cert = resolveCertOrKey(opts.tls.cert);
-	const key = resolveCertOrKey(opts.tls.key);
-	if (!cert && !key) {
-		if (opts.protocol === "https") throw new TypeError("TLS `cert` and `key` must be provided for `https` protocol.");
-		return;
-	}
-	if (!cert || !key) throw new TypeError("TLS `cert` and `key` must be provided together.");
-	return {
-		cert,
-		key,
-		passphrase: opts.tls.passphrase
-	};
-}
-function resolveCertOrKey(value) {
-	if (!value) return;
-	if (typeof value !== "string") throw new TypeError("TLS certificate and key must be strings in PEM format or file paths.");
-	if (value.startsWith("-----BEGIN ")) return value;
-	const { readFileSync } = process.getBuiltinModule("node:fs");
-	return readFileSync(value, "utf8");
-}
-function createWaitUntil() {
-	const promises = /* @__PURE__ */ new Set();
-	return {
-		waitUntil: (promise) => {
-			if (typeof promise?.then !== "function") return;
-			promises.add(Promise.resolve(promise).catch(console.error).finally(() => {
-				promises.delete(promise);
-			}));
-		},
-		wait: () => {
-			return Promise.all(promises);
-		}
-	};
-}
-
-//#endregion
-export { resolveTLSOptions as a, resolvePortAndHost as i, fmtURL as n, printListening as r, createWaitUntil as t };
+const noColor = /* @__PURE__ */ (() => {
+	const env = globalThis.process?.env ?? {};
+	return env.NO_COLOR === "1" || env.TERM === "dumb";
+})();
+const _c = (c, r = 39) => (t) => noColor ? t : `\u001B[${c}m${t}\u001B[${r}m`;
+const bold = /* @__PURE__ */ _c(1, 22);
+const red = /* @__PURE__ */ _c(31);
+const green = /* @__PURE__ */ _c(32);
+const yellow = /* @__PURE__ */ _c(33);
+const blue = /* @__PURE__ */ _c(34);
+const cyan = /* @__PURE__ */ _c(36);
+const gray = /* @__PURE__ */ _c(90);
+const url = (title, url) => noColor ? `[${title}](${url})` : `\u001B]8;;${url}\u001B\\${title}\u001B]8;;\u001B\\`;
+export { green as a, yellow as c, gray as i, bold as n, red as o, cyan as r, url as s, blue as t };

package/dist/_chunks/_utils2.mjs

@@ -0,0 +1,70 @@
+function resolvePortAndHost(opts) {
+	const _port = opts.port ?? globalThis.process?.env.PORT ?? 3e3;
+	const port = typeof _port === "number" ? _port : Number.parseInt(_port, 10);
+	if (port < 0 || port > 65535) throw new RangeError(`Port must be between 0 and 65535 (got "${port}").`);
+	return {
+		port,
+		hostname: opts.hostname ?? globalThis.process?.env.HOST
+	};
+}
+function fmtURL(host, port, secure) {
+	if (!host || !port) return;
+	if (host.includes(":")) host = `[${host}]`;
+	return `http${secure ? "s" : ""}://${host}:${port}/`;
+}
+function printListening(opts, url) {
+	if (!url || (opts.silent ?? globalThis.process?.env?.TEST)) return;
+	let additionalInfo = "";
+	try {
+		const _url = new URL(url);
+		if (_url.hostname === "[::]" || _url.hostname === "0.0.0.0") {
+			_url.hostname = "localhost";
+			url = _url.href;
+			additionalInfo = " (all interfaces)";
+		}
+	} catch {}
+	let listeningOn = `➜ Listening on:`;
+	if (globalThis.process.stdout?.isTTY) {
+		listeningOn = `\u001B[32m${listeningOn}\u001B[0m`;
+		url = `\u001B[36m${url}\u001B[0m`;
+		additionalInfo = `\u001B[2m${additionalInfo}\u001B[0m`;
+	}
+	console.log(`${listeningOn} ${url}${additionalInfo}`);
+}
+function resolveTLSOptions(opts) {
+	if (!opts.tls || opts.protocol === "http") return;
+	const cert = resolveCertOrKey(opts.tls.cert);
+	const key = resolveCertOrKey(opts.tls.key);
+	if (!cert && !key) {
+		if (opts.protocol === "https") throw new TypeError("TLS `cert` and `key` must be provided for `https` protocol.");
+		return;
+	}
+	if (!cert || !key) throw new TypeError("TLS `cert` and `key` must be provided together.");
+	return {
+		cert,
+		key,
+		passphrase: opts.tls.passphrase
+	};
+}
+function resolveCertOrKey(value) {
+	if (!value) return;
+	if (typeof value !== "string") throw new TypeError("TLS certificate and key must be strings in PEM format or file paths.");
+	if (value.startsWith("-----BEGIN ")) return value;
+	const { readFileSync } = process.getBuiltinModule("node:fs");
+	return readFileSync(value, "utf8");
+}
+function createWaitUntil() {
+	const promises = /* @__PURE__ */ new Set();
+	return {
+		waitUntil: (promise) => {
+			if (typeof promise?.then !== "function") return;
+			promises.add(Promise.resolve(promise).catch(console.error).finally(() => {
+				promises.delete(promise);
+			}));
+		},
+		wait: () => {
+			return Promise.all(promises);
+		}
+	};
+}
+export { resolveTLSOptions as a, resolvePortAndHost as i, fmtURL as n, printListening as r, createWaitUntil as t };

package/dist/_chunks/loader.d.mts

@@ -0,0 +1,74 @@
+import { ServerHandler } from "srvx";
+
+//#region src/loader.d.ts
+declare const defaultExts: string[];
+declare const defaultEntries: string[];
+/**
+* Options for loading a server entry module.
+*/
+type LoadOptions = {
+  /**
+  * Path or URL to the server entry file.
+  *
+  * If not provided, common entry points will be searched automatically.
+  */
+  entry?: string;
+  /**
+  * Base directory for resolving relative paths.
+  *
+  * @default "."
+  */
+  dir?: string;
+  /**
+  * Set to `false` to disable interception of `http.Server.listen` to detect legacy handlers.
+  *
+  * @default true
+  */
+  interceptHttpListen?: boolean;
+  /**
+  * Set to `false` to disable Node.js handler (req, res) compatibility.
+  */
+  nodeCompat?: boolean;
+  /**
+  * Hook called after the module is loaded to allow for custom processing.
+  *
+  * You can return a modified version of the module if needed.
+  */
+  onLoad?: (module: unknown) => any;
+};
+/**
+* Result of loading a server entry module.
+*/
+type LoadedServerEntry = {
+  /**
+  * The web fetch handler extracted from the loaded module.
+  *
+  * This is resolved from `module.fetch`, `module.default.fetch`,
+  * or upgraded from a legacy Node.js handler.
+  */
+  fetch?: ServerHandler;
+  /**
+  * The raw loaded module.
+  */
+  module?: any;
+  /**
+  * Whether the handler was upgraded from a legacy Node.js HTTP handler.
+  *
+  * When `true`, the original module exported a Node.js-style `(req, res)` handler
+  * that has been wrapped for web fetch compatibility.
+  */
+  nodeCompat?: boolean;
+  /**
+  * The resolved `file://` URL of the loaded entry module.
+  */
+  url?: string;
+  /**
+  * Whether the specified entry file was not found.
+  *
+  * When `true`, no valid entry point could be located.
+  */
+  notFound?: boolean;
+};
+declare function loadServerEntry(opts: LoadOptions): Promise<LoadedServerEntry>;
+//#endregion
+export { loadServerEntry as a, defaultExts as i, LoadedServerEntry as n, defaultEntries as r, LoadOptions as t };

package/dist/_chunks/loader.mjs

@@ -0,0 +1,108 @@
+import { pathToFileURL } from "node:url";
+import { existsSync } from "node:fs";
+import { resolve } from "node:path";
+import * as nodeHTTP$1 from "node:http";
+const defaultExts = [
+	".mjs",
+	".js",
+	".mts",
+	".ts"
+];
+const defaultEntries = [
+	"server",
+	"server/index",
+	"src/server",
+	"server/server"
+];
+async function loadServerEntry(opts) {
+	let entry = opts.entry;
+	if (entry) {
+		entry = resolve(opts.dir || ".", entry);
+		if (!existsSync(entry)) return { notFound: true };
+	} else {
+		for (const defEntry of defaultEntries) {
+			for (const defExt of defaultExts) {
+				const entryPath = resolve(opts.dir || ".", `${defEntry}${defExt}`);
+				if (existsSync(entryPath)) {
+					entry = entryPath;
+					break;
+				}
+			}
+			if (entry) break;
+		}
+		if (!entry) return { notFound: true };
+	}
+	const url = entry.startsWith("file://") ? entry : pathToFileURL(resolve(entry)).href;
+	let mod;
+	let listenHandler;
+	try {
+		if (opts.interceptHttpListen !== false) {
+			const loaded = await interceptListen(() => import(url));
+			mod = loaded.res;
+			listenHandler = loaded.listenHandler;
+		} else mod = await import(url);
+	} catch (error) {
+		if (error?.code === "ERR_UNKNOWN_FILE_EXTENSION") {
+			const message = String(error);
+			if (/"\.(m|c)?ts"/g.test(message)) throw new Error(`Make sure you're using Node.js v22.18+ or v24+ for TypeScript support (current version: ${process.versions.node})`, { cause: error });
+			else if (/"\.(m|c)?tsx"/g.test(message)) throw new Error(`You need a compatible loader for JSX support (Deno, Bun or srvx --register jiti/register)`, { cause: error });
+		}
+		throw error;
+	}
+	mod = await opts?.onLoad?.(mod) || mod;
+	let fetchHandler = mod?.fetch || mod?.default?.fetch || mod?.default?.default?.fetch;
+	if (!fetchHandler && typeof mod?.default === "function" && mod.default.length < 2) fetchHandler = mod.default;
+	let nodeCompat = false;
+	if (!fetchHandler && opts.nodeCompat !== false) {
+		const nodeHandler = listenHandler || (typeof mod?.default === "function" ? mod.default : void 0);
+		if (nodeHandler) {
+			nodeCompat = true;
+			const { fetchNodeHandler } = await import("srvx/node");
+			fetchHandler = (webReq) => fetchNodeHandler(nodeHandler, webReq);
+		}
+	}
+	return {
+		module: mod,
+		nodeCompat,
+		url,
+		fetch: fetchHandler
+	};
+}
+let _interceptQueue = Promise.resolve();
+async function interceptListen(cb) {
+	const result = _interceptQueue.then(async () => {
+		const originalListen = nodeHTTP$1.Server.prototype.listen;
+		let res;
+		let listenHandler;
+		try {
+			nodeHTTP$1.Server.prototype.listen = function(arg1, arg2) {
+				listenHandler = this._events.request;
+				if (Array.isArray(listenHandler)) listenHandler = listenHandler[0];
+				nodeHTTP$1.Server.prototype.listen = originalListen;
+				const listenCallback = [arg1, arg2].find((arg) => typeof arg === "function");
+				setImmediate(() => {
+					listenCallback?.();
+				});
+				return new Proxy({}, { get(_, prop) {
+					const server = globalThis.__srvx__;
+					if (!server && prop === "address") return () => ({
+						address: "",
+						family: "",
+						port: 0
+					});
+					return server?.node?.server?.[prop];
+				} });
+			};
+			res = await cb();
+		} finally {
+			nodeHTTP$1.Server.prototype.listen = originalListen;
+		}
+		return {
+			res,
+			listenHandler
+		};
+	});
+	_interceptQueue = result.catch(() => {});
+	return result;
+}
+export { defaultExts as n, loadServerEntry as r, defaultEntries as t };

package/dist/adapters/aws-lambda.d.mts

@@ -0,0 +1,19 @@
+import { FetchHandler, ServerOptions } from "../types.mjs";
+import * as AWS from "aws-lambda";
+
+//#region src/adapters/_aws/utils.d.ts
+type AWSLambdaResponseStream = NodeJS.WritableStream & {
+  setContentType(contentType: string): void;
+};
+//#endregion
+//#region src/adapters/aws-lambda.d.ts
+type MaybePromise<T> = T | Promise<T>;
+type AwsLambdaEvent = AWS.APIGatewayProxyEvent | AWS.APIGatewayProxyEventV2;
+type AWSLambdaHandler = (event: AwsLambdaEvent, context: AWS.Context) => MaybePromise<AWS.APIGatewayProxyResult | AWS.APIGatewayProxyResultV2>;
+type AWSLambdaStreamingHandler = (event: AwsLambdaEvent, responseStream: AWSLambdaResponseStream, context: AWS.Context) => MaybePromise<void>;
+declare function toLambdaHandler(options: ServerOptions): AWSLambdaHandler;
+declare function handleLambdaEvent(fetchHandler: FetchHandler, event: AwsLambdaEvent, context: AWS.Context): Promise<AWS.APIGatewayProxyResult | AWS.APIGatewayProxyResultV2>;
+declare function handleLambdaEventWithStream(fetchHandler: FetchHandler, event: AwsLambdaEvent, responseStream: AWSLambdaResponseStream, context: AWS.Context): Promise<void>;
+declare function invokeLambdaHandler(handler: AWSLambdaHandler, request: Request): Promise<Response>;
+//#endregion
+export { AWSLambdaHandler, type AWSLambdaResponseStream, AWSLambdaStreamingHandler, AwsLambdaEvent, handleLambdaEvent, handleLambdaEventWithStream, invokeLambdaHandler, toLambdaHandler };