bun-router 0.7.3 → 0.7.4-experimental.11

package/lib/http/status.ts

@@ -1,66 +1,66 @@
 const httpStatusCodes: { [key: number]: string } = {
-    100: 'Continue',
-    101: 'Switching Protocols',
-    102: 'Processing',
-    103: 'Early Hints',
-    200: 'OK',
-    201: 'Created',
-    202: 'Accepted',
-    203: 'Non-Authoritative Information',
-    204: 'No Content',
-    205: 'Reset Content',
-    206: 'Partial Content',
-    207: 'Multi-Status',
-    208: 'Already Reported',
-    226: 'IM Used',
-    300: 'Multiple Choices',
-    301: 'Moved Permanently',
-    302: 'Found',
-    303: 'See Other',
-    304: 'Not Modified',
-    305: 'Use Proxy',
-    307: 'Temporary Redirect',
-    308: 'Permanent Redirect',
-    400: 'Bad Request',
-    401: 'Unauthorized',
-    402: 'Payment Required',
-    403: 'Forbidden',
-    404: 'Not Found',
-    405: 'Method Not Allowed',
-    406: 'Not Acceptable',
-    407: 'Proxy Authentication Required',
-    408: 'Request Timeout',
-    409: 'Conflict',
-    410: 'Gone',
-    411: 'Length Required',
-    412: 'Precondition Failed',
-    413: 'Payload Too Large',
-    414: 'URI Too Long',
-    415: 'Unsupported Media Type',
-    416: 'Range Not Satisfiable',
-    417: 'Expectation Failed',
-    418: "I'm a Teapot",
-    421: 'Misdirected Request',
-    422: 'Unprocessable Entity',
-    423: 'Locked',
-    424: 'Failed Dependency',
-    425: 'Too Early',
-    426: 'Upgrade Required',
-    428: 'Precondition Required',
-    429: 'Too Many Requests',
-    431: 'Request Header Fields Too Large',
-    451: 'Unavailable For Legal Reasons',
-    500: 'Internal Server Error',
-    501: 'Not Implemented',
-    502: 'Bad Gateway',
-    503: 'Service Unavailable',
-    504: 'Gateway Timeout',
-    505: 'HTTP Version Not Supported',
-    506: 'Variant Also Negotiates',
-    507: 'Insufficient Storage',
-    508: 'Loop Detected',
-    510: 'Not Extended',
-    511: 'Network Authentication Required',
-  };
+	100: 'Continue',
+	101: 'Switching Protocols',
+	102: 'Processing',
+	103: 'Early Hints',
+	200: 'OK',
+	201: 'Created',
+	202: 'Accepted',
+	203: 'Non-Authoritative Information',
+	204: 'No Content',
+	205: 'Reset Content',
+	206: 'Partial Content',
+	207: 'Multi-Status',
+	208: 'Already Reported',
+	226: 'IM Used',
+	300: 'Multiple Choices',
+	301: 'Moved Permanently',
+	302: 'Found',
+	303: 'See Other',
+	304: 'Not Modified',
+	305: 'Use Proxy',
+	307: 'Temporary Redirect',
+	308: 'Permanent Redirect',
+	400: 'Bad Request',
+	401: 'Unauthorized',
+	402: 'Payment Required',
+	403: 'Forbidden',
+	404: 'Not Found',
+	405: 'Method Not Allowed',
+	406: 'Not Acceptable',
+	407: 'Proxy Authentication Required',
+	408: 'Request Timeout',
+	409: 'Conflict',
+	410: 'Gone',
+	411: 'Length Required',
+	412: 'Precondition Failed',
+	413: 'Payload Too Large',
+	414: 'URI Too Long',
+	415: 'Unsupported Media Type',
+	416: 'Range Not Satisfiable',
+	417: 'Expectation Failed',
+	418: 'I\'m a Teapot',
+	421: 'Misdirected Request',
+	422: 'Unprocessable Entity',
+	423: 'Locked',
+	424: 'Failed Dependency',
+	425: 'Too Early',
+	426: 'Upgrade Required',
+	428: 'Precondition Required',
+	429: 'Too Many Requests',
+	431: 'Request Header Fields Too Large',
+	451: 'Unavailable For Legal Reasons',
+	500: 'Internal Server Error',
+	501: 'Not Implemented',
+	502: 'Bad Gateway',
+	503: 'Service Unavailable',
+	504: 'Gateway Timeout',
+	505: 'HTTP Version Not Supported',
+	506: 'Variant Also Negotiates',
+	507: 'Insufficient Storage',
+	508: 'Loop Detected',
+	510: 'Not Extended',
+	511: 'Network Authentication Required',
+};
 
