@tanstack/solid-query 6.0.0-beta.6 → 6.0.0-beta.8

package/build/_tsup-dts-rollup.d.cts

@@ -147,6 +147,15 @@ export { CancelledError }
 
 export { CancelOptions }
 
+/**
+ * Client side of the channel. Created by `QueryClientProvider` on the
+ * client and handed to `useBaseQuery` via context so hydrated components
+ * can attach their observers as soon as their query's entry has been
+ * primed — per query, not at global hydration end, which keeps
+ * early-hydrated components live while other boundaries still stream.
+ */
+export declare function createHydrationCoordinator(client: () => QueryClient): HydrationCoordinator;
+
 export declare const createInfiniteQuery: typeof useInfiniteQuery;
 
 export declare const createMutation: typeof useMutation;
@@ -155,6 +164,34 @@ export declare const createQueries: typeof useQueries;
 
 export declare const createQuery: typeof useQuery;
 
+/**
+ * Server side of the library-owned serialization channel.
+ *
+ * Returns an AsyncIterable that yields a cumulative snapshot of the
+ * dehydrated query cache (success entries, per query-core `dehydrate()`
+ * shapes) every time a query settles during SSR. `QueryClientProvider`
+ * holds it as a signal value, so Solid serializes it through the normal
+ * per-computation path: the server runtime tees the iterator into the
+ * hydration serializer (`ctx.serialize(id, tapped)` in solid-js'
+ * `processResult`) and seroval streams each yield to the client as a
+ * script chunk riding the SSR stream.
+ *
+ * The iterable must terminate for the SSR stream to complete: the
+ * hydration serializer's `flush()` only fires its `onDone` once all
+ * pending streams have closed, and the render root is disposed *after*
+ * that, so neither `onCleanup` nor the serializer itself can close the
+ * channel. Instead the channel closes itself on cache quiescence: after
+ * every cache event (and once at creation) it schedules a timer-task
+ * check; if no query is fetching by then, no further settle can occur —
+ * suspense retry passes that start waterfall fetches are scheduled on
+ * microtasks, so they have begun before the check runs — and the channel
+ * emits its final cumulative snapshot with `done: true` and completes.
+ *
+ * Single-consumer by design: solid-js creates exactly one iterator from
+ * the value and shares it between the memo and the serializer tap.
+ */
+export declare function createServerDehydrationChannel(client: QueryClient): AsyncIterable<DehydrationChannelYield>;
+
 export { DataTag }
 
 export { dataTagErrorSymbol }
@@ -212,10 +249,40 @@ export { DefinedUseQueryResult as DefinedUseQueryResult_alias_1 }
 
 export { dehydrate }
 
+declare type DehydratedQueryEntry = DehydratedState['queries'][number];
+
 export { DehydratedState }
 
 export { DehydrateOptions }
 
+/**
+ * A single message on the dehydration channel. `entries` is *cumulative* —
+ * every yield carries all entries settled so far. Two reasons:
+ *
+ * - It is what makes Solid's signal-path hydration replay lossless.
+ *   Yields still buffered when hydration begins are conflated to the
+ *   LATEST one (`normalizeIterator` drains synchronously available
+ *   results, keeps the last data yield, and delivers the stream's done
+ *   result on a subsequent pull), so each yield must be self-contained:
+ *   the latest cumulative snapshot alone carries everything the dropped
+ *   intermediates did. Requires the solid-js build with that conflation
+ *   behavior (> 2.0.0-beta.32); earlier betas pinned the replay at the
+ *   FIRST buffered yield, dropping every later entry and the `done`
+ *   marker.
+ * - Entry objects keep their identity across yields, so seroval's
+ *   cross-reference serialization emits each entry once and later yields
+ *   only reference it — the cumulative shape costs bytes proportional to
+ *   the number of entries, not its square.
+ *
+ * `done: true` marks the final yield. The client uses it to release
+ * subscribers still waiting for entries that will never arrive (e.g.
+ * queries that errored during SSR and were not dehydrated).
+ */
+export declare interface DehydrationChannelYield {
+    entries: Array<DehydratedQueryEntry>;
+    done: boolean;
+}
+
 export { DistributiveOmit }
 
 export { EnsureInfiniteQueryDataOptions }
