@emeryld/rrroutes-server 2.4.1 → 2.4.3

package/README.md

@@ -153,6 +153,19 @@ bindExpressRoutes(
 )
 ```
 
+If you need access to the parsed params/query/body inside `buildCtx`, destructure them from the single argument:
+
+```ts
+const server = createRRRoute(app, {
+  buildCtx: ({ params, query, body }) => ({
+    user: lookupUser(params.id),
+    verbose: query?.verbose === 'yes',
+  }),
+})
+```
+
+> `buildCtx` now receives the `{ req, res, params, query, body }` object; the legacy `(req, res)` signature is no longer supported.
+
 - `defineControllers<Registry, Ctx>()(map)` keeps literal `"METHOD /path"` keys accurate and infers params/query/body/output types per leaf.
 - `registerControllers` accepts partial maps (missing routes are skipped); `bindAll` enforces completeness at compile time.
 - `warnMissingControllers(router, registry, logger)` inspects the Express stack and warns for any leaf without a handler.
@@ -174,6 +187,11 @@ const server = createRRRoute(app, {
   globalMiddleware: { before: [audit] },
 })
 
+const routeBefore = ({ params, query, body, ctx, next }) => {
+  ctx.routesLogger?.debug?.('route.before payload', { params, query, body })
+  next()
+}
+
 // Inside any Express middleware (even outside route.before), use getCtx to retrieve typed ctx:
 app.use((req, res, next) => {
   const ctx = getCtx<Ctx>(res)
@@ -183,6 +201,7 @@ app.use((req, res, next) => {
 ```
 
 - `CtxRequestHandler` receives `{ req, res, next, ctx }` with your typed ctx.
+- `route.before` handlers now receive the same parsed `params`, `query`, and `body` payload as the handler, alongside `req`, `res`, and `ctx`.
 - Need post-response hooks? Register a middleware that wires `res.on('finish', handler)` inside `route.before`/`global.before` instead of relying on a dedicated "after" stage.
 
 ### Derived middleware from route cfg (uploads)

package/dist/index.cjs

@@ -94,6 +94,20 @@ var decodeJsonLikeQueryValue = (value) => {
   return value;
 };
 var CTX_SYMBOL = /* @__PURE__ */ Symbol.for("typedLeaves.ctx");
+var REQUEST_PAYLOAD_SYMBOL = /* @__PURE__ */ Symbol.for(
+  "typedLeaves.requestPayload"
+);
+function getRouteRequestPayload(res) {
+  const payload = res.locals[REQUEST_PAYLOAD_SYMBOL];
+  if (payload) {
+    return payload;
+  }
+  throw new Error("Request payload was not initialized before middleware");
+}
+function setRouteRequestPayload(res, payload) {
+  ;
+  res.locals[REQUEST_PAYLOAD_SYMBOL] = payload;
+}
 function getCtx(res) {
   return res.locals[CTX_SYMBOL];
 }
@@ -111,6 +125,26 @@ function adaptCtxMw(mw) {
     }
   };
 }
