@nkzw/fate-indexeddb 1.15.0 → 1.16.0

package/README.md

@@ -69,7 +69,9 @@ vp create fate
 
 Explore the [fate stack](https://fate.technology/#stack) to see the tools included in your new project.
 
-Choose a backend in the template selector: Void, tRPC with Drizzle or Prisma, GraphQL with Prisma, or a client for an existing GraphQL server. React is the default; choose Vue in the selector or pass `--framework vue`.
+Choose a backend in the template selector: Void, tRPC with Drizzle or Prisma, GraphQL with Prisma, or a client for an existing GraphQL server. React is the default. Choose Vue in the selector or pass `--framework vue`.
+
+Choose **Client Only** or pass `--template client-only` to start with a static Void app that saves its data in IndexedDB. See [Persisting Client State](/docs/guide/client-state.md#persisting-client-state).
 
 ### Manual Installation
 
@@ -880,8 +882,6 @@ For GraphQL servers with incremental delivery enabled, [streaming batched reads]
 
 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
@@ -1606,7 +1606,7 @@ Pending mutations are never evicted to make room for cached data. If a new mutat
 
 ### Actions & Mutations
 
-With persistence configured, fate saves mutations before applying their optimistic updates or sending them to the server. The API is the same as for regular [Actions](/docs/guide/actions.md):
+With persistence and a durable mutation transport configured, fate saves server mutations before applying their optimistic updates or sending them to the server. The API is the same as for regular [Actions](/docs/guide/actions.md):
 
 ```tsx
 const [result, like] = useActionState(fate.actions.post.like, null);
@@ -1712,7 +1712,7 @@ return idempotency.execute({
 
 Forward the entire identity on every attempt. When `identity.replayOnly` is true, the endpoint must return the saved result or a 404 without running the mutation. `createMutationIdempotency` handles this for you.
 
-Without a durable adapter, saved reads and `persist: false` calls still work, but new durable mutations fail before being queued.
+Without a durable adapter, server mutations send immediately by default. Use `persist: true` to require durable delivery. The call fails before sending if persistence or the adapter is missing. Existing queued mutations stay saved and report a delivery error until the adapter is available again. Remote read caching and client state persistence work independently of the adapter.
 
 For GraphQL, return a standard `extensions.code` or numeric `extensions.http.status` for terminal client errors. Unrecognized execution errors remain retryable for saved mutations.
 
@@ -3109,34 +3109,34 @@ For Prisma, pass Prisma query options such as `{ where: { ... } }` in `extra` in
 
 ### Data View Resolvers
 
-fate data views support computed fields. Use `computed`, `field`, and `count` to describe the hidden data needed to resolve a public field:
+fate data views support computed fields. Use `computed` to describe the hidden data needed to resolve a public field.
 
 ```tsx
-import { computed, count, field } from '@nkzw/fate/server';
+import { computed, count } from '@nkzw/fate/server';
 
 export const userDataView = dataView<UserItem>('User')({
-  email: computed<UserItem, string | null, AppContext>({
-    authorize: ({ id }, context) => context?.sessionUser?.id === id,
+  email: computed({
+    authorize: ({ id }, context?: AppContext) => context?.sessionUser?.id === id,
     select: {
-      email: field('email'),
+      email: true,
     },
-    resolve: (_item, deps) => (deps.email as string | null) ?? null,
+    resolve: (_item: UserItem, { email }) => email ?? null,
   }),
   id: true,
 });
 
 export const postDataView = dataView<PostItem>('Post')({
-  commentCount: computed<PostItem, number>({
+  commentCount: computed({
     select: {
       count: count('comments'),
     },
-    resolve: (_item, deps) => (deps.count as number) ?? 0,
+    resolve: (_item: PostItem, { count }) => count,
   }),
   id: true,
 });
 ```
 
-The adapters fetch the hidden `field(...)` and `count(...)` dependencies for you. This keeps private fields like `email` available to the resolver without exposing them to the client selection.
+Set a dependency to `true` to select a field by the same name. Use `field('path')` for aliases or nested paths and `count('relation')` for relation counts. The adapters fetch these dependencies for you. This keeps private fields like `email` available to the resolver without exposing them to the client selection.
 
 ### Connecting the Client
 
@@ -3569,6 +3569,12 @@ After changing your database schema or auth configuration, run `vp run db:genera
 
 See [Void's Cloudflare deployment guide](https://void.cloud/integrations/cloudflare) for custom domains, secrets, and CI configuration.
 
+### Client-only Apps
+
+Choose `--template client-only` when creating the app. The template uses Void Pages Routing and prerenders both routes as static shells. IndexedDB stores application data in each browser.
+
+Run `vp exec void deploy --platform cloudflare` from the generated app to deploy the assets. You can also run `vp run build` and serve `dist/client/` from another static host that supports clean URLs.
+
 ### Migrating from cf-fate
 
 Fate 1.6 replaces the standalone Cloudflare adapter and template with the Void integration. Use `--template void` for new projects and `transport: 'void'` in the fate Vite plugin.

package/lib/index.mjs

@@ -1,5 +1,11 @@
 import { openDB } from "idb";
 // src/index.ts
+const prefixEnd = (prefix) => {
+	for (let index = prefix.length - 1; index >= 0; index--) {
+		const unit = prefix.charCodeAt(index);
+		if (unit < 65535) return prefix.slice(0, index) + String.fromCharCode(unit + 1);
+	}
+};
 function createIndexedDBStorage({ name = "fate" } = {}) {
 	let connectionLeases = 0;
 	let connection;
@@ -42,7 +48,8 @@ function createIndexedDBStorage({ name = "fate" } = {}) {
 	return {
 		exclusive(key, run) {
 			if (typeof navigator === "undefined" || !navigator.locks) throw new Error("fate(indexeddb): Web Locks are required for safe durable writes across tabs.");
-			return navigator.locks.request(`fate:${JSON.stringify([name, key])}`, async () => {
+			const lockName = `fate:${JSON.stringify([name, key])}`;
+			const request = (lockName) => navigator.locks.request(lockName, async () => {
 				connectionLeases++;
 				try {
 					return await run();
@@ -50,6 +57,7 @@ function createIndexedDBStorage({ name = "fate" } = {}) {
 					releaseDatabase();
 				}
 			});
+			return lockName.length <= 1024 ? request(lockName) : crypto.subtle.digest("SHA-256", new TextEncoder().encode(lockName)).then((digest) => request(`fate:sha256:${Array.from(new Uint8Array(digest), (byte) => byte.toString(16).padStart(2, "0")).join("")}`));
 		},
 		async read(key) {
 			const db = await acquireDatabase();
@@ -60,21 +68,24 @@ function createIndexedDBStorage({ name = "fate" } = {}) {
 			}
 		},
 		async scan(prefix, after, limit = 64) {
+			const lowerOpen = after !== void 0 && after >= prefix;
+			const lower = lowerOpen ? after : prefix;
+			if (!(limit > 0) || !lower.startsWith(prefix)) return [];
+			const upper = prefixEnd(prefix);
+			const range = upper === void 0 ? IDBKeyRange.lowerBound(lower, lowerOpen) : IDBKeyRange.bound(lower, upper, lowerOpen, true);
+			const count = Math.min(Math.ceil(limit), 4294967295);
 			const db = await acquireDatabase();
 			try {
-				const range = IDBKeyRange.lowerBound(after !== void 0 && after >= prefix ? after : prefix, after !== void 0 && after >= prefix);
 				const transaction = db.transaction("fate");
-				const entries = [];
-				let cursor = await transaction.store.openCursor(range);
-				while (cursor && String(cursor.key).startsWith(prefix) && entries.length < limit) {
-					entries.push({
-						key: String(cursor.key),
-						value: cursor.value
-					});
-					cursor = await cursor.continue();
-				}
-				await transaction.done;
-				return entries;
+				const [keys, values] = await Promise.all([
+					transaction.store.getAllKeys(range, count),
+					transaction.store.getAll(range, count),
+					transaction.done
+				]);
+				return keys.map((key, index) => ({
+					key: String(key),
+					value: values[index]
+				}));
 			} finally {
 				releaseDatabase();
 			}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nkzw/fate-indexeddb",
-  "version": "1.15.0",
+  "version": "1.16.0",
   "description": "Optional IndexedDB persistence adapter for fate.",
   "license": "MIT",
   "files": [
@@ -19,7 +19,7 @@
     "idb": "^8.0.4"
   },
   "devDependencies": {
-    "@nkzw/fate": "1.15.0",
+    "@nkzw/fate": "1.16.0",
     "fake-indexeddb": "^6.2.7",
     "vite": "npm:@voidzero-dev/vite-plus-core@1.5.0",
     "vite-plus": "1.5.0"