@nkzw/fate-indexeddb 1.12.1 → 1.13.0

package/README.md

@@ -874,12 +874,16 @@ function PostComments({
 
 `useView` and `useLiveListView` can read deferred values too. This works with every transport. GraphQL currently fetches deferred fields with separate queries, rather than streaming `@defer` responses.
 
+For GraphQL servers with incremental delivery enabled, [streaming batched reads](/docs/integrations/graphql.md#streaming-batched-reads) allows deferred follow-up requests to resolve independently within one HTTP response. This does not change when a deferred field is read or require different React hooks.
+
 ## List Views
 
 ### Pagination with `useListView`
 
 You can wrap a list of references using `useListView` to enable connection-style lists with pagination support.
 
+Run the regular example with `vp run dev` (tRPC) or `vp run dev:graphql` (GraphQL), then open **Pagination** from its header (`http://localhost:6001/pagination/preview`). The demo uses the existing posts, client, and router to exercise independent view ranges, navigation, refreshes, and optimistic insertion and rollback. Reading and pagination work without signing in; insertions require an example account and successful insertions create real posts in its database. Browser network throttling makes pending work easier to observe.
+
 For example, you can define a `CommentView` and reuse it inside of a `CommentConnectionView`:
 
 ```tsx
@@ -956,7 +960,11 @@ const CommentConnectionView = {
 
 When `loadNext` runs, fate sends the next cursor as `after` and keeps the page size in `first`. When `loadPrevious` runs, fate sends the previous cursor as `before` and uses `last` for the page size. This lets the server distinguish forward and backward pagination while keeping the component API small.
 
-Loading another page adds items to the list. Refreshing the query without `after` or `before` replaces the loaded list with the latest result, including removed items or an empty list. This applies to nested connections as well as root lists. A failed page load can be retried.
+Each logical view has its own requested window, identified by the view, connection, and original arguments. Calling `loadNext` or `loadPrevious` expands that window. Fate retains the loaded range with the cached connection, so returning to the same view after a remount restores its range. Fetching or paginating the same data through a different view does not expand the original view. Failed page loads leave the window unchanged and can be retried. Multiple readers of the same logical view share its pagination progress.
+
+Queries share cached entities and compatible pages, but `first` and `last` still bound an ordinary request's result. A smaller preview refresh does not truncate pages already loaded by another reader. Partial refreshes update the fetched portion and retain cached continuation pages. A complete server result, including an empty result, can remove stale membership. These rules apply to nested connections and root lists.
+
+Explicit mutation insertions remain visible beyond the initial page size and survive background refreshes. Insertions not yet reconciled with a server list remain local overrides, including across empty responses. Once the server has included an inserted entry, a later authoritative response covering that entry can remove it. Explicit deletions and relationship replacements also remove entries.
 
 Additional arguments on a root request are scoped to that root list:
 
@@ -2215,6 +2223,25 @@ Queries made together are batched into one GraphQL operation. Mutations run sepa
 
 [Deferred fields](/docs/guide/deferred-views.md) load when a component reads them. This uses ordinary GraphQL queries; incremental `@defer` responses are not supported yet.
 
+### Streaming Batched Reads
+
+For a server that supports GraphQL `@defer` and the `v0.2` incremental delivery protocol, enable streaming when creating your client:
+
+```tsx
+const fate = createFateClient({
+  streaming: true,
+  url: 'https://api.example.com/graphql',
+});
+```
+
+Reads still share one HTTP request. Each read is wrapped in its own labeled `@defer` fragment and resolves when that operation's complete result arrives. Separate requests under separate Suspense boundaries can render independently, while one request continues to wait for all the data it declares.
+
+The transport negotiates `multipart/mixed;incrementalSpec=v0.2` and also accepts complete JSON responses. Mutations continue to use ordinary JSON responses. Streaming is disabled by default; enable it only after configuring your server and verifying that your proxy forwards response chunks promptly. Unsupported directives and incompatible multipart protocols produce errors rather than silently retrying requests.
+
+With GraphQL Yoga, install `@graphql-yoga/plugin-defer-stream` and add `useDeferStream()` to the server's plugins. Keep client timeouts and error boundaries in place: completed reads remain available if another operation fails or the connection ends, while unfinished reads reject. Canceling one read keeps the connection alive for its siblings; the connection is released when no reads still need it.
+
+This mode delivers complete operation results through the existing normalized cache. Field-level patches and item-by-item `@stream` updates are not supported. Existing fate `defer()` selections remain lazy identity-based follow-up reads, which can themselves share a streaming batch.
+
 ### Refetch Fields
 
 For servers without `nodes(ids:)`, configure a query field for each refetchable entity type:

package/lib/index.d.mts

@@ -1,7 +1,5 @@
 import { PersistenceStorage } from "@nkzw/fate/persistence";
-//#region src/index.d.ts
 export type IndexedDBStorageOptions = Readonly<{
   name?: string;
 }>;
-export declare function createIndexedDBStorage({ name }?: IndexedDBStorageOptions): PersistenceStorage;
-//#endregion
+export declare function createIndexedDBStorage({ name }?: IndexedDBStorageOptions): PersistenceStorage;

package/lib/index.mjs

@@ -1,5 +1,5 @@
 import { openDB } from "idb";
-//#region src/index.ts
+// src/index.ts
 function createIndexedDBStorage({ name = "fate" } = {}) {
 	let connectionLeases = 0;
 	let connection;
@@ -122,5 +122,4 @@ function createIndexedDBStorage({ name = "fate" } = {}) {
 		}
 	};
 }
-//#endregion
 export { createIndexedDBStorage };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nkzw/fate-indexeddb",
-  "version": "1.12.1",
+  "version": "1.13.0",
   "description": "Optional IndexedDB persistence adapter for fate.",
   "license": "MIT",
   "files": [
@@ -19,10 +19,10 @@
     "idb": "^8.0.4"
   },
   "devDependencies": {
-    "@nkzw/fate": "1.12.1",
+    "@nkzw/fate": "1.13.0",
     "fake-indexeddb": "^6.2.6",
-    "vite": "npm:@voidzero-dev/vite-plus-core@1.3.0",
-    "vite-plus": "1.3.0"
+    "vite": "npm:@voidzero-dev/vite-plus-core@1.4.0",
+    "vite-plus": "1.4.0"
   },
   "peerDependencies": {
     "@nkzw/fate": "^1.5.1"