@@ -280,6 +347,24 @@ export { hydrate }
 
 export { HydrateOptions }
 
+declare interface HydrationCoordinator {
+    /**
+     * Prime the QueryClient from a channel yield. Entries already applied
+     * (same queryHash and dataUpdatedAt) are skipped; the rest go through
+     * query-core `hydrate()`, which keeps whichever data is newer.
+     */
+    applyYield: (value: DehydrationChannelYield) => void;
+    /**
+     * Invoke `callback` (on a microtask) once the entry for `queryHash` has
+     * been applied — or immediately-on-a-microtask if it already was, or
+     * when the channel completes without one (SSR-errored queries are not
+     * dehydrated, so their components must not wait forever).
+     */
+    whenQueryPrimed: (queryHash: string, callback: () => void) => void;
+}
+
+export declare const HydrationCoordinatorContext: Context<HydrationCoordinator | null>;
+
 export { InferDataFromTag }
 
 export { InferErrorFromTag }

package/build/_tsup-dts-rollup.d.ts

@@ -147,6 +147,15 @@ export { CancelledError }
 
 export { CancelOptions }
 
+/**
+ * Client side of the channel. Created by `QueryClientProvider` on the
+ * client and handed to `useBaseQuery` via context so hydrated components
+ * can attach their observers as soon as their query's entry has been
+ * primed — per query, not at global hydration end, which keeps
+ * early-hydrated components live while other boundaries still stream.
+ */
+export declare function createHydrationCoordinator(client: () => QueryClient): HydrationCoordinator;
+
 export declare const createInfiniteQuery: typeof useInfiniteQuery;
 
 export declare const createMutation: typeof useMutation;
@@ -155,6 +164,34 @@ export declare const createQueries: typeof useQueries;
 
 export declare const createQuery: typeof useQuery;
 
+/**
+ * Server side of the library-owned serialization channel.
+ *
+ * Returns an AsyncIterable that yields a cumulative snapshot of the
+ * dehydrated query cache (success entries, per query-core `dehydrate()`
+ * shapes) every time a query settles during SSR. `QueryClientProvider`
+ * holds it as a signal value, so Solid serializes it through the normal
+ * per-computation path: the server runtime tees the iterator into the
+ * hydration serializer (`ctx.serialize(id, tapped)` in solid-js'
+ * `processResult`) and seroval streams each yield to the client as a
+ * script chunk riding the SSR stream.
+ *
+ * The iterable must terminate for the SSR stream to complete: the
+ * hydration serializer's `flush()` only fires its `onDone` once all
+ * pending streams have closed, and the render root is disposed *after*
+ * that, so neither `onCleanup` nor the serializer itself can close the
+ * channel. Instead the channel closes itself on cache quiescence: after
+ * every cache event (and once at creation) it schedules a timer-task
+ * check; if no query is fetching by then, no further settle can occur —
+ * suspense retry passes that start waterfall fetches are scheduled on
+ * microtasks, so they have begun before the check runs — and the channel
+ * emits its final cumulative snapshot with `done: true` and completes.
+ *
+ * Single-consumer by design: solid-js creates exactly one iterator from
+ * the value and shares it between the memo and the serializer tap.
+ */
+export declare function createServerDehydrationChannel(client: QueryClient): AsyncIterable<DehydrationChannelYield>;
+
 export { DataTag }
 
 export { dataTagErrorSymbol }
@@ -212,10 +249,40 @@ export { DefinedUseQueryResult as DefinedUseQueryResult_alias_1 }
 
 export { dehydrate }
 
+declare type DehydratedQueryEntry = DehydratedState['queries'][number];
+
 export { DehydratedState }
 
 export { DehydrateOptions }
 
