bun-router 0.5.0 → 0.5.4

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/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

@@ -26,6 +26,7 @@ const colorCode = (n: number, text?:string): string => {
     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 => {
@@ -53,7 +54,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);
 
@@ -75,6 +76,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,4 +1,5 @@
 import { TLSOptions, TLSWebSocketServeOptions, WebSocketServeOptions, ServeOptions, TLSServeOptions } from 'bun';
+import { Logger } from '../logger/logger';
 import { Database } from 'bun:sqlite';
 
 
@@ -7,6 +8,7 @@ type Context = {
     params: Map<string, string>,
     token?: string,
     db: Database,
+    logger: Logger,
 }
 
 type Route = {
@@ -28,6 +30,8 @@ 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,
 }

package/lib/router/router.ts

@@ -1,15 +1,17 @@
 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'}
+        headers: { 'Content-Type': 'text/html; charset-uft-8' }
     });
     return new Promise((resolve) => {
         resolve(response);
@@ -127,7 +129,7 @@ const match = (route: Route, ctx: Context): boolean => {
     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();
 
@@ -137,6 +139,15 @@ const match = (route: Route, ctx: Context): boolean => {
     return false;
 }
 
+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>) => {
@@ -153,6 +164,20 @@ const router: Router = (port?: number | string, options?: RouterOptions<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, _) => {
@@ -180,36 +205,54 @@ const router: Router = (port?: number | string, options?: RouterOptions<Options>
         // start the server
         serve: () => {
             lgr.start(port ?? 3000);
-            let opts: Options = {db: ':memory:'};
+            let opts: Options = { db: ':memory:' };
 
             Bun.serve({
                 port: port ?? 3000,
                 ...options,
                 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(),
-                            db: new Database(opts.db ?? ':memory:'),
-                        };
+                        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)) {
                             const res = await route.callback(ctx);
-                            lgr.info(res.status, url.pathname, route.method); 
-                            return res;
+                            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 httpMessage(404, '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]);
+
                 }
             });
         },

package/package.json

@@ -8,5 +8,5 @@
   "peerDependencies": {
     "typescript": "^5.0.0"
   },
-  "version": "0.5.0"
+  "version": "0.5.4"
 }