bun-router 0.6.0 → 0.7.1

package/README.md

@@ -1,83 +1,40 @@
-# Bun Router
-
-I needed a router for `Bun`, so I made one. It's simple, naive, and hardly anything is abstracted. 
+# Bun router
 
 ### Usage
-```typescript
-import { router } from 'bun-router';
-
-const r = router();
-
-r.add('/', 'GET', (ctx) => new Response('Hello World'));
-
-r.serve();
-```
-#### Static Files
-```typescript
-import { router } from 'bun-router';
-
-const r = router();
-
-r.static('/', './pages');
-
-r.serve();
-```
+`npm i -s bun-router` 
 
-##### Example
-```typescript
-import {router, html, json } from 'bun-router';
+or 
 
-const r = router(3001);
+`bun i bun-router`
 
-r.add('/', (ctx) => html('<h1>Hello World</h1>'));
 
-r.add('/greeting/:name', 'GET', (ctx) => {
-    const name = ctx.params.get('name');
-    if (!name) return new Response('invalid url parameters', {status: 400});
+#### Example
+```ts
+import { Router, http } from 'bun-router';
 
-    return html(`<h4>Greetings, ${name}!</h4>`);
-});
+const router = Router();
 
-const store: Map<string, string> = new Map();
+router.add('/', 'GET', () => http.ok());
 
-r.add('/user/:id', 'GET', (ctx) => {
-    const id = ctx.params.get('id');
-    if (!id) return new Response('user not found', {status: 404});
-    
-    const user = store.get(id);
+router.get('/u/:username', ctx => {
+    const username = ctx.params.get('username');
 
-    if (!user) return new Response('user not found', { status: 404 });
+    if (!username) return http.badRequest();
 
-    return json(user);
+    return ctx.json({ username: username });
 });
 
-r.serve();
+router.serve();
 ```
 
-**SQLite**
+##### Static
 ```ts
-import { router, json } from '..';
-import { Database } from 'bun:sqlite';
-
-const r = router(3000, {db: './examples/dbs/test.db'});
+import { Router } from 'bun-router';
 
-r.add('/u/new/:name', 'GET', (ctx) => {
-    const name = ctx.params.get('name');
-    const rando = Math.floor(Math.random()*1000);
+const router = Router();
 
-    ctx.db.run(`INSERT INTO test VALUES(${rando}, "${name}")`);
-
-    return json({message: 'ok'});
-});
+router.static('/assets', 'static');
 
-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 ? json(d) : new Response('not found', {status: 404});
-});
-
-r.serve();
+router.serve();
+```
 
-```

package/examples/basic.ts

@@ -1,18 +1,13 @@
-import { router, http } from '..';
+import { Router, http } from '..';
 
-const r = router();
+const router = Router();
 
-r.add('/', 'GET', () => http.json(200, 'ok'));
+router.add('/', 'GET', () => http.json(200, 'ok'));
 
