srvx 0.6.0 → 0.7.1

package/dist/bun.d.mts

@@ -0,0 +1,22 @@
+import { BunFetchHandler, Server, ServerOptions } from "./chunks/types-egi3HKdd.mjs";
+import { FastURL$2 as FastURL } from "./chunks/_url-BwTFuoNW.mjs";
+import * as bun from "bun";
+
+//#region src/adapters/bun.d.ts
+declare const FastResponse: typeof globalThis.Response;
+declare function serve(options: ServerOptions): BunServer;
+declare class BunServer implements Server<BunFetchHandler> {
+  readonly runtime = "bun";
+  readonly options: Server["options"];
+  readonly bun: Server["bun"];
+  readonly serveOptions: bun.ServeOptions | bun.TLSServeOptions;
+  readonly fetch: BunFetchHandler;
+  constructor(options: ServerOptions);
+  serve(): Promise<this>;
+  get url(): string | undefined;
+  ready(): Promise<this>;
+  close(closeAll?: boolean): Promise<void>;
+}
+
+//#endregion
+export { FastResponse, FastURL, serve };

package/dist/bun.mjs

@@ -0,0 +1,77 @@
+import { FastURL$1 as FastURL, fmtURL, printListening, resolvePortAndHost, resolveTLSOptions } from "./chunks/_url-CirWh9Lc.mjs";
+import { wrapFetch } from "./chunks/_middleware-DSFIayTI.mjs";
+
+//#region src/adapters/bun.ts
+const FastResponse = Response;
+function serve(options) {
+	return new BunServer(options);
+}
+var BunServer = class {
+	runtime = "bun";
+	options;
+	bun = {};
+	serveOptions;
+	fetch;
+	constructor(options) {
+		this.options = {
+			...options,
+			middleware: [...options.middleware || []]
+		};
+		for (const plugin of options.plugins || []) plugin(this);
+		const fetchHandler = wrapFetch(this);
+		this.fetch = (request, server) => {
+			Object.defineProperties(request, {
+				runtime: {
+					enumerable: true,
+					value: {
+						runtime: "bun",
+						bun: { server }
+					}
+				},
+				ip: {
+					enumerable: true,
+					get() {
+						return server?.requestIP(request)?.address;
+					}
+				}
+			});
+			return fetchHandler(request);
+		};
+		const tls = resolveTLSOptions(this.options);
+		this.serveOptions = {
+			...resolvePortAndHost(this.options),
+			reusePort: this.options.reusePort,
+			error: this.options.error,
+			...this.options.bun,
+			tls: {
+				cert: tls?.cert,
+				key: tls?.key,
+				passphrase: tls?.passphrase,
+				...this.options.bun?.tls
+			},
+			fetch: this.fetch
+		};
+		if (!options.manual) this.serve();
+	}
+	serve() {
+		if (!this.bun.server) this.bun.server = Bun.serve(this.serveOptions);
+		printListening(this.options, this.url);
+		return Promise.resolve(this);
+	}
+	get url() {
+		const server = this.bun?.server;
+		if (!server) return;
+		const address = server.address;
+		if (address) return fmtURL(address.address, address.port, server.protocol === "https");
+		return server.url.href;
+	}
+	ready() {
+		return Promise.resolve(this);
+	}
+	close(closeAll) {
+		return Promise.resolve(this.bun?.server?.stop(closeAll));
+	}
+};
+
+//#endregion
+export { FastResponse, FastURL, serve };

package/dist/chunks/_middleware-DSFIayTI.mjs

@@ -0,0 +1,13 @@
+//#region src/_middleware.ts
+function wrapFetch(server) {
+	const fetchHandler = server.options.fetch;
+	const middleware = server.options.middleware || [];
+	return middleware.length === 0 ? fetchHandler : (request) => callMiddleware(request, fetchHandler, middleware, 0);
+}
+function callMiddleware(request, fetchHandler, middleware, index) {
+	if (index === middleware.length) return fetchHandler(request);
+	return middleware[index](request, () => callMiddleware(request, fetchHandler, middleware, index + 1));
+}
+
+//#endregion
+export { wrapFetch };