-  export { httpStatusCodes }
+export { httpStatusCodes };

package/lib/logger/color.ts

@@ -1,36 +1,36 @@
 const Colors: Record<string,string> = {
-    reset: "\x1b[0m",
+	reset: '\x1b[0m',
   
-    // foreground
-    black: "\x1b[30m",
-    red: "\x1b[31m",
-    green: "\x1b[32m",
-    yellow: "\x1b[33m",
-    blue: "\x1b[34m",
-    magenta: "\x1b[35m",
-    cyan: "\x1b[36m",
-    white: "\x1b[37m",
+	// foreground
+	black: '\x1b[30m',
+	red: '\x1b[31m',
+	green: '\x1b[32m',
+	yellow: '\x1b[33m',
+	blue: '\x1b[34m',
+	magenta: '\x1b[35m',
+	cyan: '\x1b[36m',
+	white: '\x1b[37m',
   
-    // background
-    bgBlack: "\x1b[40m",
-    bgRed: "\x1b[41m",
-    bgGreen: "\x1b[42m",
-    bgYellow: "\x1b[43m",
-    bgBlue: "\x1b[44m",
-    bgMagenta: "\x1b[45m",
-    bgCyan: "\x1b[46m",
-    bgWhite: "\x1b[47m",
-  } as const;
+	// background
+	bgBlack: '\x1b[40m',
+	bgRed: '\x1b[41m',
+	bgGreen: '\x1b[42m',
+	bgYellow: '\x1b[43m',
+	bgBlue: '\x1b[44m',
+	bgMagenta: '\x1b[45m',
+	bgCyan: '\x1b[46m',
+	bgWhite: '\x1b[47m',
+} as const;
 
   
 
 function color(foreground: string, background: string, message: string) {
-  const _foreground = Colors[foreground];
-  const _background = Colors[background];
-  const reset = Colors.reset;
-  return `${_foreground}${_background}${message}${reset}`;
+	const _foreground = Colors[foreground];
+	const _background = Colors[background];
+	const reset = Colors.reset;
+	return `${_foreground}${_background}${message}${reset}`;
 }
 
 
   
-export { color }
+export { color };

package/lib/logger/logger.d.ts

@@ -5,4 +5,4 @@ type BunLogger = {
     message: (message: string) => void,
 }
 
-export { BunLogger }
+export { BunLogger };

package/lib/logger/logger.ts

@@ -1,5 +1,4 @@
 import { color } from './color';
