@torpor/build 0.4.8 → 0.4.10

package/src/server/Server.ts

@@ -1,144 +0,0 @@
-import pathToRegex from "../utils/pathToRegex";
-import ServerEvent from "./ServerEvent";
-import type MiddlewareFunction from "./types/MiddlewareFunction";
-import type ServerFunction from "./types/ServerFunction";
-
-const noop = () => {};
-
-/**
- * A Fetch API Request/Response server.
- */
-export default class Server {
-	// TODO: We don't use any of the routes, just add("*") in runDev/runBuild...
-	routes: RouteHandler[] = [];
-	// TODO: We only use the Vite middleware here
-	middleware: MiddlewareFunction[] = [];
-
-	constructor() {
-		this.routes = [];
-		this.middleware = [];
-	}
-
-	/**
-	 * The standard Fetch API method that should work in any runtime (including
-	 * Node with polyfills).
-	 * @returns
-	 */
-	fetch = async (input: RequestInfo | URL, init?: RequestInit): Promise<Response> => {
-		const request = new Request(input, init);
-		const url = new URL(request.url);
-		const match = this.match(url.pathname);
-		let ev = new ServerEvent(request, match?.params);
-
-		if (this.middleware.length) {
-			// TODO: Get middleware that applies to this route only?
-			await this.middleware[0](ev, buildNext(this.middleware, 0));
-			function buildNext(middleware: MiddlewareFunction[], i: number): () => void | Promise<void> {
-				if (ev.response) {
-					return noop;
-				}
-
-				if (i < middleware.length - 1) {
-					let next = middleware[i + 1];
-					return async () => next(ev, buildNext(middleware, i + 1));
-				} else {
-					return match
-						? async () => {
-								ev.response = await match.fn(ev);
-							}
-						: noop;
-				}
-			}
-		} else if (match) {
-			ev.response = await match.fn(ev);
-		} else {
-			return new Response(null, { status: 404 });
-		}
-
-		// TODO: Should I be returning 200 if there's no response? Because it's not an error??
-		ev.response ??= new Response(null, { status: 200 });
-		ev.addHeaders();
-
-		return ev.response;
-	};
-
-	/**
-	 * Adds a server function at a route path.
-	 * @param path The route path pattern.
-	 * @param fn The function to call when the pattern is matched.
-	 * @returns
-	 */
-	add(path: string, fn: ServerFunction): Server {
-		this.routes.push(new RouteHandler(path, fn));
-		this.#sortRoutes();
-		return this;
-	}
-
-	match(path: string): Match | undefined {
-		for (let handler of this.routes) {
-			let match = path.match(handler.regex);
-			if (match) {
-				return {
-					fn: handler.fn,
-					params: match.groups,
-				};
-			}
-		}
-		console.log(`Server path not found: ${path}`);
-	}
-
-	// TODO:
-	//use(path: string, ...fn: MiddlewareFunction[])
-	use(...fn: MiddlewareFunction[]): Server {
-		this.middleware = this.middleware.concat(fn);
-		return this;
-	}
-
-	#sortRoutes() {
-		this.routes = this.routes.sort((a, b) => {
-			// Sort [param]s after paths
-			// There might be a quicker/easier way to do this
-			for (let i = 0; i < Math.min(a.path.length, b.path.length); i++) {
-				if (a.path[i] === "[" && b.path[i] !== "[") {
-					return 1;
-				} else if (b.path[i] === "[" && a.path[i] !== "[") {
-					return -1;
-				} else if (a.path[i] === b.path[i]) {
-					// Keep going...
-				} else {
-					return a.path[i].localeCompare(b.path[i]);
-				}
-			}
-			return a.path.length - b.path.length;
-		});
-	}
-}
-
-class RouteHandler {
-	path: string;
-	regex: RegExp;
-	fn: ServerFunction;
-
-	constructor(path: string, fn: ServerFunction) {
-		this.path = path;
-		this.regex = pathToRegex(path);
-		this.fn = fn;
-	}
-}
-
-//class MiddlewareHandler {
-//	path: string;
-//	regex: RegExp;
-//	fn: MiddlewareFunction;
-//
-//	constructor(path: string, fn: MiddlewareFunction) {
-//		this.path = path;
-//		this.regex = pathToRegex(path);
-//		this.fn = fn;
-//	}
-//}
-
-interface Match {
-	fn: ServerFunction;
-	params?: Record<string, string>;
-}

