bun-router 0.7.3 → 0.7.4-experimental.11

package/lib/router/router.ts

@@ -1,100 +1,133 @@
 import path from 'path';
 import { Database } from 'bun:sqlite';
-import { Route, BunRouter, RouterOptions, Options, HttpHandler } from './router.d';
+import { Route, BunRouter, RouterOptions, Options } from './router.d';
 import { httpStatusCodes } from '../http/status';
 import { readDir } from '../fs/fsys';
 import { Logger, startMessage } from '../logger/logger';
 import { http } from '../http/http';
-import {RouteTree } from './tree';
+import { RouteTree } from './routeTree';
 import { createContext } from './context';
 
-
 const Router: BunRouter = (port?: number | string, options?: RouterOptions<Options>) => {
-    const { addRoute, findRoute } = RouteTree();
-    const logger = Logger();
-
-    return {
-        // add a route to the router tree 
-        add: (pattern, method, callback) => { addRoute(pattern, method, callback) },
-        get: (pattern: string, callback: HttpHandler) => { addRoute(pattern, 'GET', callback) },
-        post: (pattern, callback) => { addRoute(pattern, 'POST', callback) },
-        put: (pattern, callback) => { addRoute(pattern, 'PUT', callback)},
-        delete: (pattern, callback) => { addRoute(pattern, 'DELETE', callback) },
+	const { addRoute, findRoute } = RouteTree();
+	const logger = Logger(options?.enableFileLogging ?? false);
+
+	// load a component from the root directory relative to the cwd
+	async function loadComponent(root: string, name: string) {
+		const module = await import(path.join(process.cwd(), root, name));
+		return module.default;
+	}
+
+	// extract the path, extension, and base name from a file path
+	function extractPathExtBase(pattern: string, pathname: string) {
+		const extension = path.extname(pathname);
+		let base = encodeURIComponent(path.basename(pathname));
+
+		if (extension === '.html' || extension === '.tsx') base = base.replace(extension, '');
+
+		let patternPath = [pattern, base].join('/');
+
+		if (base === 'index') patternPath = pattern;
+		
+		return { patternPath, extension, base };
+	}
+
+	// check if a file exists
+	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); },
+		get: (pattern, callback) => { addRoute(pattern, 'GET', callback); },
+		post: (pattern, callback) => { addRoute(pattern, 'POST', callback); },
+		put: (pattern, callback) => { addRoute(pattern, 'PUT', callback);},
+		delete: (pattern, callback) => { addRoute(pattern, 'DELETE', callback); },
         
