@rpcbase/client 0.416.0 → 0.418.0

package/dist/{useQuery-NQNva6kg.js → useQuery-CPx0Im8Z.js}

@@ -1,4 +1,4 @@
-import { createContext, useContext, useId, useMemo, useState, useRef, useEffect } from "react";
+import { createContext, useContext, useMemo, useState, useRef, useEffect } from "react";
 import { jsx } from "react/jsx-runtime";
 import { c } from "react/compiler-runtime";
 const STATIC_RPCBASE_RTS_HYDRATION_DATA_KEY = "__staticRpcbaseRtsHydrationData";
@@ -1178,14 +1178,31 @@ const preparePopulateCacheOptions = (options, source) => {
     populate
   };
 };
+const isPlainObject = (value) => {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+};
+const serializeRtsQueryValue = (value) => {
+  return JSON.stringify(value, (_key, currentValue) => {
+    if (!isPlainObject(currentValue)) return currentValue;
+    return Object.keys(currentValue).sort().reduce((acc, key) => {
+      acc[key] = currentValue[key];
+      return acc;
+    }, {});
+  }) ?? "";
+};
 const computeRtsQueryKey = (query, options) => {
   const key = options.key ?? "";
-  const projection = options.projection ? JSON.stringify(options.projection) : "";
-  const sort = options.sort ? JSON.stringify(options.sort) : "";
+  const projection = options.projection ? serializeRtsQueryValue(options.projection) : "";
+  const sort = options.sort ? serializeRtsQueryValue(options.sort) : "";
   const limit = typeof options.limit === "number" ? String(options.limit) : "";
-  const populate = options.populate ? JSON.stringify(options.populate) : "";
-  const pagination = options.pagination ? JSON.stringify(options.pagination) : "";
-  return `${key}${JSON.stringify(query)}${projection}${sort}${limit}${populate}${pagination}`;
+  const populate = options.populate ? serializeRtsQueryValue(options.populate) : "";
+  const pagination = options.pagination ? serializeRtsQueryValue(options.pagination) : "";
+  return `${key}${serializeRtsQueryValue(query)}${projection}${sort}${limit}${populate}${pagination}`;
+};
+const hasSnapshotError = (snapshot) => {
+  return snapshot?.error !== null && snapshot?.error !== void 0;
 };
 const TENANT_ID_QUERY_PARAM = "rb-tenant-id";
 const RTS_CHANGES_PATH = "/api/rb/rts/changes";
@@ -1400,6 +1417,121 @@ const normalizeTotalCount$1 = (value) => {
   if (!Number.isFinite(value) || value < 0) return void 0;
   return Math.floor(value);
 };