package/src/server/ServerEvent.ts

@@ -1,39 +0,0 @@
-import CookieHelper from "./CookieHelper";
-import HeaderHelper from "./HeaderHelper";
-
-export default class ServerEvent {
-	request: Request;
-	response: Response | undefined | void;
-	// TODO: Should we cast types??
-	params?: Record<string, string>;
-
-	adapter: any;
-
-	cookies: CookieHelper;
-	headers: HeaderHelper;
-
-	constructor(request: Request, params?: Record<string, string>) {
-		this.request = request;
-		this.params = params;
-		this.cookies = new CookieHelper(request);
-		this.headers = new HeaderHelper(request);
-
-		// Adapters may have added the `adapter` property to globalThis
-		// @ts-ignore
-		this.adapter = globalThis.adapter;
-	}
-
-	addHeaders(): void {
-		if (!this.response) {
-			throw new Error("Response not created yet");
-		}
-
-		for (let cookie of this.cookies.cookies.values()) {
-			this.response.headers.append("set-cookie", cookie);
-		}
-
-		for (let header of this.headers.headers.entries()) {
-			this.response.headers.append(header[0], header[1]);
-		}
-	}
-}

package/src/server/connect/bufferToArrayBuffer.ts

@@ -1,8 +0,0 @@
-// From https://stackoverflow.com/a/79345620
-// No idea why it is needed
-export default function bufferToArrayBuffer(buffer: Buffer): ArrayBuffer {
-	return buffer.buffer.slice(
-		buffer.byteOffset,
-		buffer.byteOffset + buffer.byteLength,
-	) as ArrayBuffer;
-}

package/src/server/connect/connectMiddleware.ts

@@ -1,81 +0,0 @@
-import { IncomingMessage, ServerResponse } from "node:http";
-import type MiddlewareFunction from "../types/MiddlewareFunction";
-import bufferToArrayBuffer from "./bufferToArrayBuffer";
-import flattenHeaders from "./flattenHeaders";
-import nodeMessageToNodeResponse from "./nodeMessageToNodeResponse";
-import readableToBuffer from "./readableToBuffer";
-import requestToNodeMessage from "./requestToNodeMessage";
-
-// From https://github.com/vikejs/vike-node/blob/main/packages/vike-node/src/runtime/adapters/connectToWeb.ts
-
-/**
- * Converts a Connect-style middleware to a web-compatible request handler.
- *
- * @param handler - The Connect-style middleware function to be converted.
- * @returns A function that handles web requests and returns a Response or undefined.
- */
-export default function connectMiddleware(
-	handler: ConnectMiddleware | ConnectMiddlewareBoolean,
-): MiddlewareFunction {
-	return async (ev, next) => {
-		const req = requestToNodeMessage(ev.request);
-		const { res, onReadable } = nodeMessageToNodeResponse(req);
-
-		return new Promise<void>(async (resolve, reject) => {
-			onReadable(async ({ readable, headers, status }) => {
-				const responseBody = statusCodesWithoutBody.includes(status)
-					? null
-					: //(Readable.toWeb(readable) as ReadableStream);
-						// HACK: Chunked bodies are not being
-						// read correctly somewhere...
-						bufferToArrayBuffer(await readableToBuffer(readable));
-				ev.response = new Response(responseBody, {
-					status,
-					headers: flattenHeaders(headers),
-				});
-				resolve();
-			});
-
-			const cnext = async (error?: unknown) => {
-				if (error) {
-					// eslint-disable-next-line no-base-to-string
-					reject(error instanceof Error ? error : new Error(String(error)));
-				} else {
-					// TODO: Can we nest the next functions less? This is a bit weird
-					await next();
-					resolve();
-				}
-			};
-
-			try {
-				const handled = await handler(req, res, cnext);
-				if (handled === false) {
-					res.destroy();
-					resolve();
-				}
-			} catch (e) {
-				await cnext(e);
-			}
-		});
-	};
-}
-
-const statusCodesWithoutBody = [
-	100, // Continue
-	101, // Switching Protocols
-	102, // Processing (WebDAV)
-	103, // Early Hints
-	204, // No Content
-	205, // Reset Content
-	304, // Not Modified
-];
-
-type NextFunction = (err?: unknown) => void;
-type ConnectMiddleware<
-	PlatformRequest extends IncomingMessage = IncomingMessage,
-	PlatformResponse extends ServerResponse = ServerResponse,
-> = (req: PlatformRequest, res: PlatformResponse, next: NextFunction) => void | Promise<void>;
-type ConnectMiddlewareBoolean<
-	PlatformRequest extends IncomingMessage = IncomingMessage,
-	PlatformResponse extends ServerResponse = ServerResponse,
-> = (req: PlatformRequest, res: PlatformResponse, next: NextFunction) => boolean | Promise<boolean>;

