@emeryld/rrroutes-client 2.2.11 → 2.2.13

package/README.md

@@ -392,21 +392,24 @@ const listRooms = client.build(registry.byKey['GET /v1/rooms'], { staleTime: 120
 
 const useSocketedRooms = buildSocketedRoute({
   built: listRooms,
-  event: 'chat:message',
-  toRooms: (page) => page.items.map((r) => r.id), // derive rooms from data (feeds supported)
-  joinMeta: { source: 'rooms:list' },
-  leaveMeta: { source: 'rooms:list' },
+  toRooms: (page) => ({
+    rooms: page.items.map((r) => r.id), // derive rooms from data (feeds supported)
+    joinMeta: { source: 'rooms:list' },
+    leaveMeta: { source: 'rooms:list' },
+  }),
   useSocketClient,
-  applyMessage: (prev, payload) => {
-    if (!prev) return prev;
-    // Example: bump unread count in cache
-    const apply = (items: any[]) =>
-      items.map((room) =>
-        room.id === payload.roomId ? { ...room, unread: (room.unread ?? 0) + 1 } : room,
-      );
-    return 'pages' in prev
-      ? { ...prev, pages: prev.pages.map((p) => ({ ...p, items: apply(p.items) })) }
-      : { ...prev, items: apply(prev.items) };
+  applyMessage: {
+    'chat:message': (prev, payload) => {
+      if (!prev) return prev;
+      // Example: bump unread count in cache
+      const apply = (items: any[]) =>
+        items.map((room) =>
+          room.id === payload.roomId ? { ...room, unread: (room.unread ?? 0) + 1 } : room,
+        );
+      return 'pages' in prev
+        ? { ...prev, pages: prev.pages.map((p) => ({ ...p, items: apply(p.items) })) }
+        : { ...prev, items: apply(prev.items) };
+    },
   },
 });
 

package/dist/index.cjs

@@ -71,8 +71,17 @@ var defaultFetcher = async (req) => {
 // src/routesV3.client.index.ts
 var import_react = require("react");
 var import_react_query = require("@tanstack/react-query");
+var import_zod = require("zod");
 var import_rrroutes_contract = require("@emeryld/rrroutes-contract");
 var toUpper = (m) => m.toUpperCase();
+var defaultFeedQuerySchema = import_zod.z.object({
+  cursor: import_zod.z.string().optional(),
+  limit: import_zod.z.coerce.number().min(1).max(100).default(20)
+});
+var defaultFeedOutputSchema = import_zod.z.object({
+  items: import_zod.z.array(import_zod.z.unknown()),
+  nextCursor: import_zod.z.string().optional()
+});
 function zParse(value, schema) {
   return schema ? schema.parse(value) : value;
 }
@@ -174,6 +183,37 @@ function extractArgs(args) {
 function toArgsTuple(args) {
   return typeof args === "undefined" ? [] : [args];
 }
+function augmentFeedQuerySchema(schema) {
+  if (!schema) return defaultFeedQuerySchema;
+  if (schema instanceof import_zod.z.ZodObject) {
+    const shape = schema.shape ? schema.shape : schema._def?.shape?.();
+    return schema.extend({
+      ...shape ?? {},
+      cursor: defaultFeedQuerySchema.shape.cursor,
+      limit: defaultFeedQuerySchema.shape.limit
+    });
+  }
+  return import_zod.z.intersection(schema, defaultFeedQuerySchema);
+}
+function augmentFeedOutputSchema(schema) {
+  if (!schema) return defaultFeedOutputSchema;
+  if (schema instanceof import_zod.z.ZodObject) {
+    const shape = schema.shape ? schema.shape : schema._def?.shape?.();
+    const hasItems = Boolean(shape?.items);
+    if (hasItems) return schema.extend({ nextCursor: import_zod.z.string().optional() });
+    return import_zod.z.object({
+      items: import_zod.z.array(schema),
+      nextCursor: import_zod.z.string().optional()
+    });
+  }
+  if (schema instanceof import_zod.z.ZodArray) {
+    return import_zod.z.object({
+      items: schema,
+      nextCursor: import_zod.z.string().optional()
+    });
+  }
+  return defaultFeedOutputSchema;
+}
 function buildUrl(leaf, baseUrl, params, query) {
   const normalizedParams = zParse(params, leaf.cfg.paramsSchema);
   const normalizedQuery = zParse(query, leaf.cfg.querySchema);
@@ -202,8 +242,13 @@ function createRouteClient(opts) {
   function buildInternal(leaf, rqOpts, meta) {
     const isGet = leaf.method === "get";
     const isFeed = !!leaf.cfg.feed;
+    const leafCfg = isFeed ? {
+      ...leaf.cfg,
+      querySchema: augmentFeedQuerySchema(leaf.cfg.querySchema),
+      outputSchema: augmentFeedOutputSchema(leaf.cfg.outputSchema)
+    } : leaf.cfg;
     const method = toUpper(leaf.method);
-    const expectsArgs = Boolean(leaf.cfg.paramsSchema || leaf.cfg.querySchema);
+    const expectsArgs = Boolean(leafCfg.paramsSchema || leafCfg.querySchema);
     const leafLabel = `${leaf.method.toUpperCase()} ${String(leaf.path)}`;
     const debugName = meta?.name;
     const emit = (event) => emitDebug(event, debugName);
@@ -247,13 +292,18 @@ function createRouteClient(opts) {
       const a = extractArgs(tuple);
       const params = a?.params;
       const query = options?.queryOverride ?? a?.query;
-      const { url, normalizedQuery, normalizedParams } = buildUrl(leaf, baseUrl, params, query);
+      const { url, normalizedQuery, normalizedParams } = buildUrl(
+        { ...leaf, cfg: leafCfg },
+        baseUrl,
+        params,
+        query
+      );
       let payload;
-      const acceptsBody = Boolean(leaf.cfg.bodySchema);
+      const acceptsBody = Boolean(leafCfg.bodySchema);
       const requiresBody = options?.requireBody ?? (!isGet && acceptsBody);
       if (typeof options?.body !== "undefined") {
-        const normalizedBody = zParse(options.body, leaf.cfg.bodySchema);
-        const isMultipart = Array.isArray(leaf.cfg.bodyFiles) && leaf.cfg.bodyFiles.length > 0;
+        const normalizedBody = zParse(options.body, leafCfg.bodySchema);
+        const isMultipart = Array.isArray(leafCfg.bodyFiles) && leafCfg.bodyFiles.length > 0;
         payload = isMultipart ? toFormData(normalizedBody) : normalizedBody;
       } else if (requiresBody) {
         throw new Error("Body is required when invoking a mutation fetch.");
@@ -277,7 +327,7 @@ function createRouteClient(opts) {
         const out = await fetcher(
           payload === void 0 ? { url, method } : { url, method, body: payload }
         );
-        const parsed = zParse(out, leaf.cfg.outputSchema);
+        const parsed = zParse(out, leafCfg.outputSchema);
         emit(
           decorateDebugEvent(
             {
@@ -313,7 +363,7 @@ function createRouteClient(opts) {
       }
     };
     const fetchGet = (...tupleWithBody) => {
-      const acceptsBody = Boolean(leaf.cfg.bodySchema);
+      const acceptsBody = Boolean(leafCfg.bodySchema);
       const tupleLength = tupleWithBody.length;
       const maybeBodyIndex = expectsArgs ? 1 : 0;
       const hasBodyCandidate = acceptsBody && tupleLength > maybeBodyIndex;
@@ -346,7 +396,12 @@ function createRouteClient(opts) {
           },
           []
         );
-        const { normalizedQuery, normalizedParams } = buildUrl(leaf, baseUrl, params, query);
+        const { normalizedQuery, normalizedParams } = buildUrl(
+          { ...leaf, cfg: leafCfg },
+          baseUrl,
+          params,
+          query
+        );
         const queryResult = (0, import_react_query.useInfiniteQuery)({
           ...buildOptions,
           queryKey: getQueryKeys(...tuple),
@@ -400,7 +455,7 @@ function createRouteClient(opts) {
           },
           []
         );
-        buildUrl(leaf, baseUrl, params, query);
+        buildUrl({ ...leaf, cfg: leafCfg }, baseUrl, params, query);
         const queryResult = (0, import_react_query.useQuery)({
           ...buildOptions,
           queryKey: getQueryKeys(...tuple),
@@ -488,9 +543,9 @@ function toFormData(body) {
 }
 
 // src/sockets/socket.client.sys.ts
-var import_zod = require("zod");
-var roomValueSchema = import_zod.z.union([import_zod.z.array(import_zod.z.string()), import_zod.z.string()]);
-var buildRoomPayloadSchema = (metaSchema) => import_zod.z.object({
+var import_zod2 = require("zod");
+var roomValueSchema = import_zod2.z.union([import_zod2.z.array(import_zod2.z.string()), import_zod2.z.string()]);
+var buildRoomPayloadSchema = (metaSchema) => import_zod2.z.object({
   rooms: roomValueSchema,
   meta: metaSchema
 });
@@ -731,72 +786,84 @@ function normalizeRooms(rooms) {
   }
   return normalized;
 }
+function mergeRoomState(prev, toRoomsResult) {
+  const merged = new Set(prev.rooms);
+  for (const r of normalizeRooms(toRoomsResult.rooms)) merged.add(r);
+  return {
+    rooms: Array.from(merged),
+    joinMeta: toRoomsResult.joinMeta ?? prev.joinMeta,
+    leaveMeta: toRoomsResult.leaveMeta ?? prev.leaveMeta
+  };
+}
 function roomsFromData(data, toRooms) {
-  if (data == null) return [];
-  const merge = /* @__PURE__ */ new Set();
+  if (data == null) return { rooms: [] };
+  let state = { rooms: [] };
   const add = (input) => {
-    for (const r of normalizeRooms(input)) merge.add(r);
+    state = mergeRoomState(state, toRooms(input));
   };
   const maybePages = data?.pages;
   if (Array.isArray(maybePages)) {
-    for (const page of maybePages) add(toRooms(page));
-    return Array.from(merge);
+    for (const page of maybePages) add(page);
+    return state;
   }
-  add(toRooms(data));
-  return Array.from(merge);
+  add(data);
+  return state;
 }
 function buildSocketedRoute(options) {
-  const { built, event, toRooms, applyMessage, joinMeta, leaveMeta, useSocketClient: useSocketClient2 } = options;
+  const { built, toRooms, applyMessage, useSocketClient: useSocketClient2 } = options;
   return (...useArgs) => {
     const client = useSocketClient2();
     const endpointResult = built.useEndpoint(...useArgs);
     const argsKey = (0, import_react2.useMemo)(() => JSON.stringify(useArgs[0] ?? null), [useArgs]);
-    const [rooms, setRooms] = (0, import_react2.useState)(
+    const [roomState, setRoomState] = (0, import_react2.useState)(
       () => roomsFromData(endpointResult.data, toRooms)
     );
-    const roomsKey = (0, import_react2.useMemo)(() => rooms.join("|"), [rooms]);
+    const roomsKey = (0, import_react2.useMemo)(() => roomState.rooms.join("|"), [roomState.rooms]);
+    const joinMetaKey = (0, import_react2.useMemo)(() => JSON.stringify(roomState.joinMeta ?? null), [roomState.joinMeta]);
+    const leaveMetaKey = (0, import_react2.useMemo)(() => JSON.stringify(roomState.leaveMeta ?? null), [roomState.leaveMeta]);
     (0, import_react2.useEffect)(() => {
       const unsubscribe = endpointResult.onReceive((data) => {
-        setRooms((prev) => {
-          const next = normalizeRooms(toRooms(data));
-          if (next.length === 0) return prev;
-          const merged = new Set(prev);
-          next.forEach((r) => merged.add(r));
-          return Array.from(merged);
-        });
+        setRoomState((prev) => mergeRoomState(prev, toRooms(data)));
       });
       return unsubscribe;
     }, [endpointResult, toRooms]);
     (0, import_react2.useEffect)(() => {
-      setRooms(roomsFromData(endpointResult.data, toRooms));
+      setRoomState(roomsFromData(endpointResult.data, toRooms));
     }, [endpointResult.data, toRooms]);
     (0, import_react2.useEffect)(() => {
-      if (rooms.length === 0) return;
+      if (roomState.rooms.length === 0) return;
+      const { joinMeta, leaveMeta } = roomState;
+      if (!joinMeta || !leaveMeta) return;
       let active = true;
       (async () => {
         try {
-          await client.joinRooms(rooms, joinMeta);
+          await client.joinRooms(roomState.rooms, joinMeta);
         } catch {
         }
       })();
       return () => {
-        if (!active || rooms.length === 0) return;
+        if (!active || roomState.rooms.length === 0) return;
         active = false;
-        void client.leaveRooms(rooms, leaveMeta).catch(() => {
+        void client.leaveRooms(roomState.rooms, leaveMeta).catch(() => {
         });
       };
-    }, [client, joinMeta, leaveMeta, roomsKey]);
+    }, [client, roomsKey, roomState.joinMeta, roomState.leaveMeta, joinMetaKey, leaveMetaKey]);
     (0, import_react2.useEffect)(() => {
-      const unsubscribe = client.on(event, (payload, meta) => {
-        built.setData((prev) => {
-          const next = applyMessage(prev, payload, meta);
-          setRooms(roomsFromData(next, toRooms));
-          return next;
-        }, ...useArgs);
-      });
-      return unsubscribe;
-    }, [client, event, applyMessage, built, argsKey]);
-    return { ...endpointResult, rooms };
+      const entries = Object.entries(applyMessage).filter(
+        ([_event, fn]) => typeof fn === "function"
+      );
+      const unsubscribes = entries.map(
+        ([ev, fn]) => client.on(ev, (payload, meta) => {
+          built.setData((prev) => {
+            const next = fn(prev, payload, meta);
+            setRoomState(roomsFromData(next, toRooms));
+            return next;
+          }, ...useArgs);
+        })
+      );
+      return () => unsubscribes.forEach((u) => u?.());
+    }, [client, applyMessage, built, argsKey, toRooms]);
+    return { ...endpointResult, rooms: roomState.rooms };
   };
 }