package/dist/chunks/_plugins-BTotWVHV.mjs

@@ -0,0 +1,16 @@
+//#region src/_plugins.ts
+const errorPlugin = (server) => {
+	const errorHandler = server.options.error;
+	if (!errorHandler) return;
+	server.options.middleware.unshift((_req, next) => {
+		try {
+			const res = next();
+			return res instanceof Promise ? res.catch((error) => errorHandler(error)) : res;
+		} catch (error) {
+			return errorHandler(error);
+		}
+	});
+};
+
+//#endregion
+export { errorPlugin };

package/dist/chunks/_url-BwTFuoNW.d.mts

@@ -0,0 +1,13 @@
+//#region src/_url.d.ts
+/**
+* Wrapper for URL with fast path access to `.pathname` and `.search` props.
+*
+* **NOTE:** It is assumed that the input URL is already ecoded and formatted from an HTTP request and contains no hash.
+*
+* **NOTE:** Triggering the setters or getters on other props will deoptimize to full URL parsing.
+*/
+declare const FastURL: {
+  new (url: string): URL;
+};
+//#endregion
+export { FastURL as FastURL$2 };

package/dist/chunks/_url-CirWh9Lc.mjs

@@ -0,0 +1,151 @@
+//#region src/_utils.node.ts
+function resolvePortAndHost(opts) {
+	const _port = opts.port ?? globalThis.process?.env.PORT ?? 3e3;
+	const port = typeof _port === "number" ? _port : Number.parseInt(_port, 10);
+	const hostname = opts.hostname ?? globalThis.process?.env.HOST;
+	return {
+		port,
+		hostname
+	};
+}
+function fmtURL(host, port, secure) {
+	if (!host || !port) return void 0;
+	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");
+}
+
+//#endregion
+//#region src/_url.ts
+/**
+* Wrapper for URL with fast path access to `.pathname` and `.search` props.
+*
+* **NOTE:** It is assumed that the input URL is already ecoded and formatted from an HTTP request and contains no hash.
+*
+* **NOTE:** Triggering the setters or getters on other props will deoptimize to full URL parsing.
+*/
+const FastURL = /* @__PURE__ */ (() => {
+	const FastURL$1 = class URL$1 {
+		#originalURL;
+		#parsedURL;
+		_pathname;
+		_urlqindex;
+		_query;
+		_search;
+		constructor(url) {
+			this.#originalURL = url;
+		}
+		get _url() {
+			if (!this.#parsedURL) this.#parsedURL = new globalThis.URL(this.#originalURL);
+			return this.#parsedURL;
+		}
+		toString() {
+			return this._url.toString();
+		}
+		toJSON() {
+			return this.toString();
+		}
+		get pathname() {
+			if (this.#parsedURL) return this.#parsedURL.pathname;
+			if (this._pathname === void 0) {
+				const url = this.#originalURL;
+				const protoIndex = url.indexOf("://");
+				if (protoIndex === -1) return this._url.pathname;
+				const pIndex = url.indexOf(
+					"/",
+					protoIndex + 4
+					/* :// */
+);
+				if (pIndex === -1) return this._url.pathname;
+				const qIndex = this._urlqindex = url.indexOf("?", pIndex);
+				this._pathname = url.slice(pIndex, qIndex === -1 ? void 0 : qIndex);
+			}
+			return this._pathname;
+		}
+		set pathname(value) {
+			this._pathname = void 0;
+			this._url.pathname = value;
+		}
+		get searchParams() {
+			if (this.#parsedURL) return this.#parsedURL.searchParams;
+			if (!this._query) this._query = new URLSearchParams(this.search);
+			return this._query;
+		}
+		get search() {
+			if (this.#parsedURL) return this.#parsedURL.search;
+			if (this._search === void 0) {
+				const qIndex = this._urlqindex;
+				if (qIndex === -1 || qIndex === this.#originalURL.length - 1) this._search = "";
+				else this._search = qIndex === void 0 ? this._url.search : this.#originalURL.slice(qIndex);
+			}
+			return this._search;
+		}
+		set search(value) {
+			this._search = void 0;
+			this._query = void 0;
+			this._url.search = value;
+		}
+	};
+	const slowProps = [
+		"hash",
+		"host",
+		"hostname",
+		"href",
+		"origin",
+		"password",
+		"port",
+		"protocol",
+		"username"
+	];
+	for (const prop of slowProps) Object.defineProperty(FastURL$1.prototype, prop, {
+		get() {
+			return this._url[prop];
+		},
+		set(value) {
+			this._url[prop] = value;
+		}
+	});
+	Object.setPrototypeOf(FastURL$1, globalThis.URL);
+	return FastURL$1;
+})();
+
+//#endregion
+export { FastURL as FastURL$1, fmtURL, printListening, resolvePortAndHost, resolveTLSOptions };

package/dist/chunks/types-egi3HKdd.d.mts

@@ -0,0 +1,237 @@
+import * as NodeHttp$1 from "node:http";
+import * as NodeHttps from "node:https";
+import * as NodeHttp2 from "node:http2";
+import * as NodeNet from "node:net";
+import * as Bun from "bun";
+import * as CF from "@cloudflare/workers-types";
+
+//#region src/types.d.ts
+type MaybePromise<T> = T | Promise<T>;
+/**
+* Faster URL constructor with lazy access to pathname and search params (For Node, Deno, and Bun).
+*/
+declare const FastURL: typeof globalThis.URL;
+/**
+* Faster Response constructor optimized for Node.js (same as Response for other runtimes).
+*/
+declare const FastResponse: typeof globalThis.Response;
+/**
+* Create a new server instance.
+*/
+declare function serve(options: ServerOptions): Server;
+/**
+* Web fetch compatible request handler
+*/
+type ServerHandler = (request: ServerRequest) => MaybePromise<Response>;
+type ServerMiddleware = (request: ServerRequest, next: () => Response | Promise<Response>) => Response | Promise<Response>;
+type ServerPlugin = (server: Server) => void;
+/**
+* Server options
+*/
+interface ServerOptions {
+  /**
+  * The fetch handler handles incoming requests.
+  */
+  fetch: ServerHandler;
+  /**
+  * Handle lifecycle errors.
+  *
+  * @note This handler will set built-in Bun and Deno error handler.
+  */
+  error?: ErrorHandler;
+  /**
+  * Server middleware handlers to run before the main fetch handler.
+  */
+  middleware?: ServerMiddleware[];
+  /**
+  * Server plugins.
+  */
+  plugins?: ServerPlugin[];
+  /**
+  * If set to `true`, server will not start listening automatically.
+  */
+  manual?: boolean;
+  /**
+  * The port server should be listening to.
+  *
+  * Default is read from `PORT` environment variable or will be `3000`.
+  *
+  * **Tip:** You can set the port to `0` to use a random port.
+  */
+  port?: string | number;
+  /**
+  * The hostname (IP or resolvable host) server listener should bound to.
+  *
+  * When not provided, server with listen to all network interfaces by default.
+  *
+  * **Important:** If you are running a server that is not expected to be exposed to the network, use `hostname: "localhost"`.
+  */
+  hostname?: string;
+  /**
+  * Enabling this option allows multiple processes to bind to the same port, which is useful for load balancing.
+  *
+  * **Note:** Despite Node.js built-in behavior that has `exclusive` flag (opposite of `reusePort`) enabled by default, srvx uses non-exclusive mode for consistency.
+  */
+  reusePort?: boolean;
+  /**
+  * The protocol to use for the server.
+  *
+  * Possible values are `http` and `https`.
+  *
+  * If `protocol` is not set, Server will use `http` as the default protocol or `https` if both `tls.cert` and `tls.key` options are provided.
+  */
+  protocol?: "http" | "https";
+  /**
+  * If set to `true`, server will not print the listening address.
+  */
+  silent?: boolean;
+  /**
+  * TLS server options.
+  */
+  tls?: {
+    /**
+    * File path or inlined TLS certificate in PEM format (required).
+    */
+    cert?: string;
+    /**
+    * File path or inlined TLS private key in PEM format (required).
+    */
+    key?: string;
+    /**
+    * Passphrase for the private key (optional).
+    */
+    passphrase?: string;
+  };
+  /**
+  * Node.js server options.
+  */
+  node?: (NodeHttp$1.ServerOptions | NodeHttps.ServerOptions | NodeHttp2.ServerOptions) & NodeNet.ListenOptions & {
+    http2?: boolean;
+  };
+  /**
+  * Bun server options
+  *
+  * @docs https://bun.sh/docs/api/http
+  */
+  bun?: Omit<Bun.ServeOptions | Bun.TLSServeOptions, "fetch">;
+  /**
+  * Deno server options
+  *
+  * @docs https://docs.deno.com/api/deno/~/Deno.serve
+  */
+  deno?: Deno.ServeOptions;
+  /**
+  * Service worker options
+  */
+  serviceWorker?: {
+    /**
+    * The path to the service worker file to be registered.
+    */
+    url?: string;
+    /**
+    * The scope of the service worker.
+    *
+    */
+    scope?: string;
+  };
+}
+interface Server<Handler = ServerHandler> {
+  /**
+  * Current runtime name
+  */
+  readonly runtime: "node" | "deno" | "bun" | "cloudflare" | "service-worker" | "generic";
+  /**
+  * Server options
+  */
+  readonly options: ServerOptions & {
+    middleware: ServerMiddleware[];
+  };
+  /**
+  * Server URL address.
+  */
+  readonly url?: string;
+  /**
+  * Node.js context.
+  */
+  readonly node?: {
+    server?: NodeHttp$1.Server | NodeHttp2.Http2Server;
+    handler: (req: NodeServerRequest, res: NodeServerResponse) => void | Promise<void>;
+  };
+  /**
+  * Bun context.
+  */
+  readonly bun?: {
+    server?: Bun.Server;
+  };
+  /**
+  * Deno context.
+  */
+  readonly deno?: {
+    server?: Deno.HttpServer;
+  };
+  /**
+  * Server fetch handler
+  */
+  readonly fetch: Handler;
+  /**
+  * Returns a promise that resolves when the server is ready.
+  */
+  ready(): Promise<Server<Handler>>;
+  /**
+  * Stop listening to prevent new connections from being accepted.
+  *
+  * By default, it does not cancel in-flight requests or websockets. That means it may take some time before all network activity stops.
+  *
+  * @param closeActiveConnections Immediately terminate in-flight requests, websockets, and stop accepting new connections.
+  * @default false
+  */
+  close(closeActiveConnections?: boolean): Promise<void>;
+}
+interface ServerRuntimeContext {
+  name: "node" | "deno" | "bun" | "cloudflare" | (string & {});
+  /**
+  * Underlying Node.js server request info.
+  */
+  node?: {
+    req: NodeServerRequest;
+    res?: NodeServerResponse;
+  };
+  /**
+  * Underlying Deno server request info.
+  */
+  deno?: {
+    info: Deno.ServeHandlerInfo<Deno.NetAddr>;
+  };
+  /**
+  * Underlying Bun server request context.
+  */
+  bun?: {
+    server: Bun.Server;
+  };
+  /**
+  * Underlying Cloudflare request context.
+  */
+  cloudflare?: {
+    env: unknown;
+    context: CF.ExecutionContext;
+  };
+}
+interface ServerRequest extends Request {
+  /**
+  * Runtime specific request context.
+  */
+  runtime?: ServerRuntimeContext;
+  /**
+  * IP address of the client.
+  */
+  ip?: string | undefined;
+}
+type FetchHandler = (request: Request) => Response | Promise<Response>;
+type ErrorHandler = (error: unknown) => Response | Promise<Response>;
+type BunFetchHandler = (request: Request, server?: Bun.Server) => Response | Promise<Response>;
+type DenoFetchHandler = (request: Request, info?: Deno.ServeHandlerInfo<Deno.NetAddr>) => Response | Promise<Response>;
+type NodeServerRequest = NodeHttp$1.IncomingMessage | NodeHttp2.Http2ServerRequest;
+type NodeServerResponse = NodeHttp$1.ServerResponse | NodeHttp2.Http2ServerResponse;
+type NodeHttpHandler = (req: NodeServerRequest, res: NodeServerResponse) => void | Promise<void>;
+type CloudflareFetchHandler = CF.ExportedHandlerFetchHandler; //#endregion
+export { BunFetchHandler, CloudflareFetchHandler, DenoFetchHandler, ErrorHandler, FastResponse, FastURL, FetchHandler, NodeHttpHandler, NodeServerRequest, NodeServerResponse, Server, ServerHandler, ServerMiddleware, ServerOptions, ServerPlugin, ServerRequest, ServerRuntimeContext, serve };

package/dist/cloudflare.d.mts

@@ -0,0 +1,10 @@
+import { Server, ServerOptions } from "./chunks/types-egi3HKdd.mjs";
+import * as CF from "@cloudflare/workers-types";
+
+//#region src/adapters/cloudflare.d.ts
+declare const FastURL: typeof globalThis.URL;
+declare const FastResponse: typeof globalThis.Response;
+declare function serve(options: ServerOptions): Server<CF.ExportedHandlerFetchHandler>;
+
+//#endregion
+export { FastResponse, FastURL, serve };

package/dist/cloudflare.mjs

@@ -0,0 +1,53 @@
+import { wrapFetch } from "./chunks/_middleware-DSFIayTI.mjs";
+import { errorPlugin } from "./chunks/_plugins-BTotWVHV.mjs";
+
+//#region src/adapters/cloudflare.ts
+const FastURL = URL;
+const FastResponse = Response;
+function serve(options) {
+	return new CloudflareServer(options);
+}
+var CloudflareServer = class {
+	runtime = "cloudflare";
+	options;
+	serveOptions;
+	fetch;
+	constructor(options) {
+		this.options = {
+			...options,
+			middleware: [...options.middleware || []]
+		};
+		for (const plugin of options.plugins || []) plugin(this);
+		errorPlugin(this);
+		const fetchHandler = wrapFetch(this);
+		this.fetch = (request, env, context) => {
+			Object.defineProperties(request, { runtime: {
+				enumerable: true,
+				value: {
+					runtime: "cloudflare",
+					cloudflare: {
+						env,
+						context
+					}
+				}
+			} });
+			return fetchHandler(request);
+		};
+		this.serveOptions = { fetch: this.fetch };
+		if (!options.manual) this.serve();
+	}
+	serve() {
+		addEventListener("fetch", (event) => {
+			event.respondWith(this.fetch(event.request, {}, event));
+		});
+	}
+	ready() {
+		return Promise.resolve().then(() => this);
+	}
+	close() {
+		return Promise.resolve();
+	}
+};
+
+//#endregion
+export { FastResponse, FastURL, serve };

package/dist/deno.d.mts

@@ -0,0 +1,22 @@
+import { DenoFetchHandler, Server, ServerOptions } from "./chunks/types-egi3HKdd.mjs";
+import { FastURL$2 as FastURL } from "./chunks/_url-BwTFuoNW.mjs";
+
+//#region src/adapters/deno.d.ts
+declare const FastResponse: typeof globalThis.Response;
+declare function serve(options: ServerOptions): DenoServer;
+declare class DenoServer implements Server<DenoFetchHandler> {
+  #private;
+  readonly runtime = "deno";
+  readonly options: Server["options"];
+  readonly deno: Server["deno"];
+  readonly serveOptions: Deno.ServeTcpOptions | (Deno.ServeTcpOptions & Deno.TlsCertifiedKeyPem);
+  readonly fetch: DenoFetchHandler;
+  constructor(options: ServerOptions);
+  serve(): Promise<this>;
+  get url(): string | undefined;
+  ready(): Promise<Server>;
+  close(): Promise<void | undefined>;
+}
+
+//#endregion
+export { FastResponse, FastURL, serve };