package/src/server/connect/flattenHeaders.ts

@@ -1,44 +0,0 @@
-import { IncomingHttpHeaders } from "node:http";
-import { OutgoingHttpHeaders } from "node:http2";
-
-export default function flattenHeaders(
-	headers: IncomingHttpHeaders | OutgoingHttpHeaders,
-): HeadersInit {
-	const flatHeaders = new Headers();
-	for (const [key, value] of Object.entries(headers)) {
-		if (value === undefined || value === null) {
-			continue;
-		} else if (Array.isArray(value)) {
-			for (const v of value) {
-				if (v !== undefined && v !== null) {
-					value.forEach((v) => flatHeaders.append(key, v));
-				}
-			}
-		} else {
-			flatHeaders.set(key, String(value));
-		}
-	}
-	return flatHeaders;
-
-	/*
-            const flatHeaders: [string, string][] = [];
-
-	for (const [key, value] of Object.entries(headers)) {
-		if (value === undefined || value === null) {
-			continue;
-		}
-
-		if (Array.isArray(value)) {
-			for (const v of value) {
-				if (v != null) {
-					flatHeaders.push([key, String(v)]);
-				}
-			}
-		} else {
-			flatHeaders.push([key, String(value)]);
-		}
-	}
-
-	return flatHeaders;
-    */
-}

package/src/server/connect/nodeMessageToNodeResponse.ts

@@ -1,89 +0,0 @@
-import {
-	type IncomingMessage,
-	type OutgoingHttpHeader,
-	type OutgoingHttpHeaders,
-	ServerResponse,
-} from "node:http";
-import { PassThrough, Readable } from "node:stream";
-
-// From https://github.com/vikejs/vike-node/blob/main/packages/vike-node/src/runtime/adapters/createServerResponse.ts
-
-/**
- * Creates a custom ServerResponse object that allows for intercepting and
- * streaming the response.
- *
- * @param incomingMessage The incoming HTTP request message.
- * @returns An object containing the custom ServerResponse and a function that
- * takes a callback to invoke when the response is readable, providing an object
- * with the readable stream, headers and status code.
- */
-export default function nodeMessageToNodeResponse(
-	incomingMessage: IncomingMessage,
-): ServerResponseResponse {
-	const res = new ServerResponse(incomingMessage);
-	const passThrough = new PassThrough();
-	let handled = false;
-
-	const onReadable = (
-		cb: (result: { readable: Readable; headers: OutgoingHttpHeaders; status: number }) => void,
-	) => {
-		const handleReadable = () => {
-			if (handled) return;
-			handled = true;
-			cb({
-				readable: Readable.from(passThrough),
-				headers: res.getHeaders(),
-				status: res.statusCode,
-			});
-		};
-
-		passThrough.once("readable", handleReadable);
-		passThrough.once("end", handleReadable);
-	};
-
-	passThrough.once("finish", () => {
-		res.emit("finish");
-	});
-	passThrough.once("close", () => {
-		res.destroy();
-		res.emit("close");
-	});
-	passThrough.on("drain", () => {
-		res.emit("drain");
-	});
-
-	res.write = passThrough.write.bind(passThrough);
-	res.end = passThrough.end.bind(passThrough) as any;
-
-	res.writeHead = function writeHead(
-		statusCode: number,
-		statusMessage?: string | OutgoingHttpHeaders | OutgoingHttpHeader[],
-		headers?: OutgoingHttpHeaders | OutgoingHttpHeader[],
-	): ServerResponse {
-		res.statusCode = statusCode;
-		if (typeof statusMessage === "object") {
-			headers = statusMessage;
-			statusMessage = undefined;
-		}
-		if (headers) {
-			for (const [key, value] of Object.entries(headers)) {
-				if (value !== undefined) {
-					res.setHeader(key, value);
-				}
-			}
-		}
-		return res;
-	};
-
-	return {
-		res,
-		onReadable,
-	};
-}
-
-interface ServerResponseResponse {
-	res: ServerResponse;
-	onReadable: (
-		cb: (result: { readable: Readable; headers: OutgoingHttpHeaders; status: number }) => void,
-	) => void;
-}

