yedra 0.14.5 → 0.15.1

package/dist/routing/app.d.ts

@@ -11,6 +11,18 @@ declare class Context {
     constructor(server: Server, wss: WebSocketServer, counter: Counter);
     stop(): Promise<void>;
 }
+type ServeResponse = {
+    status?: number;
+    body: Uint8Array | string;
+    headers?: Record<string, string>;
+};
+type ServeFallback = (req: {
+    href: string;
+}) => ServeResponse | Promise<ServeResponse>;
+type ServeConfig = {
+    dir: string;
+    fallback?: string | ServeFallback;
+};
 type ConnectMiddleware = (req: IncomingMessage, res: ServerResponse, next: () => void) => void;
 export declare class Yedra {
     private restRoutes;
@@ -32,7 +44,7 @@ export declare class Yedra {
             url: string;
         }[];
     }): object;
-    private static loadStatic;
+    private static loadServe;
     private performRequest;
     private middlewareNext;
     listen(port: number, options?: {
@@ -45,10 +57,7 @@ export declare class Yedra {
             path: string;
             get?: () => Promise<string> | string;
         };
-        static?: {
-            dir: string;
-            fallback?: string;
-        };
+        serve?: ServeConfig;
         /**
          * Prevents all normal output from Yedra. Mostly useful for tests.
          */

package/dist/routing/app.js

@@ -3,6 +3,7 @@ import { createServer as createHttpServer } from 'node:http';
 import { createServer as createHttpsServer } from 'node:https';
 import { extname, join } from 'node:path';
 import { URL } from 'node:url';
+import { isUint8Array } from 'node:util/types';
 import mime from 'mime';
 import { WebSocketServer } from 'ws';
 import { Counter } from '../util/counter.js';
@@ -82,14 +83,17 @@ export class Yedra {
             paths,
         };
     }
-    static async loadStatic(options) {
-        if (options === undefined) {
-            return new Map();
+    static async loadServe(config) {
+        if (config === undefined) {
+            return {
+                files: new Map(),
+                fallback: undefined,
+            };
         }
         const staticFiles = new Map();
-        const files = await readdir(options.dir, { recursive: true });
+        const files = await readdir(config.dir, { recursive: true });
         await Promise.all(files.map(async (file) => {
-            const absolute = join(options.dir, file);
+            const absolute = join(config.dir, file);
             if (!(await stat(absolute)).isFile()) {
                 return;
             }
@@ -99,16 +103,30 @@ export class Yedra {
                 mime: mime.getType(extname(file)) ?? 'application/octet-stream',
             });
         }));
-        if (options.fallback) {
-            const data = await readFile(options.fallback);
-            staticFiles.set('__fallback', {
-                data,
-                mime: mime.getType(extname(options.fallback)) ?? 'application/octet-stream',
-            });
+        if (config.fallback) {
+            if (typeof config.fallback === 'string') {
+                const data = await readFile(config.fallback);
+                staticFiles.set('__fallback', {
+                    data,
+                    mime: mime.getType(extname(config.fallback)) ??
+                        'application/octet-stream',
+                });
+                return {
+                    files: staticFiles,
+                    fallback: undefined,
+                };
+            }
+            return {
+                files: staticFiles,
+                fallback: config.fallback,
+            };
         }
-        return staticFiles;
+        return {
+            files: staticFiles,
+            fallback: undefined,
+        };
     }
-    async performRequest(staticFiles, req) {
+    async performRequest(serveData, req) {
         if (req.method !== 'GET' &&
             req.method !== 'POST' &&
             req.method !== 'PUT' &&
@@ -120,7 +138,8 @@ export class Yedra {
             // no matching route found
             if (req.method === 'GET') {
                 // look for a static file
-                const staticFile = staticFiles.get(req.url.pathname) ?? staticFiles.get('__fallback');
+                const staticFile = serveData.files.get(req.url.pathname) ??
+                    serveData.files.get('__fallback');
                 if (staticFile !== undefined) {
                     return {
                         status: 200,
@@ -130,6 +149,25 @@ export class Yedra {
                         },
                     };
                 }
+                if (serveData.fallback !== undefined) {
+                    try {
+                        const response = await serveData.fallback({ href: req.url.href });
+                        return {
+                            status: response.status ?? 200,
+                            body: isUint8Array(response.body)
+                                ? response.body
+                                : Buffer.from(response.body, 'utf-8'),
+                            headers: response.headers,
+                        };
+                    }
+                    catch (error) {
+                        if (error instanceof HttpError) {
+                            return Yedra.errorResponse(error.status, error.message);
+                        }
+                        console.error(error);
+                        return Yedra.errorResponse(500, 'Internal Server Error.');
+                    }
+                }
             }
             if (match.invalidMethod) {
                 // we found a route, but it did not match the request method
@@ -168,7 +206,7 @@ export class Yedra {
         }
     }
     async listen(port, options) {
-        const staticFiles = await Yedra.loadStatic(options?.static);
+        const serveData = await Yedra.loadServe(options?.serve);
         const server = options?.tls === undefined
             ? createHttpServer()
             : createHttpsServer({
@@ -183,7 +221,7 @@ export class Yedra {
                 counter.increment();
                 const url = new URL(req.url, 'http://localhost');
                 const begin = Date.now();
-                const response = await this.performRequest(staticFiles, {
+                const response = await this.performRequest(serveData, {
                     method: req.method ?? 'GET',
                     url,
                     body: req,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "yedra",
-  "version": "0.14.5",
+  "version": "0.15.1",
   "repository": "github:0codekit/yedra",
   "main": "dist/index.js",
   "devDependencies": {