@lithia-js/core 1.0.0-canary.1 → 1.0.0-canary.3

package/src/server/request.ts

@@ -1,247 +0,0 @@
-import type { IncomingHttpHeaders, IncomingMessage } from "node:http";
-import busboy, { type FileInfo } from "busboy";
-import { type Cookies, parse as parseCookie } from "cookie";
-import type { Lithia } from "../lithia";
-
-/** Route parameters extracted from the route matcher. */
-export type Params = Record<string, any>;
-
-/** Parsed query parameters. Values may be a string or an array for repeated keys. */
-export type Query = Record<string, any>;
-
-/** Represents an uploaded file. */
-export interface UploadedFile extends FileInfo {
-	/** Field name in the form. */
-	fieldname: string;
-	/** File buffer. */
-	buffer: Buffer;
-}
-
-/** Request wrapper passed to route handlers.
- *
- * Provides convenient accessors for headers, params, query, body and helpers
- * such as `ip()` and `isSecure()`. The wrapper also exposes a simple
- * per-request storage via `get()`/`set()` and cookie parsing helpers.
- */
-export class LithiaRequest {
-	headers: Readonly<IncomingHttpHeaders>;
-	method: Readonly<string>;
-	params: Params;
-	pathname: Readonly<string>;
-	query: Query;
-
-	private storage = new Map<string, unknown>();
-	private _bodyCache: unknown | null = null;
-	private _filesCache: UploadedFile[] | null = null;
-	private _cookies: Cookies | null = null;
-
-	/**
-	 * Wrap a Node `IncomingMessage` into a `LithiaRequest`.
-	 *
-	 * `lithia` is the runtime instance and is stored in request-local
-	 * storage under the `lithia` key for handlers that need access.
-	 */
-	constructor(
-		private readonly req: IncomingMessage,
-		private readonly lithia: Lithia,
-	) {
-		const protocol =
-			(req.headers["x-forwarded-proto"] as string) === "https" ||
-			(req.socket as any)?.encrypted === true
-				? "https"
-				: "http";
-		const host = req.headers.host || "unknown";
-		const fullUrl = `${protocol}://${host}${req.url || "/"}`;
-		const url = new URL(fullUrl);
-
-		this.pathname = url.pathname;
-		this.method = (req.method || "GET").toUpperCase();
-		this.headers = req.headers;
-		this.query = parseQueryToObject(url.searchParams);
-		this.params = {};
-
-		this.storage.set("lithia", this.lithia);
-	}
-
-	/**
-	 * Read and parse the request body. For JSON content-type this returns the
-	 * parsed object; for other content types it returns the raw string. The
-	 * result is cached and subsequent calls return the cached value.
-	 */
-	async body<T>(): Promise<T> {
-		if (!["POST", "PUT", "PATCH", "DELETE"].includes(this.method)) {
-			return {} as T;
-		}
-
-		if (this._bodyCache !== null) return this._bodyCache as T;
-
-		const contentType = (this.headers["content-type"] || "") as string;
-
-		if (contentType.includes("multipart/form-data")) {
-			await this.parseMultipart();
-			return this._bodyCache as T;
-		}
-
-		const contentLength = parseInt(
-			(this.headers["content-length"] as string) || "0",
-			10,
-		);
-		const maxBodySize = this.lithia.options.http.maxBodySize || 1024 * 1024;
-
-		if (contentLength > maxBodySize) {
-			throw new Error("Request body too large");
-		}
-
-		const body = await new Promise<T>((resolve, reject) => {
-			let bodyData = "";
-			this.req.on("data", (chunk) => {
-				bodyData += chunk;
-				if (bodyData.length > maxBodySize) {
-					reject(new Error("Request body too large"));
-				}
-			});
-
-			this.req.on("end", () => {
-				if (!bodyData) return resolve({} as T);
-				try {
-					if (contentType.includes("application/json")) {
-						resolve(JSON.parse(bodyData) as T);
-					} else {
-						resolve(bodyData as unknown as T);
-					}
-				} catch (err) {
-					reject(err);
-				}
-			});
-
-			this.req.on("error", (err) => reject(err));
-		});
-
-		this._bodyCache = body;
-		this.storage.set("body", body);
-		return body;
-	}
-
-	/**
-	 * Get uploaded files from a multipart/form-data request.
-	 */
-	async files(): Promise<UploadedFile[]> {
-		const contentType = (this.headers["content-type"] || "") as string;
-		if (!contentType.includes("multipart/form-data")) return [];
-
-		if (this._filesCache !== null) return this._filesCache;
-
-		await this.parseMultipart();
-		return this._filesCache!;
-	}
-
-	/** Set the request body manually (e.g. after validation/sanitization). */
-	setBody(value: unknown) {
-		this._bodyCache = value;
-		this.storage.set("body", value);
-	}
-
-	private async parseMultipart(): Promise<void> {
-		if (this._bodyCache !== null && this._filesCache !== null) return;
-
-		return new Promise((resolve, reject) => {
-			const bb = busboy({ headers: this.headers });
-			const fields: Record<string, any> = {};
-			const files: UploadedFile[] = [];
-
-			bb.on("file", (name, file, info) => {
-				const chunks: Buffer[] = [];
-				file.on("data", (data) => chunks.push(data));
-				file.on("end", () => {
-					files.push({
-						fieldname: name,
-						buffer: Buffer.concat(chunks),
-						...info,
-					});
-				});
-			});
-
-			bb.on("field", (name, val) => {
-				fields[name] = val;
-			});
-
-			bb.on("close", () => {
-				this._bodyCache = fields;
-				this._filesCache = files;
-				resolve();
-			});
-
-			bb.on("error", (err) => reject(err));
-
-			this.req.pipe(bb);
-		});
-	}
-
-	/** Retrieve a value from per-request storage. */
-	get<T>(key: string): T | undefined {
-		return this.storage.get(key) as T | undefined;
-	}
-
-	/** Store a value in per-request storage. */
-	set(key: string, value: unknown): void {
-		this.storage.set(key, value);
-	}
-
-	/** Parse cookies from the `Cookie` header. */
-	cookies(): Cookies {
-		if (this._cookies === null) {
-			const cookieHeader = this.headers.cookie;
-			const parsedCookies = cookieHeader ? parseCookie(cookieHeader) : {};
-			this._cookies = parsedCookies;
-		}
-		return this._cookies || {};
-	}
-
-	/** Return a single cookie value by name. */
-	cookie(name: string): string | undefined {
-		return this.cookies()[name];
-	}
-
-	/** Client IP address (considers `X-Forwarded-For` and `X-Real-IP`). */
-	ip(): string {
-		return (
-			(this.headers["x-forwarded-for"] as string)?.split(",")[0]?.trim() ||
-			(this.headers["x-real-ip"] as string) ||
-			(this.req.socket as any)?.remoteAddress ||
-			"unknown"
-		);
-	}
-
-	/** `User-Agent` header value or empty string. */
-	userAgent(): string {
-		return (this.headers["user-agent"] as string) || "";
-	}
-
-	/** Return true when the request was made over TLS. */
-	isSecure(): boolean {
-		return (
-			(this.headers["x-forwarded-proto"] as string) === "https" ||
-			(this.req.socket as any)?.encrypted === true
-		);
-	}
-
-	/** Host header or `unknown` when missing. */
-	host(): string {
-		return (this.headers.host as string) || "unknown";
-	}
-
-	/** Full URL constructed from host and pathname. */
-	url(): string {
-		return `${this.isSecure() ? "https" : "http"}://${this.host()}${this.pathname}`;
-	}
-}
-
-export function parseQueryToObject(raw: URLSearchParams) {
-	const obj: Query = {};
-	for (const [k, v] of raw.entries()) {
-		if (obj[k] === undefined) obj[k] = v;
-		else if (Array.isArray(obj[k])) (obj[k] as string[]).push(v);
-		else obj[k] = [obj[k] as string, v];
-	}
-	return obj;
-}