package/src/server/connect/readableToBuffer.ts

@@ -1,16 +0,0 @@
-import { Readable } from "node:stream";
-
-export default function readableToBuffer(req: Readable): Promise<Buffer> {
-	return new Promise<Buffer>((resolve, reject) => {
-		const chunks: Buffer[] = [];
-		req.on("data", (chunk: Buffer) => {
-			chunks.push(chunk);
-		});
-		req.on("end", () => {
-			resolve(Buffer.concat(chunks));
-		});
-		req.on("error", (err) => {
-			reject(err);
-		});
-	});
-}

package/src/server/connect/requestToNodeMessage.ts

@@ -1,26 +0,0 @@
-import { type IncomingMessage } from "node:http";
-import { Readable } from "node:stream";
-
-// From https://github.com/vikejs/vike-node/blob/main/packages/vike-node/src/runtime/adapters/connectToWeb.ts
-
-const DUMMY_BASE_URL = "http://localhost";
-
-/**
- * Creates an IncomingMessage object from a web Request.
- *
- * @param {Request} request - The web Request object.
- * @returns {IncomingMessage} An IncomingMessage-like object compatible with Node.js HTTP module.
- */
-export default function requestToNodeMessage(request: Request): IncomingMessage {
-	const parsedUrl = new URL(request.url, DUMMY_BASE_URL);
-	const pathAndQuery = (parsedUrl.pathname || "") + (parsedUrl.search || "");
-	// HACK: Using Readable.fromWeb locks request.body so that the request cannot be used again
-	// As we're only using this for Vite middlewares, it's safe to discard the body for now?
-	const body = /*request.body ? Readable.fromWeb(request.body as any) :*/ Readable.from([]);
-
-	return Object.assign(body, {
-		url: pathAndQuery,
-		method: request.method,
-		headers: Object.fromEntries(request.headers),
-	}) as IncomingMessage;
-}

package/src/server/contentType.ts

