hanni 1.0.6 → 1.0.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hanni",
-  "version": "1.0.6",
+  "version": "1.0.7",
   "description": "Minimalist Bun web framework with built-in Swagger UI",
   "type": "module",
   "main": "./src/hanni.js",

package/src/hanni.js

@@ -1,83 +1,87 @@
-import { Router as _Router } from './router.js'
-import { createContext } from './context.js'
-import { buildSpec, swaggerHTML } from './swagger.js'
-import { compose } from './middleware.js'
-import { parseBody, corsHeaders } from './utils.js'
+import { Router as _Router } from './router.js';
+import { createContext } from './context.js';
+import { buildSpec, swaggerHTML } from './swagger.js';
+import { compose, Static as _Static } from './middleware.js';
+import { parseBody, corsHeaders } from './utils.js';
 
-export { _Router as Router }
+export { _Router as Router, _Static as Static };
 
 export function Hanni(config = {}) {
-  const router = new _Router()
-  const middlewares = []
-  const mounts = []
-  const swaggerCfg = config.swagger
+  const router = new _Router();
+  const middlewares = [];
+  const mounts = [];
+  const swaggerCfg = config.swagger;
 
-  const app = {}
+  const app = {};
 
-  const methods = ['GET', 'POST', 'PUT', 'PATCH', 'DELETE', 'HEAD', 'OPTIONS', 'ALL']
+  const methods = ['GET', 'POST', 'PUT', 'PATCH', 'DELETE', 'HEAD', 'OPTIONS', 'ALL'];
   for (const m of methods) {
     app[m.toLowerCase()] = (path, handler, meta) => {
-      router.add(m, path, handler, meta)
-      return app
-    }
+      router.add(m, path, handler, meta);
+      return app;
+    };
   }
 
   app.use = (arg1, arg2) => {
     if (typeof arg1 === 'string' && arg2 && arg2.list) {
-      mounts.push({ path: arg1, router: arg2 })
+      mounts.push({ path: arg1, router: arg2 });
     } else if (typeof arg1 === 'function') {
-      middlewares.push(arg1)
+      middlewares.push(arg1);
     }
-    return app
-  }
+    return app;
+  };
 
-  app.listen = port => {
+  app.listen = (port) => {
     Bun.serve({
       port,
       async fetch(req) {
-        const url = new URL(req.url)
+        const url = new URL(req.url);
 
         if (swaggerCfg) {
-          const base = swaggerCfg.path
+          const base = swaggerCfg.path;
           if (url.pathname === base || url.pathname === base + '/') {
-            return new Response(swaggerHTML(base + '/json', swaggerCfg), { headers: { 'Content-Type': 'text/html' } })
+            return new Response(swaggerHTML(base + '/json', swaggerCfg), { headers: { 'Content-Type': 'text/html' } });
           }
           if (url.pathname === base + '/json') {
             const allRoutes = [
               ...router.list(),
               ...mounts.flatMap(mount => mount.router.list().map(r => ({ ...r, path: mount.path + r.path })))
-            ]
-            return Response.json(buildSpec(allRoutes, swaggerCfg))
+            ];
+            return Response.json(buildSpec(allRoutes, swaggerCfg));
           }
         }
 
-        if (config.cors && req.method === 'OPTIONS') return new Response(null, { headers: corsHeaders() })
+        if (config.cors && req.method === 'OPTIONS') {
+          return new Response(null, { headers: corsHeaders() });
+        }
 
-        let match = router.match(req.method, url.pathname)
+        let match = router.match(req.method, url.pathname);
         if (!match) {
           for (const mount of mounts) {
             if (url.pathname.startsWith(mount.path)) {
-              const subPath = url.pathname.slice(mount.path.length) || '/'
-              match = mount.router.match(req.method, subPath)
-              if (match) break
+              const subPath = url.pathname.slice(mount.path.length) || '/';
+              match = mount.router.match(req.method, subPath);
+              if (match) break;
             }
           }
         }
 
-        if (!match) return new Response('Not Found', { status: 404 })
+        if (!match) return new Response('Not Found', { status: 404 });
 
-        const ctx = createContext(req, match.params)
-        ctx.body = await parseBody(req)
+        const ctx = createContext(req, match.params);
+        ctx.body = await parseBody(req);
 
-        const handler = compose(middlewares, match.handler)
-        const res = await handler(ctx)
+        const handler = compose(middlewares, match.handler);
+        const res = await handler(ctx);
 
-        if (config.cors) Object.entries(corsHeaders()).forEach(([k, v]) => res.headers.set(k, v))
+        if (config.cors) {
+          Object.entries(corsHeaders()).forEach(([k, v]) => res.headers.set(k, v));
+        }
 
-        return res
+        return res;
       }
-    })
-  }
+    });
+  };
 
-  return app
+  return app;
 }

package/src/middleware.js

@@ -1,13 +1,44 @@
+import { existsSync } from "fs";
+import { join } from "path";
+
+export function Static({ path: urlPath, folder }) {
+  return async function (ctx, next) {
+    const reqPath = ctx.req.url;
+    if (!reqPath.startsWith(urlPath)) return next();
+
+    const filePath = join(folder, reqPath.slice(urlPath.length));
+    if (!existsSync(filePath)) {
+      ctx.res.status = 404;
+      ctx.res.body = "File not found";
+      return;
+    }
+
+    const file = Bun.file(filePath);
+    ctx.res.body = file;
+    ctx.res.headers.set("Content-Type", getContentType(filePath));
+  };
+}
+
+function getContentType(filePath) {
+  if (filePath.endsWith(".html")) return "text/html";
+  if (filePath.endsWith(".css")) return "text/css";
+  if (filePath.endsWith(".js")) return "application/javascript";
+  if (filePath.endsWith(".json")) return "application/json";
+  if (filePath.endsWith(".png")) return "image/png";
+  if (filePath.endsWith(".jpg") || filePath.endsWith(".jpeg")) return "image/jpeg";
+  return "text/plain";
+}
+
 export function compose(middlewares, handler) {
   return function (ctx) {
-    let i = -1
-    const dispatch = idx => {
-      if (idx <= i) return Promise.reject()
-      i = idx
-      const fn = idx === middlewares.length ? handler : middlewares[idx]
-      if (!fn) return Promise.resolve()
-      return Promise.resolve(fn(ctx, () => dispatch(idx + 1)))
-    }
-    return dispatch(0)
-  }
+    let i = -1;
+    const dispatch = (idx) => {
+      if (idx <= i) return Promise.reject();
+      i = idx;
+      const fn = idx === middlewares.length ? handler : middlewares[idx];
+      if (!fn) return Promise.resolve();
+      return Promise.resolve(fn(ctx, () => dispatch(idx + 1)));
+    };
+    return dispatch(0);
+  };
 }