snapback4 0.0.12 → 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/interpreter.d.ts

@@ -60,6 +60,8 @@ export declare class Interpreter {
     private beyondHorizon;
     /** The program's page had more rows and no cursor to continue on. */
     private pageOverflow;
+    /** A field of a pending row was read while building an object. */
+    private pendingTouched;
     private page;
     private pageDepth;
     private created;

package/dist/replica/interpreter.js

@@ -137,6 +137,8 @@ export class Interpreter {
     beyondHorizon = false;
     /** The program's page had more rows and no cursor to continue on. */
     pageOverflow = false;
+    /** A field of a pending row was read while building an object. */
+    pendingTouched = false;
     page = null;
     pageDepth = 0;
     created = new Set();
@@ -361,6 +363,8 @@ export class Interpreter {
                     return null;
                 if (typeof base !== "object")
                     throw new Refused({ code: "E_FIELD", family: "input", message: `no field ${b.name}` });
+                if (base.pending === true)
+                    this.pendingTouched = true;
                 return base[b.name] ?? null;
             }
             case "Array": {
@@ -370,9 +374,16 @@ export class Interpreter {
                 return out;
             }
             case "Object": {
+                // A shape over a pending row is pending: the card's word survives
+                // the field selection, so a screen shows "Sending…" on shaped rows too.
+                const outer = this.pendingTouched;
+                this.pendingTouched = false;
                 const out = {};
                 for (const [k, v] of Object.entries(body))
                     out[k] = await this.expr(v);
+                if (this.pendingTouched && !("pending" in out))
+                    out.pending = true;
+                this.pendingTouched = outer || this.pendingTouched;
                 return out;
             }
             case "Binary": {

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.12",
+  "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.12"
+    "snapback4-darwin-arm64": "0.0.14"
   },
   "scripts": {
     "build": "tsc -p tsconfig.build.json",