bun-router 0.4.0 → 0.5.0

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

@@ -14,6 +14,7 @@ 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 => {
     const s = ` [${String(n)}${text ?? ''}] `;
     if (n < 100) return color('black', 'bgYellow', s);
@@ -39,6 +40,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}]`)

package/lib/router/router.d.ts

@@ -1,11 +1,12 @@
 import { TLSOptions, TLSWebSocketServeOptions, WebSocketServeOptions, ServeOptions, TLSServeOptions } from 'bun';
+import { Database } from 'bun:sqlite';
 
 
 type Context = {
     request: Request,
     params: Map<string, string>,
-    fs: Map<string, string>,
     token?: string,
+    db: Database,
 }
 
 type Route = {
@@ -14,18 +15,22 @@ 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,
     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,24 @@
-import { Route, Router, Context, Options } from './router.d';
+import { Database } from 'bun:sqlite';
+import { Route, Router, Context, RouterOptions, Options } from './router.d';
 import { readDir } from '../fs/fsys';
 import { logger } from '../logger/logger';
 import path from 'path';
 
-const notFound = async (): Promise<Response> => {
-    const response = new Response('not found', {
+// 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);
+    });
+};
+
+// 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 +29,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 +41,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 +98,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 +107,6 @@ const extract = (route: Route, ctx: Context) => {
 
     if (pathSegments.length !== urlSegments.length) return
 
-
     return {
         params: () => {
             for (let i = 0; i < pathSegments.length; i++) {
@@ -98,6 +121,7 @@ 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, '([^/]+)') + '$');
@@ -113,12 +137,15 @@ const match = (route: Route, ctx: Context): boolean => {
     return false;
 }
 
-const router: Router = (port?: number | string, options?: Options) => {
+
+
+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 +153,7 @@ const router: Router = (port?: number | string, options?: Options) => {
                 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 +161,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 +177,44 @@ 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;
+                    }
                     for (const route of routes) {
                         const ctx: Context = {
                             request: req,
                             params: new Map(),
-                            fs: new Map(),
+                            db: new Database(opts.db ?? ':memory:'),
                         };
 
                         if (url.pathname === '/favicon.ico') return noContent();
 
                         if (match(route, ctx)) {
-                            lgr.info(200, route.pattern, route.method)
-                            return route.callback(ctx);
+                            const res = await route.callback(ctx);
+                            lgr.info(res.status, url.pathname, route.method); 
+                            return res;
                         }
                     }
                     lgr.info(404, url.pathname, req.method, 'not found');
-                    return new Response('not found');
+                    return httpMessage(404, 'not found');
                 }
             });
         },
     }
 }
 
+
 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.0"
 }

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);
     });
 });
+