bun-router 0.7.4-experimental.8 → 0.7.4-experimental.9

package/examples/static.ts

@@ -2,6 +2,6 @@ import { Router } from '..';
 
 const r = Router(3001);
 
-r.static('/page', './pages');
+r.static('/', './examples/pages');
 
 r.serve();

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/logger.ts

@@ -9,7 +9,7 @@ _                          _
 |___|___|_|_|  |_| |___|___|_| |___|_|  
                                                                                     
 `;
-const VERSION = '0.7.4-experimental.8';
+const VERSION = '0.7.4-experimental.9';
 const Logger = (): BunLogger => {
 	return {
 		info: async (statusCode: number, routePath: string, method: string, message?: string) => {

package/lib/router/routeTree.ts

@@ -18,7 +18,7 @@ const createRoute = (path: string, method: string, handler: HttpHandler): Route
 const RouteTree = () => {
 	const root = createRoute('', 'GET', () => http.notFound());
 
-	const addRoute = (pattern: string, method: string, handler: HttpHandler) => {
+	function addRoute (pattern: string, method: string, handler: HttpHandler){
 		const pathParts = pattern.split('/');
 		let current = root;
 
@@ -36,7 +36,7 @@ const RouteTree = () => {
 		current.handler = handler;
 		current.isLast = true;
 		current.path = pattern;
-	};
+	}
 
 	function findRoute(pathname: string): Route | undefined {
 		const pathParts = pathname.split('/');
@@ -54,7 +54,31 @@ const RouteTree = () => {
 		return current;
 	}
 
-	return { addRoute, findRoute };
+	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 };
 
 };
 

package/lib/router/router.ts

@@ -2,14 +2,14 @@ import path from 'path';
 import { Database } from 'bun:sqlite';
 import { Route, BunRouter, RouterOptions, Options, HttpHandler } from './router.d';
 import { httpStatusCodes } from '../http/status';
-import { readDir, exists } from '../fs/fsys';
+import { readDir } from '../fs/fsys';
 import { Logger, startMessage } from '../logger/logger';
 import { http } from '../http/http';
 import { RouteTree } from './routeTree';
 import { createContext } from './context';
 
 const Router: BunRouter = (port?: number | string, options?: RouterOptions<Options>) => {
-	const { addRoute, findRoute } = RouteTree();
+	const { addRoute, findRoute, list } = RouteTree();
 	const logger = Logger();
 
 	async function loadComponent(root: string, name: string) {
@@ -17,9 +17,9 @@ const Router: BunRouter = (port?: number | string, options?: RouterOptions<Optio
 		return module.default;
 	}
 
-	function normalizePath(pattern: string, pathname: string) {
+	function extractPathExtBase(pattern: string, pathname: string) {
 		const extension = path.extname(pathname);
-		let base = path.basename(pathname);
+		let base = encodeURIComponent(path.basename(pathname));
 
 		if (extension === '.html' || extension === '.tsx') base = base.replace(extension, '');
 
@@ -27,9 +27,14 @@ const Router: BunRouter = (port?: number | string, options?: RouterOptions<Optio
 
 		if (base === 'index') patternPath = pattern;
 		
-		return { patternPath, extension, base }
+		return { patternPath, extension, base };
 	}
 
+	async function exists(fp: string) {
+		const f = Bun.file(fp);
+		return await f.exists();
+	}
+	
 	return {
 		// add a route to the router tree 
 		add: (pattern, method, callback) => { addRoute(pattern, method, callback); },
@@ -43,15 +48,15 @@ const Router: BunRouter = (port?: number | string, options?: RouterOptions<Optio
 		// all other file extensions are served as files
 		// the root directory is traversed recursively
 		static: async (pattern: string, root: string) => {
-			if (!exists(root)) console.log(`Cannot find directory ${root}`);
+			if (!exists(root)) return console.error(`Directory not found: ${root}`);
 			await readDir(root, async (fp) => {
-				const { patternPath, extension, base } = normalizePath(pattern, fp);
+				const { patternPath, extension, base } = extractPathExtBase(pattern, fp);
 
 				const route: Route = {
 					children: new Map(),
 					dynamicPath: '',
 					isLast: true,
-					path: patternPath.slice(1), // remove the leading '/'
+					path: patternPath.startsWith('//') ? patternPath.slice(1) : patternPath, // remove the leading '/' if it exists
 					method: 'GET',
 					handler: async () => {
 						if (extension === '.tsx') {
@@ -65,6 +70,9 @@ const Router: BunRouter = (port?: number | string, options?: RouterOptions<Optio
 
 				addRoute(route.path, 'GET', route.handler);
 			});
+
+			console.log(list());
+			
 		},
 		// start the server
 		serve: () => {
@@ -102,11 +110,16 @@ const Router: BunRouter = (port?: number | string, options?: RouterOptions<Optio
 						return Promise.resolve(response);
 					} 
 
-					// if no route is found, return 404
+					// if no route is found, return 404 
 					const response = await http.notFound();
                         
 					logger.info(response.status, url.pathname, req.method, httpStatusCodes[response.status]);
 					return Promise.resolve(http.notFound());
+				},
+				error(error) {
+					return new Response(`<pre>${error}\n${error.stack}</pre>`, {
+						headers: { 'Content-Type': 'text/html' },
+					});
 				}
 			});
 		},

package/package.json

@@ -14,7 +14,7 @@
   "peerDependencies": {
     "typescript": "^5.0.0"
   },
-  "version": "0.7.4-experimental.8",
+  "version": "0.7.4-experimental.9",
   "dependencies": {
     "@types/react": "^18.2.22",
     "eslint-plugin-react-hooks": "^4.6.0",

package/tests/router.test.ts

@@ -1,35 +1,36 @@
 import { describe, test, expect } from 'bun:test';
 
 describe('Router', () => {
-    test('Serve', async () => {
-        const proc = Bun.spawn(['./tests/serve.test.sh'], {
-            onExit: (_proc, _exitCode, _signalCode , error) => {
-                if (error) console.error(error);     
-            },
-        });
+	test('Serve', async () => {
+		const proc = Bun.spawn(['./tests/serve.test.sh'], {
+			onExit: (_proc, _exitCode, _signalCode , error) => {
+				if (error) console.error(error);     
+			},
+		});
     
-        const text = await new Response(proc.stdout).text();
+		const text = await new Response(proc.stdout).text();
         
-        const hasFailed = text.includes('Failed');
+		const hasFailed = text.includes('Failed');
 
-        if (hasFailed) console.log(text);
+		if (hasFailed) console.log(text);
 
-        expect(hasFailed).toBe(false);
+		expect(hasFailed).toBe(false);
 
-        proc.kill(0);
-    })
+		proc.kill(0);
+	});
 
-    test('Static', async() => {
-        const proc = Bun.spawn(['./tests/static.test.sh']);
+	test('Static', async() => {
+		const proc = Bun.spawn(['./tests/static.test.sh']);
         
-        const text = await new Response(proc.stdout).text();
+		const text = await new Response(proc.stdout).text();
 
-        const hasFailed = text.includes('Failed');
-        if (hasFailed) console.log(text);
+		const hasFailed = text.includes('Failed');
+		if (hasFailed) console.log(text);
 
-        expect(hasFailed).toBe(false);
+		expect(hasFailed).toBe(false);
 
-        proc.kill(0);
-    });
+		proc.kill(0);
+	});
 });
 
+