@emeryld/rrroutes-client 2.2.15 → 2.2.16

package/dist/index.mjs

@@ -155,7 +155,9 @@ function getZodShape(schema) {
 function augmentFeedQuerySchema(schema) {
   if (!schema) return defaultFeedQuerySchema;
   if (!(schema instanceof z.ZodObject)) {
-    console.warn("Feed queries must be a ZodObject; default pagination applied.");
+    console.warn(
+      "Feed queries must be a ZodObject; default pagination applied."
+    );
     return defaultFeedQuerySchema;
   }
   return schema.extend(paginationQueryShape);
@@ -520,9 +522,77 @@ function createRouteClient(opts) {
       fetch: fetchMutation
     };
   }
+  const fetchRaw = async (input) => {
+    const { path, method, query, body, params } = input;
+    if (!path || typeof path !== "string") {
+      throw new Error("fetch(path, ...) requires a non-empty string path.");
+    }
+    if (!method) {
+      throw new Error("fetch(path, method, ...) requires an HTTP method.");
+    }
+    const methodLower = String(method).toLowerCase();
+    const methodUpper = toUpper(methodLower);
+    const flatQuery = normalizeFlatQuery(query);
+    const search = toSearchString(flatQuery);
+    const compiledPath = compileRawPath(path, params);
+    const url = `${baseUrl ?? ""}${compiledPath}${search}`;
+    const leafLabel = `${methodUpper} ${path}`;
+    const startedAt = Date.now();
+    const detail = isVerboseDebug ? { params, query: flatQuery } : void 0;
+    emitDebug(
+      decorateDebugEvent(
+        {
+          type: "fetch",
+          stage: "start",
+          method: methodUpper,
+          url,
+          leaf: leafLabel,
+          ...body !== void 0 ? { body } : {}
+        },
+        detail
+      )
+    );
+    try {
+      const out = await fetcher(
+        body === void 0 ? { url, method: methodUpper } : { url, method: methodUpper, body }
+      );
+      emitDebug(
+        decorateDebugEvent(
+          {
+            type: "fetch",
+            stage: "success",
+            method: methodUpper,
+            url,
+            leaf: leafLabel,
+            durationMs: Date.now() - startedAt
+          },
+          isVerboseDebug ? { params, query: flatQuery, output: out } : void 0
+        )
+      );
+      return out;
+    } catch (error) {
+      emitDebug(
+        decorateDebugEvent(
+          {
+            type: "fetch",
+            stage: "error",
+            method: methodUpper,
+            url,
+            leaf: leafLabel,
+            durationMs: Date.now() - startedAt,
+            ...body !== void 0 ? { body } : {},
+            error
+          },
+          detail
+        )
+      );
+      throw error;
+    }
+  };
   return {
     queryClient,
     invalidate,
+    fetch: fetchRaw,
     build: buildInternal
   };
 }
@@ -544,6 +614,71 @@ function toFormData(body) {
   }
   return fd;
 }
+function getPathParamNames(path) {
+  const names = /* @__PURE__ */ new Set();
+  const re = /:([A-Za-z0-9_]+)/g;
+  let match;
+  while ((match = re.exec(path)) !== null) {
+    names.add(match[1]);
+  }
+  return names;
+}
+function normalizeFlatQuery(query) {
+  if (query == null) return void 0;
+  if (typeof query !== "object" || Array.isArray(query)) {
+    throw new Error("Query must be a plain object (Record<string, string>).");
+  }
+  const result = {};
+  for (const [k, v] of Object.entries(query)) {
+    if (v == null) continue;
+    if (typeof v !== "string") {
+      throw new Error(
+        `Query param "${k}" must be a string; received type "${typeof v}".`
+      );
+    }
+    result[k] = v;
+  }
+  return Object.keys(result).length > 0 ? result : void 0;
+}
+function compileRawPath(path, params) {
+  const placeholders = getPathParamNames(path);
+  if (!params || typeof params !== "object" || Array.isArray(params)) {
+    if (placeholders.size > 0) {
+      throw new Error(
+        `Missing path parameters for "${path}": ${[...placeholders].join(
+          ", "
+        )}`
+      );
+    }
+    return path;
+  }
+  const paramObj = params;
+  const providedNames = new Set(Object.keys(paramObj));
+  for (const name of providedNames) {
+    if (!placeholders.has(name)) {
+      throw new Error(
+        `Unexpected path parameter "${name}" for template "${path}".`
+      );
+    }
+    const value = paramObj[name];
+    if (value != null && (typeof value === "object" || Array.isArray(value))) {
+      throw new Error(
+        `Path parameter "${name}" must be a primitive; received "${typeof value}".`
+      );
+    }
+  }
+  for (const name of placeholders) {
+    if (!providedNames.has(name)) {
+      throw new Error(
+        `Missing value for path parameter "${name}" in template "${path}".`
+      );
+    }
+  }
+  if (placeholders.size === 0) {
+    return path;
+  }
+  return compilePath(path, paramObj);
+}
 
 // src/sockets/socket.client.sys.ts
 import { z as z2 } from "zod";