bun-router 0.2.7 → 0.3.0

package/README.md

@@ -3,96 +3,55 @@
 I needed a router for `Bun`, so I made one. It's simple, naive, and hardly anything is abstracted. 
 
 ### Usage
-Import the `router`.
 ```typescript
 import { router } from 'bun-router';
-```
-
-Create the `router`.
-```typescript
-const r = router(3000)
-```
-
-Add routes to the `router`.
-```typescript
-r.add('/', 'GET', req => new Response('Hello World'));
-```
-
-The `req` parameter is of type `HttpRequest` which is just a type that contains both `Response` and `Params` for URL parameters. 
-
-Start the server.
-```typescript
-r.serve()
-```
-
-Some overly-simple examples: 
-```typescript 
-import { router, json } from '..';
 
 const r = router();
 
-const pets = {
-    dogs: ['Joey', 'Benny', 'Max'],
-    cats: ['Charles', 'Arya', 'Binx'],
-}
-
-const foods = {
-    apple: '🍎', banana: '🍌', strawberry: '🍓', pear: '🍐',
-}
-
-r.add('/pets/:type', 'GET', req => {
-    const petType = req.params.get('type') as keyof typeof pets;
-    return json(pets[petType] ?? 'not found');
-});
-r.add('/grocery/:food', 'GET', req => {
-    const food = req.params.get('food') as keyof typeof foods
-    return json(foods[food] ?? 'not found')
-});
+r.add('/', 'GET', (ctx) => new Response('Hello World'));
 
 r.serve();
 ```
-
+#### Static Files
 ```typescript
-import { router, json } from "..";
+import { router } from 'bun-router';
 
 const r = router();
 
+r.static('/', './pages');
 
-const cacher = () => {
-    const cache = new Map();
-    return {
-        set: (key: string, value: string) => {
-            cache.set(key, value);
-        },
-        get: (key: string) => cache.get(key)!,
-    }
-}
+r.serve();
+```
 