@@ -1,85 +0,0 @@
-// From https://developer.mozilla.org/en-US/docs/Web/HTTP/Guides/MIME_types/Common_types
-
-export default function contentType(extension: string): string {
-	return types[extension] || "application/octet-stream";
-}
-
-const types: Record<string, string> = {
-	".aac": "audio/aac",
-	".abw": "application/x-abiword",
-	".apng": "image/apng",
-	".arc": "application/x-freearc",
-	".avif": "image/avif",
-	".avi": "video/x-msvideo",
-	".azw": "application/vnd.amazon.ebook",
-	".bin": "application/octet-stream",
-	".bmp": "image/bmp",
-	".bz": "application/x-bzip",
-	".bz2": "application/x-bzip2",
-	".cda": "application/x-cdf",
-	".csh": "application/x-csh",
-	".css": "text/css",
-	".csv": "text/csv",
-	".doc": "application/msword",
-	".docx": "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
-	".eot": "application/vnd.ms-fontobject",
-	".epub": "application/epub+zip",
-	".gz": "application/gzip",
-	".gif": "image/gif",
-	".htm": "text/html",
-	".html": "text/html",
-	".ico": "image/vnd.microsoft.icon",
-	".ics": "text/calendar",
-	".jar": "application/java-archive",
-	".jpeg": "image/jpeg",
-	".jpg": "image/jpeg",
-	".js": "text/javascript",
-	".json": "application/json",
-	".jsonld": "application/ld+json",
-	".mid": "audio/midi",
-	".midi": "audio/midi",
-	".mjs": "text/javascript",
-	".mp3": "audio/mpeg",
-	".mp4": "video/mp4",
-	".mpeg": "video/mpeg",
-	".mpkg": "application/vnd.apple.installer+xml",
-	".odp": "application/vnd.oasis.opendocument.presentation",
-	".ods": "application/vnd.oasis.opendocument.spreadsheet",
-	".odt": "application/vnd.oasis.opendocument.text",
-	".oga": "audio/ogg",
-	".ogv": "video/ogg",
-	".ogx": "application/ogg",
-	".opus": "audio/ogg",
-	".otf": "font/otf",
-	".png": "image/png",
-	".pdf": "application/pdf",
-	".php": "application/x-httpd-php",
-	".ppt": "application/vnd.ms-powerpoint",
-	".pptx": "application/vnd.openxmlformats-officedocument.presentationml.presentation",
-	".rar": "application/vnd.rar",
-	".rtf": "application/rtf",
-	".sh": "application/x-sh",
-	".svg": "image/svg+xml",
-	".tar": "application/x-tar",
-	".tif": "image/tiff",
-	".tiff": "image/tiff",
-	".ts": "video/mp2t",
-	".ttf": "font/ttf",
-	".txt": "text/plain",
-	".vsd": "application/vnd.visio",
-	".wav": "audio/wav",
-	".weba": "audio/webm",
-	".webm": "video/webm",
-	".webp": "image/webp",
-	".woff": "font/woff",
-	".woff2": "font/woff2",
-	".xhtml": "application/xhtml+xml",
-	".xls": "application/vnd.ms-excel",
-	".xlsx": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
-	".xml": "application/xml",
-	".xul": "application/vnd.mozilla.xul+xml",
-	".zip": "application/zip",
-	".3gp": "video/3gpp",
-	".3g2": "video/3gpp2",
-	".7z": "application/x-7z-compressed",
-};

package/src/server/types/HttpMethod.ts

@@ -1,12 +0,0 @@
-type HttpMethod =
-	| "GET"
-	| "HEAD"
-	| "PATCH"
-	| "POST"
-	| "PUT"
-	| "DELETE"
-	| "OPTIONS"
-	| "CONNECT"
-	| "TRACE";
-
-export default HttpMethod;

package/src/server/types/MiddlewareFunction.ts

@@ -1,8 +0,0 @@
-import ServerEvent from "../ServerEvent";
-
-type MiddlewareFunction = (
-	ev: ServerEvent,
-	next: () => void | Promise<void>,
-) => void | Promise<void>;
-
-export default MiddlewareFunction;

package/src/server/types/ServerFunction.ts

@@ -1,7 +0,0 @@
-import ServerEvent from "../ServerEvent";
-
-type ServerFunction = (
-	e: ServerEvent,
-) => Response | undefined | void | Promise<Response | undefined | void>;
-
-export default ServerFunction;

package/src/server.ts

@@ -1,7 +0,0 @@
-import CookieHelper from "./server/CookieHelper";
-import HeaderHelper from "./server/HeaderHelper";
-import Server from "./server/Server";
-import ServerEvent from "./server/ServerEvent";
-import connectMiddleware from "./server/connect/connectMiddleware";
-
-export { Server, ServerEvent, CookieHelper, HeaderHelper, connectMiddleware };