-r.add('/user/:name', 'GET', (ctx) => {
+router.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();
+router.serve();

package/examples/db.ts

@@ -0,0 +1,10 @@
+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/examples/dynamic.ts

@@ -1,29 +1,24 @@
-import { router, http } from '..';
+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 = () => 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);
+const r = Router();
 
+r.add('/', 'GET', home);
+r.add('/r/:subreddit', 'GET', subreddit);
+r.add('/u/:user', 'GET', user);
 
 r.serve();

package/examples/logger.ts

@@ -1,16 +1,11 @@
-import { router, logger, http } from '..';
+import { Router, http } from '..';
 
-const r = router();
-const log = logger();
+const r = Router();
 
-r.add('/:foo', 'GET', (ctx) => {
-    const url = new URL(ctx.request.url);
-    const foo = ctx.params.get('foo');
-    if (!foo) {
-        log.error(500, url.pathname, ctx.request.method, new Error('undefined'));
-        return http.json(500,{text: 'Foo is undefined'});
-    }
-    return http.html(200, `<h4 style='font-family: sans-serif;'>Oh hello, ${foo}</h4>`)
+r.get('/', ctx => {
+    ctx.logger.debug('hello from home');
+    
+    return http.ok();
 });
 
 r.serve();

package/examples/static.ts

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

package/examples/todo.ts

@@ -1,4 +1,4 @@
-import { router, http } from '..';
+import { Router, http } from '..';
 import { Context } from '../lib/router/router.d';
 
 const Todo = () => {
@@ -15,7 +15,7 @@ const Todo = () => {
 
 const todo = Todo();
 
-const r = router();
+const r = Router();
 
 r.add('/api/new', 'POST', ctx => {
     const query = new URL(ctx.request.url).searchParams;

package/lib/fs/fsys.ts

@@ -20,7 +20,7 @@ const readDir = async (dirpath: string, handler: (filepath: string, entry: BunFi
             if (isdir) await readDir(fp, handler);
             else handler(fp, bunFile);
         }
-
 }
 
+
 export { readDir }

package/lib/http/{generic-methods.ts → http.ts}

@@ -1,6 +1,12 @@
 import { httpStatusCodes } from "./status";
 
 const http = {
+    ok: async (msg?: string): Promise<Response> => {
+        return Promise.resolve(new Response(msg ?? httpStatusCodes[200], {
+            status: 200,
+            statusText: httpStatusCodes[200],
+        }));
+    },
     json: async (statusCode: number, data: any): Promise<Response> => {
         const jsonString = JSON.stringify(data);
         return Promise.resolve(new Response(jsonString, {
@@ -10,8 +16,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 +55,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,
@@ -57,7 +71,7 @@ const http = {
             headers: {'Content-Type': 'text/html; charset-utf-8'},
         });
         return Promise.resolve(response)
-    }, 
+    },
 }
 
 export { http }

package/lib/logger/color.ts

@@ -20,16 +20,16 @@ const Colors: Record<string,string> = {
     bgMagenta: "\x1b[45m",
     bgCyan: "\x1b[46m",
     bgWhite: "\x1b[47m",
-  };
+  } as const;
 
   
-const color = (c: string, bkg: string, msg: string) => {
-    const foreground = Colors[c];
-    const background = Colors[bkg];
-    const reset = Colors.reset;
 
-    return `${foreground}${background}${msg}${reset}`;
-};
+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}`;
+}
 
 
   

package/lib/logger/logger.d.ts

@@ -1,9 +1,8 @@
-type Logger = {
-    start: (port: number | string) => void,
+type BunLogger = {
     info: (statusCode: number, routePath: string, method: string, message?: string) => void,
     error: (statusCode: number, routePath: string, method: string, error: Error) => void,
-    warn: (msg: string) => void,
-    message: (msg: string) => void,
+    warn: (message: string) => void,
+    message: (message: string) => void,
 }
 
-export { Logger }
+export { BunLogger }

package/lib/logger/logger.ts

@@ -1,9 +1,58 @@
 import { color } from './color';
-import {Logger} from './logger.d';
+import { BunLogger } from './logger.d';
+
+
+const TITLE = `
+_                          _           
+| |_ _ _ ___    ___ ___ _ _| |_ ___ ___ 
+| . | | |   |  |  _| . | | |  _| -_|  _|
+|___|___|_|_|  |_| |___|___|_| |___|_|  
+                                                                                    
+`
+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`
 
-const pad = (n: number) => String(n).padStart(2, '0'); 
+            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`;
 
-const timestamp = (date: Date) => {
+            await Bun.write(Bun.stdout, message);
+        },
+    }
+}
+
+function timestamp(date: Date) {
     const month = pad(date.getMonth());
     const day = pad(date.getDate());
     const hour = pad(date.getHours());
@@ -14,79 +63,32 @@ const timestamp = (date: Date) => {
     return {month, day, hour, minute, stamp};
 }
 
-// append ANSI color escape sequences to a string based on the given HTTP status code.
-const colorCode = (n: number, text?:string): string => {
+function setColor(n: number, text?: string){
     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);
+
     return color('white', 'bgBlack', `[${s}]`).trim();
 }
 
-
-const clean = (s: string) => s.replace(/\x1B\[\d{1,2}(;\d{1,2}){0,2}m/g, '');
-
-const format = (statusCode: number, routePath: string, method: string, message?: string): string => {
+function startMessage(port: number | string) {
     const { stamp } = timestamp((new Date(Date.now())));
-    const source = color('green', 'bgBlack', `[bun-router ${stamp}]`);
-    const rp = color('white', 'bgBlack', routePath);
+    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`);
 
-    return `${source} : ${colorCode(statusCode)} : ${rp} ${(method === 'GET') ? '->' : '<-'} ${method}\n`
+    Bun.write(Bun.stdout, TITLE + '\n' + version);
+    Bun.write(Bun.stdout, msg);
 }
 
-const logger = (): Logger => {
-    const messages: string[] = [];
-    const errors: string[] = [];
-    return {
-        // initial log message
-        start: async (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`;
-
-            await Bun.write(Bun.stdout, msg);
-        },
-        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);
-            const msg = `${source}: ${colorCode(statusCode)}: ${rp} ${(method === 'GET') ? '->' : '<-'} ${method}${' | ' +message ?? ''}\n`
-
-            await Bun.write(Bun.stdout, msg);
-
-            messages.push(clean(msg));
-        },
-        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 msg = `${source}: ${colorCode(statusCode)}: ${rp} ${(method === 'GET') ? '->' : '<-'} ${error.message}\n`;
-
-            await Bun.write(Bun.stdout, msg);
-
-            errors.push(clean(msg));
-        },
-        warn: async (msg: string) => {
-            const { stamp } = timestamp((new Date(Date.now())));
-            const source = color('black', 'bgYellow', `[warning ${stamp}]`);
-            const msgColor = color('yellow', 'bgBlack', msg);
-            msg = `${source} : ${msgColor}\n`;
-            await Bun.write(Bun.stdout, msg);
-        },
-        message: async (msg: string) => {
-            const { stamp } = timestamp((new Date(Date.now())));
-            const source = color('black', 'bgCyan', `[message ${stamp}]`);
-            const msgColor = color('yellow', 'bgBlack', msg);
-            msg = `${source}: ${msgColor}\n`;
-            await Bun.write(Bun.stdout, msg);
-
-            messages.push(clean(msg));
-        }
-    }
+function pad(n: number) {
+    return String(n).padStart(2, '0');
 }
 
-export { logger }
+export { Logger, startMessage }

package/lib/router/context.ts

@@ -0,0 +1,49 @@
+import { Route, Context } from "./router.d";
+import { Logger } from "../..";
+import { http } from "./router";
+
+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('/');
+
+    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);
+        }
+    }
+
+    return params;
+}
+
+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),
+    });
+}
+
+function getContentType(headers: Headers): string {
+    const contentType = headers.get('Content-Type');
+    if (!contentType) return '';
+    return contentType;
+}
+
+function isMultiPartForm(headers: Headers): boolean {
+    const contentType = getContentType(headers);
+    return contentType.includes('multipart/form-data');
+}
+
+export { createContext }

package/lib/router/router.d.ts

@@ -2,26 +2,37 @@ import { TLSOptions, TLSWebSocketServeOptions, WebSocketServeOptions, ServeOptio
 import { Logger } from '../logger/logger';
 import { Database } from 'bun:sqlite';
 
+type BunRouter = (port?: number | string, options?: RouterOptions) => {
+    add: (pattern: string, method: string, callback: HttpHandler) => void;
+    get: (pattern: string, callback: HttpHandler) => void;
+    post: (pattern: string, callback: HttpHandler) => void;
+    put: (pattern: string, callback: HttpHandler) => void;
+    delete: (pattern: string, callback: HttpHandler) => void;
+    static: (pattern: string, root: string) => void;
+    serve: () => void;
+}
+
+type Route = {
+    children: Map<string, Route>;
+    path: string;
+    dynamicPath: string;
+    method: string;
+    handler: HttpHandler;
+    isLast: boolean;
+}
 
 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,
+    db?: Database;
+    formData: FormData | Promise<FormData>;
+    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>
-}
+type HttpHandler = (ctx: Context) => Response | Promise<Response>
 
 type Options = {
     db: string,
@@ -33,15 +44,4 @@ type RouterOptions<Options> = ServeOptions
 | TLSWebSocketServeOptions<Options>
 | undefined
 
-
-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,
-}
-
-
-
-export { Context , Route, Router, RouterOptions, Options }
+export { Context , Route, BunRouter, RouterOptions, Options, HttpHandler }

package/lib/router/router.ts

@@ -1,96 +1,27 @@
 import path from 'path';
 import { Database } from 'bun:sqlite';
-import { Route, Router, Context, RouterOptions, Options } from './router.d';
+import { Route, BunRouter, 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 { Logger, startMessage } from '../logger/logger';
+import { http } from '../http/http';
+import {RouteTree } from './tree';
+import { createContext } from './context';
 
-// 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 url = new URL(ctx.request.url);
-    const pathSegments = route.pattern.split('/');
-    const urlSegments = url.pathname.split('/');
 
-    if (pathSegments.length !== urlSegments.length) return
+const Router: BunRouter = (port?: number | string, options?: RouterOptions<Options>) => {
+    const { addRoute, findRoute } = RouteTree();
+    const logger = Logger();
 
     return {
-        params: () => {
-            for (let i = 0; i < pathSegments.length; i++) {
-                if ((pathSegments[i][0] === ':')) {
-                    const k = pathSegments[i].replace(':', '');
-                    const v = urlSegments[i];
-                    ctx.params.set(k, v);
-                }
-            }
-        }
-    }
-
-}
-
-// 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 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 for static files
+        // 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) },
+        
+        // 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,17 +38,20 @@ 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
         serve: () => {
-            lgr.start(port ?? 3000);
+            startMessage(port ?? 3000);
             let opts: Options = { db: ':memory:' };
 
             Bun.serve({
@@ -125,52 +59,42 @@ const router: Router = (port?: number | string, options?: RouterOptions<Options>
                 ...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;
-
-                    for (const route of routes) {
-                        const ctx = setContext(req, lgr, opts, route);
+                    const route = findRoute(path);
 
-                        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) {
+                            logger.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 = await 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;
+                        logger.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();
+                        
+                    logger.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]));
                 }
             });
         },
     }
 }
 
-
-export { router, extract, http }
+export { Router, http }

package/lib/router/tree.ts

@@ -0,0 +1,63 @@
+import { HttpHandler, Context, 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

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

package/package.json

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

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

@@ -1,15 +0,0 @@
-import { router } from '..';
-
-const r = router();
-
-r.add('/set-cookie', 'GET', ctx => {
-    ctx.cookies.set('domain', 'localhost');
-    ctx.cookies.set('path', '/set-cookie');
-
-    ctx.logger.message(ctx.token ?? 'no token provided');
-
-    return ctx.json( 200, {message: 'cookie stored'});
-});
-
-
-r.serve();

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();