bun-router 0.5.5 → 0.5.8

package/examples/todo.ts

@@ -0,0 +1,49 @@
+import { router, http } from '..';
+import { Context } from '../lib/router/router.d';
+
+const Todo = () => {
+    const list: Record<string, string> = {};
+
+    return {
+        add: (key: string, value: string) => { list[key] = value },
+        get: (key: string) => list[key],
+        remove: (key: string) => { delete list[key] },
+        size: () => Object.entries(list).length,
+        export: () => list,
+    }
+}
+
+const todo = Todo();
+
+const r = router();
+
+r.add('/api/new', 'POST', ctx => {
+    const query = new URL(ctx.request.url).searchParams;
+    const key = query.get('key');
+    const content = query.get('content');
+
+    if (!key || !content) return http.message(400, 'invalid query params');
+    ctx.logger.message(`Adding ${key} with ${content}`);
+    todo.add(key, content);
+
+    return ctx.json({ message: 'ok' });
+});
+
+r.add('/api/todo/:key', 'GET', ctx => {
+    const key = ctx.params.get('key');
+    if (!key) return http.message(400, 'invalid params');
+
+    const content = todo.get(key);
+    if (!content) return http.notFound();
+
+    return ctx.json({key: key, content: content});
+});
+
+r.add('/api/get/all', 'GET', ctx => {
+    return ctx.json(todo.export());
+});
+
+r.serve();
+
+
+

package/lib/router/router.d.ts

@@ -5,10 +5,12 @@ import { Database } from 'bun:sqlite';
 
 type Context = {
     request: Request,
+    route: Route,
     params: Map<string, string>,
     token?: string,
     db: Database,
     logger: Logger,
+    json: (data: any) => Response | Promise<Response>,
 }
 
 type Route = {

package/lib/router/router.ts

@@ -1,9 +1,9 @@
+import path from 'path';
 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';
 import { http } from '../http/generic-methods';
 
@@ -47,17 +47,17 @@ const match = (route: Route, ctx: Context): boolean => {
 }
 
 // set the context for the reuest
-const setContext = (req: Request, lgr: Logger, opts: Options): Context => {
+const setContext = (req: Request, lgr: Logger, opts: Options, route: Route): Context => {
     return {
         request: req,
         params: new Map(),
         db: new Database(opts.db ?? ':memory:'),
         logger: lgr,
+        route: route,
+        json: (data: any) => http.json(data),
     }
 }
 
-
-
 const router: Router = (port?: number | string, options?: RouterOptions<Options>) => {
     const routes: Array<Route> = new Array();
     const lgr = logger();
@@ -107,6 +107,7 @@ const router: Router = (port?: number | string, options?: RouterOptions<Options>
                     method: 'GET',
                     callback: async () => await http.file(pure),
                 };
+
                 routes.push(route);
             });
         },
@@ -129,38 +130,27 @@ const router: Router = (port?: number | string, options?: RouterOptions<Options>
                     let statusCode = 404;
 
                     for (const route of routes) {
-                        const ctx = setContext(req, lgr, opts);
-
-                        if (url.pathname === '/favicon.ico') {
-                            return http.noContent();
-                        }
-
-                        if (route.method !== req.method) {
-                            statusCode = 405;
-                            continue;
-                        }
-
-                        if (match(route, ctx)) {
-                            const res = await route.callback(ctx);
-                            if (res) {
-                                statusCode = 200;
-                                lgr.info(statusCode, url.pathname, req.method, httpStatusCodes[statusCode]);
-                                return res
+                        const ctx = setContext(req, lgr, opts, route);
+
+                        if (match(route, ctx) || route.pattern === url.pathname) {
+                            if (route.method === ctx.request.method) {
+                                const res = await route.callback(ctx);
+                                statusCode = res.status;
+                                lgr.info(res.status, route.pattern, req.method, httpStatusCodes[res.status]);
+                                return Promise.resolve(res);
                             } else {
-                                statusCode = 500;
-                                break;
+                                const res = new Response(httpStatusCodes[405], {
+                                    status: 405,
+                                    statusText: httpStatusCodes[305]
+                                });
+                                lgr.info(405, route.pattern, req.method, httpStatusCodes[405])
+                                return Promise.resolve(res);
                             }
-                        }
-                    }
-
-                    if (statusCode === 405) {
-                        lgr.info(statusCode, url.pathname, req.method, httpStatusCodes[statusCode]);
-                        return http.message(statusCode, httpStatusCodes[statusCode]);
+                        }  
                     }
 
                     lgr.info(statusCode, url.pathname, req.method, httpStatusCodes[statusCode]);
-                    return http.message(statusCode, httpStatusCodes[statusCode]);
-
+                    return Promise.resolve(http.message(statusCode, httpStatusCodes[statusCode]));
                 }
             });
         },

package/package.json

@@ -8,5 +8,5 @@
   "peerDependencies": {
     "typescript": "^5.0.0"
   },
-  "version": "0.5.5"
+  "version": "0.5.8"
 }