snapback4 0.0.1 → 0.0.2

package/dist/replica/cursor.js

@@ -0,0 +1,81 @@
+// Opaque cursors, byte-for-byte the server's (`cursor.rs`): base64url over
+// canonical JSON of `[1, table, index, order, suffix, values]`, values in
+// the tagged form. A page position minted here resumes on the server and
+// vice versa.
+/** Canonical JSON: compact, object keys sorted, as serde_json writes a BTreeMap. */
+export function canonicalJson(value) {
+    if (value === null || value === undefined)
+        return "null";
+    if (typeof value === "number")
+        return Number.isInteger(value) ? String(value) : JSON.stringify(value);
+    if (typeof value === "string" || typeof value === "boolean")
+        return JSON.stringify(value);
+    if (Array.isArray(value))
+        return `[${value.map(canonicalJson).join(",")}]`;
+    const keys = Object.keys(value).sort();
+    return `{${keys.map((k) => `${JSON.stringify(k)}:${canonicalJson(value[k])}`).join(",")}}`;
+}
+function tagFor(kind, value) {
+    if (value === null || value === undefined)
+        return "Null";
+    const name = typeof kind === "string" ? kind : Object.keys(kind)[0];
+    const inner = typeof kind === "object" && kind !== null ? kind[name] : undefined;
+    switch (name) {
+        case "Optional": return tagFor(inner, value);
+        case "Id":
+        case "Principal":
+        case "Ref": return { Id: value };
+        case "Text":
+        case "Enum": return { String: value };
+        case "Int":
+        case "Time":
+        case "Decimal":
+        case "Money": return { Int: value };
+        case "Bool": return { Bool: value };
+        case "Bytes": return { Bytes: value };
+        default: return typeof value === "string" ? { String: value } : typeof value === "number" ? { Int: value } : typeof value === "boolean" ? { Bool: value } : "Null";
+    }
+}
+function untag(tagged) {
+    if (tagged === "Null")
+        return null;
+    if (typeof tagged !== "object" || tagged === null)
+        return tagged;
+    const [k, v] = Object.entries(tagged)[0];
+    return k === "Array" ? v.map(untag) : v;
+}
+const base64url = (bytes) => {
+    let binary = "";
+    for (const b of bytes)
+        binary += String.fromCharCode(b);
+    return btoa(binary).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+};
+const fromBase64url = (text) => {
+    try {
+        const padded = text.replace(/-/g, "+").replace(/_/g, "/") + "=".repeat((4 - (text.length % 4)) % 4);
+        const binary = atob(padded);
+        return Uint8Array.from(binary, (c) => c.charCodeAt(0));
+    }
+    catch {
+        return null;
+    }
+};
+export function encodeCursor(position) {
+    const tagged = [1, position.table, position.index, position.order, position.suffix, position.values.map((v, i) => tagFor(position.suffix[i]?.kind, v))];
+    return base64url(new TextEncoder().encode(canonicalJson(tagged)));
+}
+export function decodeCursor(token) {
+    const bytes = fromBase64url(token);
+    if (!bytes)
+        return null;
+    try {
+        const parsed = JSON.parse(new TextDecoder().decode(bytes));
+        if (!Array.isArray(parsed) || parsed[0] !== 1)
+            return null;
+        const suffix = parsed[4];
+        return { table: parsed[1], index: parsed[2], order: parsed[3], suffix, values: parsed[5].map(untag) };
+    }
+    catch {
+        return null;
+    }
+}

package/dist/replica/index.d.ts

@@ -0,0 +1,3 @@
+export { openSqlite, expoSqliteDriver, nodeSqliteDriver, type SqliteDriver } from "./sqlite.ts";
+export { MemoryStore, openIndexedDb, type Store, type StoreTx, type SchemaJson, type Row } from "./store.ts";
+export { encodeKey, upperBound, compareKeys, type Kind } from "./key.ts";

package/dist/replica/index.js

@@ -0,0 +1,6 @@
+// The replica's parts, for hosts that bring their own store: the SQLite
+// store behind a four-method driver (`expo-sqlite`, `node:sqlite`), the
+// memory store, and the store contract itself.
+export { openSqlite, expoSqliteDriver, nodeSqliteDriver } from "./sqlite.js";
+export { MemoryStore, openIndexedDb } from "./store.js";
+export { encodeKey, upperBound, compareKeys } from "./key.js";

package/dist/replica/interpreter.d.ts

@@ -0,0 +1,106 @@
+import type { Row, SchemaJson, StoreTx } from "./store.ts";
+export type Json = unknown;
+export interface ProgramJson {
+    name: string;
+    kind: "Query" | "Mutation" | "job";
+    args: Record<string, unknown>;
+    body: unknown[];
+}
+export interface Refusal {
+    code: string;
+    family: string;
+    message: string;
+    site?: string;
+    rule?: string;
+    retryable?: boolean;
+}
+export declare class Refused extends Error {
+    readonly refusal: Refusal;
+    constructor(refusal: Refusal);
+}
+/** A query's outcome on the device. */
+export interface LocalRead {
+    data: unknown;
+    /** False beyond a horizon, at an online-only site, or past the meter. */
+    complete: boolean;
+    next: string | null;
+    tables: Set<string>;
+}
+export interface Ceilings {
+    examined: number;
+    ruleProbes: number;
+    steps: number;
+    rowsWritten: number;
+}
+export declare const CEILINGS: Ceilings;
+export declare function literal(v: unknown): unknown;
+/** The value model's total order over plain values. */
+export declare function totalCompare(a: unknown, b: unknown): number;
+export declare function equal(a: unknown, b: unknown): boolean;
+export interface Context {
+    viewer: string;
+    args: Record<string, unknown>;
+    now: number;
+    newIds: string[];
+    mint: () => string;
+}
+/** Runs programs over one store transaction. */
+export declare class Interpreter {
+    private tx;
+    private schema;
+    private ctx;
+    private mode;
+    private ceilings;
+    private env;
+    private examined;
+    private probes;
+    private steps;
+    private written;
+    private capped;
+    private beyondHorizon;
+    private page;
+    private pageDepth;
+    private created;
+    readonly tables: Set<string>;
+    readonly writes: {
+        table: string;
+        row: Row;
+        old?: Row;
+    }[];
+    private site;
+    constructor(tx: StoreTx, schema: SchemaJson, ctx: Context, mode: "query" | "mutation", ceilings?: Ceilings);
+    private charge;
+    private step;
+    run(program: ProgramJson): Promise<LocalRead>;
+    private nextCursor;
+    private statements;
+    private domain;
+    private recurse;
+    expr(e: unknown): Promise<unknown>;
+    private builtin;
+    private get;
+    private scan;
+    private merge;
+    /** The server's `scan_visibility`, on the device: a read rule whose every
+     * field the prefix pins is decided once for the whole range (`uniform`);
+     * one the prefix proves is `decidedTrue` before any row is read. A
+     * uniform-false range halts after one row at the cost of an empty one,
+     * so the rows the viewer may no longer read (delivered history) are never
+     * counted. */
+    private visibility;
+    private ruleTrue;
+    /** The read rule for one row, with probes over the replica. */
+    readable(table: string, row: Row): Promise<boolean>;
+    private rule;
+    private permitted;
+    private constraints;
+    private insert;
+    private update;
+    private upsert;
+    private delete;
+    private put;
+    /** A device keeps its counts honest while a prediction stands. */
+    private maintain;
+}
+/** A plain value as the server's tagged literal (for canonical ids). */
+export declare function tag(v: unknown): unknown;