snapback4 0.0.1 → 0.0.2

package/dist/replica/store.js

@@ -0,0 +1,359 @@
+// The replica store: rows by (table, id) and one index entry per (index,
+// key bytes), the server's layout on the device. Two stores share one
+// interface — in memory for tests and the simulator's twin, IndexedDB on
+// the web. Every read runs inside one transaction; every write commits as
+// one batch, so a partition batch applies atomically and a watermark never
+// gets ahead of its rows.
+import { compareKeys, encodeKey, kindOf, upperBound } from "./key.js";
+/** The index components' kinds for a table, from the schema. */
+export function indexKinds(schema, table, index) {
+    const definition = schema.tables[table]?.indexes[index];
+    if (!definition)
+        throw new Error(`no index ${table}.${index}`);
+    const columns = definition.components.map((c) => ("Column" in c ? c.Column : "")).filter(Boolean);
+    const kinds = columns.map((column) => (column === "id" ? "id" : kindOf(schema.tables[table].columns[column])));
+    return { columns, kinds };
+}
+/** The stored key of one index entry: the components, then the id. */
+export function indexKey(schema, table, index, row) {
+    const { columns, kinds } = indexKinds(schema, table, index);
+    const components = columns.map((column, i) => [kinds[i], row[column] ?? null]);
+    components.push(["id", row.id]);
+    return encodeKey(components);
+}
+/** The byte range of a scan: `[lo, hi)`, or null when empty. */
+export function scanRange(schema, table, index, prefix, bounds, dir) {
+    const { kinds } = indexKinds(schema, table, index);
+    const enc = (values) => encodeKey(values.map((v, i) => [kinds[i] ?? "string", v]));
+    const base = enc(prefix);
+    let lo = base;
+    let hi = upperBound(base);
+    const withNext = (value) => enc([...prefix, value]);
+    const max = (a, b) => (compareKeys(a, b) >= 0 ? a : b);
+    const min = (a, b) => (compareKeys(a, b) <= 0 ? a : b);
+    if (bounds.gte !== undefined)
+        lo = max(lo, withNext(bounds.gte));
+    if (bounds.gt !== undefined)
+        lo = max(lo, upperBound(withNext(bounds.gt)));
+    if (bounds.lte !== undefined)
+        hi = min(hi, upperBound(withNext(bounds.lte)));
+    if (bounds.lt !== undefined)
+        hi = min(hi, withNext(bounds.lt));
+    if (bounds.after) {
+        const position = enc([...prefix, ...bounds.after]);
+        if (dir === "asc")
+            lo = max(lo, upperBound(position));
+        else
+            hi = min(hi, position);
+    }
+    if (bounds.before) {
+        const position = enc([...prefix, ...bounds.before]);
+        if (dir === "asc")
+            hi = min(hi, position);
+        else
+            lo = max(lo, upperBound(position));
+    }
+    return compareKeys(lo, hi) < 0 ? [lo, hi] : null;
+}
+// ---------------------------------------------------------------------------
+// In memory.
+function lowerBoundIndex(entries, key) {
+    let lo = 0, hi = entries.length;
+    while (lo < hi) {
+        const mid = (lo + hi) >> 1;
+        if (compareKeys(entries[mid].key, key) < 0)
+            lo = mid + 1;
+        else
+            hi = mid;
+    }
+    return lo;
+}
+export class MemoryStore {
+    schema;
+    rows = new Map();
+    indexes = new Map();
+    meta = new Map();
+    sides = new Map();
+    constructor(schema) {
+        this.schema = schema;
+    }
+    tx() {
+        const self = this;
+        const entries = (table, index) => {
+            const name = `${table}.${index}`;
+            let list = self.indexes.get(name);
+            if (!list) {
+                list = [];
+                self.indexes.set(name, list);
+            }
+            return list;
+        };
+        const side = (name) => {
+            let map = self.sides.get(name);
+            if (!map) {
+                map = new Map();
+                self.sides.set(name, map);
+            }
+            const m = map;
+            return {
+                async get(key) { return m.get(key); },
+                async put(key, value) { m.set(key, structuredClone(value)); },
+                async delete(key) { m.delete(key); },
+                async all() { return [...m.entries()].map(([key, value]) => ({ key, value })); },
+                async clear() { m.clear(); },
+            };
+        };
+        return {
+            async get(table, id) { return self.rows.get(table)?.get(id); },
+            async lookup(table, index, key) {
+                const { kinds } = indexKinds(self.schema, table, index);
+                const prefix = encodeKey(key.map((v, i) => [kinds[i] ?? "string", v]));
+                const list = entries(table, index);
+                const at = lowerBoundIndex(list, prefix);
+                const entry = list[at];
+                if (!entry || compareKeys(entry.key, upperBound(prefix)) >= 0)
+                    return undefined;
+                return self.rows.get(table)?.get(entry.id);
+            },
+            async scan(table, index, prefix, bounds, dir, limit) {
+                const range = scanRange(self.schema, table, index, prefix, bounds, dir);
+                if (!range)
+                    return [];
+                const [lo, hi] = range;
+                const list = entries(table, index);
+                const start = lowerBoundIndex(list, lo);
+                const end = lowerBoundIndex(list, hi);
+                const out = [];
+                if (dir === "asc") {
+                    for (let i = start; i < end && out.length < limit; i++) {
+                        const row = self.rows.get(table)?.get(list[i].id);
+                        if (row)
+                            out.push({ row, key: list[i].key });
+                    }
+                }
+                else {
+                    for (let i = end - 1; i >= start && out.length < limit; i--) {
+                        const row = self.rows.get(table)?.get(list[i].id);
+                        if (row)
+                            out.push({ row, key: list[i].key });
+                    }
+                }
+                return out;
+            },
+            async count(table, index, prefix, limit) {
+                const range = scanRange(self.schema, table, index, prefix, {}, "asc");
+                if (!range)
+                    return 0;
+                const list = entries(table, index);
+                return Math.min(limit, lowerBoundIndex(list, range[1]) - lowerBoundIndex(list, range[0]));
+            },
+            async put(table, row) {
+                let rows = self.rows.get(table);
+                if (!rows) {
+                    rows = new Map();
+                    self.rows.set(table, rows);
+                }
+                const old = rows.get(row.id);
+                const definition = self.schema.tables[table];
+                if (!definition)
+                    throw new Error(`unknown table ${table}`);
+                for (const index of Object.keys(definition.indexes)) {
+                    const list = entries(table, index);
+                    if (old) {
+                        const before = indexKey(self.schema, table, index, old);
+                        const at = lowerBoundIndex(list, before);
+                        if (list[at] && compareKeys(list[at].key, before) === 0)
+                            list.splice(at, 1);
+                    }
+                    const key = indexKey(self.schema, table, index, row);
+                    list.splice(lowerBoundIndex(list, key), 0, { key, id: row.id });
+                }
+                rows.set(row.id, structuredClone(row));
+            },
+            async delete(table, id) {
+                const rows = self.rows.get(table);
+                const old = rows?.get(id);
+                if (!old)
+                    return;
+                for (const index of Object.keys(self.schema.tables[table]?.indexes ?? {})) {
+                    const list = entries(table, index);
+                    const before = indexKey(self.schema, table, index, old);
+                    const at = lowerBoundIndex(list, before);
+                    if (list[at] && compareKeys(list[at].key, before) === 0)
+                        list.splice(at, 1);
+                }
+                rows.delete(id);
+            },
+            async getMeta(key) { return self.meta.get(key); },
+            async setMeta(key, value) { self.meta.set(key, value); },
+            side,
+        };
+    }
+    async read(body) { return body(this.tx()); }
+    async write(body) { return body(this.tx()); }
+    async clearRows() { this.rows.clear(); this.indexes.clear(); }
+    async close() { }
+}
+// ---------------------------------------------------------------------------
+// IndexedDB.
+const STORES = ["rows", "idx", "meta", "outbox", "predicted", "log"];
+/** IndexedDB compares binary keys byte-wise; hand it a plain ArrayBuffer. */
+function idbKey(bytes) {
+    return bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
+}
+function request(req) {
+    return new Promise((resolve, reject) => {
+        req.onsuccess = () => resolve(req.result);
+        req.onerror = () => reject(req.error);
+    });
+}
+export async function openIndexedDb(name, schema) {
+    const db = await new Promise((resolve, reject) => {
+        const open = indexedDB.open(name, 1);
+        open.onupgradeneeded = () => {
+            const database = open.result;
+            for (const store of STORES)
+                if (!database.objectStoreNames.contains(store))
+                    database.createObjectStore(store);
+        };
+        open.onsuccess = () => resolve(open.result);
+        open.onerror = () => reject(open.error);
+    });
+    return new IndexedDbStore(db, schema);
+}
+class IndexedDbStore {
+    db;
+    schema;
+    constructor(db, schema) {
+        this.db = db;
+        this.schema = schema;
+    }
+    tx(mode) {
+        const transaction = this.db.transaction([...STORES], mode);
+        const done = new Promise((resolve, reject) => {
+            transaction.oncomplete = () => resolve();
+            transaction.onerror = () => reject(transaction.error);
+            transaction.onabort = () => reject(transaction.error ?? new Error("aborted"));
+        });
+        const rows = transaction.objectStore("rows");
+        const idx = transaction.objectStore("idx");
+        const meta = transaction.objectStore("meta");
+        const schema = this.schema;
+        const side = (name) => {
+            const store = transaction.objectStore(name);
+            return {
+                get: (key) => request(store.get(key)),
+                put: async (key, value) => { await request(store.put(value, key)); },
+                delete: async (key) => { await request(store.delete(key)); },
+                all: async () => {
+                    const keys = await request(store.getAllKeys());
+                    const values = await request(store.getAll());
+                    return keys.map((key, i) => ({ key: String(key), value: values[i] }));
+                },
+                clear: async () => { await request(store.clear()); },
+            };
+        };
+        const api = {
+            get: (table, id) => request(rows.get([table, id])),
+            async lookup(table, index, key) {
+                const { kinds } = indexKinds(schema, table, index);
+                const prefix = encodeKey(key.map((v, i) => [kinds[i] ?? "string", v]));
+                const range = IDBKeyRange.bound([`${table}.${index}`, idbKey(prefix)], [`${table}.${index}`, idbKey(upperBound(prefix))], false, true);
+                const id = await request(idx.get(range));
+                return id === undefined ? undefined : request(rows.get([table, id]));
+            },
+            async scan(table, index, prefix, bounds, dir, limit) {
+                const range = scanRange(schema, table, index, prefix, bounds, dir);
+                if (!range || limit <= 0)
+                    return [];
+                const name = `${table}.${index}`;
+                const keyRange = IDBKeyRange.bound([name, idbKey(range[0])], [name, idbKey(range[1])], false, true);
+                const out = [];
+                await new Promise((resolve, reject) => {
+                    const cursor = idx.openCursor(keyRange, dir === "asc" ? "next" : "prev");
+                    cursor.onerror = () => reject(cursor.error);
+                    cursor.onsuccess = () => {
+                        const c = cursor.result;
+                        if (!c || out.length >= limit) {
+                            resolve();
+                            return;
+                        }
+                        const id = c.value;
+                        const key = new Uint8Array(c.key[1]);
+                        const get = rows.get([table, id]);
+                        get.onsuccess = () => {
+                            if (get.result)
+                                out.push({ row: get.result, key });
+                            if (out.length >= limit)
+                                resolve();
+                            else
+                                c.continue();
+                        };
+                        get.onerror = () => reject(get.error);
+                    };
+                });
+                return out;
+            },
+            async count(table, index, prefix, limit) {
+                const range = scanRange(schema, table, index, prefix, {}, "asc");
+                if (!range)
+                    return 0;
+                const name = `${table}.${index}`;
+                const n = await request(idx.count(IDBKeyRange.bound([name, idbKey(range[0])], [name, idbKey(range[1])], false, true)));
+                return Math.min(n, limit);
+            },
+            async put(table, row) {
+                const old = (await request(rows.get([table, row.id])));
+                const definition = schema.tables[table];
+                if (!definition)
+                    throw new Error(`unknown table ${table}`);
+                for (const index of Object.keys(definition.indexes)) {
+                    const name = `${table}.${index}`;
+                    if (old)
+                        await request(idx.delete([name, idbKey(indexKey(schema, table, index, old))]));
+                    await request(idx.put(row.id, [name, idbKey(indexKey(schema, table, index, row))]));
+                }
+                await request(rows.put(row, [table, row.id]));
+            },
+            async delete(table, id) {
+                const old = (await request(rows.get([table, id])));
+                if (!old)
+                    return;
+                for (const index of Object.keys(schema.tables[table]?.indexes ?? {})) {
+                    await request(idx.delete([`${table}.${index}`, idbKey(indexKey(schema, table, index, old))]));
+                }
+                await request(rows.delete([table, id]));
+            },
+            getMeta: (key) => request(meta.get(key)),
+            setMeta: async (key, value) => { await request(meta.put(value, key)); },
+            side,
+        };
+        return { transaction, api, done };
+    }
+    async read(body) {
+        const { api, done } = this.tx("readonly");
+        const result = await body(api);
+        await done;
+        return result;
+    }
+    async write(body) {
+        const { transaction, api, done } = this.tx("readwrite");
+        try {
+            const result = await body(api);
+            await done;
+            return result;
+        }
+        catch (error) {
+            try {
+                transaction.abort();
+            }
+            catch { /* already done */ }
+            throw error;
+        }
+    }
+    async clearRows() {
+        const transaction = this.db.transaction(["rows", "idx", "predicted"], "readwrite");
+        await Promise.all([request(transaction.objectStore("rows").clear()), request(transaction.objectStore("idx").clear()), request(transaction.objectStore("predicted").clear())]);
+    }
+    async close() { this.db.close(); }
+}

