srvx 0.6.0 → 0.7.0

package/dist/_middleware.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/_plugins.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/_url.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$1 };

package/dist/_url.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, fmtURL, printListening, resolvePortAndHost, resolveTLSOptions };

package/dist/bun.d.mts

@@ -0,0 +1,22 @@
+import { BunFetchHandler, Server, ServerOptions } from "./types.mjs";
+import { FastURL$1 as FastURL } from "./_url.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, fmtURL, printListening, resolvePortAndHost, resolveTLSOptions } from "./_url.mjs";
+import { wrapFetch } from "./_middleware.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/cloudflare.d.mts

@@ -0,0 +1,10 @@
+import { Server, ServerOptions } from "./types.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 "./_middleware.mjs";
+import { errorPlugin } from "./_plugins.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 "./types.mjs";
+import { FastURL$1 as FastURL } from "./_url.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 };

package/dist/deno.mjs

@@ -0,0 +1,86 @@
+import { FastURL, fmtURL, printListening, resolvePortAndHost, resolveTLSOptions } from "./_url.mjs";
+import { wrapFetch } from "./_middleware.mjs";
+
+//#region src/adapters/deno.ts
+const FastResponse = Response;
+function serve(options) {
+	return new DenoServer(options);
+}
+var DenoServer = class {
+	runtime = "deno";
+	options;
+	deno = {};
+	serveOptions;
+	fetch;
+	#listeningPromise;
+	#listeningInfo;
+	constructor(options) {
+		this.options = {
+			...options,
+			middleware: [...options.middleware || []]
+		};
+		for (const plugin of options.plugins || []) plugin(this);
+		const fetchHandler = wrapFetch(this);
+		this.fetch = (request, info) => {
+			Object.defineProperties(request, {
+				runtime: {
+					enumerable: true,
+					value: {
+						runtime: "deno",
+						deno: {
+							info,
+							server: this.deno?.server
+						}
+					}
+				},
+				ip: {
+					enumerable: true,
+					get() {
+						return (info?.remoteAddr)?.hostname;
+					}
+				}
+			});
+			return fetchHandler(request);
+		};
+		const tls = resolveTLSOptions(this.options);
+		this.serveOptions = {
+			...resolvePortAndHost(this.options),
+			reusePort: this.options.reusePort,
+			onError: this.options.error,
+			...tls ? {
+				key: tls.key,
+				cert: tls.cert,
+				passphrase: tls.passphrase
+			} : {},
+			...this.options.deno
+		};
+		if (!options.manual) this.serve();
+	}
+	serve() {
+		if (this.deno?.server) return Promise.resolve(this.#listeningPromise).then(() => this);
+		const onListenPromise = Promise.withResolvers();
+		this.#listeningPromise = onListenPromise.promise;
+		this.deno.server = Deno.serve({
+			...this.serveOptions,
+			onListen: (info) => {
+				this.#listeningInfo = info;
+				if (this.options.deno?.onListen) this.options.deno.onListen(info);
+				printListening(this.options, this.url);
+				onListenPromise.resolve();
+			}
+		}, this.fetch);
+		return Promise.resolve(this.#listeningPromise).then(() => this);
+	}
+	get url() {
+		return this.#listeningInfo ? fmtURL(this.#listeningInfo.hostname, this.#listeningInfo.port, !!this.serveOptions.cert) : void 0;
+	}
+	ready() {
+		return Promise.resolve(this.#listeningPromise).then(() => this);
+	}
+	close() {
+		return Promise.resolve(this.deno?.server?.shutdown());
+	}
+};
+
+//#endregion
+export { FastResponse, FastURL, serve };

package/dist/generic.d.mts

@@ -0,0 +1,9 @@
+import { Server, ServerOptions } from "./types.mjs";
+
+//#region src/adapters/generic.d.ts
+declare const FastURL: typeof globalThis.URL;
+declare const FastResponse: typeof globalThis.Response;
+declare function serve(options: ServerOptions): Server;
+
+//#endregion
+export { FastResponse, FastURL, serve };

package/dist/generic.mjs

@@ -0,0 +1,36 @@
+import { wrapFetch } from "./_middleware.mjs";
+import { errorPlugin } from "./_plugins.mjs";
+
+//#region src/adapters/generic.ts
+const FastURL = URL;
+const FastResponse = Response;
+function serve(options) {
+	return new GenericServer(options);
+}
+var GenericServer = class {
+	runtime = "generic";
+	options;
+	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) => {
+			return Promise.resolve(fetchHandler(request));
+		};
+	}
+	serve() {}
+	ready() {
+		return Promise.resolve(this);
+	}
+	close() {
+		return Promise.resolve();
+	}
+};
+
+//#endregion
+export { FastResponse, FastURL, serve };

package/dist/node.d.mts

@@ -0,0 +1,55 @@
+import { FetchHandler, NodeHttpHandler, NodeServerRequest, NodeServerResponse, Server, ServerOptions, ServerRequest } from "./types.mjs";
+import { FastURL$1 as FastURL } from "./_url.mjs";
+import NodeHttp from "node:http";
+import { Readable } from "node:stream";
+
+//#region src/adapters/_node/request.d.ts
+type NodeRequestContext = {
+  req: NodeServerRequest;
+  res?: NodeServerResponse;
+};
+declare const NodeRequest: {
+  new (nodeCtx: NodeRequestContext): ServerRequest;
+};
+
+//#endregion
+//#region src/adapters/_node/headers.d.ts
+declare const NodeRequestHeaders: {
+  new (nodeCtx: {
+    req: NodeServerRequest;
+    res?: NodeServerResponse;
+  }): globalThis.Headers;
+};
+declare const NodeResponseHeaders: {
+  new (nodeCtx: {
+    req?: NodeServerRequest;
+    res: NodeServerResponse;
+  }): globalThis.Headers;
+};
+
+//#endregion
+//#region src/adapters/_node/response.d.ts
+type NodeResponse = InstanceType<typeof NodeResponse>;
+/**
+* Fast Response for Node.js runtime
+*
+* It is faster because in most cases it doesn't create a full Response instance.
+*/
+declare const NodeResponse: {
+  new (body?: BodyInit | null, init?: ResponseInit): globalThis.Response & {
+    readonly nodeResponse: () => {
+      status: number;
+      statusText: string;
+      headers: NodeHttp.OutgoingHttpHeader[];
+      body: string | Buffer | Uint8Array | DataView | ReadableStream<Uint8Array> | Readable | undefined | null;
+    };
+  };
+};
+
+//#endregion
+//#region src/adapters/node.d.ts
+declare function serve(options: ServerOptions): Server;
+declare function toNodeHandler(fetchHandler: FetchHandler): NodeHttpHandler;
+
+//#endregion
+export { NodeResponse as FastResponse, FastURL, NodeRequest, NodeRequestHeaders, NodeResponse, NodeResponseHeaders, serve, toNodeHandler };