@emeryld/rrroutes-client 2.6.6 → 2.6.7

package/dist/index.mjs

@@ -1,5 +1,12 @@
 "use client";
 
+// src/routesV3.client.ts
+import {
+  lowProfileParse as lowProfileParse5
+} from "@emeryld/rrroutes-contract";
+import { keepPreviousData as keepPreviousData3, useQuery as useQuery2 } from "@tanstack/react-query";
+import { useCallback as useCallback4, useRef as useRef4 } from "react";
+
 // src/routesV3.client.fetch.ts
 var HttpError = class extends Error {
   constructor({
@@ -1095,6 +1102,7 @@ function buildMutationLeaf(leaf, rqOpts, env) {
 }
 
 // src/routesV3.client.ts
+var BUILT_LEAF_META = "__rrroutesLeaf";
 var defaultDebugLogger = (event) => {
   if (typeof console === "undefined") return;
   const fn = console.debug ?? console.log;
@@ -1161,6 +1169,7 @@ function createRouteClient(opts) {
   const fetcher = opts.fetcher ?? defaultFetcher;
   const baseUrl = opts.baseUrl;
   const environment = opts.environment ?? void 0;
+  const validateResponses = opts.validateResponses ?? true;
   const { emit: emitDebug, mode: debugMode } = createDebugEmitter(
     opts.debug,
     environment
@@ -1175,13 +1184,23 @@ function createRouteClient(opts) {
     await queryClient.invalidateQueries({ queryKey, exact });
     emitDebug({ type: "invalidate", key: queryKey, exact });
   }
+  const toArgsTuple2 = (args) => typeof args === "undefined" ? [] : [args];
+  const getBuiltLeaf = (built) => {
+    const leaf = built[BUILT_LEAF_META];
+    if (!leaf) {
+      throw new Error(
+        "buildBranch(...) expects endpoints created with this route client via client.build(...)."
+      );
+    }
+    return leaf;
+  };
+  const encodeLeafKey = (leaf) => encodeURIComponent(`${leaf.method.toUpperCase()} ${leaf.path}`);
   function buildInternal(leaf, rqOpts, meta) {
     const leafLabel = `${leaf.method.toUpperCase()} ${String(leaf.path)}`;
     const debugName = meta?.name;
     const emit = (event) => emitDebug(event, debugName);
     const isGet = leaf.method === "get";
     const isFeed = !!leaf.cfg.feed;
-    const validateResponses = opts.validateResponses ?? true;
     const env = {
       baseUrl,
       validateResponses,
@@ -1192,25 +1211,33 @@ function createRouteClient(opts) {
       isVerboseDebug,
       leafLabel
     };
+    let built;
     if (isGet && isFeed) {
-      return buildInfiniteGetLeaf(
+      built = buildInfiniteGetLeaf(
         leaf,
         rqOpts,
         env
       );
-    }
-    if (isGet) {
-      return buildGetLeaf(
+    } else if (isGet) {
+      built = buildGetLeaf(
+        leaf,
+        rqOpts,
+        env
+      );
+    } else {
+      built = buildMutationLeaf(
         leaf,
         rqOpts,
         env
       );
     }
-    return buildMutationLeaf(
-      leaf,
-      rqOpts,
-      env
-    );
+    Object.defineProperty(built, BUILT_LEAF_META, {
+      value: leaf,
+      enumerable: false,
+      configurable: false,
+      writable: false
+    });
+    return built;
   }
   const fetchRaw = async (input) => {
     const { path, method, query, body, params } = input;
@@ -1279,11 +1306,151 @@ function createRouteClient(opts) {
       throw error;
     }
   };
+  const buildBranchInternal = (leaves, options) => {
+    const batchMethod = options.method ?? "POST";
+    const defaultHeaders = options.headers;
+    const getQueryKeys = (input) => {
+      const out = {};
+      const argsByLeaf = input ?? {};
+      for (const [alias, built] of Object.entries(leaves)) {
+        const args = argsByLeaf[alias];
+        out[alias] = built.getQueryKeys(...toArgsTuple2(args));
+      }
+      return out;
+    };
+    const invalidateBranch = async (input) => {
+      const argsByLeaf = input ?? {};
+      await Promise.all(
+        Object.entries(leaves).map(([alias, built]) => {
+          const args = argsByLeaf[alias];
+          return built.invalidate(...toArgsTuple2(args));
+        })
+      );
+    };
+    const setDataBranch = (input) => {
+      const out = {};
+      for (const [alias, def] of Object.entries(input)) {
+        if (!def) continue;
+        const built = leaves[alias];
+        if (!built) continue;
+        out[alias] = built.setData(
+          def.updater,
+          ...toArgsTuple2(def.args)
+        );
+      }
+      return out;
+    };
+    const fetchBranch = async (input) => {
+      const payload = {};
+      const keyByAlias = /* @__PURE__ */ new Map();
+      for (const [aliasRaw, built] of Object.entries(leaves)) {
+        const alias = aliasRaw;
+        const leaf = getBuiltLeaf(built);
+        const encodedLeaf = encodeLeafKey(leaf);
+        keyByAlias.set(alias, encodedLeaf);
+        const branchInput = input[alias];
+        const args = branchInput?.args;
+        const body = branchInput?.body;
+        payload[encodedLeaf] = {
+          ...args?.params !== void 0 ? { params: args.params } : {},
+          ...args?.query !== void 0 ? { query: args.query } : {},
+          ...body !== void 0 ? { body } : {}
+        };
+      }
+      const batchResponse = await fetchRaw({
+        path: options.path,
+        method: batchMethod,
+        body: payload,
+        headers: defaultHeaders
+      });
+      const rawData = batchResponse.data;
+      if (!rawData || typeof rawData !== "object" || Array.isArray(rawData)) {
+        throw new Error(
+          "Batch response must be a plain object keyed by encoded route keys."
+        );
+      }
+      const mapped = {};
+      for (const [aliasRaw, built] of Object.entries(leaves)) {
+        const alias = aliasRaw;
+        const encodedLeaf = keyByAlias.get(alias);
+        if (!encodedLeaf) {
+          throw new Error(
+            `Internal batch error: missing encoded key for alias "${String(alias)}".`
+          );
+        }
+        if (!(encodedLeaf in rawData)) {
+          throw new Error(`Batch response missing key "${encodedLeaf}".`);
+        }
+        const leaf = getBuiltLeaf(built);
+        const rawLeafData = rawData[encodedLeaf];
+        const parsedLeafData = validateResponses && leaf.cfg.outputSchema ? lowProfileParse5(leaf.cfg.outputSchema, rawLeafData) : rawLeafData;
+        if (validateResponses && !leaf.cfg.outputSchema) {
+          throw new Error(
+            `No output schema defined for leaf ${leaf.method.toUpperCase()} ${leaf.path}, cannot validate batch response.`
+          );
+        }
+        ;
+        mapped[aliasRaw] = parsedLeafData;
+      }
+      return mapped;
+    };
+    const useEndpoint = (input, rqOpts) => {
+      const queryKeys = getQueryKeys(input);
+      const branchQueryKey = [
+        "batch",
+        String(batchMethod).toLowerCase(),
+        options.path,
+        queryKeys
+      ];
+      const { onReceive, ...useQueryOptions } = rqOpts ?? {};
+      const listenersRef = useRef4(
+        /* @__PURE__ */ new Set()
+      );
+      const notifyOnReceive = useCallback4(
+        (data) => {
+          onReceive?.(data);
+          listenersRef.current.forEach((listener) => listener(data));
+        },
+        [onReceive]
+      );
+      const registerOnReceive = useCallback4(
+        (listener) => {
+          listenersRef.current.add(listener);
+          return () => {
+            listenersRef.current.delete(listener);
+          };
+        },
+        []
+      );
+      const queryResult = useQuery2(
+        {
+          ...useQueryOptions,
+          queryKey: branchQueryKey,
+          placeholderData: useQueryOptions.placeholderData ?? keepPreviousData3,
+          queryFn: async () => {
+            const result = await fetchBranch(input);
+            notifyOnReceive(result);
+            return result;
+          }
+        },
+        queryClient
+      );
+      return { ...queryResult, onReceive: registerOnReceive };
+    };
+    return {
+      fetch: fetchBranch,
+      useEndpoint,
+      getQueryKeys,
+      invalidate: invalidateBranch,
+      setData: setDataBranch
+    };
+  };
   return {
     queryClient,
     invalidate,
     fetch: fetchRaw,
-    build: buildInternal
+    build: buildInternal,
+    buildBranch: buildBranchInternal
   };
 }
 function buildRouter(routeClient, routes) {
@@ -2402,7 +2569,7 @@ function SocketProvider(props) {
 }
 
 // src/sockets/socketedRoute/socket.client.helper.route.ts
-import { useEffect as useEffect3, useMemo as useMemo3, useRef as useRef5, useState as useState2 } from "react";
+import { useEffect as useEffect3, useMemo as useMemo3, useRef as useRef6, useState as useState2 } from "react";
 
 // src/sockets/socketedRoute/socket.client.helper.debug.ts
 var objectReferenceIds = /* @__PURE__ */ new WeakMap();
@@ -2574,12 +2741,12 @@ function buildSocketedRoute(options) {
     const [roomState, setRoomState] = useState2(
       () => roomsFromData(endpointResult.data, toRooms)
     );
-    const renderCountRef = useRef5(0);
-    const clientReadyRef = useRef5(null);
-    const onReceiveEffectDebugRef = useRef5(null);
-    const deriveRoomsEffectDebugRef = useRef5(null);
-    const joinRoomsEffectDebugRef = useRef5(null);
-    const applySocketEffectDebugRef = useRef5(null);
+    const renderCountRef = useRef6(0);
+    const clientReadyRef = useRef6(null);
+    const onReceiveEffectDebugRef = useRef6(null);
+    const deriveRoomsEffectDebugRef = useRef6(null);
+    const joinRoomsEffectDebugRef = useRef6(null);
+    const applySocketEffectDebugRef = useRef6(null);
     renderCountRef.current += 1;
     const roomsKey = useMemo3(() => roomState.rooms.join("|"), [roomState.rooms]);
     const joinMetaKey = useMemo3(