-import { BunLogger } from './logger.d';
 
 
 const TITLE = `
@@ -8,87 +7,104 @@ _                          _
 | . | | |   |  |  _| . | | |  _| -_|  _|
 |___|___|_|_|  |_| |___|___|_| |___|_|  
                                                                                     
-`
-const VERSION = '0.7.1';
-const Logger = (): BunLogger => {
-    return {
-        info: async (statusCode: number, routePath: string, method: string, message?: string) => {
-            const { stamp } = timestamp((new Date(Date.now())));
-            const source = color('green', 'bgBlack', `[bun-router ${stamp}]`);
-            const rp = color('white', 'bgBlack', routePath);
-
-            message = `${source}: ${setColor(statusCode)}: ${rp} ${(method === 'GET') ? '->' : '<-'} ${method}${ message ?? ''}\n`
-
-            await Bun.write(Bun.stdout, message);
-
-        },
-        error: async (statusCode: number, routePath: string, method: string, error: Error) => {
-            const { stamp } = timestamp((new Date(Date.now())));
-            const source = color('black', 'bgRed', `[error ${stamp}]`);
-            const rp = color('white', 'bgBlack', routePath);
-
-            const message = `${source}: ${setColor(statusCode)}: ${rp} ${(method === 'GET') ? '->' : '<-'} ${error.message}\n`
-
-            await Bun.write(Bun.stdout, message);
-        },
-        warn: async (message: string) => {
-            const { stamp } = timestamp((new Date(Date.now())));
-            const source = color('black', 'bgYellow', `[warning ${stamp}]`);
-            const messageColor = color('yellow', 'bgBlack', message);
-
-            message = `${source} : ${messageColor}\n`;
-
-            await Bun.write(Bun.stdout, message);
-        },
-        message: async (message: string) => {
-            const { stamp } = timestamp((new Date(Date.now())));
-            const source = color('black', 'bgCyan', `[message ${stamp}]`);
-            const messageColor = color('yellow', 'bgBlack', message);
-
-            message = `${source}: ${messageColor}\n`;
-
-            await Bun.write(Bun.stdout, message);
-        },
-    }
-}
+`;
+const VERSION = '0.7.4-experimental.11';
+const Logger = (enableFileLogging: boolean) => {
+	const file = Bun.file('bun-router.log');
+	const writer = enableFileLogging ? file.writer() : null;
+
+	function stripAnsi(str: string) {
+		const ansiRegex = /\u001B\[(?:[0-9]{1,3}(?:;[0-9]{1,3})*)?[m|K]/g;
+		return str.replace(ansiRegex, '');
+	}
+
+	async function write(message: string) {
+		await Bun.write(Bun.stdout, message);
+		if (writer) {
+			writer.write(stripAnsi(message));
+			writer.flush();
+		}
+	}
+
+	return {
+		info: async (statusCode: number, routePath: string, method: string, message?: string) => {
+			const { stamp } = timestamp((new Date(Date.now())));
+			const source = color('green', 'bgBlack', `[bun-router ${stamp}]`);
+			const rp = color('white', 'bgBlack', routePath);
+
+			message = `${source}: ${setColor(statusCode)}: ${rp} ${(method === 'GET') ? ' ->' : ' <-'} ${method} ${ message ?? ''}\n`;
+
+			await write(message);
+
+		},
+		error: async (statusCode: number, routePath: string, method: string, error: Error) => {
+			const { stamp } = timestamp((new Date(Date.now())));
+			const source = color('black', 'bgRed', `[error ${stamp}]`);
+			const rp = color('white', 'bgBlack', routePath);
+
+			const message = `${source}: ${setColor(statusCode)}: ${rp} ${(method === 'GET') ? ' -> ' : ' <-'} ${error.message}\n`;
+
+			await write(message);
+		},
+		warn: async (message: string) => {
+			const { stamp } = timestamp((new Date(Date.now())));
+			const source = color('black', 'bgYellow', `[warning ${stamp}]`);
+			const messageColor = color('yellow', 'bgBlack', message);
+
+			message = `${source} : ${messageColor}\n`;
+
+			await write(message);
+		},
+		message: async (message: string) => {
+			const { stamp } = timestamp((new Date(Date.now())));
+			const source = color('black', 'bgCyan', `[message ${stamp}]`);
+			const messageColor = color('yellow', 'bgBlack', message);
+
+			message = `${source}: ${messageColor}\n`;
+
+			await write(message);
+		},
+
+	};
+};
 
 function timestamp(date: Date) {
-    const month = pad(date.getMonth());
-    const day = pad(date.getDate());
-    const hour = pad(date.getHours());
-    const minute = pad(date.getMinutes());
-    const seconds = pad(date.getSeconds());
-    const stamp = `${hour}:${minute}:${seconds}`;
-
-    return {month, day, hour, minute, stamp};
+	const month = pad(date.getMonth());
+	const day = pad(date.getDate());
+	const hour = pad(date.getHours());
+	const minute = pad(date.getMinutes());
+	const seconds = pad(date.getSeconds());
+	const stamp = `${hour}:${minute}:${seconds}`;
+
+	return {month, day, hour, minute, stamp};
 }
 
 function setColor(n: number, text?: string){
-    const s = ` [${String(n)}${text ?? ''}] `;
+	const s = ` [${String(n)}${text ?? ''}] `;
 
-    if (n < 100) return color('black', 'bgYellow', s);
-    else if (n >= 100 && n < 200) return color('black', 'bgCyan', s);
-    else if (n >= 200 && n < 300) return color('black', 'bgGreen', s);
-    else if (n >= 300 && n < 400) return color('black', 'bgRed', s);
-    else if (n >= 400 && n < 500) return color('black', 'bgRed', s);
-    else if (n >= 500) return color('white', 'bgRed', s);
+	if (n < 100) return color('black', 'bgYellow', s);
+	else if (n >= 100 && n < 200) return color('black', 'bgCyan', s);
+	else if (n >= 200 && n < 300) return color('black', 'bgGreen', s);
+	else if (n >= 300 && n < 400) return color('black', 'bgRed', s);
+	else if (n >= 400 && n < 500) return color('black', 'bgRed', s);
+	else if (n >= 500) return color('white', 'bgRed', s);
 
-    return color('white', 'bgBlack', `[${s}]`).trim();
+	return color('white', 'bgBlack', `[${s}]`).trim();
 }
 
 function startMessage(port: number | string) {
-    const { stamp } = timestamp((new Date(Date.now())));
-    const source = color('green', 'bgBlack', `[bun-router ${stamp}]`)
-    const portColor = color('green', 'bgBlack', String(port));
-    const msg = `${source}: Starting Server on :${portColor}\n`;
-    const version = color('red', 'bgBlack', `v${VERSION}\n`);
-
-    Bun.write(Bun.stdout, TITLE + '\n' + version);
-    Bun.write(Bun.stdout, msg);
+	const { stamp } = timestamp((new Date(Date.now())));
+	const source = color('green', 'bgBlack', `[bun-router ${stamp}]`);
+	const portColor = color('green', 'bgBlack', String(port));
+	const msg = `${source}: Starting Server on :${portColor}\n`;
+	const version = color('red', 'bgBlack', `v${VERSION}\n`);
+
+	Bun.write(Bun.stdout, TITLE + '\n' + version);
+	Bun.write(Bun.stdout, msg);
 }
 
 function pad(n: number) {
-    return String(n).padStart(2, '0');
+	return String(n).padStart(2, '0');
 }
 
-export { Logger, startMessage }
+export { Logger, startMessage };

package/lib/router/context.ts

@@ -1,51 +1,64 @@
-import { Route, Context } from "./router.d";
-import { Logger } from "../..";
-import { http } from "./router";
-
-async function createContext(path: string, route: Route, request: Request): Promise<Context> {
-    const params = extractParams(path, route);
-    const query = new URLSearchParams(path);
-    const formData = isMultiPartForm(request.headers) ? await request.formData() : new FormData();
-
-    return Promise.resolve({
-        params,
-        request,
-        query,
-        formData,
-        logger: Logger(),
-        json: (statusCode: number, data: any) => http.json(statusCode, data),
-    });
+/* eslint-disable  @typescript-eslint/no-explicit-any */
+import { Route, Context } from './router.d';
+import { renderToReadableStream } from 'react-dom/server';
+import { Logger } from '../logger/logger';
+import { http } from './router';
+import { ReactNode } from 'react';
+
+// createContext creates a context object
+async function createContext(path: string, route: Route, request: Request, enableFileLogging: boolean): Promise<Context> {
+	const query = new URLSearchParams(path);
+	const params = extractParams(path, route);
+	const formData = isMultiPartForm(request.headers) ? await request.formData() : new FormData();
+
+	return Promise.resolve({
+		params,
+		request,
+		query,
+		formData,
+		logger: Logger(enableFileLogging),
+		json: (statusCode: number, data: any) => http.json(statusCode, data),
+		render: async (component: ReactNode) => await renderStream(component),
+	});
 }
 
-function extractParams(path: string, route: Route): Map<string, string> {
-    const params: Map<string, string> = new Map();
-    const pathSegments = path.split('/');
-    const routeSegments = route.path.split('/');
+// extractParams extracts the parameters from the path
+// and returns a map of key/value pairs
+// e.g. /users/:id => /users/123 => { id: 123 }
+function extractParams(pattern: string, route: Route): Map<string, string> {
+	const params: Map<string, string> = new Map();
+	const pathSegments = pattern.split('/');
+	const routeSegments = route.path.split('/');
 
-    if (pathSegments.length !== routeSegments.length) return params;
+	if (pathSegments.length !== routeSegments.length) return params;
 
-    for (let i = 0; i < pathSegments.length; i++) {
-        if (routeSegments[i][0] === ':') {
-            const key = routeSegments[i].replace(':', '');
-            const value = pathSegments[i];
-            params.set(key, value);
-        }
-    }
+	for (let i = 0; i < pathSegments.length; i++) {
+		if (routeSegments[i][0] === ':') {
+			const key = routeSegments[i].slice(1);
+			const value = pathSegments[i];
+			params.set(key, value);
+		}
+	}
 
-    return params;
+	return params;
 }
 
+// getContentType returns the content type from the headers
 function getContentType(headers: Headers): string {
-    const contentType = headers.get('Content-Type');
-    if (!contentType) return '';
-    return contentType;
+	const contentType = headers.get('Content-Type');
+	return contentType ?? '';
 }
 
+// isMultiPartForm returns true if the content type is multipart/form-data
 function isMultiPartForm(headers: Headers): boolean {
-    const contentType = getContentType(headers);
-    return contentType.includes('multipart/form-data');
+	const contentType = getContentType(headers);
+	return contentType.includes('multipart/form-data');
 }
 
+// renderStream renders the component to a readable stream
+async function renderStream(children: ReactNode) {
+	const stream = await renderToReadableStream(children);
+	return new Response(stream, { headers: { 'Content-Type': 'text/html' } });
+}
 
-
-export { createContext }
+export { createContext };

package/lib/router/routeTree.ts

@@ -0,0 +1,86 @@
+import { HttpHandler, Route } from './router.d';
+import { http } from '../http/http';
+import { createContext } from './context';
+
+const createRoute = (path: string, method: string, handler: HttpHandler): Route => {
+	const route: Route = {
+		children: new Map(),
+		path: path,
+		dynamicPath: '',
+		method: method,
+		handler: handler,
+		isLast: false
+	};
+
+	return route;
+};
+
+const RouteTree = () => {
+	const root = createRoute('', 'GET', () => http.notFound());
+
+	function addRoute (pattern: string, method: string, handler: HttpHandler){
+		console.log(pattern);
+		const pathParts = pattern.split('/');
+		let current = root;
+
+		for (let i = 0; i < pathParts.length; i++) {
+			const part = pathParts[i];
+			if (part.startsWith(':')) {
+				current.dynamicPath = part;
+			}
+			if (!current.children.has(part)) {
+				current.children.set(part, createRoute(part, method, handler));
+			}
+			current = current.children.get(part)!;
+		}
+
+		current.handler = handler;
+		current.isLast = true;
+		current.path = pattern;
+	}
+
+	function findRoute(pathname: string): Route | undefined {
+		const pathParts = pathname.split('/');
+		let current = root;
+		for (let i = 0; i < pathParts.length; i++) {
+			const part = pathParts[i];
+			if (current.children.has(part)) {
+				current = current.children.get(part)!;
+			} else if (current.dynamicPath) {
+				current = current.children.get(current.dynamicPath)!;
+			} else {
+				return;
+			}
+		}
+		return current;
+	}
+
+	function size() {
+		let count = 0;
+		function traverse(route: Route) {
+			count++;
+			for (const child of route.children.values()) {
+				traverse(child);
+			}
+		}
+		traverse(root);
+		return count;
+	}
+
+	function list() {
+		const routes: Route[] = [];
+		function traverse(route: Route) {
+			routes.push(route);
+			for (const child of route.children.values()) {
+				traverse(child);
+			}
+		}
+		traverse(root);
+		return routes;
+	}
+
+	return { addRoute, findRoute, size, list };
+
+};
+
+export { RouteTree, createContext };

package/lib/router/router.d.ts

@@ -1,4 +1,5 @@
-import { TLSOptions, TLSWebSocketServeOptions, WebSocketServeOptions, ServeOptions, TLSServeOptions } from 'bun';
+/* eslint-disable  @typescript-eslint/no-explicit-any */
+import { TLSWebSocketServeOptions, WebSocketServeOptions, ServeOptions, TLSServeOptions } from 'bun';
 import { Logger } from '../logger/logger';
 import { Database } from 'bun:sqlite';
 
@@ -20,7 +21,6 @@ type Route = {
     handler: HttpHandler;
     isLast: boolean;
 }
-
 type Context = {
     db?: Database;
     formData: FormData | Promise<FormData>;
@@ -29,12 +29,14 @@ type Context = {
     params: Map<string, string>;
     query: URLSearchParams;
     request: Request;
+    render: (component: React.ReactNode) => Response | Promise<Response>;
 };
 
 type HttpHandler = (ctx: Context) => Response | Promise<Response>
 
 type Options = {
-    db: string,
+    db: string;
+    enableFileLogging: boolean;
 }
 
 type RouterOptions<Options> = ServeOptions
@@ -43,4 +45,4 @@ type RouterOptions<Options> = ServeOptions
 | TLSWebSocketServeOptions<Options>
 | undefined
 
-export { Context , Route, BunRouter, RouterOptions, Options, HttpHandler }
+export { Context , Route, BunRouter, RouterOptions, Options, HttpHandler };