+const updateQuerySubscriptionSnapshot = (subscription, snapshot) => {
+  if (snapshot.context.source === "cache" && subscription.lastSnapshot?.context.source === "network") {
+    return false;
+  }
+  subscription.lastSnapshot = snapshot;
+  return true;
+};
+const updateCountSubscriptionSnapshot = (subscription, snapshot) => {
+  if (snapshot.context.source === "cache" && subscription.lastSnapshot?.context.source === "network") {
+    return false;
+  }
+  subscription.lastSnapshot = snapshot;
+  return true;
+};
+const dispatchQuerySnapshotToSubscription = (subscription, snapshot) => {
+  for (const callback of subscription.callbacks) {
+    callback(snapshot.error, snapshot.data, snapshot.context);
+  }
+};
+const dispatchQuerySnapshotToOneshotCallbacks = (cbKey, snapshot) => {
+  const callbacks = queryCallbacks.get(cbKey);
+  if (!callbacks || !callbacks.size) return;
+  for (const callback of callbacks) {
+    callback(snapshot.error, snapshot.data, snapshot.context);
+  }
+};
+const dispatchCountSnapshotToSubscription = (subscription, snapshot) => {
+  for (const callback of subscription.callbacks) {
+    callback(snapshot.error, snapshot.count, snapshot.context);
+  }
+};
+const dispatchCountSnapshotToOneshotCallbacks = (cbKey, snapshot) => {
+  const callbacks = countCallbacks.get(cbKey);
+  if (!callbacks || !callbacks.size) return;
+  for (const callback of callbacks) {
+    callback(snapshot.error, snapshot.count, snapshot.context);
+  }
+};
+const requestRegisteredQueryRefresh = (subscription) => {
+  sendToServer({
+    type: "run-query",
+    modelName: subscription.modelName,
+    queryKey: subscription.queryKey,
+    query: subscription.query,
+    options: subscription.options
+  });
+};
+const requestRegisteredCountRefresh = (subscription) => {
+  sendToServer({
+    type: "run-count",
+    modelName: subscription.modelName,
+    queryKey: subscription.queryKey,
+    query: subscription.query,
+    options: subscription.options
+  });
+};
+const requestSubscriptionLocalQuery = (cbKey, subscription) => {
+  if (!currentUid || subscription.options.pagination) return;
+  const populateCache = subscription.populateCache;
+  const hasPopulate = Boolean(populateCache);
+  if (hasPopulate && populateCache) {
+    void runPopulatedQuery({
+      modelName: subscription.modelName,
+      query: subscription.query,
+      options: {
+        uid: currentUid,
+        projection: populateCache.rootProjection,
+        sort: subscription.options.sort,
+        limit: subscription.options.limit,
+        populate: populateCache.populate
+      }
+    }).then(({
+      hit,
+      data,
+      context
+    }) => {
+      if (!hit) return;
+      const currentSubscription = subscriptions.get(cbKey);
+      if (!currentSubscription) return;
+      const snapshot = {
+        error: null,
+        data,
+        context
+      };
+      if (!updateQuerySubscriptionSnapshot(currentSubscription, snapshot)) return;
+      dispatchQuerySnapshotToSubscription(currentSubscription, snapshot);
+    }).catch(() => {
+    });
+    return;
+  }
+  void runQuery({
+    modelName: subscription.modelName,
+    query: subscription.query,
+    options: {
+      uid: currentUid,
+      projection: subscription.options.projection,
+      sort: subscription.options.sort,
+      limit: subscription.options.limit
+    }
+  }).then(({
+    data,
+    context
+  }) => {
+    const currentSubscription = subscriptions.get(cbKey);
+    if (!currentSubscription) return;
+    const snapshot = {
+      error: null,
+      data,
+      context
+    };
+    if (!updateQuerySubscriptionSnapshot(currentSubscription, snapshot)) return;
+    dispatchQuerySnapshotToSubscription(currentSubscription, snapshot);
+  }).catch(() => {
+  });
+};
 const handleQueryPayload = (payload) => {
   const {
     modelName,
@@ -1409,9 +1541,10 @@ const handleQueryPayload = (payload) => {
     txnId
   } = payload;
   const cbKey = `${modelName}.${queryKey}`;
-  const callbacks = queryCallbacks.get(cbKey);
-  if (!callbacks || !callbacks.size) return;
   const subscription = subscriptions.get(cbKey);
+  const hasSubscriptionCallbacks = Boolean(subscription?.callbacks.size);
+  const hasOneshotCallbacks = Boolean(queryCallbacks.get(cbKey)?.size);
+  if (!hasSubscriptionCallbacks && !hasOneshotCallbacks) return;
   const pageInfo = normalizePageInfo$1(payload.pageInfo);
   const totalCount = normalizeTotalCount$1(payload.totalCount);
   const populateCache = subscription?.populateCache;
@@ -1429,11 +1562,22 @@ const handleQueryPayload = (payload) => {
       totalCount
     } : {}
   };
+  const snapshot = {
+    error: error ?? null,
+    data,
+    context
+  };
   if (error) {
-    for (const cb of callbacks) cb(error, void 0, context);
+    if (subscription && updateQuerySubscriptionSnapshot(subscription, snapshot)) {
+      dispatchQuerySnapshotToSubscription(subscription, snapshot);
+    }
+    dispatchQuerySnapshotToOneshotCallbacks(cbKey, snapshot);
     return;
   }
-  for (const cb of callbacks) cb(null, data, context);
+  if (subscription && updateQuerySubscriptionSnapshot(subscription, snapshot)) {
+    dispatchQuerySnapshotToSubscription(subscription, snapshot);
+  }
+  dispatchQuerySnapshotToOneshotCallbacks(cbKey, snapshot);
   if (!currentUid) return;
   const docs = Array.isArray(data) ? data.filter(isDocWithId) : [];
   if (hasPagination) return;
@@ -1460,20 +1604,33 @@ const handleCountPayload = (payload) => {
     txnId
   } = payload;
   const cbKey = `${modelName}.${queryKey}`;
-  const callbacks = countCallbacks.get(cbKey);
-  if (!callbacks || !callbacks.size) return;
+  const subscription = countSubscriptions.get(cbKey);
+  const hasSubscriptionCallbacks = Boolean(subscription?.callbacks.size);
+  const hasOneshotCallbacks = Boolean(countCallbacks.get(cbKey)?.size);
+  if (!hasSubscriptionCallbacks && !hasOneshotCallbacks) return;
   const isLocal = !!(txnId && localTxnBuf.includes(txnId));
   const context = {
     source: "network",
     isLocal,
     txnId
   };
+  const normalizedCount = normalizeTotalCount$1(count);
+  const snapshot = {
+    error: error ?? null,
+    count: normalizedCount,
+    context
+  };
   if (error) {
-    for (const cb of callbacks) cb(error, void 0, context);
+    if (subscription && updateCountSubscriptionSnapshot(subscription, snapshot)) {
+      dispatchCountSnapshotToSubscription(subscription, snapshot);
+    }
+    dispatchCountSnapshotToOneshotCallbacks(cbKey, snapshot);
     return;
   }
-  const normalizedCount = normalizeTotalCount$1(count);
-  for (const cb of callbacks) cb(null, normalizedCount, context);
+  if (subscription && updateCountSubscriptionSnapshot(subscription, snapshot)) {
+    dispatchCountSnapshotToSubscription(subscription, snapshot);
+  }
+  dispatchCountSnapshotToOneshotCallbacks(cbKey, snapshot);
 };
 const handleEvent = (payload) => {
   const callbacks = messageCallbacks.get(payload.event);
@@ -1778,84 +1935,72 @@ const registerQuery = (modelName, query, optionsOrCallback, callbackMaybe, behav
   const cbKey = `${modelName}.${queryKey}`;
   const runInitialNetworkQuery = behavior?.runInitialNetworkQuery !== false;
   const runInitialLocalQuery = behavior?.runInitialLocalQuery !== false;
+  const forceRefreshOnMount = behavior?.forceRefreshOnMount === true;
   const populateCache = preparePopulateCacheOptions({
     projection: options.projection,
     populate: options.populate
   }, "registerQuery");
-  const hasPopulate = Boolean(populateCache);
   const hasPagination = Boolean(options.pagination);
-  const set = queryCallbacks.get(cbKey) ?? /* @__PURE__ */ new Set();
-  set.add(callback);
-  queryCallbacks.set(cbKey, set);
-  subscriptions.set(cbKey, {
+  const existingSubscription = subscriptions.get(cbKey);
+  const subscription = existingSubscription ?? {
     modelName,
     query,
     options,
     queryKey,
+    callbacks: /* @__PURE__ */ new Set(),
     runInitialNetworkQuery,
+    hasRequestedInitialLocalQuery: false,
     ...populateCache ? {
       populateCache
     } : {}
-  });
-  if (currentUid && runInitialLocalQuery && !hasPagination) {
-    if (hasPopulate && populateCache) {
-      void runPopulatedQuery({
-        modelName,
-        query,
-        options: {
-          uid: currentUid,
-          projection: populateCache.rootProjection,
-          sort: options.sort,
-          limit: options.limit,
-          populate: populateCache.populate
-        }
-      }).then(({
-        hit,
-        data,
-        context
-      }) => {
-        if (!hit) return;
-        callback?.(null, data, context);
-      }).catch(() => {
-      });
-    } else {
-      void runQuery({
-        modelName,
-        query,
-        options: {
-          uid: currentUid,
-          projection: options.projection,
-          sort: options.sort,
-          limit: options.limit
-        }
-      }).then(({
-        data,
-        context
-      }) => {
-        callback?.(null, data, context);
-      }).catch(() => {
-      });
+  };
+  const hadCallbacks = subscription.callbacks.size > 0;
+  const hadInitialNetworkQuery = subscription.runInitialNetworkQuery;
+  subscription.callbacks.add(callback);
+  if (runInitialNetworkQuery) {
+    subscription.runInitialNetworkQuery = true;
+  }
+  subscriptions.set(cbKey, subscription);
+  let seeded = false;
+  if (behavior?.seedSnapshot && updateQuerySubscriptionSnapshot(subscription, behavior.seedSnapshot)) {
+    dispatchQuerySnapshotToSubscription(subscription, behavior.seedSnapshot);
+    seeded = true;
+  }
+  if (!seeded && hadCallbacks && subscription.lastSnapshot && !hasSnapshotError(subscription.lastSnapshot)) {
+    callback(subscription.lastSnapshot.error, subscription.lastSnapshot.data, subscription.lastSnapshot.context);
+  }
+  if (!hadCallbacks) {
+    if (runInitialLocalQuery && !hasPagination) {
+      subscription.hasRequestedInitialLocalQuery = true;
+      requestSubscriptionLocalQuery(cbKey, subscription);
     }
-  }
-  sendToServer({
-    type: "register-query",
-    modelName,
-    queryKey,
-    query,
-    options,
-    runInitialQuery: runInitialNetworkQuery
-  });
-  return () => {
     sendToServer({
-      type: "remove-query",
+      type: "register-query",
       modelName,
-      queryKey
+      queryKey,
+      query,
+      options,
+      runInitialQuery: runInitialNetworkQuery
     });
-    const callbacks = queryCallbacks.get(cbKey);
-    callbacks?.delete(callback);
-    if (callbacks && callbacks.size === 0) {
-      queryCallbacks.delete(cbKey);
+  } else {
+    if (runInitialLocalQuery && !subscription.hasRequestedInitialLocalQuery && !hasPagination) {
+      subscription.hasRequestedInitialLocalQuery = true;
+      requestSubscriptionLocalQuery(cbKey, subscription);
+    }
+    if (forceRefreshOnMount || runInitialNetworkQuery && (!hadInitialNetworkQuery || hasSnapshotError(subscription.lastSnapshot))) {
+      requestRegisteredQueryRefresh(subscription);
+    }
+  }
+  return () => {
+    const currentSubscription = subscriptions.get(cbKey);
+    currentSubscription?.callbacks.delete(callback);
+    if (currentSubscription && currentSubscription.callbacks.size === 0) {
       subscriptions.delete(cbKey);
+      sendToServer({
+        type: "remove-query",
+        modelName,
+        queryKey
+      });
     }
   };
 };
@@ -1876,29 +2021,47 @@ const registerCount = (modelName, query, optionsOrCallback, callbackMaybe, behav
   const queryKey = computeRtsQueryKey(query, options);
   const cbKey = `${modelName}.${queryKey}`;
   const runInitialNetworkQuery = behavior?.runInitialNetworkQuery !== false;
-  const set = countCallbacks.get(cbKey) ?? /* @__PURE__ */ new Set();
-  set.add(callback);
-  countCallbacks.set(cbKey, set);
-  countSubscriptions.set(cbKey, {
+  const forceRefreshOnMount = behavior?.forceRefreshOnMount === true;
+  const existingSubscription = countSubscriptions.get(cbKey);
+  const subscription = existingSubscription ?? {
     modelName,
     query,
     options,
     queryKey,
+    callbacks: /* @__PURE__ */ new Set(),
     runInitialNetworkQuery
-  });
-  sendToServer({
-    type: "register-count",
-    modelName,
-    queryKey,
-    query,
-    options,
-    runInitialQuery: runInitialNetworkQuery
-  });
+  };
+  const hadCallbacks = subscription.callbacks.size > 0;
+  const hadInitialNetworkQuery = subscription.runInitialNetworkQuery;
+  subscription.callbacks.add(callback);
+  if (runInitialNetworkQuery) {
+    subscription.runInitialNetworkQuery = true;
+  }
+  countSubscriptions.set(cbKey, subscription);
+  let seeded = false;
+  if (behavior?.seedSnapshot && updateCountSubscriptionSnapshot(subscription, behavior.seedSnapshot)) {
+    dispatchCountSnapshotToSubscription(subscription, behavior.seedSnapshot);
+    seeded = true;
+  }
+  if (!seeded && hadCallbacks && subscription.lastSnapshot && !hasSnapshotError(subscription.lastSnapshot)) {
+    callback(subscription.lastSnapshot.error, subscription.lastSnapshot.count, subscription.lastSnapshot.context);
+  }
+  if (!hadCallbacks) {
+    sendToServer({
+      type: "register-count",
+      modelName,
+      queryKey,
+      query,
+      options,
+      runInitialQuery: runInitialNetworkQuery
+    });
+  } else if (forceRefreshOnMount || runInitialNetworkQuery && (!hadInitialNetworkQuery || hasSnapshotError(subscription.lastSnapshot))) {
+    requestRegisteredCountRefresh(subscription);
+  }
   return () => {
-    const callbacks = countCallbacks.get(cbKey);
-    callbacks?.delete(callback);
-    if (callbacks && callbacks.size === 0) {
-      countCallbacks.delete(cbKey);
+    const currentSubscription = countSubscriptions.get(cbKey);
+    currentSubscription?.callbacks.delete(callback);
+    if (currentSubscription && currentSubscription.callbacks.size === 0) {
       countSubscriptions.delete(cbKey);
       sendToServer({
         type: "remove-count",
@@ -2188,17 +2351,16 @@ const useQuery = (modelName, query = {}, options = {}) => {
     throw new Error("useQuery: modelName must be a non-empty string");
   }
   assertIncludeOnlyProjection(options.projection);
-  const id = useId();
   const enabled = options.enabled ?? true;
   const ssrEnabled = options.ssr !== false;
   const refreshOnMount = options.refreshOnMount === true;
-  const key = options.key ?? id;
-  const queryJson = JSON.stringify(query);
-  const projectionJson = options.projection ? JSON.stringify(options.projection) : "";
-  const sortJson = options.sort ? JSON.stringify(options.sort) : "";
+  const key = options.key;
+  const queryJson = serializeRtsQueryValue(query);
+  const projectionJson = options.projection ? serializeRtsQueryValue(options.projection) : "";
+  const sortJson = options.sort ? serializeRtsQueryValue(options.sort) : "";
   const limitStr = typeof options.limit === "number" ? String(options.limit) : "";
-  const populateJson = options.populate ? JSON.stringify(options.populate) : "";
-  const paginationJson = options.pagination ? JSON.stringify(options.pagination) : "";
+  const populateJson = options.populate ? serializeRtsQueryValue(options.populate) : "";
+  const paginationJson = options.pagination ? serializeRtsQueryValue(options.pagination) : "";
   preparePopulateCacheOptions({
     projection: options.projection,
     populate: options.populate
@@ -2354,12 +2516,12 @@ const useQuery = (modelName, query = {}, options = {}) => {
         return;
       }
       hasFirstReply.current = true;
-      const networkPageInfo = context.source === "network" ? context.pageInfo : void 0;
-      const networkTotalCount = context.source === "network" ? context.totalCount : void 0;
+      const nextPageInfo = context.pageInfo;
+      const nextTotalCount = context.totalCount;
       const payloadForHash = isPaginated ? {
         result,
-        pageInfo: networkPageInfo,
-        totalCount: networkTotalCount
+        pageInfo: nextPageInfo,
+        totalCount: nextTotalCount
       } : result;
       let nextJson = "";
       try {
@@ -2377,18 +2539,34 @@ const useQuery = (modelName, query = {}, options = {}) => {
       if (isPaginated) {
         setHeadPage({
           nodes: result,
-          ...networkPageInfo ? {
-            pageInfo: networkPageInfo
+          ...nextPageInfo ? {
+            pageInfo: nextPageInfo
           } : {}
         });
-        setTotalCount((current) => networkTotalCount === void 0 ? current : networkTotalCount);
+        setTotalCount((current) => nextTotalCount === void 0 ? current : nextTotalCount);
         return;
       }
       setData(result);
       setTotalCount(void 0);
     }, {
       runInitialNetworkQuery,
-      runInitialLocalQuery
+      runInitialLocalQuery,
+      forceRefreshOnMount: refreshOnMount,
+      ...hasSeedData ? {
+        seedSnapshot: {
+          error: null,
+          data: seedData,
+          context: {
+            source: "cache",
+            ...seedPageInfo ? {
+              pageInfo: seedPageInfo
+            } : {},
+            ...seedTotalCount !== void 0 ? {
+              totalCount: seedTotalCount
+            } : {}
+          }
+        }
+      } : {}
     });
     return () => {
       unsubscribe?.();
@@ -2535,12 +2713,13 @@ const useQuery = (modelName, query = {}, options = {}) => {
   }), [data, effectivePageInfo, error, fetchNext, fetchPrevious, isPaginated, loading, mergedPaginatedData, source, totalCount]);
 };
 export {
-  runNetworkCount as A,
-  runNetworkQuery as B,
-  runQuery as C,
-  sendMessage as D,
-  syncRtsChanges as E,
-  updateDocs as F,
+  resetRtsPouchStore as A,
+  runNetworkCount as B,
+  runNetworkQuery as C,
+  runQuery as D,
+  sendMessage as E,
+  syncRtsChanges as F,
+  updateDocs as G,
   RtsSsrRuntimeProvider as R,
   STATIC_RPCBASE_RTS_HYDRATION_DATA_KEY as S,
   consumeHydratedRtsCount as a,
@@ -2561,13 +2740,13 @@ export {
   peekHydratedRtsCount as p,
   getCollection as q,
   registerCount as r,
-  getConnectionError as s,
-  getConnectionStatus as t,
+  serializeRtsQueryValue as s,
+  getConnectionError as t,
   useQuery as u,
-  onConnectionStatusChange as v,
-  onMessage as w,
-  reconnect as x,
-  registerQuery as y,
-  resetRtsPouchStore as z
+  getConnectionStatus as v,
+  onConnectionStatusChange as w,
+  onMessage as x,
+  reconnect as y,
+  registerQuery as z
 };
-//# sourceMappingURL=useQuery-NQNva6kg.js.map
+//# sourceMappingURL=useQuery-CPx0Im8Z.js.map