+function adaptRouteBeforeMw(mw) {
+  return (req, res, next) => {
+    try {
+      const result = mw({
+        req,
+        res,
+        next,
+        ctx: getCtx(res),
+        ...getRouteRequestPayload(res)
+      });
+      if (result && typeof result.then === "function") {
+        return result.catch((err) => next(err));
+      }
+      return result;
+    } catch (err) {
+      next(err);
+      return void 0;
+    }
+  };
+}
 function logHandlerDebugWithRoutesLogger(logger, event) {
   if (!logger || event.type !== "handler") return;
   const payload = [
@@ -201,7 +235,9 @@ function createRRRoute(router, config) {
     const emit = (event) => activeEmit(event, debugName);
     const isVerboseDebug = activeDebugMode === "complete";
     emit({ type: "register", method: methodUpper, path });
-    const routeSpecific = (def?.before ?? []).map((mw) => adaptCtxMw(mw));
+    const routeSpecific = (def?.before ?? []).map(
+      (mw) => adaptRouteBeforeMw(mw)
+    );
     const derived = buildDerived(leaf);
     const ctxMw = async (req, res, next) => {
       const requestUrl = req.originalUrl ?? path;
@@ -213,8 +249,66 @@ function createRRRoute(router, config) {
         path,
         url: requestUrl
       });
+      let params;
+      let query;
+      let body;
       try {
-        const ctx = await config.buildCtx(req, res);
+        params = leaf.cfg.paramsSchema ? (0, import_rrroutes_contract.lowProfileParse)(leaf.cfg.paramsSchema, req.params) : Object.keys(req.params || {}).length ? req.params : void 0;
+        const hasQueryKeys = req.query && Object.keys(req.query || {}).length > 0;
+        const parsedQueryInput = leaf.cfg.querySchema && hasQueryKeys ? decodeJsonLikeQueryValue(req.query) : req.query;
+        if (leaf.cfg.querySchema) {
+          try {
+            query = (0, import_rrroutes_contract.lowProfileParse)(
+              leaf.cfg.querySchema,
+              parsedQueryInput
+            );
+          } catch (err) {
+            const parseError = new Error(
+              `Query parsing error: ${err.message ?? String(err)}`
+            );
+            parseError.raw = JSON.stringify(req.query);
+            parseError.cause = err;
+            throw parseError;
+          }
+        } else {
+          query = hasQueryKeys ? req.query : void 0;
+        }
+        body = leaf.cfg.bodySchema ? (0, import_rrroutes_contract.lowProfileParse)(leaf.cfg.bodySchema, req.body) : req.body !== void 0 ? req.body : void 0;
+      } catch (err) {
+        const payloadError = {
+          params,
+          query,
+          body
+        };
+        emit(
+          decorateDebugEvent(
+            isVerboseDebug,
+            {
+              type: "request",
+              stage: "error",
+              method: methodUpper,
+              path,
+              url: requestUrl,
+              durationMs: Date.now() - startedAt,
+              error: err
+            },
+            isVerboseDebug ? payloadError : void 0
+          )
+        );
+        next(err);
+        return;
+      }
+      const requestPayload = {
+        params,
+        query,
+        body
+      };
+      setRouteRequestPayload(res, requestPayload);
+      try {
+        const ctx = await config.buildCtx({
+          req,
+          res
+        });
         res.locals[CTX_SYMBOL] = ctx;
         emit({
           type: "buildCtx",
@@ -254,21 +348,16 @@ function createRRRoute(router, config) {
         path,
         url: requestUrl
       });
-      let params;
-      let query;
-      let body;
+      const requestPayload = getRouteRequestPayload(res);
+      const params = requestPayload.params;
+      const query = requestPayload.query;
+      const body = requestPayload.body;
       let responsePayload;
       let hasResponsePayload = false;
       const downstreamNext = next;
       const ctx = res.locals[CTX_SYMBOL];
       const ctxRoutesLogger = ctx?.routesLogger;
       const emitWithCtx = (event, details) => {
-        if (event.type == "request" && event.stage == "error") {
-          console.log("Request error event emitted:", {
-            event,
-            ctxRoutesLogger: !!ctxRoutesLogger
-          });
-        }
         const decorated = decorateDebugEvent(isVerboseDebug, event, details);
         if (!config.debug || !config.debug[decorated.type]) {
           return;
@@ -280,26 +369,6 @@ function createRRRoute(router, config) {
         }
       };
       try {
-        params = leaf.cfg.paramsSchema ? (0, import_rrroutes_contract.lowProfileParse)(leaf.cfg.paramsSchema, req.params) : Object.keys(req.params || {}).length ? req.params : void 0;
-        try {
-          const parsedQueryInput = leaf.cfg.querySchema && req.query ? decodeJsonLikeQueryValue(req.query) : req.query;
-          query = leaf.cfg.querySchema ? (0, import_rrroutes_contract.lowProfileParse)(leaf.cfg.querySchema, parsedQueryInput) : Object.keys(req.query || {}).length ? req.query : void 0;
-        } catch (e) {
-          emitWithCtx({
-            type: "request",
-            stage: "error",
-            method: methodUpper,
-            path,
-            url: requestUrl,
-            error: {
-              ...e,
-              raw: JSON.stringify(req.query),
-              message: `Query parsing error: ${e.message}`
-            }
-          });
-          throw e;
-        }
-        body = leaf.cfg.bodySchema ? (0, import_rrroutes_contract.lowProfileParse)(leaf.cfg.bodySchema, req.body) : req.body !== void 0 ? req.body : void 0;
         const handlerStartedAt = Date.now();
         emitWithCtx(
           {
@@ -390,29 +459,28 @@ function createRRRoute(router, config) {
     registered.add(key);
   }
   function registerControllers(registry, controllers, all) {
-    if (all !== void 0 && all !== false) {
-      const label = typeof all === "string" ? all : all === true ? "true" : String(all);
-      throw new Error(
-        `registerControllers: "${label}" is not allowed at runtime. Use bindAll(...) for compile-time coverage or warnMissingControllers(...) to surface missing routes.`
-      );
-    }
     for (const leaf of registry.all) {
       const key = (0, import_rrroutes_contract.keyOf)(leaf.method, leaf.path, false);
       knownLeaves.set(key, leaf);
     }
-    ;
+    const missingLeaves = [];
     Object.keys(controllers).forEach((key) => {
       const leaf = registry.byKey[key];
       if (!leaf) {
-        console.warn(
-          `No leaf found for controller key: ${key}. Not registering route.`
-        );
+        missingLeaves.push(key);
         return;
       }
       const def = controllers[key];
       if (!def) return;
       register(leaf, def);
     });
+    if (all && missingLeaves.length > 0) {
+      throw new Error(
+        `Cannot register controllers: missing definitions for routes: ${missingLeaves.join(
+          ", "
+        )}`
+      );
+    }
   }
   function warnMissing(registry, warnLogger) {
     const registeredFromStore = new Set(Array.from(registered));
@@ -509,8 +577,12 @@ function createBuiltInConnectionHandlers(opts) {
   const pingEvent = "sys:ping";
   const pongEvent = "sys:pong";
   const heartbeatEnabled = heartbeat?.enabled !== false;
-  const joinPayloadSchema = buildRoomPayloadSchema(config.joinMetaMessage);
-  const leavePayloadSchema = buildRoomPayloadSchema(config.leaveMetaMessage);
+  const joinPayloadSchema = buildRoomPayloadSchema(
+    config.joinMetaMessage
+  );
+  const leavePayloadSchema = buildRoomPayloadSchema(
+    config.leaveMetaMessage
+  );
   const pingPayloadSchema = config.pingPayload;
   const pongPayloadSchema = config.pongPayload;
   const sysEvents = sys;