@buoy-gg/react-query 7.0.15 → 7.0.17

package/lib/commonjs/react-query/sync/dehydrate.js

@@ -34,10 +34,12 @@ function dehydrateMutation(mutation) {
 function dehydrateQuery(query) {
   const observerStates = query.observers.map(observer => ({
     queryHash: query.queryHash,
-    options: observer.options,
     // Remove queryFn from observer options so the dashboard can't accidentally
     // run device fetch functions (they aren't serializable anyway)
-    queryFn: undefined
+    options: {
+      ...observer.options,
+      queryFn: undefined
+    }
   }));
   return {
     state: {

package/lib/commonjs/react-query/sync/snapshotProvider.js

@@ -0,0 +1,138 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createQuerySnapshotProvider = createQuerySnapshotProvider;
+exports.registerQuerySnapshotProvider = registerQuerySnapshotProvider;
+var _sharedUi = require("@buoy-gg/shared-ui");
+var _dehydrate = require("./dehydrate");
+/**
+ * Time Machine snapshot provider for React Query.
+ *
+ * Unlike the other providers this one can't register at module init — the
+ * QueryClient only exists in React context — so useReactQuerySyncAdapter
+ * (mounted app-lifetime by FloatingDevTools' auto external sync) registers
+ * it per-client via an effect.
+ *
+ * Restore is a device-safe DIFF against the live cache, NOT the desktop
+ * Hydrate: that one detaches live observers and mocks queryFns, which is
+ * fine on a mirror client and destructive in a running app. Here existing
+ * queries get `setState` (observers stay attached and are notified, keeping
+ * their real queryFns), missing ones are built into the cache, and extras
+ * are removed. Mutations aren't restorable (mutationFns can't be captured);
+ * the mutation cache is cleared instead.
+ */
+
+/** A restored query must never claim an in-flight fetch it doesn't have. */
+function normalizeState(state) {
+  return {
+    ...state,
+    fetchStatus: "idle",
+    fetchMeta: null
+  };
+}
+function createQuerySnapshotProvider(queryClient) {
+  return {
+    id: "query",
+    label: "React Query",
+    status: () => ({
+      canCapture: true,
+      canRestore: true
+    }),
+    async capture() {
+      const {
+        queries,
+        mutations
+      } = (0, _dehydrate.dehydrateQueryClient)(queryClient);
+      const warnings = [];
+      if (mutations.length > 0) {
+        warnings.push(`${mutations.length} mutation(s) not captured (mutation functions cannot be restored)`);
+      }
+      return {
+        data: {
+          queries: queries.map(({
+            observers: _observers,
+            ...query
+          }) => ({
+            ...query,
+            state: normalizeState(query.state)
+          }))
+        },
+        warnings
+      };
+    },
+    async restore(data) {
+      const snapshot = data;
+      const result = {
+        ok: true,
+        applied: 0,
+        skipped: [],
+        warnings: []
+      };
+      if (!snapshot?.queries) {
+        return {
+          ok: false,
+          applied: 0,
+          skipped: [],
+          warnings: ["empty query snapshot"]
+        };
+      }
+      const cache = queryClient.getQueryCache();
+      const snapHashes = new Set(snapshot.queries.map(q => q.queryHash));
+      for (const snap of snapshot.queries) {
+        try {
+          const state = normalizeState(snap.state);
+          const existing = cache.get(snap.queryHash);
+          if (existing) {
+            // Observers stay attached (with their real queryFns) and get
+            // notified — the safe on-device path, same as triggerError's.
+            existing.setState(state);
+          } else {
+            cache.build(queryClient, {
+              queryKey: snap.queryKey,
+              queryHash: snap.queryHash,
+              ...(snap.meta && {
+                meta: snap.meta
+              })
+            }, state);
+          }
+          result.applied += 1;
+        } catch (e) {
+          result.skipped.push({
+            id: snap.queryHash,
+            reason: String(e)
+          });
+          result.ok = false;
+        }
+      }
+
+      // Cache entries the snapshot doesn't know about get removed; a mounted
+      // observer will rebuild + refetch its query on next interaction.
+      for (const query of cache.getAll().slice()) {
+        if (!snapHashes.has(query.queryHash)) {
+          try {
+            cache.remove(query);
+            result.applied += 1;
+          } catch (e) {
+            result.skipped.push({
+              id: query.queryHash,
+              reason: String(e)
+            });
+          }
+        }
+      }
+      const mutationCount = queryClient.getMutationCache().getAll().length;
+      if (mutationCount > 0) {
+        queryClient.getMutationCache().clear();
+        result.warnings.push(`mutation cache cleared (${mutationCount} mutation(s))`);
+      }
+      return result;
+    }
+  };
+}
+
+/** Register for one client; returns the unregister fn. Last client wins. */
+function registerQuerySnapshotProvider(queryClient) {
+  return (0, _sharedUi.registerStateSnapshotProvider)(createQuerySnapshotProvider(queryClient));
+}

package/lib/commonjs/react-query/sync/useReactQuerySyncAdapter.js

@@ -7,6 +7,7 @@ exports.useReactQuerySyncAdapter = useReactQuerySyncAdapter;
 var _react = require("react");
 var _reactQuery = require("@tanstack/react-query");
 var _reactQuerySyncAdapter = require("./reactQuerySyncAdapter");
+var _snapshotProvider = require("./snapshotProvider");
 /**
  * Context-based variant of createReactQuerySyncAdapter for zero-config
  * wiring (FloatingDevTools' auto external sync): reads the QueryClient from
@@ -22,5 +23,12 @@ function useReactQuerySyncAdapter() {
   } catch {
     queryClient = null;
   }
+
+  // Register the Time Machine snapshot provider for this client — this hook
+  // is the one app-lifetime spot that actually holds the QueryClient.
+  (0, _react.useEffect)(() => {
+    if (!queryClient) return;
+    return (0, _snapshotProvider.registerQuerySnapshotProvider)(queryClient);
+  }, [queryClient]);
   return (0, _react.useMemo)(() => queryClient ? (0, _reactQuerySyncAdapter.createReactQuerySyncAdapter)(queryClient) : null, [queryClient]);
 }

package/lib/module/react-query/sync/dehydrate.js

@@ -30,10 +30,12 @@ function dehydrateMutation(mutation) {
 function dehydrateQuery(query) {
   const observerStates = query.observers.map(observer => ({
     queryHash: query.queryHash,
-    options: observer.options,
     // Remove queryFn from observer options so the dashboard can't accidentally
     // run device fetch functions (they aren't serializable anyway)
-    queryFn: undefined
+    options: {
+      ...observer.options,
+      queryFn: undefined
+    }
   }));
   return {
     state: {

package/lib/module/react-query/sync/snapshotProvider.js

@@ -0,0 +1,133 @@
+"use strict";
+
+/**
+ * Time Machine snapshot provider for React Query.
+ *
+ * Unlike the other providers this one can't register at module init — the
+ * QueryClient only exists in React context — so useReactQuerySyncAdapter
+ * (mounted app-lifetime by FloatingDevTools' auto external sync) registers
+ * it per-client via an effect.
+ *
+ * Restore is a device-safe DIFF against the live cache, NOT the desktop
+ * Hydrate: that one detaches live observers and mocks queryFns, which is
+ * fine on a mirror client and destructive in a running app. Here existing
+ * queries get `setState` (observers stay attached and are notified, keeping
+ * their real queryFns), missing ones are built into the cache, and extras
+ * are removed. Mutations aren't restorable (mutationFns can't be captured);
+ * the mutation cache is cleared instead.
+ */
+
+import { registerStateSnapshotProvider } from "@buoy-gg/shared-ui";
+import { dehydrateQueryClient } from "./dehydrate";
+/** A restored query must never claim an in-flight fetch it doesn't have. */
+function normalizeState(state) {
+  return {
+    ...state,
+    fetchStatus: "idle",
+    fetchMeta: null
+  };
+}
+export function createQuerySnapshotProvider(queryClient) {
+  return {
+    id: "query",
+    label: "React Query",
+    status: () => ({
+      canCapture: true,
+      canRestore: true
+    }),
+    async capture() {
+      const {
+        queries,
+        mutations
+      } = dehydrateQueryClient(queryClient);
+      const warnings = [];
+      if (mutations.length > 0) {
+        warnings.push(`${mutations.length} mutation(s) not captured (mutation functions cannot be restored)`);
+      }
+      return {
+        data: {
+          queries: queries.map(({
+            observers: _observers,
+            ...query
+          }) => ({
+            ...query,
+            state: normalizeState(query.state)
+          }))
+        },
+        warnings
+      };
+    },
+    async restore(data) {
+      const snapshot = data;
+      const result = {
+        ok: true,
+        applied: 0,
+        skipped: [],
+        warnings: []
+      };
+      if (!snapshot?.queries) {
+        return {
+          ok: false,
+          applied: 0,
+          skipped: [],
+          warnings: ["empty query snapshot"]
+        };
+      }
+      const cache = queryClient.getQueryCache();
+      const snapHashes = new Set(snapshot.queries.map(q => q.queryHash));
+      for (const snap of snapshot.queries) {
+        try {
+          const state = normalizeState(snap.state);
+          const existing = cache.get(snap.queryHash);
+          if (existing) {
+            // Observers stay attached (with their real queryFns) and get
+            // notified — the safe on-device path, same as triggerError's.
+            existing.setState(state);
+          } else {
+            cache.build(queryClient, {
+              queryKey: snap.queryKey,
+              queryHash: snap.queryHash,
+              ...(snap.meta && {
+                meta: snap.meta
+              })
+            }, state);
+          }
+          result.applied += 1;
+        } catch (e) {
+          result.skipped.push({
+            id: snap.queryHash,
+            reason: String(e)
+          });
+          result.ok = false;
+        }
+      }
+
+      // Cache entries the snapshot doesn't know about get removed; a mounted
+      // observer will rebuild + refetch its query on next interaction.
+      for (const query of cache.getAll().slice()) {
+        if (!snapHashes.has(query.queryHash)) {
+          try {
+            cache.remove(query);
+            result.applied += 1;
+          } catch (e) {
+            result.skipped.push({
+              id: query.queryHash,
+              reason: String(e)
+            });
+          }
+        }
+      }
+      const mutationCount = queryClient.getMutationCache().getAll().length;
+      if (mutationCount > 0) {
+        queryClient.getMutationCache().clear();
+        result.warnings.push(`mutation cache cleared (${mutationCount} mutation(s))`);
+      }
+      return result;
+    }
+  };
+}
+
+/** Register for one client; returns the unregister fn. Last client wins. */
+export function registerQuerySnapshotProvider(queryClient) {
+  return registerStateSnapshotProvider(createQuerySnapshotProvider(queryClient));
+}

package/lib/module/react-query/sync/useReactQuerySyncAdapter.js

@@ -1,8 +1,9 @@
 "use strict";
 
-import { useMemo } from "react";
+import { useEffect, useMemo } from "react";
 import { useQueryClient } from "@tanstack/react-query";
 import { createReactQuerySyncAdapter } from "./reactQuerySyncAdapter";
+import { registerQuerySnapshotProvider } from "./snapshotProvider";
 
 /**
  * Context-based variant of createReactQuerySyncAdapter for zero-config
@@ -19,5 +20,12 @@ export function useReactQuerySyncAdapter() {
   } catch {
     queryClient = null;
   }
+
+  // Register the Time Machine snapshot provider for this client — this hook
+  // is the one app-lifetime spot that actually holds the QueryClient.
+  useEffect(() => {
+    if (!queryClient) return;
+    return registerQuerySnapshotProvider(queryClient);
+  }, [queryClient]);
   return useMemo(() => queryClient ? createReactQuerySyncAdapter(queryClient) : null, [queryClient]);
 }

package/lib/typescript/react-query/sync/snapshotProvider.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Time Machine snapshot provider for React Query.
+ *
+ * Unlike the other providers this one can't register at module init — the
+ * QueryClient only exists in React context — so useReactQuerySyncAdapter
+ * (mounted app-lifetime by FloatingDevTools' auto external sync) registers
+ * it per-client via an effect.
+ *
+ * Restore is a device-safe DIFF against the live cache, NOT the desktop
+ * Hydrate: that one detaches live observers and mocks queryFns, which is
+ * fine on a mirror client and destructive in a running app. Here existing
+ * queries get `setState` (observers stay attached and are notified, keeping
+ * their real queryFns), missing ones are built into the cache, and extras
+ * are removed. Mutations aren't restorable (mutationFns can't be captured);
+ * the mutation cache is cleared instead.
+ */
+import type { QueryClient } from "@tanstack/react-query";
+import { type StateSnapshotProvider } from "@buoy-gg/shared-ui";
+export declare function createQuerySnapshotProvider(queryClient: QueryClient): StateSnapshotProvider;
+/** Register for one client; returns the unregister fn. Last client wins. */
+export declare function registerQuerySnapshotProvider(queryClient: QueryClient): () => void;
+//# sourceMappingURL=snapshotProvider.d.ts.map

package/lib/typescript/react-query/sync/snapshotProvider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"snapshotProvider.d.ts","sourceRoot":"","sources":["../../../../src/react-query/sync/snapshotProvider.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AACH,OAAO,KAAK,EAAE,WAAW,EAAc,MAAM,uBAAuB,CAAC;AACrE,OAAO,EAEL,KAAK,qBAAqB,EAG3B,MAAM,oBAAoB,CAAC;AAc5B,wBAAgB,2BAA2B,CACzC,WAAW,EAAE,WAAW,GACvB,qBAAqB,CAsFvB;AAED,4EAA4E;AAC5E,wBAAgB,6BAA6B,CAC3C,WAAW,EAAE,WAAW,GACvB,MAAM,IAAI,CAEZ"}

package/lib/typescript/react-query/sync/useReactQuerySyncAdapter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useReactQuerySyncAdapter.d.ts","sourceRoot":"","sources":["../../../../src/react-query/sync/useReactQuerySyncAdapter.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,2BAA2B,EAAE,MAAM,yBAAyB,CAAC;AAEtE;;;;;GAKG;AACH,wBAAgB,wBAAwB,IAAI,UAAU,CACpD,OAAO,2BAA2B,CACnC,GAAG,IAAI,CAcP"}
+{"version":3,"file":"useReactQuerySyncAdapter.d.ts","sourceRoot":"","sources":["../../../../src/react-query/sync/useReactQuerySyncAdapter.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,2BAA2B,EAAE,MAAM,yBAAyB,CAAC;AAGtE;;;;;GAKG;AACH,wBAAgB,wBAAwB,IAAI,UAAU,CACpD,OAAO,2BAA2B,CACnC,GAAG,IAAI,CAqBP"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@buoy-gg/react-query",
-  "version": "7.0.15",
+  "version": "7.0.17",
   "description": "TanStack Query devtools inside your React Native app — cache inspection, refetch & invalidate, offline toggle. Part of Buoy devtools.",
   "main": "lib/commonjs/index.js",
   "module": "lib/module/index.js",
@@ -24,10 +24,13 @@
   "files": [
     "lib"
   ],
-  "sideEffects": false,
+  "sideEffects": [
+    "**/snapshotProvider.js",
+    "**/snapshotProvider.ts"
+  ],
   "dependencies": {
-    "@buoy-gg/floating-tools-core": "^7.0.15",
-    "@buoy-gg/shared-ui": "^7.0.15"
+    "@buoy-gg/shared-ui": "^7.0.17",
+    "@buoy-gg/floating-tools-core": "^7.0.17"
   },
   "peerDependencies": {
     "@tanstack/react-query": ">=5.0.0",