bun-router 0.3.0 → 0.3.4

package/README.md

@@ -29,8 +29,6 @@ import {router, html, json } from 'bun-router';
 
 const r = router(3001);
 
-r.static('/assets', './assets');
-
 r.add('/', (ctx) => html('<h1>Hello World</h1>'));
 
 r.add('/greeting/:name', 'GET', (ctx) => {

package/examples/logger.ts

@@ -0,0 +1,16 @@
+import { router, logger, json, html } from '..';
+
+const r = router();
+const log = logger();
+
+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 json({status: 500, text: 'Foo is undefined'});
+    }
+    return html(`<h4 style='font-family: sans-serif;'>Oh hello, ${foo}</h4>`)
+});
+
+r.serve();

package/index.ts

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

package/lib/logger/color.ts

@@ -0,0 +1,36 @@
+const Colors: Record<string,string> = {
+    reset: "\x1b[0m",
+  
+    // foreground
+    black: "\x1b[30m",
+    red: "\x1b[31m",
+    green: "\x1b[32m",
+    yellow: "\x1b[33m",
+    blue: "\x1b[34m",
+    magenta: "\x1b[35m",
+    cyan: "\x1b[36m",
+    white: "\x1b[37m",
+  
+    // background
+    bgBlack: "\x1b[40m",
+    bgRed: "\x1b[41m",
+    bgGreen: "\x1b[42m",
+    bgYellow: "\x1b[43m",
+    bgBlue: "\x1b[44m",
+    bgMagenta: "\x1b[45m",
+    bgCyan: "\x1b[46m",
+    bgWhite: "\x1b[47m",
+  };
+
+  
+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}`;
+};
+
+
+  
+export { color }

package/lib/logger/logger.d.ts

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

package/lib/logger/logger.ts

@@ -0,0 +1,80 @@
+import { color } from './color';
+import {Logger} from './logger.d';
+
+const pad = (n: number) => String(n).padStart(2, '0'); 
+
+const timestamp = (date: Date) => {
+    const month = pad(date.getMonth());
+    const day = pad(date.getDate());
+    const hour = pad(date.getHours());
+    const minute = pad(date.getMinutes());
+    const seconds = pad(date.getSeconds());
+    const stamp = `${hour}:${minute}:${seconds}`;
+
+    return {month, day, hour, minute, stamp};
+}
+
+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();
+}
+
+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 => {
+    const { stamp } = timestamp((new Date(Date.now())));
+    const source = color('green', 'bgBlack', `[bun-router ${stamp}]`);
+    const rp = color('white', 'bgBlack', routePath);
+
+    return `${source} : ${colorCode(statusCode)} : ${rp} ${(method === 'GET') ? '->' : '<-'} ${method}\n`
+}
+
+const logger = (): Logger => {
+    const messages: string[] = [];
+    const errors: string[] = [];
+    return {
+        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}\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);
+        }
+    }
+}
+
+export { logger }

package/lib/router/router.ts

@@ -1,5 +1,6 @@
 import { Route, Router, Context, Options } from './router.d';
 import { readDir } from '../fs/fsys';
+import { logger } from '../logger/logger';
 import path from 'path';
 
 const notFound = async (): Promise<Response> => {
@@ -14,6 +15,17 @@ const notFound = async (): Promise<Response> => {
     });
 }
 
+const noContent = async (): Promise<Response> => {
+    const response = new Response('no content', {
+        status: 204,
+        statusText: 'no content',
+    });
+
+    return new Promise((resolve) => {
+        resolve(response);
+    });
+}
+
 const file = async (filepath: string): Promise<Response> => {
     const file = Bun.file(filepath);
     const exists = await file.exists();
@@ -93,6 +105,7 @@ const match = (route: Route, ctx: Context): boolean => {
 const router: Router = (port?: number | string, options?: Options) => {
     const routes: Array<Route> = new Array();
     const paths: { [key: string]: string } = {};
+    const lgr = logger();
 
     return {
         add: (pattern: string, method: string, callback: (ctx: Context) => Response | Promise<Response>) => {
@@ -114,15 +127,12 @@ const router: Router = (port?: number | string, options?: Options) => {
 
                 }
 
-                console.log((pattern[0] != '/'))
                 if (pattern[0] !== '/') pattern = '/' + pattern;
 
                 let patternPath = pattern + base;
 
                 if (base === 'index') patternPath = pattern;
 
-                console.log(patternPath);
-
                 const route: Route = {
                     pattern: patternPath,
                     method: 'GET',
@@ -130,15 +140,14 @@ const router: Router = (port?: number | string, options?: Options) => {
                 };
                 routes.push(route);
             });
-            console.log(routes.length);
-
         },
         serve: () => {
-            console.log(`[bun-router]: Listening on port -> :${port ?? 3000}`)
+            lgr.start(port ?? 3000);
             Bun.serve({
                 port: port ?? 3000,
                 ...options,
                 fetch(req) {
+                    const url = new URL(req.url);
                     for (const route of routes) {
                         const ctx: Context = {
                             request: req,
@@ -150,9 +159,14 @@ const router: Router = (port?: number | string, options?: Options) => {
 
                         extractor?.params();
 
-                        if (match(route, ctx))
+                        if (url.pathname === '/favicon.ico') return noContent();
+
+                        if (match(route, ctx)) {
+                            lgr.info(200, route.pattern, route.method)
                             return route.callback(ctx);
+                        }
                     }
+                    lgr.info(404, url.pathname, req.method, 'not found');
                     return new Response('not found');
                 }
             });

package/package.json

@@ -8,5 +8,5 @@
   "peerDependencies": {
     "typescript": "^5.0.0"
   },
-  "version": "0.3.0"
+  "version": "0.3.4"
 }

package/tests/router.test.ts

@@ -1,6 +1,8 @@
 import { describe, test, expect } from 'bun:test';
 import { router, 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', () => {
@@ -98,4 +100,4 @@ describe('Router', () => {
 
         proc.kill(0);
     });
-});
+});

package/tests/static.test.sh

@@ -46,7 +46,10 @@ function run_test() {
         echo "Failed: $url returned $actual | expected: $expected"
     fi
 
-    rm "$name"
+    if does_exist "$name"; then
+        rm "$name"
+    fi
+
 }
 
 for expected in "${!test_cases[@]}"; do