-const cache = cacher();
+##### Example
+```typescript
+import {router, html, json } from 'bun-router';
 
-const rand = (max: number) => Math.floor(Math.random() * max);
+const r = router(3001);
 
-r.add('/set', 'POST', req => {
-    const url = new URL(req.request.url);
-    const query = url.searchParams;
+r.static('/assets', './assets');
 
-    const name = query.get('name')!;
+r.add('/', (ctx) => html('<h1>Hello World</h1>'));
 
-    cache.set(name, `${rand(1000)}`)
+r.add('/greeting/:name', 'GET', (ctx) => {
+    const name = ctx.params.get('name');
+    if (!name) return new Response('invalid url parameters', {status: 400});
 
-    return new Response('thank you for joining\n');
+    return html(`<h4>Greetings, ${name}!</h4>`);
 });
 
-r.add('/get/:key', 'GET', req => {
-    const name = req.params.get('key')
-    const result = cache.get(name ?? '');
+const store: Map<string, string> = new Map();
 
-    if (!result) return new Response('not found')
+r.add('/user/:id', 'GET', (ctx) => {
+    const id = ctx.params.get('id');
+    if (!id) return new Response('user not found', {status: 404});
     
-    return json(`Welcome user ID: ${result}`)
+    const user = store.get(id);
 
+    if (!user) return new Response('user not found', { status: 404 });
+
+    return json(user);
 });
 
 r.serve();
-```
-
+```

package/examples/basic.ts

@@ -0,0 +1,18 @@
+import { router, html, json } from '..';
+
+const r = router();
+
+r.add('/', 'GET', () => json('ok'));
+
+r.add('/user/:name', 'GET', (ctx) => {
+    const name = ctx.params.get('name');
+    return 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});
+});
+
+r.serve();

package/examples/static.ts

@@ -0,0 +1,6 @@
+import { router } from '..';
+
+const r = router(3001);
+
+r.static('/', './examples/pages');
+r.serve();

package/index.ts

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

package/lib/fs/fsys.ts

@@ -0,0 +1,24 @@
+import { BunFile } from "bun";
+import fs from 'node:fs/promises';
+import path from 'path';
+
+const isDir = async (fp: string): Promise<boolean> => (await fs.lstat(fp)).isDirectory();
+
+const readDir = async (dirpath: string, handler: (filepath: string, entry: BunFile) => void) => {
+    try {
+        const files = await fs.readdir(dirpath);
+
+        for (const file of files) {
+            const bunFile = Bun.file(file);
+            const fp = path.join(dirpath, bunFile.name!);
+            const isdir = await isDir(fp);
+
+            if (isdir) await readDir(fp, handler);
+            else handler(fp, bunFile);
+        }
+    } catch (err) {
+        console.error(err);
+    }
+}
+
+export { readDir }

package/lib/router/router.d.ts

@@ -1,15 +1,17 @@
 import { TLSOptions, TLSWebSocketServeOptions, WebSocketServeOptions, ServeOptions, TLSServeOptions } from 'bun';
 
 
-type HttpRequest = {
+type Context = {
     request: Request,
     params: Map<string, string>,
+    fs: Map<string, string>,
+    token?: string,
 }
 
 type Route = {
     pattern: string,
     method: string,
-    callback: (req: HttpRequest) => Response | Promise<Response>
+    callback: (req: Context) => Response | Promise<Response>
 }
 
 type Options = ServeOptions
@@ -20,9 +22,10 @@ type Options = ServeOptions
 
 
 type Router = (port?: number | string, options?: Options) => {
-    add: (pattern: string, method: string, callback: (req: HttpRequest) => Response | Promise<Response>) => void,
+    add: (pattern: string, method: string, callback: (req: Context) => Response | Promise<Response>) => void,
+    static: (pattern: string, root: string) => void,
     serve: () => void,
 }
 
 
-export { HttpRequest, Route, Router, Options }
+export { Context , Route, Router, Options }

package/lib/router/router.ts

@@ -1,4 +1,6 @@
-import { Route, Router, HttpRequest, Options } from './router.d';
+import { Route, Router, Context, Options } from './router.d';
+import { readDir } from '../fs/fsys';
+import path from 'path';
 
 const notFound = async (): Promise<Response> => {
     const response = new Response('not found', {
@@ -19,14 +21,20 @@ const file = async (filepath: string): Promise<Response> => {
     if (!exists)
         return notFound();
 
-    const content = await file.text();
-    if (content === '')
+    const content = await file.arrayBuffer();
+    if (!content)
         return notFound();
 
+    let contentType = 'text/html; charset=utf-8';
+
+    if (file.type.includes('image')) {
+        contentType = file.type + '; charset=utf-8';
+    }
+
     const response = new Response(content, {
         status: 200,
         statusText: 'ok',
-        headers: { 'Content-Type': 'text/html; charset=utf-8' },
+        headers: { 'Content-Type': contentType },
     });
 
     return new Promise<Response>((resolve) => {
@@ -38,8 +46,9 @@ const html = async (content: string): Promise<Response> => {
     const response = new Response(content, {
         status: 200,
         statusText: 'ok',
-        headers: {'Content-Type': 'text/html; charset=utf-8'},
+        headers: { 'Content-Type': 'text/html; charset=utf-8' },
     });
+    content = Bun.escapeHTML(content);
 
     return new Promise<Response>((resolve) => {
         resolve(response);
@@ -55,57 +64,94 @@ const json = (data: any): Response => {
     return res
 }
 
-const extractParams = (route: Route, req: HttpRequest) => {
-    const url = new URL(req.request.url);
+const extract = (route: Route, ctx: Context) => {
+    const url = new URL(ctx.request.url);
     const pathSegments = route.pattern.split('/');
     const urlSegments = url.pathname.split('/');
 
     if (pathSegments.length !== urlSegments.length) return
 
-    for (let i = 0; i < pathSegments.length; i++) {
-        if ((pathSegments[i][0] === ':') && (pathSegments[i - 1] === urlSegments[i - 1])) {
-            const k = pathSegments[i].replace(':', '');
-            const v = urlSegments[i];
-            req.params.set(k, v);
+
+    return {
+        params: () => {
+            for (let i = 0; i < pathSegments.length; i++) {
+                if ((pathSegments[i][0] === ':')) {
+                    const k = pathSegments[i].replace(':', '');
+                    const v = urlSegments[i];
+                    ctx.params.set(k, v);
+                }
+            }
         }
     }
+
 }
 
-const match = (route: Route, req: HttpRequest): boolean => {
-    return req.params.size !== 0 || route.pattern === (new URL(req.request.url)).pathname
+const match = (route: Route, ctx: Context): boolean => {
+    return ctx.params.size !== 0 || route.pattern === (new URL(ctx.request.url)).pathname
 }
 
 const router: Router = (port?: number | string, options?: Options) => {
     const routes: Array<Route> = new Array();
+    const paths: { [key: string]: string } = {};
 
     return {
-        add: (pattern: string, method: string, callback: (req: HttpRequest) => Response | Promise<Response>) => {
+        add: (pattern: string, method: string, callback: (ctx: Context) => Response | Promise<Response>) => {
             routes.push({
                 pattern: pattern,
                 method: method,
                 callback: callback,
             })
         },
+        static: async (pattern: string, root: string) => {
+            await readDir(root, async (fp, _) => {
+                const pure = path.join('.', fp);
+                const ext = path.extname(pure);
+
+                let base = path.basename(pure);
+
+                if (ext === '.html') {
+                    base = base.replace(ext, '');
+
+                }
+
+                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',
+                    callback: async () => await file(pure),
+                };
+                routes.push(route);
+            });
+            console.log(routes.length);
+
+        },
         serve: () => {
-            console.log(`[bun-router]: Listening on port -> :${ port ?? 3000 }`)
+            console.log(`[bun-router]: Listening on port -> :${port ?? 3000}`)
             Bun.serve({
                 port: port ?? 3000,
                 ...options,
                 fetch(req) {
-                    const url = new URL(req.url);
                     for (const route of routes) {
-                        const httpRequest: HttpRequest = {
+                        const ctx: Context = {
                             request: req,
                             params: new Map(),
+                            fs: new Map(),
                         };
 
-                        extractParams(route, httpRequest);
-
-                        if (match(route, httpRequest))
-                            return route.callback(httpRequest);
+                        const extractor = extract(route, ctx);
 
+                        extractor?.params();
 
-                        if (match(route, httpRequest)) return route.callback(httpRequest);
+                        if (match(route, ctx))
+                            return route.callback(ctx);
                     }
                     return new Response('not found');
                 }
@@ -114,4 +160,4 @@ const router: Router = (port?: number | string, options?: Options) => {
     }
 }
 
-export { router, json, file, extractParams, html }
+export { router, json, file, extract, html }

package/package.json

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

package/tests/router.test.ts

@@ -1,47 +1,101 @@
 import { describe, test, expect } from 'bun:test';
-import { file, json, extractParams } from '..';
-import { HttpRequest, Route } from '../lib/router/router.d';
-
-describe('Helpers', async () => {
-    test('html', async () => {
-        const fp = './examples/pages/index.html';
-        const res = await file(fp);
-        const contentType = res.headers.get('Content-Type');
-    
-        expect(contentType).toBe('text/html; charset=utf-8');
-        expect(res.status).toBe(200);
-    });
+import { router, extract } from '..';
+import { Context, Route } from '../lib/router/router.d';
 
-    test('json', async () => {
-        const test = { message: 'ok' }
-        const res = await json(test);
-        const jsn = await res.json();
+describe('URL Params', () => {
+    test('/user/:name', () => {
+        const route: Route = {
+            pattern: '/user/:name',
+            method: 'GET',
+            callback: () => new Response('ok'),
+        };
+
+        const ctx: Context = {
+            request: new Request('http://localhost:3000/user/foo'),
+            params: new Map(),
+            fs: new Map(),
+        };
 
-        expect(jsn).toStrictEqual({ message: 'ok' })
+        const extractor = extract(route, ctx);
 
+        extractor?.params();
+
+        const name = ctx.params.get('name');
+        expect(name).toBe('foo');
     });
 
-    test('extract params 1', () => {
-        const route: Route = {pattern: '/:name', method: 'GET', callback: (req) => new Response('ok')};
-        const httpRequest: HttpRequest = {
-            request: new Request('http://localhost:3000/foo'),
+    test('/user/:name/:id', () => {
+        const route: Route = {
+            pattern: '/user/:name/:id',
+            method: 'GET',
+            callback: () => new Response('ok'),
+        };
+
+        const ctx: Context = {
+            request: new Request('http://localhost:3000/user/foo/123'),
             params: new Map(),
-        }
+            fs: new Map(),
+        };
+
+        const extractor = extract(route, ctx);
+
+        extractor?.params();
+
+        const name = ctx.params.get('name');
+        const id = ctx.params.get('id');
 
-        extractParams(route, httpRequest);
-        const name = httpRequest.params.get('name');
         expect(name).toBe('foo');
+        expect(id).toBe('123');
     });
 
-    test('extract params 2', () =>{
-        const route: Route = {pattern: '/foo/:name', method: 'GET', callback: (req) => new Response('ok')};
-        const httpRequest: HttpRequest = {
-            request: new Request('http://localhost:3000/foo/bar'),
+    test('/foo', () => {
+        const route: Route = {
+            pattern: '/foo',
+            method: 'GET',
+            callback: () => new Response('ok'),
+        }
+
+        const ctx: Context = {
+            request: new Request('http://localhost:3000/foo'),
             params: new Map(),
+            fs: new Map(),
         }
 
-        extractParams(route, httpRequest);
-        const name = httpRequest.params.get('name');
-        expect(name).toBe('bar');
+        const url = new URL(ctx.request.url);
+
+        expect(url.pathname).toBe(route.pattern);
+    });
+});
+
+describe('Router', () => {
+    test('Serve', async () => {
+        const proc = Bun.spawn(['./tests/serve.test.sh'], {
+            onExit: (proc, exitCode, signalCode , error) => {
+                if (error) console.error(error);     
+            },
+        });
+    
+        const text = await new Response(proc.stdout).text();
+        
+        const hasFailed = text.includes('Failed');
+
+        if (hasFailed) console.log(text);
+
+        expect(hasFailed).toBe(false);
+
+        proc.kill(0);
+    })
+
+    test('Static', async() => {
+        const proc = Bun.spawn(['./tests/static.test.sh']);
+        
+        const text = await new Response(proc.stdout).text();
+
+        const hasFailed = text.includes('Failed');
+        if (hasFailed) console.log(text);
+
+        expect(hasFailed).toBe(false);
+
+        proc.kill(0);
     });
 });

package/tests/serve.test.sh

@@ -0,0 +1,35 @@
+#!/bin/bash
+
+bun run ./examples/basic.ts &
+SERVER_PID=$!
+
+function stop_server {
+    kill $SERVER_PID
+}
+
+trap stop_server EXIT
+
+sleep .1
+
+declare -A test_cases
+test_cases['"ok"']="http://localhost:3000/"
+test_cases['"baz"']="http://localhost:3000/user/baz"
+
+function run_test() {
+    local expected_response="$1"
+    local url="$2"
+
+    actual_response=$(curl -sS "$url")
+
+    if [[ "$actual_response" == "$expected_response" ]]; then
+        echo "Passed."
+    else
+        echo "Failed: $url returned $actual_response : $expected_response"
+    fi
+}
+
+for expected in "${!test_cases[@]}"; do
+    url="${test_cases[$expected]}"
+    run_test "$expected" "$url"
+done
+

package/tests/static.test.sh

@@ -0,0 +1,55 @@
+#!/bin/bash
+
+bun run ./examples/static.ts &
+SERVER_PID=$!
+
+function stop_server {
+    kill $SERVER_PID
+}
+
+trap stop_server EXIT
+
+sleep .1
+
+index=$(<./examples/pages/index.html)
+vader=$(md5sum ./examples/pages/vader.jpg | awk '{print $1}')
+gopher=$(md5sum ./examples/pages/gopher.png | awk '{print $1}')
+
+declare -A test_cases
+test_cases["$index"]="http://localhost:3001/"
+test_cases["$vader"]="http://localhost:3001/vader.jpg"
+test_cases["$gopher"]="http://localhost:3001/gopher.png"
+
+function does_exist() {
+    if [ ! -f "$1" ]; then
+        echo "Error: File '$1' not found."
+        exit 1
+    fi
+}
+
+function run_test() {
+    local expected="$1"
+    local url="$2"
+    local actual=""
+
+    if [[ "$url" == *".jpg"* ]] || [[ "$url" == *".png"* ]]; then
+        name="${url//[^[:alnum:]. ]}"
+        curl -sSo "$name" "$url"
+        actual=$(md5sum "$name" | awk '{print $1}')
+    else
+        actual=$(curl -sS "$url")
+    fi
+
+    if [ "$actual" == "$expected" ]; then
+        echo "Passed."
+    else
+        echo "Failed: $url returned $actual | expected: $expected"
+    fi
+
+    rm "$name"
+}
+
+for expected in "${!test_cases[@]}"; do
+    url="${test_cases[$expected]}"
+    run_test "$expected" "$url"
+done

package/examples/cache.ts

@@ -1,41 +0,0 @@
-import { router, json } from "..";
-
-const r = router();
-
-
-const cacher = () => {
-    const cache = new Map();
-    return {
-        set: (key: string, value: string) => {
-            cache.set(key, value);
-        },
-        get: (key: string) => cache.get(key)!,
-    }
-}
-
-const cache = cacher();
-
-const rand = (max: number) => Math.floor(Math.random() * max);
-
-r.add('/set', 'POST', req => {
-    const url = new URL(req.request.url);
-    const query = url.searchParams;
-
-    const name = query.get('name')!;
-
-    cache.set(name, `${rand(1000)}`)
-
-    return new Response('thank you for joining\n');
-});
-
-r.add('/get/:key', 'GET', req => {
-    const name = req.params.get('key')
-    const result = cache.get(name ?? '');
-
-    if (!result) return new Response('not found')
-    
-    return json(`Welcome user ID: ${result}`)
-
-});
-
-r.serve();

package/examples/file.ts

@@ -1,12 +0,0 @@
-import { router, html } from '..';
-import path from 'path';
-
-const r = router();
-
-r.add('/page/:name', 'GET', async req => {
-    const pageName = req.params.get('name')!;
-    const fullpath = path.join('.', 'examples', 'pages', pageName+'.html');
-    return html(fullpath);
-});
-
-r.serve();

package/examples/html.ts

@@ -1,9 +0,0 @@
-import { router, file } from '..';
-
-Bun.serve
-
-const r = router(3000);
-
-r.add('/', 'GET', () => file('./examples/pages/index.html'));
-
-r.serve();

package/examples/params.ts

@@ -1,24 +0,0 @@
-import { router, json } from '..';
-
-const r = router();
-
-const pets = {
-    dogs: ['Joey', 'Benny', 'Max'],
-    cats: ['Charles', 'Arya', 'Binx'],
-}
-
-const foods = {
-    apple: '🍎', banana: '🍌', strawberry: '🍓', pear: '🍐',
-}
-
-r.add('/pets/:type', 'GET', req => {
-    const petType = req.params.get('type') as keyof typeof pets;
-    return json(pets[petType] ?? 'not found');
-});
-r.add('/grocery/:food', 'GET', req => {
-    const food = req.params.get('food') as keyof typeof foods
-    return json(foods[food] ?? 'not found')
-});
-
-r.serve();
-

package/examples/post.ts

@@ -1,38 +0,0 @@
-import { router, json, } from '..';
-
-const r = router(3030);
-
-const userStore = new Map();
-const rando = (max: number) => `${Math.floor(Math.random() * max)}`
-
-r.add('/new', 'POST', req => {
-    const url = new URL(req.request.url);
-    const query = url.searchParams;
-
-    const name = query.get('name');
-    const email = query.get('email');
-
-    if (typeof name === 'undefined' || typeof email === 'undefined') 
-        return new Response('invalid query parameters');
-    
-
-    const id = rando(2_000_000);
-    userStore.set(id, {name: name, email: email});
-
-    const message = `Thank you, ${name} for registering your email: ${email}.\nYour ID is ${id}`
-    return new Response(message);
-});
-
-r.add('/user/:id', 'GET', req => {
-    const id = req.params.get('id');
-    if (typeof id === 'undefined') 
-        return new Response('invalid id');
-    
-    const user = userStore.get(id);
-    if (typeof user === 'undefined') 
-        return new Response('not found');
-
-    return json(user);
-});
-
-r.serve();

package/examples/space.ts

@@ -1,16 +0,0 @@
-import { router, html, json } from '..';
-
-const r = router();
-
-const aliens = '👽'.repeat(30);
-
-r.add('/', 'GET', (req) => {
-    const message = {
-        page: 'home',
-        space: 'home',
-        body: 'ok'
-    };
-    return json(message);
-});
-
-r.serve();

package/tests/router.test.sh

@@ -1,42 +0,0 @@
-#!/bin/bash
-
-PARAMS_TEST=(
-    "http://localhost:3000/pets/dogs"
-    "http://localhost:3000/grocery/strawberry"
-)
-
-echo "Starting test server"
-bun run ./examples/params.ts &
-
-SERVER_PID=$!
-
-function stop_server {
-    echo "Stopping the server $SERVER_PID"
-    kill $SERVER_PID
-}
-
-trap stop_server EXIT
-
-sleep .1
-
-expected='["Joey","Benny","Max"]'
-response=$(curl -sS "${PARAMS_TEST[0]}")
-response_trimmed=$(echo "$response" | xargs -0)
-expected_trimmed=$(echo "$expected" | xargs -0)
-
-if [ "$response_trimmed" = "$expected_trimmed" ]; then
-    echo "Passed."
-else
-    echo "$response_trimmed"
-    echo "$expected_trimmed"
-    echo "Failed."
-fi
-
-expected="🍓"
-response=$(curl -s "${PARAMS_TEST[1]}")
-if [ "$response" = "$expected" ]; then
-    echo "Failed: ${PARAMS_TEST[1]}"
-else
-    echo "Passed."
-fi
-