@emeryld/rrroutes-server 2.6.1 → 2.6.2

package/dist/index.js

@@ -341,6 +341,44 @@ function adaptRouteBeforeMw(mw) {
     }
   };
 }
+function runRouteBeforeHandler(mw, args) {
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    const next = (err) => {
+      if (settled) return;
+      settled = true;
+      if (err) {
+        reject(err);
+        return;
+      }
+      resolve();
+    };
+    try {
+      const result = mw({ ...args, next });
+      if (result && typeof result.then === "function") {
+        ;
+        result.then(() => {
+          if (settled) return;
+          settled = true;
+          resolve();
+        }).catch((err) => {
+          if (settled) return;
+          settled = true;
+          reject(err);
+        });
+        return;
+      }
+      if (!settled) {
+        settled = true;
+        resolve();
+      }
+    } catch (err) {
+      if (settled) return;
+      settled = true;
+      reject(err);
+    }
+  });
+}
 function logHandlerDebugWithRoutesLogger(logger, event) {
   if (!logger || event.type !== "handler") return;
   const payload = [
@@ -393,6 +431,7 @@ function createRRRoute(router, config) {
   const send = config.send ?? defaultSend;
   const { emit: defaultEmitDebug, mode: defaultDebugMode } = createServerDebugEmitter(config.debug);
   const knownLeaves = /* @__PURE__ */ new Map();
+  const registeredDefs = /* @__PURE__ */ new Map();
   const decorateDebugEvent = (isVerbose, event, details) => {
     if (!isVerbose || !details) return event;
     return { ...event, ...details };
@@ -694,6 +733,71 @@ function createRRRoute(router, config) {
     };
     router[method](path, ...before, wrapped);
     registered.add(key);
+    registeredDefs.set(key, {
+      leaf,
+      def
+    });
+  }
+  async function invoke(key, args) {
+    const registration = registeredDefs.get(key);
+    if (!registration) {
+      throw new Error(`No controller registered for route: ${key}`);
+    }
+    const { leaf, def } = registration;
+    const req = args.req;
+    const res = args.res;
+    const next = args.next ?? (() => void 0);
+    const parsedParams = leaf.cfg.paramsSchema ? lowProfileParse(leaf.cfg.paramsSchema, args.params) : args.params;
+    const parsedQueryInput = leaf.cfg.querySchema ? decodeJsonLikeQueryValue(args.query) : args.query;
+    let parsedQuery = parsedQueryInput;
+    if (leaf.cfg.querySchema) {
+      try {
+        parsedQuery = lowProfileParse(
+          leaf.cfg.querySchema,
+          parsedQueryInput
+        );
+      } catch (err) {
+        const parseError = new Error(
+          `Query parsing error: ${err.message ?? String(err)}`
+        );
+        parseError.raw = JSON.stringify(args.query);
+        parseError.cause = err;
+        throw parseError;
+      }
+    }
+    const parsedBody = leaf.cfg.bodySchema ? lowProfileParse(leaf.cfg.bodySchema, args.body) : args.body;
+    const payload = {
+      params: parsedParams,
+      query: parsedQuery,
+      body: parsedBody,
+      bodyFiles: args.bodyFiles
+    };
+    setRouteRequestPayload(res, payload);
+    const ctx = args.ctx ?? await config.buildCtx({
+      req,
+      res
+    });
+    res.locals[CTX_SYMBOL] = ctx;
+    for (const before of def.before ?? []) {
+      await runRouteBeforeHandler(before, {
+        req,
+        res,
+        ctx,
+        ...payload
+      });
+    }
+    const result = await def.handler({
+      req,
+      res,
+      next,
+      ctx,
+      params: payload.params,
+      query: payload.query,
+      body: payload.body,
+      bodyFiles: payload.bodyFiles
+    });
+    const output = validateOutput && leaf.cfg.outputSchema ? lowProfileParse(leaf.cfg.outputSchema, result) : result;
+    return output;
   }
   function registerControllers(registry, controllers, all) {
     for (const leaf of registry.all) {
@@ -738,6 +842,7 @@ function createRRRoute(router, config) {
     register,
     registerControllers,
     warnMissingControllers: warnMissing,
+    invoke,
     getRegisteredKeys: () => Array.from(registered)
   };
 }
@@ -751,6 +856,51 @@ function bindAll(router, registry, controllers, config) {
   server.registerControllers(registry, controllers);
   return router;
 }
+function batchLeaf(server, path, registry, options) {
+  const method = String(options?.method ?? "post").toLowerCase();
+  const allowedMethods = ["get", "post", "put", "patch", "delete"];
+  if (!allowedMethods.includes(method)) {
+    throw new Error(
+      `Invalid batch method "${String(options?.method)}". Expected one of: ${allowedMethods.join(", ")}.`
+    );
+  }
+  ;
+  server.router[method](
+    path,
+    async (req, res, next) => {
+      try {
+        const body = req.body;
+        if (!isPlainObject2(body)) {
+          throw new Error(
+            "Batch request body must be a plain object keyed by encoded route identifiers."
+          );
+        }
+        const output = {};
+        for (const [encodedKey, value] of Object.entries(body)) {
+          const decodedKey = decodeURIComponent(encodedKey);
+          const leaf = registry.byKey[decodedKey];
+          if (!leaf) {
+            throw new Error(`Unknown batch route key: ${decodedKey}`);
+          }
+          const payload = isPlainObject2(value) ? value : {};
+          output[encodedKey] = await server.invoke(decodedKey, {
+            req,
+            res,
+            next,
+            params: payload.params,
+            query: payload.query,
+            body: payload.body,
+            bodyFiles: payload.bodyFiles
+          });
+        }
+        res.json(output);
+      } catch (err) {
+        next(err);
+      }
+    }
+  );
+  return server.router;
+}
 var defineControllers = () => (m) => m;
 function warnMissingControllers(router, registry, logger) {
   const registeredStore = router[REGISTERED_ROUTES_SYMBOL];
@@ -1578,6 +1728,7 @@ var createConnectionLoggingMiddleware = (options = {}) => {
 };
 export {
   CTX_SYMBOL,
+  batchLeaf,
   bindAll,
   bindExpressRoutes,
   buildLowProfileLeaf,