package/package.json

@@ -1,13 +1,28 @@
 {
   "name": "snapback4",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "type": "module",
-  "description": "Snapback 4 client: the contract (the card), a labelled mock client, and React hooks. Week one of LLP 3000; nothing here talks to a server yet.",
+  "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": {
+    "snapback4": "bin/snapback4.js"
+  },
   "exports": {
+    "./auth": {
+      "types": "./dist/auth.d.ts",
+      "import": "./dist/auth.js"
+    },
+    "./client": {
+      "types": "./dist/client.d.ts",
+      "import": "./dist/client.js"
+    },
     "./contract": {
       "types": "./dist/contract.d.ts",
       "import": "./dist/contract.js"
     },
+    "./local": {
+      "types": "./dist/local.d.ts",
+      "import": "./dist/local.js"
+    },
     "./mock": {
       "types": "./dist/mock.d.ts",
       "import": "./dist/mock.js"
@@ -15,8 +30,20 @@
     "./react": {
       "types": "./dist/react.d.ts",
       "import": "./dist/react.js"
+    },
+    "./replica": {
+      "types": "./dist/replica/index.d.ts",
+      "import": "./dist/replica/index.js"
     }
   },
+  "files": [
+    "dist",
+    "bin",
+    "README.md"
+  ],
+  "optionalDependencies": {
+    "snapback4-darwin-arm64": "0.0.2"
+  },
   "scripts": {
     "build": "tsc -p tsconfig.build.json",
     "typecheck": "tsc -p tsconfig.json --noEmit"
@@ -37,10 +64,6 @@
     "url": "https://github.com/expo/snapback.git",
     "directory": "snapback4/packages/snapback4"
   },
-  "files": [
-    "dist",
-    "README.md"
-  ],
   "peerDependenciesMeta": {
     "react": {
       "optional": true