+/**
+ * A single message on the dehydration channel. `entries` is *cumulative* —
+ * every yield carries all entries settled so far. Two reasons:
+ *
+ * - It is what makes Solid's signal-path hydration replay lossless.
+ *   Yields still buffered when hydration begins are conflated to the
+ *   LATEST one (`normalizeIterator` drains synchronously available
+ *   results, keeps the last data yield, and delivers the stream's done
+ *   result on a subsequent pull), so each yield must be self-contained:
+ *   the latest cumulative snapshot alone carries everything the dropped
+ *   intermediates did. Requires the solid-js build with that conflation
+ *   behavior (> 2.0.0-beta.32); earlier betas pinned the replay at the
+ *   FIRST buffered yield, dropping every later entry and the `done`
+ *   marker.
+ * - Entry objects keep their identity across yields, so seroval's
+ *   cross-reference serialization emits each entry once and later yields
+ *   only reference it — the cumulative shape costs bytes proportional to
+ *   the number of entries, not its square.
+ *
+ * `done: true` marks the final yield. The client uses it to release
+ * subscribers still waiting for entries that will never arrive (e.g.
+ * queries that errored during SSR and were not dehydrated).
+ */
+export declare interface DehydrationChannelYield {
+    entries: Array<DehydratedQueryEntry>;
+    done: boolean;
+}
+
 export { DistributiveOmit }
 
 export { EnsureInfiniteQueryDataOptions }
@@ -280,6 +347,24 @@ export { hydrate }
 
 export { HydrateOptions }
 
+declare interface HydrationCoordinator {
+    /**
+     * Prime the QueryClient from a channel yield. Entries already applied
+     * (same queryHash and dataUpdatedAt) are skipped; the rest go through
+     * query-core `hydrate()`, which keeps whichever data is newer.
+     */
+    applyYield: (value: DehydrationChannelYield) => void;
+    /**
+     * Invoke `callback` (on a microtask) once the entry for `queryHash` has
+     * been applied — or immediately-on-a-microtask if it already was, or
+     * when the channel completes without one (SSR-errored queries are not
+     * dehydrated, so their components must not wait forever).
+     */
+    whenQueryPrimed: (queryHash: string, callback: () => void) => void;
+}
+
+export declare const HydrationCoordinatorContext: Context<HydrationCoordinator | null>;
+
 export { InferDataFromTag }
 
 export { InferErrorFromTag }

package/build/dev.cjs

@@ -5,6 +5,158 @@ var solidJs = require('solid-js');
 var web = require('@solidjs/web');
 
 // src/useQuery.ts
