bun-router 0.5.4 → 0.5.8

package/examples/basic.ts

@@ -1,18 +1,18 @@
-import { router, html, json } from '..';
+import { router, http } from '..';
 
 const r = router();
 
-r.add('/', 'GET', () => json('ok'));
+r.add('/', 'GET', () => http.json('ok'));
 
 r.add('/user/:name', 'GET', (ctx) => {
     const name = ctx.params.get('name');
-    return json(name);
+    return http.json(name);
 });
 
 r.add('/user/:name/:id', 'GET', (ctx) => {
     const name = ctx.params.get('name');
     const id = ctx.params.get('id');
-    return json({name: name, id: id});
+    return http.json({name: name, id: id});
 });
 
 r.serve();

package/examples/dynamic.ts

@@ -1,22 +1,22 @@
-import { router, html } from '..';
+import { router, http } from '..';
 import { Context } from '../lib/router/router.d';
 
 const handler = (ctx: Context) => {
     const name = ctx.params.get('name');
-    if (typeof name === 'undefined' || name === '') return html('<h6 style="color: red">User Undefined</h6>');
-    return html(`<h4>Hello, ${name}!</h4>`);
+    if (typeof name === 'undefined' || name === '') return http.html('<h6 style="color: red">User Undefined</h6>');
+    return http.html(`<h4>Hello, ${name}!</h4>`);
 }
 
 const space = (ctx: Context) => {
     const name = ctx.params.get('name');
-    if (typeof name === 'undefined' || name === '') return html(`<h6 style="color: red">Space [${name}] Not Found</h6>`);
-    return html(`<h4>Welcome to ${name}!`)
+    if (typeof name === 'undefined' || name === '') return http.html(`<h6 style="color: red">Space [${name}] Not Found</h6>`);
+    return http.html(`<h4>Welcome to ${name}!`)
 }
 
 const handleSettings = (ctx: Context) => {
     const name = ctx.params.get('name');
-    if (typeof name === 'undefined' || name === '') return html(`<h6 style="color: red">User Not Found</h6>`);
-    return html(`<h4>Settings for ${name}</h4>`)
+    if (typeof name === 'undefined' || name === '') return http.html(`<h6 style="color: red">User Not Found</h6>`);
+    return http.html(`<h4>Settings for ${name}</h4>`)
 }
 
 const r = router();

package/examples/logger.ts

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

package/examples/sqlite.ts

@@ -1,4 +1,4 @@
-import { router, json } from '..';
+import { router, http } from '..';
 
 const r = router(3000, {db: './examples/dbs/test.db'});
 
@@ -8,7 +8,7 @@ r.add('/u/new/:name', 'GET', (ctx) => {
 
     ctx.db.run(`INSERT INTO test VALUES(${rando}, "${name}")`);
 
-    return json({message: 'ok'});
+    return http.json({message: 'ok'});
 });
 
 r.add('/u/:name', 'GET', (ctx) => {
@@ -16,7 +16,7 @@ r.add('/u/:name', 'GET', (ctx) => {
     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});
+    return d ? http.json(d) : new Response('not found', {status: 404});
 });
 
 r.serve();

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/http/generic-methods.ts

