@thetally/httptree 0.1.0 → 0.3.0

package/dist/router.js

@@ -101,8 +101,6 @@ function finishResponse(res, result) {
     if (res.writableEnded)
         return;
     if (!result) {
-        res.statusCode = 204;
-        res.end();
         return;
     }
     if (result[responseSymbol]) {
@@ -125,6 +123,25 @@ function finishResponse(res, result) {
     res.statusCode = 204;
     res.end();
 }
+function finishThrownResponse(res, err) {
+    if (res.writableEnded)
+        return;
+    if (err && typeof err === "object" && err[responseSymbol]) {
+        const r = err;
+        res.statusCode = r.status;
+        for (const [k, v] of Object.entries(r.headers || {})) {
+            try {
+                res.setHeader(k, v);
+            }
+            catch { }
+        }
+        res.end(r.body);
+        return;
+    }
+    res.statusCode = 500;
+    res.end("Internal Server Error");
+    console.error("Error in handler:", err);
+}
 class Router {
     base;
     routes;
@@ -141,7 +158,6 @@ class Router {
         this.errorHandlers = new Map();
         this.parent = undefined;
         if (!root) {
-            this.branches = [];
             use(this.handle);
         }
     }
@@ -205,16 +221,12 @@ class Router {
     handle = async (req, res, next) => {
         const pathname = url.parse(req.url || "/").pathname || "/";
         const method = (req.method || "GET").toUpperCase();
-        debug(`Handling request: method='${method}', path='${pathname}'`);
-        let matchedRoute = null;
         for (const r of this.routes) {
             if (r.method !== "*" && r.method !== method)
                 continue;
             const m = r.info.regex.exec(pathname);
             if (!m)
                 continue;
-            debug(`Route matched: method='${r.method}', regex='${r.info.regex}', params=[${r.info.params.join(", ")}]`);
-            matchedRoute = r;
             const params = {};
             r.info.params.forEach((p, i) => {
                 debug(`Extracting param '${p}' from segment '${m[i + 1]}'`);
@@ -227,10 +239,8 @@ class Router {
                 }
             });
             for (const chk of r.prechecks) {
-                debug(`Running precheck for route: method='${r.method}', path regex='${r.info.regex}'`);
                 const ok = await chk(req, res);
                 if (!ok) {
-                    debug(`Precheck failed for route: method='${r.method}', path regex='${r.info.regex}'`);
                     res.statusCode = 403;
                     res.end("Forbidden");
                     return;
@@ -238,129 +248,14 @@ class Router {
             }
             try {
                 req.params = params;
-                debug(`Invoking handler for route: method='${r.method}', path regex='${r.info.regex}'`);
-                const result = await r.handler(req, res);
-                if (result && typeof result === "object" && result[responseSymbol]) {
-                    finishResponse(res, result);
-                    return;
-                }
-                if (!res.writableEnded) {
-                    res.end();
-                }
-                return;
+                await r.handler(req, res);
             }
             catch (e) {
-                if (e && typeof e === "object" && e[responseSymbol]) {
-                    finishResponse(res, e);
-                    return;
-                }
-                let errType = (e && typeof e === "object" && e.name) || (e && typeof e === "object" && e.constructor && e.constructor.name) || typeof e;
-                let lastError = e;
-                let current = this;
-                if (process.env.HTTPTREE_DEBUG) {
-                    debug(`Error thrown: type='${errType}' on base='${this.base}'`);
-                }
-                while (current) {
-                    const handler = current.errorHandlers.get(String(errType)) || current.errorHandlers.get("*");
-                    if (handler) {
-                        if (process.env.HTTPTREE_DEBUG) {
-                            debug(`Using error handler for type='${errType}' on base='${current.base}'`);
-                        }
-                        try {
-                            handler(lastError, req, res);
-                        }
-                        catch (err) {
-                            lastError = err;
-                            if (process.env.HTTPTREE_DEBUG) {
-                                debug(`Handler on base='${current.base}' threw, trying parent`);
-                            }
-                            current = current.parent;
-                            continue;
-                        }
-                        return;
-                    }
-                    else if (process.env.HTTPTREE_DEBUG) {
-                        debug(`No handler for type='${errType}' on base='${current.base}', moving to parent`);
-                    }
-                    current = current.parent;
-                }
-                if (!res.writableEnded) {
-                    res.statusCode = 500;
-                    res.end("Internal Server Error");
-                }
-                if (lastError &&
-                    ((typeof lastError !== "object" || !('suppressLog' in lastError)) &&
-                        !(lastError && typeof lastError === "object" && lastError.name === "NotFound"))) {
-                    console.error("Uncaught handler error:", lastError);
-                }
-                return;
-            }
-        }
-        if (!res.writableEnded) {
-            debug(`No route matched for method='${method}', path='${pathname}'. Resolving most specific branch.`);
-            let mostSpecific = this;
-            let current = this;
-            if (process.env.HTTPTREE_DEBUG) {
-                debug(`NotFound: resolving most specific branch for path='${pathname}'`);
-            }
-            while (true) {
-                let found = false;
-                if (current.branches) {
-                    let bestBranch = null;
-                    let bestLen = -1;
-                    for (const branch of current.branches) {
-                        if (pathname.startsWith(branch.base) && branch.base.length > bestLen) {
-                            bestBranch = branch;
-                            bestLen = branch.base.length;
-                        }
-                    }
-                    if (bestBranch) {
-                        if (process.env.HTTPTREE_DEBUG) {
-                            debug(`Path '${pathname}' matches branch base='${bestBranch.base}'`);
-                        }
-                        mostSpecific = bestBranch;
-                        current = bestBranch;
-                        found = true;
-                    }
-                }
-                if (!found)
-                    break;
-            }
-            let errType = "NotFound";
-            let lastError = Object.assign(new Error("Not Found"), { name: "NotFound" });
-            current = mostSpecific;
-            while (current) {
-                const handler = current.errorHandlers.get(errType) || current.errorHandlers.get("*");
-                if (handler) {
-                    if (process.env.HTTPTREE_DEBUG) {
-                        debug(`Using NotFound handler on base='${current.base}' for path='${pathname}'`);
-                    }
-                    try {
-                        handler(lastError, req, res);
-                    }
-                    catch (err) {
-                        lastError = err;
-                        if (process.env.HTTPTREE_DEBUG) {
-                            debug(`NotFound handler on base='${current.base}' threw, trying parent`);
-                        }
-                        current = current.parent;
-                        continue;
-                    }
-                    return;
-                }
-                else if (process.env.HTTPTREE_DEBUG) {
-                    debug(`No NotFound handler on base='${current.base}', moving to parent`);
-                }
-                current = current.parent;
-            }
-            if (!res.writableEnded) {
-                res.statusCode = 404;
-                res.end("Not Found");
-            }
-            if (lastError && (typeof lastError !== "object" || !('suppressLog' in lastError))) {
-                console.error("Uncaught handler error:", lastError);
+                return next(e instanceof Error ? e : new Error(String(e)));
             }
+            return;
         }
+        next();
     };
     handleWS = async (ws, req) => {
         const pathname = url.parse(req.url || "/").pathname || "/";
@@ -391,10 +286,20 @@ class Router {
         const full = join(this.base, path);
         const info = compilePattern(full);
         debug(`Adding route: method='${method}', full path='${full}', regex='${info.regex}', params=[${info.params.join(", ")}]`);
+        const wrappedHandler = async (req, res) => {
+            try {
+                const result = await handler(req, res);
+                finishResponse(res, result);
+            }
+            catch (e) {
+                // throw e instanceof Error ? e : new Error(String(e));
+                finishThrownResponse(res, e);
+            }
+        };
         this.routes.push({
             method,
             info,
-            handler,
+            handler: wrappedHandler,
             prechecks: [...this.inheritedChecks],
         });
         this.routes.sort((a, b) => b.info.score - a.info.score ||
@@ -415,6 +320,49 @@ export class BaseRouter extends Router {
                     res.statusCode = 500;
                     res.end("Internal Error");
                 }
+                else {
+                    if (res.writableEnded)
+                        return;
+                    this.handle(req, res, (err) => {
+                        if (err) {
+                            const handler = this.errorHandlers.get(err.name) ||
+                                this.errorHandlers.get("InternalError") ||
+                                this.errorHandlers.get("*");
+                            if (handler) {
+                                try {
+                                    handler(err, req, res);
+                                }
+                                catch (e) {
+                                    res.statusCode = 500;
+                                    res.end("Internal Error");
+                                }
+                            }
+                            else {
+                                res.statusCode = 500;
+                                res.end("Internal Error");
+                            }
+                        }
+                        else {
+                            if (!res.writableEnded) {
+                                const notFoundHandler = this.errorHandlers.get("NotFound") ||
+                                    this.errorHandlers.get("*");
+                                if (notFoundHandler) {
+                                    try {
+                                        notFoundHandler({ name: "NotFound", message: "Not Found" }, req, res);
+                                    }
+                                    catch (e) {
+                                        res.statusCode = 500;
+                                        res.end("Internal Error");
+                                    }
+                                }
+                                else {
+                                    res.statusCode = 404;
+                                    res.end("Not Found");
+                                }
+                            }
+                        }
+                    });
+                }
             });
         });
         this.#server = server;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@thetally/httptree",
-    "version": "0.1.0",
+    "version": "0.3.0",
     "description": "A TypeScript library for creating and managing HTTP request trees.",
     "main": "dist/index.js",
     "types": "dist/index.d.ts",