spooder 3.2.8 → 4.0.1

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "spooder",
 	"type": "module",
-	"version": "3.2.8",
+	"version": "4.0.1",
 	"exports": {
 		".": {
 			"bun": "./src/api.ts",
@@ -15,8 +15,5 @@
 	},
 	"bin": {
 		"spooder": "./src/cli.ts"
-	},
-	"dependencies": {
-		"@octokit/app": "^13.1.5"
 	}
 }

package/src/api.d.ts

@@ -1,5 +1,9 @@
+/// <reference types="node" />
 /// <reference types="bun-types" />
 /// <reference types="node" />
+/// <reference types="node" />
+import fs from 'node:fs/promises';
+import { Blob } from 'node:buffer';
 export declare class ErrorWithMetadata extends Error {
     metadata: Record<string, unknown>;
     constructor(message: string, metadata: Record<string, unknown>);
@@ -7,29 +11,53 @@ export declare class ErrorWithMetadata extends Error {
 }
 export declare function panic(err_message_or_obj: string | object, ...err: object[]): Promise<void>;
 export declare function caution(err_message_or_obj: string | object, ...err: object[]): Promise<void>;
-type HandlerReturnType = any;
+export declare function template_sub_file(template_file: string, replacements: Record<string, string>): Promise<string>;
+export declare function template_sub(template: string, replacements: Record<string, string>): string;
+export declare function generate_hash_subs(length?: number, prefix?: string): Promise<Record<string, string>>;
+type CookieOptions = {
+    same_site?: 'Strict' | 'Lax' | 'None';
+    secure?: boolean;
+    http_only?: boolean;
+    path?: string;
+    expires?: number;
+    encode?: boolean;
+};
+export declare function set_cookie(res: Response, name: string, value: string, options?: CookieOptions): void;
+export declare function get_cookies(source: Request | Response, decode?: boolean): Record<string, string>;
+export declare function apply_range(file: BunFile, request: Request): BunFile;
+type Resolvable<T> = T | Promise<T>;
+type PromiseType<T extends Promise<any>> = T extends Promise<infer U> ? U : never;
+type JsonPrimitive = string | number | boolean | null;
+type JsonArray = JsonSerializable[];
+interface JsonObject {
+    [key: string]: JsonSerializable;
+}
+interface ToJson {
+    toJSON(): any;
+}
+type JsonSerializable = JsonPrimitive | JsonObject | JsonArray | ToJson;
+type HandlerReturnType = Resolvable<string | number | BunFile | Response | JsonSerializable | Blob>;
 type RequestHandler = (req: Request, url: URL) => HandlerReturnType;
-type ErrorHandler = (err: Error) => Response;
+type WebhookHandler = (payload: JsonSerializable) => HandlerReturnType;
+type ErrorHandler = (err: Error, req: Request, url: URL) => Response;
 type DefaultHandler = (req: Request, status_code: number) => HandlerReturnType;
 type StatusCodeHandler = (req: Request) => HandlerReturnType;
-type DirOptions = {
-    ignoreHidden?: boolean;
-    index?: string;
-};
-/** Built-in route handler for redirecting to a different URL. */
-export declare function route_location(redirect_url: string): (req: Request, url: URL) => Response;
-export declare const ServerStop: {
-    /** Stops the server immediately, terminating in-flight requests. */
-    IMMEDIATE: number;
-    /** Stops the server after all in-flight requests have completed. */
-    GRACEFUL: number;
+type ServerSentEventClient = {
+    message: (message: string) => void;
+    event: (event_name: string, message: string) => void;
+    close: () => void;
+    closed: Promise<void>;
 };
-type ServerStop = typeof ServerStop[keyof typeof ServerStop];
+type ServerSentEventHandler = (req: Request, url: URL, client: ServerSentEventClient) => void;
+type BunFile = ReturnType<typeof Bun.file>;
+type DirStat = PromiseType<ReturnType<typeof fs.stat>>;
+type DirHandler = (file_path: string, file: BunFile, stat: DirStat, request: Request, url: URL) => HandlerReturnType;
 export declare function serve(port: number): {
     /** Register a handler for a specific route. */
     route: (path: string, handler: RequestHandler) => void;
     /** Serve a directory for a specific route. */
-    dir: (path: string, dir: string, options?: DirOptions) => void;
+    dir: (path: string, dir: string, handler?: DirHandler) => void;
+    webhook: (secret: string, path: string, handler: WebhookHandler) => void;
     /** Register a default handler for all status codes. */
     default: (handler: DefaultHandler) => void;
     /** Register a handler for a specific status code. */
@@ -37,6 +65,8 @@ export declare function serve(port: number): {
     /** Register a handler for uncaught errors. */
     error: (handler: ErrorHandler) => void;
     /** Stops the server. */
-    stop: (method?: ServerStop) => void;
+    stop: (immediate?: boolean) => void;
+    /** Register a handler for server-sent events. */
+    sse: (path: string, handler: ServerSentEventHandler) => void;
 };
 export {};

package/src/api.ts

@@ -1,7 +1,11 @@
 import { dispatch_report } from './dispatch';
+import { get_config } from './config';
 import http from 'node:http';
 import path from 'node:path';
 import fs from 'node:fs/promises';
+import { log } from './utils';
+import crypto from 'crypto';
+import { Blob } from 'node:buffer';
 
 export class ErrorWithMetadata extends Error {
 	constructor(message: string, public metadata: Record<string, unknown>) {
@@ -78,80 +82,232 @@ export async function caution(err_message_or_obj: string | object, ...err: objec
 	await handle_error('caution: ', err_message_or_obj, ...err);
 }
 
-type HandlerReturnType = any;
+export async function template_sub_file(template_file: string, replacements: Record<string, string>): Promise<string> {
+	const file = Bun.file(template_file);
+	const file_contents = await file.text();
+
+	return template_sub(file_contents, replacements);
+}
+
+export function template_sub(template: string, replacements: Record<string, string>): string {
+	let result = '';
+	let buffer = '';
+	let buffer_active = false;
+
+	const template_length = template.length;
+	for (let i = 0; i < template_length; i++) {
+		const char = template[i];
+
+		if (char === '{') {
+			buffer_active = true;
+			buffer = '';
+		} else if (char === '}') {
+			buffer_active = false;
+
+			result += replacements[buffer] ?? '{' + buffer + '}';
+
+			buffer = '';
+		} else if (buffer_active) {
+			buffer += char;
+		} else {
+			result += char;
+		}
+	}
+
+	return result;
+}
+
+export async function generate_hash_subs(length = 7, prefix = 'hash='): Promise<Record<string, string>> {
+	const cmd = ['git', 'ls-tree', '-r', 'HEAD'];
+	const process = Bun.spawn(cmd, {
+		stdout: 'pipe',
+		stderr: 'pipe'
+	});
+
+	await process.exited;
+
+	if (process.exitCode as number > 0)
+		throw new Error('generate_hash_subs() failed, `' + cmd.join(' ') + '` exited with non-zero exit code.');
+
+	const stdout = await Bun.readableStreamToText(process.stdout as ReadableStream);
+	const hash_map: Record<string, string> = {};
+
+	const regex = /([^\s]+)\s([^\s]+)\s([^\s]+)\t(.+)/g;
+	let match: RegExpExecArray | null;
+
+	let hash_count = 0;
+	while (match = regex.exec(stdout)) {
+		hash_map[prefix + match[4]] = match[3].substring(0, length);
+		hash_count++;
+	}
+
+	return hash_map;
+}
+
+type CookieOptions = {
+	same_site?: 'Strict' | 'Lax' | 'None',
+	secure?: boolean,
+	http_only?: boolean,
+	path?: string,
+	expires?: number,
+	encode?: boolean
+};
+
+export function set_cookie(res: Response, name: string, value: string, options?: CookieOptions): void {
+	let cookie = name + '=';
+	if (options !== undefined) {
+		cookie += options.encode ? encodeURIComponent(value) : value;
+
+		if (options.same_site !== undefined)
+			cookie += '; SameSite=' + options.same_site;
+
+		if (options.secure)
+			cookie += '; Secure';
+
+		if (options.http_only)
+			cookie += '; HttpOnly';
+
+		if (options.path !== undefined)
+			cookie += '; Path=' + options.path;
+
+		if (options.expires !== undefined) {
+			const date = new Date(Date.now() + options.expires);
+			cookie += '; Expires=' + date.toUTCString();
+		}
+	} else {
+		cookie += value;
+	}
+
+	res.headers.append('Set-Cookie', cookie);
+}
+
+export function get_cookies(source: Request | Response, decode: boolean = false): Record<string, string> {
+	const parsed_cookies: Record<string, string> = {};
+	const cookie_header = source.headers.get('cookie');
+
+	if (cookie_header !== null) {
+		const cookies = cookie_header.split('; ');
+		for (const cookie of cookies) {
+			const [name, value] = cookie.split('=');
+			parsed_cookies[name] = decode ? decodeURIComponent(value) : value;
+		}
+	}
+
+	return parsed_cookies;
+}
+
+export function apply_range(file: BunFile, request: Request): BunFile {
+	const range_header = request.headers.get('range');
+	if (range_header !== null) {
+		console.log(range_header);
+		const regex = /bytes=(\d*)-(\d*)/;
+		const match = range_header.match(regex);
+
+		if (match !== null) {
+			const start = parseInt(match[1]);
+			const end = parseInt(match[2]);
+
+			const start_is_nan = isNaN(start);
+			const end_is_nan = isNaN(end);
+
+			if (start_is_nan && end_is_nan)
+				return file;
+
+			file = file.slice(start_is_nan ? file.size - end : start, end_is_nan || start_is_nan ? undefined : end);
+		}
+	}
+	return file;
+}
+
+// Resolvable represents T that is both T or a promise resolving to T.
+type Resolvable<T> = T | Promise<T>;
+
+// PromiseType infers the resolved type of a promise (T) or just T if not a promise.
+type PromiseType<T extends Promise<any>> = T extends Promise<infer U> ? U : never;
+
+// The following types cover JSON serializable objects/classes.
+type JsonPrimitive = string | number | boolean | null;
+type JsonArray = JsonSerializable[];
+
+interface JsonObject {
+	[key: string]: JsonSerializable;
+}
+
+interface ToJson {
+	toJSON(): any;
+}
+
+type JsonSerializable = JsonPrimitive | JsonObject | JsonArray | ToJson;
+
+type HandlerReturnType = Resolvable<string | number | BunFile | Response | JsonSerializable | Blob>;
 type RequestHandler = (req: Request, url: URL) => HandlerReturnType;
-type ErrorHandler = (err: Error) => Response;
+type WebhookHandler = (payload: JsonSerializable) => HandlerReturnType;
+type ErrorHandler = (err: Error, req: Request, url: URL) => Response;
 type DefaultHandler = (req: Request, status_code: number) => HandlerReturnType;
 type StatusCodeHandler = (req: Request) => HandlerReturnType;
 
-type DirOptions = {
-	ignoreHidden?: boolean;
-	index?: string;
-};
-
-/** Built-in route handler for redirecting to a different URL. */
-export function route_location(redirect_url: string) {
-	return (req: Request, url: URL) => {
-		return new Response(null, {
-			status: 301,
-			headers: {
-				Location: redirect_url
-			}
-		});
-	};
+type ServerSentEventClient = {
+	message: (message: string) => void;
+	event: (event_name: string, message: string) => void;
+	close: () => void;
+	closed: Promise<void>;
 }
 
-function route_directory(route_path: string, dir: string, options: DirOptions): RequestHandler {
-	const ignore_hidden = options.ignoreHidden ?? true;
+type ServerSentEventHandler = (req: Request, url: URL, client: ServerSentEventClient) => void;
+
+type BunFile = ReturnType<typeof Bun.file>;
+type DirStat = PromiseType<ReturnType<typeof fs.stat>>;
+
+type DirHandler = (file_path: string, file: BunFile, stat: DirStat, request: Request, url: URL) => HandlerReturnType;
+
+function default_directory_handler(file_path: string, file: BunFile, stat: DirStat, request: Request): HandlerReturnType {
+	// ignore hidden files by default, return 404 to prevent file sniffing
+	if (path.basename(file_path).startsWith('.'))
+		return 404; // Not Found
 
+	if (stat.isDirectory())
+		return 401; // Unauthorized
+
+	return apply_range(file, request);
+}
+
+function route_directory(route_path: string, dir: string, handler: DirHandler): RequestHandler {
 	return async (req: Request, url: URL) => {
 		const file_path = path.join(dir, url.pathname.slice(route_path.length));
 
-		if (ignore_hidden && path.basename(file_path).startsWith('.'))
-			return 404;
-
 		try {
 			const file_stat = await fs.stat(file_path);
+			const bun_file = Bun.file(file_path);
 
-			if (file_stat.isDirectory()) {
-				if (options.index !== undefined) {
-					const index_path = path.join(file_path, options.index);
-					const index = Bun.file(index_path);
-
-					if (index.size !== 0)
-						return index;
-				}
-				return 401;
-			}
-
-			return Bun.file(file_path);
+			return handler(file_path, bun_file, file_stat, req, url);
 		} catch (e) {
 			const err = e as NodeJS.ErrnoException;
 			if (err?.code === 'ENOENT')
-				return 404;
+				return 404; // Not Found
 
-			return 500;
+			return 500; // Internal Server Error
 		}
 	};
 }
 
-export const ServerStop = {
-	/** Stops the server immediately, terminating in-flight requests. */
-	IMMEDIATE: 0,
+function format_query_parameters(search_params: URLSearchParams): string {
+	let result_parts = [];
 
-	/** Stops the server after all in-flight requests have completed. */
-	GRACEFUL: 1
-};
+	for (let [key, value] of search_params)
+		result_parts.push(`${key}: ${value}`);
 
-type ServerStop = typeof ServerStop[keyof typeof ServerStop];
+	return '{ ' + result_parts.join(', ') + ' }';
+}
 
-function print_request_info(req: Request, res: Response, url: URL): Response {
-	console.log(`[${res.status}] ${req.method} ${url.pathname}`);
+function print_request_info(req: Request, res: Response, url: URL, request_start: number): Response {
+	const request_time = Date.now() - request_start;
+	const search_params = url.search.length > 0 ? format_query_parameters(url.searchParams) : '';
+	console.log(`[${res.status}] ${req.method} ${url.pathname} ${search_params} [${request_time}ms]`);
 	return res;
 }
 
 export function serve(port: number) {
-	const routes = new Map<string[], RequestHandler>();
+	const routes = new Array<[string[], RequestHandler]>();
 	const handlers = new Map<number, StatusCodeHandler>();
 	
 	let error_handler: ErrorHandler | undefined;
@@ -161,13 +317,16 @@ export function serve(port: number) {
 		if (response instanceof Promise)
 			response = await response;
 
+		if (response === undefined || response === null)
+			throw new Error('HandlerReturnType cannot resolve to undefined or null');
+
 		// Pre-assembled responses are returned as-is.
 		if (response instanceof Response)
 			return response;
 	
 		// Content-type/content-length are automatically set for blobs.
 		if (response instanceof Blob)
-			return new Response(response, { status: status_code });
+			return new Response(response as Blob, { status: status_code });
 
 		// Status codes can be returned from some handlers.
 		if (return_status_code && typeof response === 'number')
@@ -175,104 +334,134 @@ export function serve(port: number) {
 
 		// This should cover objects, arrays, etc.
 		if (typeof response === 'object')
-			return new Response(JSON.stringify(response), { status: status_code, headers: { 'Content-Type': 'application/json' } });
+			return Response.json(response, { status: status_code });
 	
-		return new Response(String(response), { status: status_code })
+		return new Response(String(response), { status: status_code, headers: { 'Content-Type': 'text/html' } });
 	}
 
-	const server = Bun.serve({
-		port,
-		development: false,
-
-		async fetch(req: Request): Promise<Response> {
-			const url = new URL(req.url);
-			let status_code = 200;
-
-			try {
-				const route_array = url.pathname.split('/').filter(e => !(e === '..' || e === '.'));
-				let handler: RequestHandler | undefined;
+	async function generate_response(req: Request, url: URL): Promise<Response> {
+		let status_code = 200;
 
-				for (const [path, route_handler] of routes) {
-					const is_trailing_wildcard = path[path.length - 1] === '*';
-					if (!is_trailing_wildcard && path.length !== route_array.length)
-						continue;
+		try {
+			const route_array = url.pathname.split('/').filter(e => !(e === '..' || e === '.'));
+			let handler: RequestHandler | undefined;
 
-					let match = true;
-					for (let i = 0; i < path.length; i++) {
-						const path_part = path[i];
+			for (const [path, route_handler] of routes) {
+				const is_trailing_wildcard = path[path.length - 1] === '*';
+				if (!is_trailing_wildcard && path.length !== route_array.length)
+					continue;
 
-						if (path_part === '*')
-							continue;
+				let match = true;
+				for (let i = 0; i < path.length; i++) {
+					const path_part = path[i];
 
-						if (path_part.startsWith(':')) {
-							url.searchParams.append(path_part.slice(1), route_array[i]);
-							continue;
-						}
+					if (path_part === '*')
+						continue;
 
-						if (path_part !== route_array[i]) {
-							match = false;
-							break;
-						}
+					if (path_part.startsWith(':')) {
+						url.searchParams.append(path_part.slice(1), route_array[i]);
+						continue;
 					}
 
-					if (match) {
-						handler = route_handler;
+					if (path_part !== route_array[i]) {
+						match = false;
 						break;
 					}
 				}
 
-				// Check for a handler for the route.
-				if (handler !== undefined) {
-					const response = await resolve_handler(handler(req, url), status_code, true);
-					if (response instanceof Response)
-						return print_request_info(req, response, url);
-
-					// If the handler returned a status code, use that instead.
-					status_code = response;
-				} else {
-					status_code = 404;
+				if (match) {
+					handler = route_handler;
+					break;
 				}
+			}
 
-				// Fallback to checking for a handler for the status code.
-				const status_code_handler = handlers.get(status_code);
-				if (status_code_handler !== undefined) {
-					const response = await resolve_handler(status_code_handler(req), status_code);
-					if (response instanceof Response)
-						return print_request_info(req, response, url);
-				}
+			// Check for a handler for the route.
+			if (handler !== undefined) {
+				const response = await resolve_handler(handler(req, url), status_code, true);
+				if (response instanceof Response)
+					return response;
 
-				// Fallback to the default handler, if any.
-				if (default_handler !== undefined) {
-					const response = await resolve_handler(default_handler(req, status_code), status_code);
-					if (response instanceof Response)
-						return print_request_info(req, response, url);
-				}
+				// If the handler returned a status code, use that instead.
+				status_code = response;
+			} else {
+				status_code = 404;
+			}
 
-				// Fallback to returning a basic response.
-				return print_request_info(req, new Response(http.STATUS_CODES[status_code], { status: status_code }), url);
-			} catch (e) {
-				if (error_handler !== undefined)
-					return print_request_info(req, error_handler(e as Error), url);
+			// Fallback to checking for a handler for the status code.
+			const status_code_handler = handlers.get(status_code);
+			if (status_code_handler !== undefined) {
+				const response = await resolve_handler(status_code_handler(req), status_code);
+				if (response instanceof Response)
+					return response;
+			}
 
-				return print_request_info(req, new Response(http.STATUS_CODES[500], { status: 500 }), url);
+			// Fallback to the default handler, if any.
+			if (default_handler !== undefined) {
+				const response = await resolve_handler(default_handler(req, status_code), status_code);
+				if (response instanceof Response)
+					return response;
 			}
+
+			// Fallback to returning a basic response.
+			return new Response(http.STATUS_CODES[status_code], { status: status_code });
+		} catch (e) {
+			if (error_handler !== undefined)
+				return error_handler(e as Error, req, url);
+
+			return new Response(http.STATUS_CODES[500], { status: 500 });
+		}
+	}
+
+	const server = Bun.serve({
+		port,
+		development: false,
+
+		async fetch(req: Request): Promise<Response> {
+			const url = new URL(req.url);
+			const request_start = Date.now();
+
+			const response = await generate_response(req, url);
+			return print_request_info(req, response, url, request_start);
 		}
 	});
 
-	console.log(`Server started on port ${port}`);
+	log('server started on port ' + port);
 
 	return {
 		/** Register a handler for a specific route. */
 		route: (path: string, handler: RequestHandler): void => {
-			routes.set(path.split('/'), handler);
+			routes.push([path.split('/'), handler]);
 		},
 
 		/** Serve a directory for a specific route. */
-		dir: (path: string, dir: string, options?: DirOptions): void => {
+		dir: (path: string, dir: string, handler?: DirHandler): void => {
 			if (path.endsWith('/'))
 				path = path.slice(0, -1);
 
-			routes.set([...path.split('/'), '*'], route_directory(path, dir, options ?? {}));
+			routes.push([[...path.split('/'), '*'], route_directory(path, dir, handler ?? default_directory_handler)]);
+		},
+
+		webhook: (secret: string, path: string, handler: WebhookHandler): void => {
+			routes.push([path.split('/'), async (req: Request, url: URL) => {
+				if (req.method !== 'POST')
+					return 405; // Method Not Allowed
+
+				if (req.headers.get('Content-Type') !== 'application/json')
+					return 400; // Bad Request
+
+				const signature = req.headers.get('X-Hub-Signature-256');
+				if (signature === null)
+					return 401; // Unauthorized
+
+				const body = await req.json() as JsonSerializable;
+				const hmac = crypto.createHmac('sha256', secret);
+				hmac.update(JSON.stringify(body));
+
+				if (!crypto.timingSafeEqual(Buffer.from(signature), Buffer.from('sha256=' + hmac.digest('hex'))))
+					return 401; // Unauthorized
+
+				return handler(body);
+			}]);
 		},
 
 		/** Register a default handler for all status codes. */
@@ -291,8 +480,60 @@ export function serve(port: number) {
 		},
 
 		/** Stops the server. */
-		stop: (method: ServerStop = ServerStop.GRACEFUL): void => {
-			server.stop(method === ServerStop.IMMEDIATE);
+		stop: (immediate = false): void => {
+			server.stop(immediate);
+		},
+
+		/** Register a handler for server-sent events. */
+		sse: (path: string, handler: ServerSentEventHandler) => {
+			routes.push([path.split('/'), (req: Request, url: URL) => {			
+				let stream_controller: ReadableStreamDirectController;
+				let close_resolver: () => void;
+
+				function close_controller() {
+					stream_controller?.close();
+					close_resolver?.();
+				}
+
+				const queue = Array<string>();
+				const stream = new ReadableStream({
+					type: 'direct',
+
+					async pull(controller: ReadableStreamDirectController) {
+						stream_controller = controller;
+						while (!req.signal.aborted) {
+							if (queue.length > 0) {
+								controller.write(queue.shift()!);
+								controller.flush();
+							} else {
+								await Bun.sleep(50);
+							}
+						}
+					}
+				});
+
+				const closed = new Promise<void>(resolve => close_resolver = resolve);
+				req.signal.onabort = close_controller;
+
+				handler(req, url, {
+					message: (message: string) => {
+						queue.push('data:' + message + '\n\n');
+					},
+
+					event: (event_name: string, message: string) => {
+						queue.push('event:' + event_name + '\ndata:' + message + '\n\n');
+					},
+
+					close: close_controller,
+					closed
+				});
+				
+				return new Response(stream, { headers: {
+					'Content-Type': 'text/event-stream',
+					'Cache-Control': 'no-cache',
+					'Connection': 'keep-alive'
+				}});
+			}]);
 		}
 	}
 }