package/src/server/response.ts

@@ -1,204 +0,0 @@
-import { createReadStream, statSync } from "node:fs";
-import type { OutgoingHttpHeaders, ServerResponse } from "node:http";
-import { join } from "node:path";
-import { serialize as serializeCookie } from "cookie";
-import { logger } from "../logger";
-
-/** Options used when setting cookies on the response. */
-export interface CookieOptions {
-	domain?: string;
-	expires?: Date;
-	httpOnly?: boolean;
-	maxAge?: number;
-	path?: string;
-	sameSite?: boolean | "lax" | "strict" | "none";
-	secure?: boolean;
-}
-
-/**
- * High-level response wrapper used by Lithia handlers.
- *
- * This class wraps Node's `ServerResponse` and provides convenient helper
- * methods for common response patterns used by Lithia handlers:
- * - sending JSON (`json`), text/primitive bodies (`send`) and redirects
- * - streaming static files (`sendFile`)
- * - managing headers and queued cookies (`addHeader`, `setHeaders`, `cookie`)
- *
- * It also tracks whether the response has already been sent and will throw
- * if you attempt to mutate the response after it was finalized.
- *
- * Instances are created per incoming request and are intended to be passed
- * through middleware and route handlers.
- */
-export class LithiaResponse {
-	_ended = false;
-	private _cookies: Array<{
-		name: string;
-		value: string;
-		options?: CookieOptions;
-	}> = [];
-
-	/** Create a new `LithiaResponse` wrapping a Node `ServerResponse`. */
-	constructor(private res: ServerResponse) {
-		this.on = this.res.on.bind(this.res);
-	}
-
-	/** Current HTTP status code for the response. */
-	get statusCode(): number {
-		return this.res.statusCode;
-	}
-
-	/** Convenience passthrough to the underlying `ServerResponse#on`. */
-	on: (event: string, listener: (chunk: unknown) => void) => void;
-
-	private checkIfEnded(): void {
-		if (this._ended)
-			throw new Error("Cannot modify response after it was sent");
-	}
-
-	/** Set the numeric HTTP status code. */
-	status(status: number): LithiaResponse {
-		this.checkIfEnded();
-		if (status < 100 || status > 599)
-			throw new Error("Invalid HTTP status code");
-		this.res.statusCode = status;
-		return this;
-	}
-
-	/** Return a copy of currently set headers. */
-	headers(): Readonly<OutgoingHttpHeaders> {
-		return this.res.getHeaders();
-	}
-
-	/** Replace multiple headers at once. */
-	setHeaders(headers: OutgoingHttpHeaders): LithiaResponse {
-		this.checkIfEnded();
-
-		Object.entries(headers).forEach(([k, v]) => {
-			this.res.setHeader(k, v as any);
-		});
-
-		return this;
-	}
-
-	/** Set a single header. */
-	addHeader(name: string, value: string | number | string[]): LithiaResponse {
-		this.checkIfEnded();
-		this.res.setHeader(name, value as any);
-		return this;
-	}
-
-	/** Remove a header if present. */
-	removeHeader(name: string): LithiaResponse {
-		this.checkIfEnded();
-		this.res.removeHeader(name);
-		return this;
-	}
-
-	/** End the response without a body. */
-	end(): void {
-		this.checkIfEnded();
-		this.res.end();
-		this._ended = true;
-	}
-
-	/** Send an object as JSON. Sets `Content-Type: application/json`. */
-	json(obj: object): void {
-		this.checkIfEnded();
-		try {
-			const body = JSON.stringify(obj);
-			this.res.setHeader("Content-Type", "application/json; charset=utf-8");
-			this.res.end(body);
-		} catch (err) {
-			logger.error("Failed to serialize JSON response:", err);
-			this.res.statusCode = 500;
-			this.res.end("Internal Server Error");
-		} finally {
-			this._ended = true;
-		}
-	}
-
-	/** Send an HTTP redirect to `url`. */
-	redirect(url: string, status = 302): void {
-		this.checkIfEnded();
-		this.status(status).addHeader("Location", url).end();
-	}
-
-	/**
-	 * Send a response body.
-	 * - `Buffer` bodies are sent as `application/octet-stream`.
-	 * - Objects are serialized as JSON.
-	 * - Primitives are sent as text/plain.
-	 */
-	send(data?: unknown): void {
-		// Set cookies first
-		if (this._cookies.length > 0) {
-			const existing = (this.res.getHeader("Set-Cookie") as string[]) || [];
-			const serialized = this._cookies.map((c) =>
-				serializeCookie(c.name, c.value, c.options as any),
-			);
-			this.res.setHeader("Set-Cookie", [...existing, ...serialized]);
-			this._cookies = [];
-		}
-
-		this.checkIfEnded();
-		try {
-			if (data === undefined || data === null) {
-				this.end();
-				return;
-			}
-
-			if (Buffer.isBuffer(data)) {
-				if (!this.res.getHeader("Content-Type"))
-					this.addHeader("Content-Type", "application/octet-stream");
-				this.res.end(data);
-			} else if (typeof data === "object") {
-				this.json(data as object);
-			} else {
-				if (!this.res.getHeader("Content-Type"))
-					this.addHeader("Content-Type", "text/plain; charset=utf-8");
-				this.res.end(String(data));
-			}
-		} finally {
-			this._ended = true;
-		}
-	}
-
-	/** Queue a cookie to be set on the response. */
-	cookie(
-		name: string,
-		value: string,
-		options: CookieOptions = {},
-	): LithiaResponse {
-		this.checkIfEnded();
-		this._cookies.push({ name, value, options });
-		return this;
-	}
-
-	/** Clear a cookie by setting it with an expired date. */
-	clearCookie(name: string, options: CookieOptions = {}): LithiaResponse {
-		this.checkIfEnded();
-		return this.cookie(name, "", { ...options, expires: new Date(0) });
-	}
-
-	/** Send a static file from disk. `opts.root` may be used to resolve relative paths. */
-	sendFile(filePath: string, opts: { root?: string } = {}): void {
-		this.checkIfEnded();
-		try {
-			const full = opts.root ? join(opts.root, filePath) : filePath;
-			const stats = statSync(full);
-			if (!stats.isFile()) throw new Error("Not a file");
-
-			this.addHeader("Content-Length", String(stats.size));
-			const stream = createReadStream(full);
-			stream.pipe(this.res);
-			stream.on("error", () =>
-				this.status(404).send({ error: "File not found" }),
-			);
-		} catch {
-			this.status(404).send({ error: "File not found" });
-		} finally {
-			this._ended = true;
-		}
-	}
-}