snapback4 0.0.13 → 0.0.14

package/README.md

@@ -228,7 +228,10 @@ The local-first client opens the device's replica (IndexedDB on the web,
 memory with `store: "memory"`, SQLite on Expo — §7), syncs the viewer's
 partition, runs every query locally over it, queues every mutation
 durably and predicts its rows, and follows the server's stream for the
-rest. Its options: `url`; one of `persona` (development), `session` (from
+rest. It keeps the compiled backend in the replica too, so a device that
+starts with no network opens on what it holds (`link()` is `"offline"`,
+reads carry `fresh: false` and `since`) and catches up when the link
+returns; only a device that has never synced needs the server to open. Its options: `url`; one of `persona` (development), `session` (from
 `snapback4/auth`, kept and restored by the client), or `guest: true`
 (mint one when none is kept); `store`; `sessionStore`; `fetch`;
 `waitSeconds`. It has `query(op, args) → Read`, `observe(op, args) →

package/dist/local.js

@@ -9,6 +9,8 @@ import { Interpreter, Refused } from "./replica/interpreter.js";
 import { Replica } from "./replica/replica.js";
 import { MemoryStore, openIndexedDb } from "./replica/store.js";
 import { defaultSessionStore, forgetSession, guest, keepSession, logout, restoreSession } from "./auth.js";
+/** The meta key under which a device keeps the backend it last loaded. */
+const BACKEND = "backend";
 export async function createLocalClient(options) {
     const doFetch = options.fetch ?? globalThis.fetch.bind(globalThis);
     const base = options.url.replace(/\/$/, "");
@@ -47,11 +49,28 @@ export async function createLocalClient(options) {
             await forgetSession(base, sessions);
         }
     };
-    const backend = await loadBackend(doFetch, base, headers);
+    // The store opens before the network is asked: a device that starts
+    // offline runs on the backend it cached last time, on the rows it holds.
     const storeName = `snapback4:${base}:${viewer}`;
     const useIdb = options.store === "indexeddb" || (options.store === undefined && typeof indexedDB !== "undefined");
-    const store = typeof options.store === "object" ? await options.store.open(storeName, backend.schema) : useIdb ? await openIndexedDb(storeName, backend.schema) : new MemoryStore(backend.schema);
+    const unknown = { tables: {} };
+    const store = typeof options.store === "object" ? await options.store.open(storeName, unknown) : useIdb ? await openIndexedDb(storeName, unknown) : new MemoryStore(unknown);
+    const cached = (await store.read((tx) => tx.getMeta(BACKEND)));
     let link = "online";
+    let backend;
+    try {
+        backend = await loadBackend(doFetch, base, headers);
+        await store.write((tx) => tx.setMeta(BACKEND, backend));
+    }
+    catch (error) {
+        if (!cached) {
+            await store.close();
+            throw new Error(`createLocalClient: cannot reach ${base} and this device holds no backend yet: ${error.message}`);
+        }
+        backend = cached;
+        link = "offline";
+    }
+    store.setSchema(backend.schema);
     let closed = false;
     let seq = 0;
     const aborter = new AbortController();
@@ -117,6 +136,8 @@ export async function createLocalClient(options) {
                     backend.generation = next.generation;
                     backend.schema = next.schema;
                     backend.programs = next.programs;
+                    store.setSchema(next.schema);
+                    await store.write((tx) => tx.setMeta(BACKEND, next));
                     replica.adopt(next.schema, next.generation);
                     return { denied: { code: "E_GENERATION", family: "generation", message: "the backend changed; re-deriving the partition", retryable: true } };
                 }

package/dist/replica/sqlite.js

@@ -24,6 +24,7 @@ class SqliteStore {
         this.db = db;
         this.schema = schema;
     }
+    setSchema(schema) { this.schema = schema; }
     tx() {
         const db = this.db;
         const schema = this.schema;

package/dist/replica/store.d.ts

@@ -60,6 +60,10 @@ export interface SideTx {
     clear(): Promise<void>;
 }
 export interface Store {
+    /** The compiled backend's schema, for key encoding; set once it is known
+     * (a device that starts offline reads it from its own store first). */
+    readonly schema: SchemaJson;
+    setSchema(schema: SchemaJson): void;
     read<T>(body: (tx: StoreTx) => Promise<T>): Promise<T>;
     write<T>(body: (tx: StoreTx) => Promise<T>): Promise<T>;
     /** Drop every row and index entry (a re-bootstrap); meta and side tables stay. */
@@ -76,12 +80,13 @@ export declare function indexKey(schema: SchemaJson, table: string, index: strin
 /** The byte range of a scan: `[lo, hi)`, or null when empty. */
 export declare function scanRange(schema: SchemaJson, table: string, index: string, prefix: readonly unknown[], bounds: Bounds, dir: "asc" | "desc"): [Uint8Array, Uint8Array] | null;
 export declare class MemoryStore implements Store {
-    readonly schema: SchemaJson;
+    schema: SchemaJson;
     private rows;
     private indexes;
     private meta;
     private sides;
     constructor(schema: SchemaJson);
+    setSchema(schema: SchemaJson): void;
     private tx;
     read<T>(body: (tx: StoreTx) => Promise<T>): Promise<T>;
     write<T>(body: (tx: StoreTx) => Promise<T>): Promise<T>;

package/dist/replica/store.js

@@ -77,6 +77,7 @@ export class MemoryStore {
     constructor(schema) {
         this.schema = schema;
     }
+    setSchema(schema) { this.schema = schema; }
     tx() {
         const self = this;
         const entries = (table, index) => {
@@ -228,6 +229,7 @@ class IndexedDbStore {
         this.db = db;
         this.schema = schema;
     }
+    setSchema(schema) { this.schema = schema; }
     tx(mode) {
         const transaction = this.db.transaction([...STORES], mode);
         const done = new Promise((resolve, reject) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "snapback4",
-  "version": "0.0.13",
+  "version": "0.0.14",
   "type": "module",
   "description": "Snapback 4: the card (contract), the online and local-first clients (IndexedDB, SQLite), React hooks, sign-in, a labelled mock, and the `snapback4` CLI. LLP 3000.",
   "bin": {
@@ -42,7 +42,7 @@
     "README.md"
   ],
   "optionalDependencies": {
-    "snapback4-darwin-arm64": "0.0.13"
+    "snapback4-darwin-arm64": "0.0.14"
   },
   "scripts": {
     "build": "tsc -p tsconfig.build.json",