-        // add a static route to the router tree
-        static: async (pattern: string, root: string) => {
-            await readDir(root, async (fp, _) => {
-                const pure = path.join('.', fp);
-                const ext = path.extname(pure);
-
-                let base = path.basename(pure);
-
-                if (ext === '.html') base = base.replace(ext, '');
-
-                if (pattern[0] !== '/') pattern = '/' + pattern;
-
-                let patternPath = pattern + base;
-
-                if (base === 'index') patternPath = pattern;
-
-                const route: Route = {
-                    children: new Map(),
-                    dynamicPath: '',
-                    isLast: true,
-                    path: patternPath,
-                    method: 'GET',
-                    handler: async () => await http.file(200, pure),
-                };
-
-                addRoute(route.path, 'GET', route.handler);
-            });
-        },
-        // start the server
-        serve: () => {
-            startMessage(port ?? 3000);
-            let opts: Options = { db: ':memory:' };
-
-            Bun.serve({
-                port: port ?? 3000,
-                ...options,
-                async fetch(req) {
-                    const url = new URL(req.url);
-                    let path = url.pathname;
-
-                    // set the database
-                    if (options) {
-                        let o = options as Options;
-                        opts.db = o.db;
-                    }
-
-                    const route = findRoute(path);
-
-                    // if the route exists, execute the handler
-                    if (route) {
-                        if (route.method !== req.method) {
-                            logger.info(405, url.pathname, req.method, httpStatusCodes[405]);
-                            return Promise.resolve(http.methodNotAllowed());
-                        }
-
-                        const context = await createContext(path, route, req);
-                        context.db = new Database(opts.db);
-
-                        const response = await route.handler(context);
-
-                        logger.info(response.status, url.pathname, req.method, httpStatusCodes[response.status]);
-                        return Promise.resolve(response);
-                    } 
-
-                    // if no route is found, return 404
-                    const response = await http.notFound();
+		// add static routes to the router tree
+		// .tsx and .html are rendered as components, or pages
+		// all other file extensions are served as files
+		// the root directory is traversed recursively
+		static: async (pattern: string, root: string) => {
+			if (!exists(root)) return console.error(`Directory not found: ${root}`);
+			await readDir(root, async (fp) => {
+				const { patternPath, extension, base } = extractPathExtBase(pattern, fp);
+				const route: Route = {
+					children: new Map(),
+					dynamicPath: pattern,
+					isLast: true,
+					path: patternPath.startsWith('//') ? patternPath.slice(1) : patternPath, // remove the leading '/' if it exists
+					method: 'GET',
+					handler: async () => {
+						if (extension === '.tsx') {
+							const component = await loadComponent(root, base);
+							return await http.render(component());
+						} else {
+							return await http.file(200, fp);
+						}
+					},
+				};
+
+				addRoute(route.path, 'GET', route.handler);
+			});
+			
+		},
+		// start listening for requests
+		serve: () => {
+			startMessage(port ?? 3000);
+			const opts: Options = { db: ':memory:', enableFileLogging: false };
+
+			Bun.serve({
+				port: port ?? 3000,
+				...options,
+				async fetch(req) {
+					const url = new URL(req.url);
+					const pathname = url.pathname;
+
+					// set the database
+					if (options) {
+						const o = options as Options;
+						opts.db = o.db;
+						opts.enableFileLogging = o.enableFileLogging;
+					}
+
+					const route = findRoute(pathname);
+
+					// if the route exists, call the handler
+					if (route) {
+						if (route.method !== req.method) {
+							logger.info(405, url.pathname, req.method, httpStatusCodes[405]);
+							return Promise.resolve(http.methodNotAllowed());
+						}
+
+						// create a context for the handler
+						const context = await createContext(pathname, route, req, opts.enableFileLogging);
+						context.db = new Database(opts.db);
+
+						// call the handler
+						const response = await route.handler(context);
+
+						logger.info(response.status, url.pathname, req.method, httpStatusCodes[response.status]);
+						return Promise.resolve(response);
+					} 
+
+					// 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());
-
-                }
-            });
-        },
-    }
-}
-
-export { Router, http }
+					logger.info(response.status, url.pathname, req.method, httpStatusCodes[response.status]);
+					return Promise.resolve(http.notFound());
+				},
+				// if an error occurs, return a 500 response
+				error(error) {
+					return new Response(`<pre>${error}\n${error.stack}</pre>`, {
+						headers: { 'Content-Type': 'text/html' },
+					});
+				}
+			});
+		},
+	};
+};
+
+export { Router, http };

package/package.json

@@ -3,10 +3,21 @@
   "module": "index.ts",
   "type": "module",
   "devDependencies": {
-    "bun-types": "latest"
+    "@types/react": "^18.2.23",
+    "@types/react-dom": "^18.2.8",
+    "@typescript-eslint/eslint-plugin": "^6.7.0",
+    "@typescript-eslint/parser": "^6.7.0",
+    "bun-types": "latest",
+    "eslint": "^8.49.0",
+    "eslint-plugin-react": "^7.33.2"
   },
   "peerDependencies": {
     "typescript": "^5.0.0"
   },
-  "version": "0.7.3"
+  "version": "0.7.4-experimental.11",
+  "dependencies": {
+    "eslint-plugin-react-hooks": "^4.6.0",
+    "react": "^18.2.0",
+    "react-dom": "^18.2.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);
+	});
 });
 
+

package/tsconfig.json

@@ -16,8 +16,10 @@
     "allowJs": true,
     "noEmit": true,
     "types": [
-      "./index.d.ts",
       "bun-types" // add Bun global
-    ]
-  }
+    ],
+    "paths": {
+      "/examples/*": ["./examples/*"]
+    }
+  },
 }

package/examples/db.ts

@@ -1,10 +0,0 @@
-import { Router, http } from '..';
-
-const router = Router(3000, {db: './dbs/test.db'});
-
-router.add('/', 'GET', async (ctx) => {
-    const formData = await ctx.formData;
-    const name = formData?.get('name');
-    return http.ok();
-});
-

package/lib/router/tree.ts

@@ -1,63 +0,0 @@
-import { HttpHandler, Route } from "./router.d";
-import { http } from "../http/http";
-import { createContext } from './context';
-
-const splitPath = (s: string): string[] => s.split('/').filter(x => x !== '');
-
-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 = () => {
-    let root = createRoute('', 'GET', () => http.notFound());
-
-    const addRoute = (path: string, method: string, handler: HttpHandler) => {
-        const pathParts = splitPath(path);
-        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 = path;
-    };
-
-    const findRoute = (path: string): Route | undefined => {
-        const pathParts = splitPath(path);
-        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;
-    }
-
-    return { addRoute, findRoute }
-
-};
-
-export { RouteTree, createContext }

package/lib/util/strings.ts

@@ -1,3 +0,0 @@
-const splitPath = (path: string): string[] => path.split('/').filter(Boolean);
-
-export { splitPath }