bun-router 0.6.0 → 0.7.0

package/README.md

@@ -56,7 +56,7 @@ r.serve();
 
 **SQLite**
 ```ts
-import { router, json } from '..';
+import { router, json } from 'bun-router';
 import { Database } from 'bun:sqlite';
 
 const r = router(3000, {db: './examples/dbs/test.db'});

package/examples/basic.ts

@@ -6,13 +6,8 @@ r.add('/', 'GET', () => http.json(200, 'ok'));
 
 r.add('/user/:name', 'GET', (ctx) => {
     const name = ctx.params.get('name');
+    if (!name) return http.json(500, 'no name');
     return http.json(200, name);
 });
 
-r.add('/user/:name/:id', 'GET', (ctx) => {
-    const name = ctx.params.get('name');
-    const id = ctx.params.get('id');
-    return http.json(200, {name: name, id: id});
-});
-
 r.serve();

package/examples/dynamic.ts

@@ -1,29 +1,24 @@
 import { router, http } from '..';
 import { Context } from '../lib/router/router.d';
 
-const handler = (ctx: Context) => {
-    const name = ctx.params.get('name');
-    if (typeof name === 'undefined' || name === '') return http.html(500, '<h6 style="color: red">User Undefined</h6>');
-    return http.html(200, `<h4>Hello, ${name}!</h4>`);
-}
+const home = (ctx: Context) => new Response('Welcome Home', { status: 200 });
 
-const space = (ctx: Context) => {
-    const name = ctx.params.get('name');
-    if (typeof name === 'undefined' || name === '') return http.html(404, `<h6 style="color: red">Space [${name}] Not Found</h6>`);
-    return http.html(200, `<h4>Welcome to ${name}!`)
+const subreddit = (ctx: Context) => {
+    const sub = ctx.params.get('subreddit');
+    if (!sub) return http.json(400, { error: 'no subreddit provided' });
+    return http.json(200, { subreddit: sub });
 }
 
-const handleSettings = (ctx: Context) => {
-    const name = ctx.params.get('name');
-    if (typeof name === 'undefined' || name === '') return http.html(404, `<h6 style="color: red">User Not Found</h6>`);
-    return http.html(200, `<h4>Settings for ${name}</h4>`)
+const user = (ctx: Context) => {
+    const user = ctx.params.get('user');
+    if (!user) return http.json(400, { error: 'no user provided' });
+    return http.json(200, { user: user });
 }
 
 const r = router();
 
-r.add('/u/:name', 'GET', handler);
-r.add('/s/:name', 'GET', space);
-r.add('/u/:name/settings', 'GET', handleSettings);
-
+r.add('/', 'GET', home);
+r.add('/r/:subreddit', 'GET', subreddit);
+r.add('/u/:user', 'GET', user);
 
 r.serve();

package/lib/http/generic-methods.ts

@@ -10,8 +10,7 @@ const http = {
         }));
     },
     html: async (statusCode: number, content: string): Promise<Response> => {
-        content = Bun.escapeHTML(content);
-        return Promise.resolve(new Response(Bun.escapeHTML(content), {
+        return Promise.resolve(new Response(content, {
             status: statusCode,
             statusText: httpStatusCodes[statusCode],
             headers: {'Content-Type': 'text/html; charset=utf-8'}
@@ -50,6 +49,15 @@ const http = {
     
         return Promise.resolve(response);
     },
+    methodNotAllowed: async (msg?: string): Promise<Response> => {
+        const response = new Response(msg ?? 'method not allowed', {
+            status: 405,
+            statusText: httpStatusCodes[405],
+            headers: {'Content-Type': 'text/html'},
+        });
+    
+        return Promise.resolve(response);
+    },
     message:  async (status: number, msg?: string): Promise<Response> => {
         const response = new Response(msg ?? '?', {
             status: status,

package/lib/logger/color.ts

@@ -20,7 +20,7 @@ const Colors: Record<string,string> = {
     bgMagenta: "\x1b[45m",
     bgCyan: "\x1b[46m",
     bgWhite: "\x1b[47m",
-  };
+  } as const;
 
   
 const color = (c: string, bkg: string, msg: string) => {

package/lib/logger/logger.ts

@@ -3,6 +3,14 @@ import {Logger} from './logger.d';
 
 const pad = (n: number) => String(n).padStart(2, '0'); 
 
+const TITLE = `
+_                          _           
+| |_ _ _ ___    ___ ___ _ _| |_ ___ ___ 
+| . | | |   |  |  _| . | | |  _| -_|  _|
+|___|___|_|_|  |_| |___|___|_| |___|_|  
+                                                                                    
+`
+
 const timestamp = (date: Date) => {
     const month = pad(date.getMonth());
     const day = pad(date.getDate());
@@ -48,6 +56,7 @@ const logger = (): Logger => {
             const portColor = color('green', 'bgBlack', String(port));
             const msg = `${source}: Starting Server on :${portColor}\n`;
 
+            await Bun.write(Bun.stdout, TITLE);
             await Bun.write(Bun.stdout, msg);
         },
         info: async (statusCode: number, routePath: string, method: string, message?: string) => {

package/lib/router/router.d.ts

@@ -2,25 +2,28 @@ import { TLSOptions, TLSWebSocketServeOptions, WebSocketServeOptions, ServeOptio
 import { Logger } from '../logger/logger';
 import { Database } from 'bun:sqlite';
 
+type HttpHandler = (ctx: Context) => Response | Promise<Response>
 
 type Context = {
-    cookies: Map<string, string>,
-    db: Database,
-    formData: FormData | Promise<FormData> | undefined,
-    json: (statusCode: number, data: any) => Response | Promise<Response>,
-    logger: Logger,
-    params: Map<string, string>,
-    query: URLSearchParams,
-    request: Request,
-    route: Route,
-    token?: string,
+    cookies: Map<string, string>;
+    db?: Database;
+    formData: FormData | Promise<FormData> | undefined;
+    json: (statusCode: number, data: any) => Response | Promise<Response>;
+    logger: Logger;
+    params: Map<string, string>;
+    query: URLSearchParams;
+    request: Request;
+    token?: string;
 };
 
 
 type Route = {
-    pattern: string,
-    method: string,
-    callback: (req: Context) => Response | Promise<Response>
+    children: Map<string, Route>;
+    path: string;
+    dynamicPath: string;
+    method: string;
+    handler: HttpHandler;
+    isLast: boolean;
 }
 
 type Options = {
@@ -35,13 +38,11 @@ type RouterOptions<Options> = ServeOptions
 
 
 type Router = (port?: number | string, options?: RouterOptions) => {
-    add: (pattern: string, method: string, callback: (req: Context) => Response | Promise<Response>) => void,
-    GET: (pattern: string, callback: (ctx: Context) => Response | Promise<Response>) => void,
-    POST: (pattern: string, callback: (ctx: Context) => Response | Promise<Response>) => void,
-    static: (pattern: string, root: string) => void,
-    serve: () => void,
+    add: (pattern: string, method: string, callback: (req: Context) => Response | Promise<Response>) => void;
+    static: (pattern: string, root: string) => void;
+    serve: () => void;
 }
 
 
 
-export { Context , Route, Router, RouterOptions, Options }
+export { Context , Route, Router, RouterOptions, Options, HttpHandler }

package/lib/router/router.ts

@@ -1,17 +1,15 @@
 import path from 'path';
 import { Database } from 'bun:sqlite';
-import { Route, Router, Context, RouterOptions, Options } from './router.d';
+import { Route, Router, Context, RouterOptions, Options, HttpHandler } from './router.d';
 import { httpStatusCodes } from '../http/status';
 import { readDir } from '../fs/fsys';
 import { logger } from '../logger/logger';
-import { Logger } from '../logger/logger.d';
 import { http } from '../http/generic-methods';
+import {Radix, createContext} from './tree';
 
-// extract dynamic URL parameters
-// if the route pattern is /:foo and the request URL is /bar: {foo: 'bar'}
-const extract = (route: Route, ctx: Context) => {
+const extract = (path: string, ctx: Context) => {
     const url = new URL(ctx.request.url);
-    const pathSegments = route.pattern.split('/');
+    const pathSegments = path.split('/');
     const urlSegments = url.pathname.split('/');
 
     if (pathSegments.length !== urlSegments.length) return
@@ -19,10 +17,10 @@ const extract = (route: Route, ctx: Context) => {
     return {
         params: () => {
             for (let i = 0; i < pathSegments.length; i++) {
-                if ((pathSegments[i][0] === ':')) {
+                if((pathSegments[i][0] === ':')) {
                     const k = pathSegments[i].replace(':', '');
                     const v = urlSegments[i];
-                    ctx.params.set(k, v);
+                    ctx.params.set(k,v);
                 }
             }
         }
@@ -30,67 +28,16 @@ const extract = (route: Route, ctx: Context) => {
 
 }
 
-// ensure the route pattern matches the request URL
-const match = (route: Route, ctx: Context): boolean => {
-    const url = new URL(ctx.request.url);
-    const patternRegex = new RegExp('^' + route.pattern.replace(/:[^/]+/g, '([^/]+)') + '$');
-    const matches = url.pathname.match(patternRegex);
-
-    if (matches && route.method === ctx.request.method) {
-        const extractor = extract(route, ctx);
-        extractor?.params();
-
-        return true;
-    }
-
-    return false;
-}
-
-// set the context for the reuest
-const setContext = (req: Request, lgr: Logger, opts: Options, route: Route): Context => {
-    const token = req.headers.get('Authorization');
-    return {
-        token: token ?? '',
-        cookies: new Map(),
-        formData: req.formData(),
-        request: req,
-        params: new Map(),
-        query: new URL(req.url).searchParams,
-        db: new Database(opts.db ?? ':memory:'),
-        logger: lgr,
-        route: route,
-        json: (statusCode: number, data: any) => http.json(statusCode, data),
-    }
-}
-
 const router: Router = (port?: number | string, options?: RouterOptions<Options>) => {
-    const routes: Array<Route> = new Array();
+    const {addRoute, findRoute} = Radix();
     const lgr = logger();
 
     return {
-        // add a new route
-        add: (pattern: string, method: string, callback: (ctx: Context) => Response | Promise<Response>) => {
-            routes.push({
-                pattern: pattern,
-                method: method,
-                callback: callback,
-            })
-        },
-        GET: (pattern: string, callback: (ctx: Context) => Response | Promise<Response>) => {
-            routes.push({
-                pattern: pattern,
-                method: 'GET',
-                callback: callback,
-            });
-        },
-        POST: (pattern: string, callback: (ctx: Context) => Response | Promise<Response>) => {
-            routes.push({
-                pattern: pattern,
-                method: 'POST',
-                callback: callback,
-            });
+        // add a route to the router tree 
+        add: (pattern: string, method: string, callback: HttpHandler) => {
+            addRoute(pattern, method, callback);
         },
-        // add a route for static files
+        // add a static route to the router tree
         static: async (pattern: string, root: string) => {
             await readDir(root, async (fp, _) => {
                 const pure = path.join('.', fp);
@@ -107,12 +54,15 @@ const router: Router = (port?: number | string, options?: RouterOptions<Options>
                 if (base === 'index') patternPath = pattern;
 
                 const route: Route = {
-                    pattern: patternPath,
+                    children: new Map(),
+                    dynamicPath: '',
+                    isLast: true,
+                    path: patternPath,
                     method: 'GET',
-                    callback: async () => await http.file(200, pure),
+                    handler: async () => await http.file(200, pure),
                 };
 
-                routes.push(route);
+                addRoute(route.path, 'GET', route.handler);
             });
         },
         // start the server
@@ -120,52 +70,44 @@ const router: Router = (port?: number | string, options?: RouterOptions<Options>
             lgr.start(port ?? 3000);
             let opts: Options = { db: ':memory:' };
 
+            // TODO: add support for TLS and WebSockets
             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;
                     }
 
-                    let statusCode = 404;
+                    const route = findRoute(path);
 
-                    for (const route of routes) {
-                        const ctx = setContext(req, lgr, opts, route);
-
-                        if (match(route, ctx) || route.pattern === url.pathname) {
-                            if (route.method === ctx.request.method) {
-                                const res = await route.callback(ctx);
+                    // if the route exists, execute the handler
+                    if (route) {
+                        if (route.method !== req.method) {
+                            lgr.info(405, url.pathname, req.method, httpStatusCodes[405]);
+                            return Promise.resolve(http.methodNotAllowed());
+                        }
 
-                                let cookieValue: string[] = [];
-                                if (ctx.cookies.size !== 0) {
-                                    for (const [key, value] of ctx.cookies) {
-                                        cookieValue.push(`${key}=${value}`);
-                                    }
-                                }
+                        const context = createContext(path, route, req);
+                        context.db = new Database(opts.db);
 
-                                res.headers.set('Set-Cookie', cookieValue.join('; '));
+                        const response = await route.handler(context);
 
-                                statusCode = res.status;
+                        lgr.info(response.status, url.pathname, req.method, httpStatusCodes[response.status]);
+                        return Promise.resolve(response);
+                    } 
 
-                                lgr.info(res.status, route.pattern, req.method, httpStatusCodes[res.status]);
-                                return Promise.resolve(res);
-                            } else {
-                                const res = new Response(httpStatusCodes[405], {
-                                    status: 405,
-                                    statusText: httpStatusCodes[405]
-                                });
-                                lgr.info(405, route.pattern, req.method, httpStatusCodes[405])
-                                return Promise.resolve(res);
-                            }
-                        }
-                    }
+                    // if no route is found, return 404
+                    const response = await http.notFound();
+                        
+                    lgr.info(response.status, url.pathname, req.method, httpStatusCodes[response.status]);
+                    return Promise.resolve(http.notFound());
 
-                    lgr.info(statusCode, url.pathname, req.method, httpStatusCodes[statusCode]);
-                    return Promise.resolve(http.message(statusCode, httpStatusCodes[statusCode]));
                 }
             });
         },

package/lib/router/tree.ts

@@ -0,0 +1,90 @@
+import { HttpHandler, Context, Route } from "./router.d";
+import { http } from "../http/generic-methods";
+
+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 extractParams = (path: string, route: Route, params: Map<string, string>) => {
+    const pathParts = splitPath(path);
+    const routeParts = splitPath(route.path);
+
+    for (let i = 0; i < routeParts.length; i++) {
+        const part = routeParts[i];
+        if (part.startsWith(':')) {
+            params.set(part.slice(1), pathParts[i]);
+        }
+    }
+};
+
+const createContext = (path: string, route: Route, req: Request): Context => {
+    const params: Map<string, string> = new Map();
+
+    if (route) extractParams(path, route, params);
+
+    return {
+        params: params,
+        request: req,
+        query: new URLSearchParams(path),
+        cookies: new Map(),
+        formData: undefined,
+        logger: undefined,
+        json: (statusCode: number, data: any) => http.json(statusCode, data),
+    }
+};
+
+const Radix = () => {
+    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 { Radix, createContext }

package/package.json

@@ -8,5 +8,5 @@
   "peerDependencies": {
     "typescript": "^5.0.0"
   },
-  "version": "0.6.0"
+  "version": "0.7.0"
 }

package/tests/router.test.ts

@@ -1,68 +1,4 @@
 import { describe, test, expect } from 'bun:test';
-import { extract } from '..';
-import { Context, Route } from '../lib/router/router.d';
-
-describe('URL Params', () => {
-    test('/user/:name', () => {
-        const route: Route = {
-            pattern: '/user/:name',
-            method: 'GET',
-            callback: () => new Response('ok'),
-        };
-
-        const ctx: Context = {
-            request: new Request('http://localhost:3000/user/foo'),
-            params: new Map(),
-        };
-
-        const extractor = extract(route, ctx);
-
-        extractor?.params();
-
-        const name = ctx.params.get('name');
-        expect(name).toBe('foo');
-    });
-
-    test('/user/:name/:id', () => {
-        const route: Route = {
-            pattern: '/user/:name/:id',
-            method: 'GET',
-            callback: () => new Response('ok'),
-        };
-
-        const ctx: Context = {
-            request: new Request('http://localhost:3000/user/foo/123'),
-            params: new Map(),
-        };
-
-        const extractor = extract(route, ctx);
-
-        extractor?.params();
-
-        const name = ctx.params.get('name');
-        const id = ctx.params.get('id');
-
-        expect(name).toBe('foo');
-        expect(id).toBe('123');
-    });
-
-    test('/foo', () => {
-        const route: Route = {
-            pattern: '/foo',
-            method: 'GET',
-            callback: () => new Response('ok'),
-        }
-
-        const ctx: Context = {
-            request: new Request('http://localhost:3000/foo'),
-            params: new Map(),
-        }
-
-        const url = new URL(ctx.request.url);
-
-        expect(url.pathname).toBe(route.pattern);
-    });
-});
 
 describe('Router', () => {
     test('Serve', async () => {

package/examples/sqlite.ts

@@ -1,22 +0,0 @@
-import { router, http } from '..';
-
-const r = router(3000, {db: './examples/dbs/test.db'});
-
-r.add('/u/new/:name', 'GET', (ctx) => {
-    const name = ctx.params.get('name');
-    const rando = Math.floor(Math.random()*1000);
-
-    ctx.db.run(`INSERT INTO test VALUES(${rando}, "${name}")`);
-
-    return http.json(200, {message: 'ok'});
-});
-
-r.add('/u/:name', 'GET', (ctx) => {
-    const name = ctx.params.get('name');
-    const data = ctx.db.query(`SELECT * FROM test WHERE name = "${name}";`).get();
-    const d = data as {id: number, name: string};
-
-    return d ? http.json(200, d) : new Response('not found', {status: 404});
-});
-
-r.serve();