bun-router 0.4.0 → 0.5.3

package/README.md

@@ -52,4 +52,32 @@ r.add('/user/:id', 'GET', (ctx) => {
 });
 
 r.serve();
+```
+
+**SQLite**
+```ts
+import { router, json } from '..';
+import { Database } from 'bun:sqlite';
+
+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 json({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 ? json(d) : new Response('not found', {status: 404});
+});
+
+r.serve();
+
 ```

package/examples/dynamic.ts

@@ -1,4 +1,5 @@
-import { router, html, Context } from '..';
+import { router, html } from '..';
+import { Context } from '../lib/router/router.d';
 
 const handler = (ctx: Context) => {
     const name = ctx.params.get('name');

package/examples/sqlite.ts

@@ -0,0 +1,22 @@
+import { router, json } 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 json({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 ? json(d) : new Response('not found', {status: 404});
+});
+
+r.serve();

package/index.ts

@@ -1,5 +1,3 @@
 export * from './lib/router/router';
-export * from './lib/router/router.d';
 export * from './lib/fs/fsys';
 export * from './lib/logger/logger';
-export * from './lib/logger/logger.d';

package/lib/fs/fsys.ts

@@ -2,23 +2,25 @@ import { BunFile } from "bun";
 import fs from 'node:fs/promises';
 import path from 'path';
 
+// check if the file path is a directory
 const isDir = async (fp: string): Promise<boolean> => (await fs.lstat(fp)).isDirectory();
 
+// read a directory recursively and apply the callback to each one
 const readDir = async (dirpath: string, handler: (filepath: string, entry: BunFile) => void) => {
-    try {
         const files = await fs.readdir(dirpath);
 
         for (const file of files) {
             const bunFile = Bun.file(file);
-            const fp = path.join(dirpath, bunFile.name!);
+
+            if (typeof bunFile.name === 'undefined') return
+
+            const fp = path.join(dirpath, bunFile.name);
             const isdir = await isDir(fp);
 
             if (isdir) await readDir(fp, handler);
             else handler(fp, bunFile);
         }
-    } catch (err) {
-        console.error(err);
-    }
+
 }
 
 export { readDir }

package/lib/http/status.ts

@@ -0,0 +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',
+  };
+
+  export { httpStatusCodes }

package/lib/logger/logger.d.ts

@@ -3,6 +3,7 @@ type Logger = {
     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,
 }
 
 export { Logger }

package/lib/logger/logger.ts

@@ -14,17 +14,23 @@ const timestamp = (date: Date) => {
     return {month, day, hour, minute, stamp};
 }
 
-const colorCode = (n: number, text?:string): string => {
+// append ANSI color escape sequences to a string based on the given HTTP status code.
+const colorCode = (n: number, text?: string): 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();
+    let backgroundColor = 'bgBlack';
+    let foregroundColor = 'white';
+
+    if (n < 100) backgroundColor = 'bgYellow';
+    else if (n < 200) backgroundColor = 'bgCyan';
+    else if (n < 300) backgroundColor = 'bgGreen';
+    else if (n < 400) backgroundColor = 'bgRed';
+    else if (n < 500) backgroundColor = 'bgRed';
+    else foregroundColor = 'white';
+
+    return color(foregroundColor, backgroundColor, 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 => {
@@ -39,6 +45,7 @@ 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}]`)
@@ -51,7 +58,7 @@ const logger = (): Logger => {
             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}\n`
+            const msg = `${source}: ${colorCode(statusCode)}: ${rp} ${(method === 'GET') ? '->' : '<-'} ${method}${' | ' +message ?? ''}\n`
 
             await Bun.write(Bun.stdout, msg);
 
@@ -73,6 +80,15 @@ const logger = (): Logger => {
             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));
         }
     }
 }

package/lib/router/router.d.ts

@@ -1,11 +1,14 @@
 import { TLSOptions, TLSWebSocketServeOptions, WebSocketServeOptions, ServeOptions, TLSServeOptions } from 'bun';
+import { Logger } from '../logger/logger';
+import { Database } from 'bun:sqlite';
 
 
 type Context = {
     request: Request,
     params: Map<string, string>,
-    fs: Map<string, string>,
     token?: string,
+    db: Database,
+    logger: Logger,
 }
 
 type Route = {
@@ -14,18 +17,24 @@ type Route = {
     callback: (req: Context) => Response | Promise<Response>
 }
 
-type Options = ServeOptions
-| TLSServeOptions
-| WebSocketServeOptions
-| TLSWebSocketServeOptions
+type Options = {
+    db: string,
+}
+
+type RouterOptions<Options> = ServeOptions
+| TLSServeOptions<Options>
+| WebSocketServeOptions<Options>
+| TLSWebSocketServeOptions<Options>
 | undefined
 
 
-type Router = (port?: number | string, options?: Options) => {
+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, Options }
+export { Context , Route, Router, RouterOptions, Options }

package/lib/router/router.ts

@@ -1,10 +1,26 @@
-import { Route, Router, Context, Options } from './router.d';
+import { Database } from 'bun:sqlite';
+import { Route, Router, Context, RouterOptions, Options } from './router.d';
+import { httpStatusCodes } from '../http/status';
 import { readDir } from '../fs/fsys';
 import { logger } from '../logger/logger';
 import path from 'path';
+import { Logger } from '../logger/logger.d';
+
+// create a generic HTTP response
+const httpMessage = async (status: number, msg?: string): Promise<Response> => {
+    const response = new Response(msg ?? '?', {
+        status: status,
+        statusText: msg ?? '?',
+        headers: { 'Content-Type': 'text/html; charset-uft-8' }
+    });
+    return new Promise((resolve) => {
+        resolve(response);
+    });
+};
 
-const notFound = async (): Promise<Response> => {
-    const response = new Response('not found', {
+// a generic 'not found' HTTP response
+const notFound = async (msg?: string): Promise<Response> => {
+    const response = new Response(msg ?? 'not found', {
         status: 404,
         statusText: 'not found',
         headers: { 'Content-Type': 'text/html' },
@@ -15,6 +31,7 @@ const notFound = async (): Promise<Response> => {
     });
 }
 
+// a generic 'no content' HTTP response
 const noContent = async (): Promise<Response> => {
     const response = new Response('no content', {
         status: 204,
@@ -26,47 +43,54 @@ const noContent = async (): Promise<Response> => {
     });
 }
 
+// IO handling
 const file = async (filepath: string): Promise<Response> => {
     const file = Bun.file(filepath);
     const exists = await file.exists();
 
+    // check if the file exists, return 'not found' if it doesn't.
     if (!exists)
-        return notFound();
+        return notFound(`File not found: ${filepath}`);
 
+    // get the content of the file as an ArrayBuffer
     const content = await file.arrayBuffer();
     if (!content)
-        return notFound();
+        return noContent();
 
+    // default Content-Type + encoding
     let contentType = 'text/html; charset=utf-8';
 
+    // change the Content-Type if the file type is an image.
+    // file.type provides the necessary Content-Type
     if (file.type.includes('image')) {
         contentType = file.type + '; charset=utf-8';
     }
 
+    // create a new response with the necessary criteria
     const response = new Response(content, {
         status: 200,
         statusText: 'ok',
         headers: { 'Content-Type': contentType },
     });
 
-    return new Promise<Response>((resolve) => {
-        resolve(response);
-    });
+    return Promise.resolve(response);
 }
 
+// handle strings as HTML
 const html = async (content: string): Promise<Response> => {
     const response = new Response(content, {
         status: 200,
         statusText: 'ok',
         headers: { 'Content-Type': 'text/html; charset=utf-8' },
     });
+
+    // escape the HTML
     content = Bun.escapeHTML(content);
 
-    return new Promise<Response>((resolve) => {
-        resolve(response);
-    });
+    return Promise.resolve(response);
 }
 
+// create a JSON response
 const json = (data: any): Response => {
     const jsonString = JSON.stringify(data);
 
@@ -76,6 +100,8 @@ const json = (data: any): Response => {
     return res
 }
 
+// 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('/');
@@ -83,7 +109,6 @@ const extract = (route: Route, ctx: Context) => {
 
     if (pathSegments.length !== urlSegments.length) return
 
-
     return {
         params: () => {
             for (let i = 0; i < pathSegments.length; i++) {
@@ -98,12 +123,13 @@ 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) {
+    if (matches && route.method === ctx.request.method) {
         const extractor = extract(route, ctx);
         extractor?.params();
 
@@ -113,12 +139,24 @@ const match = (route: Route, ctx: Context): boolean => {
     return false;
 }
 
-const router: Router = (port?: number | string, options?: Options) => {
+const setContext = (req: Request, lgr: Logger, opts: Options): Context => {
+    return {
+        request: req,
+        params: new Map(),
+        db: new Database(opts.db ?? ':memory:'),
+        logger: lgr,
+    }
+}
+
+
+
+const router: Router = (port?: number | string, options?: RouterOptions<Options>) => {
     const routes: Array<Route> = new Array();
-    const paths: { [key: string]: string } = {};
     const lgr = logger();
+    let dbConn = '';
 
     return {
+        // add a new route
         add: (pattern: string, method: string, callback: (ctx: Context) => Response | Promise<Response>) => {
             routes.push({
                 pattern: pattern,
@@ -126,6 +164,21 @@ const router: Router = (port?: number | string, options?: Options) => {
                 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
         static: async (pattern: string, root: string) => {
             await readDir(root, async (fp, _) => {
                 const pure = path.join('.', fp);
@@ -133,10 +186,7 @@ const router: Router = (port?: number | string, options?: Options) => {
 
                 let base = path.basename(pure);
 
-                if (ext === '.html') {
-                    base = base.replace(ext, '');
-
-                }
+                if (ext === '.html') base = base.replace(ext, '');
 
                 if (pattern[0] !== '/') pattern = '/' + pattern;
 
@@ -152,33 +202,62 @@ const router: Router = (port?: number | string, options?: Options) => {
                 routes.push(route);
             });
         },
+        // start the server
         serve: () => {
             lgr.start(port ?? 3000);
+            let opts: Options = { db: ':memory:' };
+
             Bun.serve({
                 port: port ?? 3000,
                 ...options,
-                fetch(req) {
+                async fetch(req) {
                     const url = new URL(req.url);
+
+                    if (options) {
+                        let o = options as Options;
+                        opts.db = o.db;
+                    }
+
+                    let statusCode = 404; // Default status code for route not found
+
                     for (const route of routes) {
-                        const ctx: Context = {
-                            request: req,
-                            params: new Map(),
-                            fs: new Map(),
-                        };
+                        const ctx = setContext(req, lgr, opts);
 
-                        if (url.pathname === '/favicon.ico') return noContent();
+                        if (url.pathname === '/favicon.ico') {
+                            return noContent();
+                        }
+
+                        if (route.method !== req.method) {
+                            statusCode = 405;
+                            continue;
+                        }
 
                         if (match(route, ctx)) {
-                            lgr.info(200, route.pattern, route.method)
-                            return route.callback(ctx);
+                            const res = await route.callback(ctx);
+                            if (res) {
+                                statusCode = 200;
+                                lgr.info(statusCode, url.pathname, req.method, httpStatusCodes[statusCode]);
+                                return res
+                            } else {
+                                statusCode = 500;
+                                break;
+                            }
                         }
                     }
-                    lgr.info(404, url.pathname, req.method, 'not found');
-                    return new Response('not found');
+
+                    if (statusCode === 405) {
+                        lgr.info(statusCode, url.pathname, req.method, httpStatusCodes[statusCode]);
+                        return httpMessage(statusCode, httpStatusCodes[statusCode]);
+                    }
+
+                    lgr.info(statusCode, url.pathname, req.method, httpStatusCodes[statusCode]);
+                    return httpMessage(statusCode, httpStatusCodes[statusCode]);
+
                 }
             });
         },
     }
 }
 
+
 export { router, json, file, extract, html }

package/package.json

@@ -8,5 +8,5 @@
   "peerDependencies": {
     "typescript": "^5.0.0"
   },
-  "version": "0.4.0"
+  "version": "0.5.3"
 }

package/tests/router.test.ts

@@ -1,8 +1,6 @@
 import { describe, test, expect } from 'bun:test';
-import { router, extract } from '..';
+import { extract } from '..';
 import { Context, Route } from '../lib/router/router.d';
-import { logger } from '../lib/logger/logger';
-import { color } from '../lib/logger/color';
 
 describe('URL Params', () => {
     test('/user/:name', () => {
@@ -15,7 +13,6 @@ describe('URL Params', () => {
         const ctx: Context = {
             request: new Request('http://localhost:3000/user/foo'),
             params: new Map(),
-            fs: new Map(),
         };
 
         const extractor = extract(route, ctx);
@@ -36,7 +33,6 @@ describe('URL Params', () => {
         const ctx: Context = {
             request: new Request('http://localhost:3000/user/foo/123'),
             params: new Map(),
-            fs: new Map(),
         };
 
         const extractor = extract(route, ctx);
@@ -60,7 +56,6 @@ describe('URL Params', () => {
         const ctx: Context = {
             request: new Request('http://localhost:3000/foo'),
             params: new Map(),
-            fs: new Map(),
         }
 
         const url = new URL(ctx.request.url);
@@ -72,7 +67,7 @@ describe('URL Params', () => {
 describe('Router', () => {
     test('Serve', async () => {
         const proc = Bun.spawn(['./tests/serve.test.sh'], {
-            onExit: (proc, exitCode, signalCode , error) => {
+            onExit: (_proc, _exitCode, _signalCode , error) => {
                 if (error) console.error(error);     
             },
         });
@@ -101,3 +96,4 @@ describe('Router', () => {
         proc.kill(0);
     });
 });
+