+function createServerDehydrationChannel(client) {
+  const cache = client.getQueryCache();
+  const entryCache = /* @__PURE__ */ new Map();
+  const snapshot2 = () => {
+    const entries = [];
+    for (const query of cache.getAll()) {
+      if (query.state.status !== "success") continue;
+      let cached = entryCache.get(query.queryHash);
+      if (!cached || cached.state !== query.state) {
+        cached = {
+          state: query.state,
+          entry: {
+            dehydratedAt: Date.now(),
+            state: query.state,
+            queryKey: query.queryKey,
+            queryHash: query.queryHash,
+            ...query.meta && { meta: query.meta },
+            ...query.queryType && { queryType: query.queryType }
+          }
+        };
+        entryCache.set(query.queryHash, cached);
+      }
+      entries.push(cached.entry);
+    }
+    return entries;
+  };
+  let closed = false;
+  let pull = null;
+  const buffered = [];
+  const emit = (value) => {
+    if (closed) return;
+    if (value.done) closed = true;
+    if (pull) {
+      const resolve = pull;
+      pull = null;
+      resolve({ done: false, value });
+    } else {
+      buffered.push(value);
+    }
+  };
+  let closeTimer = null;
+  const scheduleCloseCheck = () => {
+    if (closed || closeTimer !== null) return;
+    closeTimer = setTimeout(() => {
+      closeTimer = null;
+      if (closed) return;
+      if (client.isFetching() === 0) {
+        unsubscribe();
+        emit({ entries: snapshot2(), done: true });
+      }
+    }, 0);
+  };
+  const unsubscribe = cache.subscribe((event) => {
+    if (closed) return;
+    if (event.type === "updated" && event.action.type === "success") {
+      emit({ entries: snapshot2(), done: false });
+    }
+    scheduleCloseCheck();
+  });
+  scheduleCloseCheck();
+  return {
+    [Symbol.asyncIterator]() {
+      return {
+        next() {
+          if (buffered.length > 0) {
+            return Promise.resolve({ done: false, value: buffered.shift() });
+          }
+          if (closed) {
+            return Promise.resolve({
+              done: true,
+              value: void 0
+            });
+          }
+          return new Promise(
+            (resolve) => {
+              pull = resolve;
+            }
+          );
+        },
+        return(value) {
+          if (!closed) {
+            closed = true;
+            unsubscribe();
+            if (closeTimer !== null) {
+              clearTimeout(closeTimer);
+              closeTimer = null;
+            }
+            const resolve = pull;
+            pull = null;
+            resolve?.({ done: true, value: void 0 });
+          }
+          return Promise.resolve({
+            done: true,
+            value
+          });
+        }
+      };
+    }
+  };
+}
+function createHydrationCoordinator(client) {
+  const applied = /* @__PURE__ */ new Map();
+  const waiters = /* @__PURE__ */ new Map();
+  let channelDone = false;
+  const fireWaiters = (queryHash) => {
+    const callbacks = waiters.get(queryHash);
+    if (!callbacks) return;
+    waiters.delete(queryHash);
+    for (const callback of callbacks) queueMicrotask(callback);
+  };
+  return {
+    applyYield(value) {
+      const fresh = value.entries.filter(
+        (entry) => applied.get(entry.queryHash) !== entry.state.dataUpdatedAt
+      );
+      if (fresh.length > 0) {
+        solidJs.runWithOwner(
+          null,
+          () => queryCore.hydrate(client(), { queries: fresh, mutations: [] })
+        );
+        for (const entry of fresh) {
+          applied.set(entry.queryHash, entry.state.dataUpdatedAt);
+          fireWaiters(entry.queryHash);
+        }
+      }
+      if (value.done && !channelDone) {
+        channelDone = true;
+        const remaining = [...waiters.values()];
+        waiters.clear();
+        for (const callbacks of remaining) {
+          for (const callback of callbacks) queueMicrotask(callback);
+        }
+      }
+    },
+    whenQueryPrimed(queryHash, callback) {
+      if (channelDone || applied.has(queryHash)) {
+        queueMicrotask(callback);
+        return;
+      }
+      let list = waiters.get(queryHash);
+      if (!list) {
+        list = [];
+        waiters.set(queryHash, list);
+      }
+      list.push(callback);
+    }
+  };
+}
+var HydrationCoordinatorContext = solidJs.createContext(null);
+
+// src/QueryClientProvider.tsx
+var isServer = typeof window === "undefined";
 exports.QueryClientContext = solidJs.createContext(null);
 exports.useQueryClient = (queryClient) => {
   if (queryClient) {
@@ -19,10 +171,22 @@ exports.useQueryClient = (queryClient) => {
 exports.QueryClientProvider = (props) => {
   props.client.mount();
   solidJs.onCleanup(() => props.client.unmount());
+  const [channelValue] = solidJs.createSignal(() => isServer ? createServerDehydrationChannel(props.client) : void 0);
+  const coordinator = isServer ? null : createHydrationCoordinator(() => props.client);
+  solidJs.createRenderEffect(() => isServer ? void 0 : channelValue(), (value) => {
+    if (value && coordinator) {
+      coordinator.applyYield(value);
+    }
+  });
   return web.createComponent(exports.QueryClientContext, {
     value: () => props.client,
     get children() {
-      return props.children;
+      return web.createComponent(HydrationCoordinatorContext, {
+        value: coordinator,
+        get children() {
+          return props.children;
+        }
+      });
     }
   });
 };
@@ -30,9 +194,9 @@ exports.IsRestoringContext = solidJs.createContext(() => false);
 exports.useIsRestoring = () => solidJs.useContext(exports.IsRestoringContext);
 
 // src/useBaseQuery.ts
-var isServer = typeof window === "undefined";
+var isServer2 = typeof window === "undefined";
 function _stripFnsForSSR(obj) {
-  if (!isServer) return obj;
+  if (!isServer2) return obj;
   const out = {};
   for (const k of Object.keys(obj)) {
     if (k === "refetch" || k === "fetchNextPage" || k === "fetchPreviousPage") {
@@ -72,8 +236,8 @@ function reconcileFn(store, result, reconcileOption, queryHash) {
   }
   return { ...result, data };
 }
-var hydratableObserverResult = (query, result) => {
-  if (!isServer) return result;
+var hydratableObserverResult = (_query, result) => {
+  if (!isServer2) return result;
   const obj = {
     ...solidJs.snapshot(result),
     // During SSR, functions cannot be serialized, so we need to remove them
@@ -84,12 +248,6 @@ var hydratableObserverResult = (query, result) => {
     obj.fetchNextPage = void 0;
     obj.fetchPreviousPage = void 0;
   }
-  obj.hydrationData = {
-    state: query.state,
-    queryKey: query.queryKey,
-    queryHash: query.queryHash,
-    ...query.meta && { meta: query.meta }
-  };
   return obj;
 };
 function useBaseQuery(options, Observer, queryClient) {
@@ -100,7 +258,7 @@ function useBaseQuery(options, Observer, queryClient) {
     const defaultOptions = client().defaultQueryOptions(options());
     defaultOptions._optimisticResults = isRestoring() ? "isRestoring" : "optimistic";
     defaultOptions.structuralSharing = false;
-    if (isServer) {
+    if (isServer2) {
       defaultOptions.retry = false;
       defaultOptions.throwOnError = true;
       defaultOptions.experimental_prefetchInRender = true;
@@ -172,11 +330,25 @@ function useBaseQuery(options, Observer, queryClient) {
   }
   let unsubscribe = null;
   let disposed = false;
+  const coordinator = solidJs.useContext(HydrationCoordinatorContext);
+  const attachHydratedSubscriber = () => {
+    if (!unsubscribe && !disposed && !isRestoring()) {
+      unsubscribe = createClientSubscriber();
+    }
+  };
+  const scheduleHydratedAttach = () => {
+    const queryHash = solidJs.untrack(() => observer.getCurrentQuery().queryHash);
+    if (coordinator) {
+      coordinator.whenQueryPrimed(queryHash, attachHydratedSubscriber);
+    } else {
+      queueMicrotask(attachHydratedSubscriber);
+    }
+  };
   let resolver = null;
   const [queryResource] = solidJs.createSignal(() => {
     const opts = trackedDefaultedOptions();
     const restoring = isRestoring();
-    if (isServer) {
+    if (isServer2) {
       const cached = observer.getOptimisticResult(opts);
       if (!cached.isLoading) {
         observerResult = cached;
@@ -189,9 +361,11 @@ function useBaseQuery(options, Observer, queryClient) {
         );
       }
     }
-    return new Promise((resolve, reject) => {
+    const replayProbe = { executorRan: false };
+    const resource = new Promise((resolve, reject) => {
+      replayProbe.executorRan = true;
       resolver = resolve;
-      if (isServer) {
+      if (isServer2) {
         unsubscribe = createServerSubscriber((data) => {
           resolve(data);
         }, reject);
@@ -224,10 +398,14 @@ function useBaseQuery(options, Observer, queryClient) {
         );
       }
     });
+    if (!isServer2 && !replayProbe.executorRan) {
+      scheduleHydratedAttach();
+    }
+    return resource;
   });
   solidJs.onCleanup(() => {
     disposed = true;
-    if (isServer && solidJs.isPending(queryResource)) {
+    if (isServer2 && solidJs.isPending(queryResource)) {
       unsubscribeQueued = true;
       return;
     }
@@ -235,7 +413,7 @@ function useBaseQuery(options, Observer, queryClient) {
       unsubscribe();
       unsubscribe = null;
     }
-    if (resolver && !isServer) {
+    if (resolver && !isServer2) {
       resolver(observerResult);
       resolver = null;
     }
@@ -253,7 +431,7 @@ function useBaseQuery(options, Observer, queryClient) {
       if (typeof prop === "symbol") {
         return Reflect.get(target, prop, receiver);
       }
-      if (isServer) {
+      if (isServer2) {
         const resolved = queryResource();
         if (prop in resolved) {
           return Reflect.get(resolved, prop);