@@ -0,0 +1,64 @@
+import { httpStatusCodes } from "./status";
+
+const http = {
+    json: async (data: any): Promise<Response> => {
+        const jsonString = JSON.stringify(data);
+        return Promise.resolve(new Response(jsonString, {
+            status: 200,
+            statusText: httpStatusCodes[200],
+            headers: {'Content-Type': 'application/json'},
+        }));
+    },
+    html: async (content: string): Promise<Response> => {
+        content = Bun.escapeHTML(content);
+        return Promise.resolve(new Response(Bun.escapeHTML(content), {
+            status: 200,
+            statusText: httpStatusCodes[200],
+            headers: {'Content-Type': 'text/html; charset=utf-8'}
+        }));
+    },
+    file: async (fp: string): Promise<Response> => {
+        const file = Bun.file(fp);
+        const exists = await file.exists();
+    
+        if (!exists) return http.notFound(`File not found: ${fp}`);
+    
+        const content = await file.arrayBuffer();
+        if (!content) return http.noContent();
+    
+        let contentType = 'text/html; charset=utf-9';
+    
+        if (file.type.includes('image'))
+            contentType = file.type + '; charset=utf-8';
+    
+        return Promise.resolve(new Response(content, {
+            status: 200,
+            statusText: httpStatusCodes[200],
+            headers: { 'Content-Type': contentType}
+        }));
+    },
+    noContent: async (): Promise<Response> => Promise.resolve(new Response('no content', {
+        status: 204,
+        statusText: 'no content',
+    })),
+    notFound: async(msg?: string): Promise<Response> => {
+        const response = new Response(msg ?? 'not found', {
+            status: 404,
+            statusText: httpStatusCodes[404],
+            headers: {'Content-Type': 'text/html'},
+        });
+    
+        return Promise.resolve(response);
+    },
+    message:  async (status: number, msg?: string): Promise<Response> => {
+        const response = new Response(msg ?? '?', {
+            status: status,
+            statusText: httpStatusCodes[status],
+            headers: {'Content-Type': 'text/html; charset-utf-8'},
+        });
+        return Promise.resolve(response)
+    }
+
+}
+
+export { http }

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,104 +1,11 @@
+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';
-
-// 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' },
-    });
-
-    return new Promise((resolve) => {
-        resolve(response);
-    });
-}
-
-// a generic 'no content' HTTP response
-const noContent = async (): Promise<Response> => {
-    const response = new Response('no content', {
-        status: 204,
-        statusText: 'no content',
-    });
-
-    return new Promise((resolve) => {
-        resolve(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(`File not found: ${filepath}`);
-
-    // get the content of the file as an ArrayBuffer
-    const content = await file.arrayBuffer();
-    if (!content)
-        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 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 Promise.resolve(response);
-}
-
-// create a JSON response
-const json = (data: any): Response => {
-    const jsonString = JSON.stringify(data);
-
-    const res = new Response(jsonString);
-    res.headers.set('Content-Type', 'application/json');
-
-    return res
-}
+import { http } from '../http/generic-methods';
 
 // extract dynamic URL parameters
 // if the route pattern is /:foo and the request URL is /bar: {foo: 'bar'}
@@ -139,17 +46,18 @@ const match = (route: Route, ctx: Context): boolean => {
     return false;
 }
 
-const setContext = (req: Request, lgr: Logger, opts: Options): Context => {
+// set the context for the reuest
+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();
@@ -197,8 +105,9 @@ const router: Router = (port?: number | string, options?: RouterOptions<Options>
                 const route: Route = {
                     pattern: patternPath,
                     method: 'GET',
-                    callback: async () => await file(pure),
+                    callback: async () => await http.file(pure),
                 };
+
                 routes.push(route);
             });
         },
@@ -218,41 +127,30 @@ const router: Router = (port?: number | string, options?: RouterOptions<Options>
                         opts.db = o.db;
                     }
 
-                    let statusCode = 404; // Default status code for route not found
+                    let statusCode = 404;
 
                     for (const route of routes) {
-                        const ctx = setContext(req, lgr, opts);
-
-                        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);
-                            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 httpMessage(statusCode, httpStatusCodes[statusCode]);
+                        }  
                     }
 
                     lgr.info(statusCode, url.pathname, req.method, httpStatusCodes[statusCode]);
-                    return httpMessage(statusCode, httpStatusCodes[statusCode]);
-
+                    return Promise.resolve(http.message(statusCode, httpStatusCodes[statusCode]));
                 }
             });
         },
@@ -260,4 +158,4 @@ const router: Router = (port?: number | string, options?: RouterOptions<Options>
 }
 
 
-export { router, json, file, extract, html }
+export { router, extract, http }

package/package.json

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