bun-router 0.5.5 → 0.6.0

package/examples/basic.ts

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

package/examples/cookies.ts

@@ -0,0 +1,15 @@
+import { router } from '..';
+
+const r = router();
+
+r.add('/set-cookie', 'GET', ctx => {
+    ctx.cookies.set('domain', 'localhost');
+    ctx.cookies.set('path', '/set-cookie');
+
+    ctx.logger.message(ctx.token ?? 'no token provided');
+
+    return ctx.json( 200, {message: 'cookie stored'});
+});
+
+
+r.serve();

package/examples/dynamic.ts

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

package/examples/logger.ts

@@ -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 http.json({status: 500, text: 'Foo is undefined'});
+        return http.json(500,{text: 'Foo is undefined'});
     }
-    return http.html(`<h4 style='font-family: sans-serif;'>Oh hello, ${foo}</h4>`)
+    return http.html(200, `<h4 style='font-family: sans-serif;'>Oh hello, ${foo}</h4>`)
 });
 
 r.serve();

package/examples/sqlite.ts

@@ -8,7 +8,7 @@ r.add('/u/new/:name', 'GET', (ctx) => {
 
     ctx.db.run(`INSERT INTO test VALUES(${rando}, "${name}")`);
 
-    return http.json({message: 'ok'});
+    return http.json(200, {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 ? http.json(d) : new Response('not found', {status: 404});
+    return d ? http.json(200, 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(200, { 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(200, {key: key, content: content});
+});
+
+r.add('/api/get/all', 'GET', ctx => {
+    return ctx.json(200, todo.export());
+});
+
+r.serve();
+
+
+

package/lib/http/generic-methods.ts

@@ -1,23 +1,23 @@
 import { httpStatusCodes } from "./status";
 
 const http = {
-    json: async (data: any): Promise<Response> => {
+    json: async (statusCode: number, data: any): Promise<Response> => {
         const jsonString = JSON.stringify(data);
         return Promise.resolve(new Response(jsonString, {
-            status: 200,
-            statusText: httpStatusCodes[200],
+            status: statusCode,
+            statusText: httpStatusCodes[statusCode],
             headers: {'Content-Type': 'application/json'},
         }));
     },
-    html: async (content: string): Promise<Response> => {
+    html: async (statusCode: number, content: string): Promise<Response> => {
         content = Bun.escapeHTML(content);
         return Promise.resolve(new Response(Bun.escapeHTML(content), {
-            status: 200,
-            statusText: httpStatusCodes[200],
+            status: statusCode,
+            statusText: httpStatusCodes[statusCode],
             headers: {'Content-Type': 'text/html; charset=utf-8'}
         }));
     },
-    file: async (fp: string): Promise<Response> => {
+    file: async (statusCode: number, fp: string): Promise<Response> => {
         const file = Bun.file(fp);
         const exists = await file.exists();
     
@@ -32,8 +32,8 @@ const http = {
             contentType = file.type + '; charset=utf-8';
     
         return Promise.resolve(new Response(content, {
-            status: 200,
-            statusText: httpStatusCodes[200],
+            status: statusCode,
+            statusText: httpStatusCodes[statusCode],
             headers: { 'Content-Type': contentType}
         }));
     },
@@ -57,8 +57,7 @@ const http = {
             headers: {'Content-Type': 'text/html; charset-utf-8'},
         });
         return Promise.resolve(response)
-    }
-
+    }, 
 }
 
 export { http }

package/lib/router/router.d.ts

@@ -4,12 +4,18 @@ import { Database } from 'bun:sqlite';
 
 
 type Context = {
-    request: Request,
-    params: Map<string, string>,
-    token?: string,
+    cookies: Map<string, string>,
     db: Database,
+    formData: FormData | Promise<FormData> | undefined,
+    json: (statusCode: number, data: any) => Response | Promise<Response>,
     logger: Logger,
-}
+    params: Map<string, string>,
+    query: URLSearchParams,
+    request: Request,
+    route: Route,
+    token?: string,
+};
+
 
 type Route = {
     pattern: string,
@@ -37,4 +43,5 @@ type Router = (port?: number | string, options?: RouterOptions) => {
 }
 
 
+
 export { Context , Route, Router, RouterOptions, Options }

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,21 +47,25 @@ 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 => {
+    const token = req.headers.get('Authorization');
     return {
+        token: token ?? '',
+        cookies: new Map(),
+        formData: req.formData(),
         request: req,
         params: new Map(),
+        query: new URL(req.url).searchParams,
         db: new Database(opts.db ?? ':memory:'),
         logger: lgr,
+        route: route,
+        json: (statusCode: number, data: any) => http.json(statusCode, data),
     }
 }
 
-
-
 const router: Router = (port?: number | string, options?: RouterOptions<Options>) => {
     const routes: Array<Route> = new Array();
     const lgr = logger();
-    let dbConn = '';
 
     return {
         // add a new route
@@ -105,8 +109,9 @@ const router: Router = (port?: number | string, options?: RouterOptions<Options>
                 const route: Route = {
                     pattern: patternPath,
                     method: 'GET',
-                    callback: async () => await http.file(pure),
+                    callback: async () => await http.file(200, pure),
                 };
+
                 routes.push(route);
             });
         },
@@ -129,38 +134,38 @@ const router: Router = (port?: number | string, options?: RouterOptions<Options>
                     let statusCode = 404;
 
                     for (const route of routes) {
-                        const ctx = setContext(req, lgr, opts);
+                        const ctx = setContext(req, lgr, opts, route);
 
-                        if (url.pathname === '/favicon.ico') {
-                            return http.noContent();
-                        }
+                        if (match(route, ctx) || route.pattern === url.pathname) {
+                            if (route.method === ctx.request.method) {
+                                const res = await route.callback(ctx);
 
-                        if (route.method !== req.method) {
-                            statusCode = 405;
-                            continue;
-                        }
+                                let cookieValue: string[] = [];
+                                if (ctx.cookies.size !== 0) {
+                                    for (const [key, value] of ctx.cookies) {
+                                        cookieValue.push(`${key}=${value}`);
+                                    }
+                                }
+
+                                res.headers.set('Set-Cookie', cookieValue.join('; '));
+
+                                statusCode = res.status;
 
-                        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
+                                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[405]
+                                });
+                                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.6.0"
 }