pyric 0.0.1 → 0.1.0-alpha.7

package/dist/database/sandbox/backend.d.ts

@@ -0,0 +1,403 @@
+/**
+ * RTDB sandbox backend — the data-plane that the modular SDK's
+ * sandbox / sandbox-live targets dispatch into.
+ *
+ * Responsibilities:
+ *   - Hold the in-memory JSON tree (`DataTree`).
+ *   - Run identity-aware rule checks via `RulesEvaluator`.
+ *   - Resolve `serverTimestamp()` sentinels at the write boundary.
+ *   - Mint RTDB-shaped push IDs.
+ *   - Fan out `onValue` / child listeners on write.
+ *
+ * One backend instance per `Sandbox` (the modular surface tracks the
+ * binding via a WeakMap so the same sandbox produces the same
+ * backend). The backend itself is identity-agnostic; the caller passes
+ * `AuthState` per op.
+ *
+ * Rule-evaluation oracle: the `@pyric/rtdb` simulator handler. The
+ * backend never reimplements rule semantics — it just packages the
+ * input shape the simulator expects.
+ */
+import type { AuthState, Sandbox } from 'pyric/sandbox';
+import { type JsonValue } from './data-tree.js';
+import { type QueryRow, type QuerySpec } from './query.js';
+/**
+ * Listener callback shape — fires with the JSON value at the listener's
+ * path, on subscribe and after every write that touches the path or any
+ * of its descendants.
+ *
+ * `exists` mirrors `DataSnapshot.exists()`; sandboxed equivalent of the
+ * SDK's "absent path → val === null && exists === false".
+ */
+export interface ValueListener {
+    id: string;
+    auth: AuthState;
+    cb: (snap: {
+        val: JsonValue;
+        exists: boolean;
+        key: string | null;
+    }) => void;
+    path: string;
+    /**
+     * If set, the listener is on a `query(ref, ...constraints)` rather
+     * than a plain ref. The backend evaluates the spec each time the
+     * subtree at `path` changes and only fires the callback when the
+     * windowed result has actually changed (locked by oracle observation
+     * `rtdb-modular-onvalue-with-query.json` — writes outside the window
+     * do NOT fire the listener).
+     */
+    query?: QuerySpec;
+    /**
+     * Cached last-fired payload — used by the query path to skip fires
+     * when the windowed result hasn't moved. Plain (non-query) listeners
+     * ignore this field (they fire on any descendant write).
+     */
+    lastWindow?: QueryRow[];
+    /**
+     * Cached last-fired value for a plain (non-query) listener. RTDB's
+     * SyncTree suppresses a value-listener fire when the value at the
+     * listener's exact path didn't change (DB-B8) — an ancestor/descendant
+     * write that leaves this path's subtree byte-identical does NOT
+     * re-fire. We compare the new value against this cache and skip the
+     * fire when they're deep-equal. `undefined` means "not yet fired"
+     * (the initial fire always sets it, so it's defined thereafter — a
+     * last value of `null` is stored as `null`, distinct from `undefined`).
+     */
+    lastValue?: JsonValue;
+}
+/**
+ * Child-event listener — fires per-child rather than per-subtree.
+ * Locked by oracle observations under
+ * `scripts/oracle/observations/rtdb-modular-onchild*.json`:
+ *
+ *   - `child_added`: replays existing children on subscribe (one fire
+ *     per existing key, in insertion / orderByKey order), then fires
+ *     once per NEW child after subscribe.
+ *   - `child_changed`: NO initial replay; fires once when an existing
+ *     child's value changes. Snapshot carries the NEW value.
+ *   - `child_removed`: NO initial replay; fires once when a child is
+ *     deleted (via `remove` or `set(null)`). Snapshot carries the
+ *     PRIOR value (the now-removed child's last value).
+ *   - `child_moved`: ordered-query only; under a plain ref it never
+ *     fires (matches the upstream contract — see the matrix M31 +
+ *     observation `rtdb-modular-onchildmoved-with-orderby.json`).
+ *
+ * When a listener carries a {@link ChildListener.spec} (i.e. it was
+ * registered on a `query(ref, ...)`), the add / change / remove events
+ * are computed against the ordered, WINDOWED result (`fanOutQueryChild`):
+ * a child entering the window fires `child_added`, one leaving fires
+ * `child_removed`, an in-window value change fires `child_changed`.
+ * `child_moved` on a query registers but does not fire on reorder — the
+ * reorder / `previousChildName` semantics are held pending two new oracle
+ * captures (matrix row `rtdb-modular#137`).
+ */
+export interface ChildListener {
+    id: string;
+    auth: AuthState;
+    event: 'child_added' | 'child_changed' | 'child_removed' | 'child_moved';
+    path: string;
+    cb: (snap: {
+        key: string;
+        val: JsonValue;
+    }) => void;
+    /**
+     * If set, the listener is on a `query(ref, ...constraints)` rather than
+     * a plain ref. Child events are then computed against the ordered,
+     * windowed query result instead of the raw child key-set:
+     *
+     *   - a child ENTERING the window emits `child_added`;
+     *   - a child LEAVING the window emits `child_removed`;
+     *   - an in-window value change emits `child_changed`.
+     *
+     * `child_moved` (reorder within the window) is deliberately NOT emitted
+     * — the reorder / `previousChildName` semantics are held pending two new
+     * oracle captures (matrix row `rtdb-modular#137`). Registering
+     * `onChildMoved` on a query must not throw; it simply never fires on
+     * reorder.
+     */
+    spec?: QuerySpec;
+    /**
+     * Cached last-fired ordered window for a query child listener. The diff
+     * on the next write is computed against this. `undefined` for plain-ref
+     * listeners (they diff the raw child key-set instead).
+     */
+    lastWindow?: QueryRow[];
+}
+/**
+ * RtdbBackend — the per-`Sandbox` data plane.
+ */
+export declare class RtdbBackend {
+    private readonly tree;
+    private readonly rules;
+    private readonly valueListeners;
+    private readonly childListeners;
+    private nextId;
+    /**
+     * Persistence change-subscribers. The sandbox persistence controller
+     * registers one of these (via {@link RtdbBackend.subscribeWrites}) so any
+     * tree mutation schedules a debounced flush. RTDB writes emit
+     * `kind: 'service_mutation'` events, which are NOT in the controller's
+     * `isPersistableEvent` set (`write`/`session_boundary`) — so the sandbox
+     * event stream never triggers an RTDB flush. This subscriber channel is
+     * the sole flush trigger, mirroring how auth drives its own flushes.
+     */
+    private readonly writeSubscribers;
+    /**
+     * The owning `Sandbox`, when this backend was created through the
+     * modular surface's `getDatabase(sandbox)` / `getDatabase(ctx)` path.
+     * Held only to emit RTDB write activity onto the unified Studio
+     * `onEvent`/`history()` stream (keystone, track T1). Optional because
+     * the backend is also constructed bare in unit tests that exercise the
+     * data plane directly; in that case emission is simply skipped.
+     */
+    private readonly sandbox?;
+    constructor(sandbox?: Sandbox);
+    /**
+     * Emit an RTDB {@link ServiceMutationEvent} onto the sandbox's unified
+     * stream. No-op when this backend has no owning sandbox (bare-test
+     * construction). Best-effort + isolated — a throw must not fail the
+     * write that triggered it.
+     */
+    private emitRtdbEvent;
+    private nextListenerId;
+    private nextGroupId;
+    private emitOperation;
+    private emitCommit;
+    private emitListener;
+    setData(seed: Record<string, JsonValue>): void;
+    setRules(rulesJson: {
+        rules: Record<string, unknown>;
+    } | null): void;
+    snapshotState(): JsonValue;
+    adminGet(path: string): JsonValue;
+    adminGetQuery(path: string, spec: QuerySpec): QueryRow[];
+    adminSet(path: string, value: JsonValue): void;
+    adminUpdate(path: string, patch: Record<string, JsonValue>): void;
+    adminRemove(path: string): void;
+    get(auth: AuthState, path: string): JsonValue;
+    /**
+     * `set(path, value)` — full overwrite at the path. `null` deletes the
+     * subtree (sandbox match for the RTDB invariant
+     * `remove(ref) === set(ref, null)`).
+     */
+    set(auth: AuthState, path: string, value: JsonValue): void;
+    /** Shared `set`/`remove` write path. `op` selects the emitted event
+     *  label so a `remove` (which is `set(_, null)`) surfaces as `remove`
+     *  rather than `set` on the Studio stream. */
+    private setInternal;
+    remove(auth: AuthState, path: string): void;
+    /**
+     * `update(path, patch)` — multi-path atomic update when keys are
+     * `/`-prefixed and `path === '/'`; otherwise a shallow merge at the
+     * named path. Matches `firebase/database`'s discrimination: an
+     * `update(rootRef, { '/users/a/x': 1, '/users/b/y': 2 })` fans out
+     * to both paths atomically, while `update(usersRef, { name: 'A' })`
+     * shallow-merges into `/users`.
+     */
+    update(auth: AuthState, path: string, patch: Record<string, JsonValue>): void;
+    /**
+     * Subscribe to `onValue`. Fires immediately with the current value
+     * (or `{ val: null, exists: false }` for an absent path — locked by
+     * the prod SDK's behavior), then on every write that touches `path`
+     * or any descendant.
+     *
+     * Returns an unsubscribe.
+     */
+    onValue(auth: AuthState, path: string, cb: (snap: {
+        val: JsonValue;
+        exists: boolean;
+        key: string | null;
+    }) => void, query?: QuerySpec): () => void;
+    /**
+     * One-shot `get` against a query — evaluates the constraint chain
+     * against the current tree snapshot. Same rules check as plain `get`
+     * (the read is at the query's root path; per-child rule evaluation
+     * isn't modeled here — RTDB itself rejects queries that span
+     * children with mixed read permissions).
+     */
+    getQuery(auth: AuthState, path: string, spec: QuerySpec): QueryRow[];
+    /** The last segment of `path`, or `null` for root. Mirrors
+     *  `DataSnapshot.key`. */
+    private keyForPath;
+    /**
+     * Compute the listener payload for `path` against the current tree.
+     * `key` is the last segment of the path, or `null` for root —
+     * matches `DataSnapshot.key`.
+     */
+    private makeSnap;
+    /**
+     * Fan out `value` listeners after a batch of paths were written.
+     * Fires every listener whose path either equals one of the touched
+     * paths or is an ancestor/descendant of any (the listener observes
+     * the subtree it's watching, so any descendant write triggers).
+     */
+    private fanOut;
+    /**
+     * `runTransaction(path, updateFn, options?)` — RTDB-flavored atomic
+     * read-modify-write. The contract mirrors `firebase/database`'s
+     * modular `runTransaction`:
+     *
+     *   - Read the current value at `path`.
+     *   - Call `updateFn(currentValue)`.
+     *     - `currentValue` is `null` for an absent path (oracle:
+     *       `rtdb-modular-runtransaction-current-value-arg.json` →
+     *       `missingArgs[0].isNull === true`).
+     *   - If `updateFn` returns `undefined` → **abort**: no write happens,
+     *     resolves `{ committed: false, snapshot }` where the snapshot
+     *     reflects the pre-transaction value (oracle:
+     *     `rtdb-modular-runtransaction-abort-undefined.json` → `committed:
+     *     false, snapVal: null, afterValOnServer: 100`).
+     *   - If `updateFn` returns any defined value → run the write under
+     *     the current identity's rules; on allow, commit and resolve
+     *     `{ committed: true, snapshot }` with the new value. On deny,
+     *     throw the RTDB-transaction error shape (oracle:
+     *     `rtdb-modular-runtransaction-on-rules-denied-path.json` →
+     *     `threw: true, message: 'permission_denied', code: null,
+     *     constructorName: 'Error'`).
+     *
+     * Single-client harness → no real concurrency to retry against; the
+     * documented "optimistic concurrency with retry" is degenerate here.
+     * The sandbox doesn't speculatively call `updateFn` with `null` first
+     * for a seeded path (prod does — second invocation with the server
+     * value); our contract is the SIMPLEST observable: one invocation
+     * with the actual current value.
+     *
+     * `applyLocally` semantics: when omitted or `true`, the in-flight
+     * (post-update-fn, pre-commit) value fans out to listeners as an
+     * optimistic fire. With `false`, no listener fire until commit. The
+     * difference is invisible in a single-client harness with a
+     * synchronous commit path; we still respect the flag so consumers can
+     * tune intermediate-fire counts under custom assertions.
+     *
+     * Returns a payload the modular surface wraps in a `DataSnapshot`
+     * shape — the backend stays snapshot-agnostic so the rules engine
+     * doesn't need to know about ref objects.
+     */
+    runTransaction(auth: AuthState, path: string, updateFn: (current: JsonValue) => JsonValue | undefined, options?: {
+        applyLocally?: boolean;
+    }): {
+        committed: boolean;
+        val: JsonValue;
+        key: string | null;
+    };
+    /**
+     * Subscribe to a child event at `path`.
+     *
+     * Semantics (locked by oracle observations under
+     * `scripts/oracle/observations/rtdb-modular-onchild*.json`):
+     *
+     *   - `child_added`: replays every existing direct child of `path` on
+     *     subscribe (one fire per existing key, in current key-iteration
+     *     order — matches the upstream `orderByKey` default observed in
+     *     `rtdb-modular-onchildadded-initial-replay`). Subsequent
+     *     additions fire once each.
+     *   - `child_changed`: no initial replay. Fires when an existing
+     *     child's value transitions to a NEW non-null value. Snapshot
+     *     carries the NEW value.
+     *   - `child_removed`: no initial replay. Fires when a child is
+     *     deleted (its value transitions to absent). Snapshot carries
+     *     the PRIOR (now-removed) value.
+     *   - `child_moved`: ordered-query only — never fires on a plain
+     *     ref (matches the upstream contract; Tier 3 will wire ordered
+     *     queries in).
+     *
+     * Rules check happens at subscribe time, identical to `onValue`. A
+     * denied subscribe throws the plain-`Error` `PERMISSION_DENIED`
+     * shape and the listener is never registered.
+     *
+     * Returns an idempotent unsubscribe.
+     */
+    onChild(auth: AuthState, event: ChildListener['event'], path: string, cb: (snap: {
+        key: string;
+        val: JsonValue;
+    }) => void, spec?: QuerySpec): () => void;
+    /**
+     * `off(refPath, eventType?, callback?)` — unsubscribe variant. Matches
+     * the upstream contract (oracle: `rtdb-modular-off-stops-child-fires`):
+     *
+     *   - `off(refPath)` removes ALL listeners (value + child) at the path.
+     *   - `off(refPath, 'value')` removes only `value` listeners at the path.
+     *   - `off(refPath, 'child_added')` (or any child event type) removes
+     *     only that child-event variety at the path.
+     *   - `off(refPath, eventType, cb)` removes only the matching callback.
+     *
+     * No-throw on absent listeners — matches the upstream behavior.
+     */
+    off(path: string, eventType?: 'value' | ChildListener['event'], callback?: ((snap: unknown) => void) | unknown): void;
+    /** Direct children of `path` as `{ key, val }` pairs. Returns [] if
+     *  the path is absent or its value isn't an object. Key iteration
+     *  follows `Object.keys` order, which matches `firebase/database`'s
+     *  `orderByKey` default (insertion order for non-numeric keys). */
+    private directChildren;
+    /** Snapshot the current direct children of every registered child
+     *  listener's parent path. Used to capture the "prior" half of the
+     *  diff before a write applies. */
+    private snapshotChildListenerParents;
+    /**
+     * Fan out child events after a write. `priorByParent` is the snapshot
+     * captured by `snapshotChildListenerParents` before the write applied.
+     *
+     * For each listener, compute the diff between prior and current
+     * children, then dispatch:
+     *   - `child_added` when a key appears that wasn't in prior.
+     *   - `child_changed` when a key's value transitions.
+     *   - `child_removed` when a prior key is gone.
+     */
+    private fanOutChildren;
+    /**
+     * Fan out a single QUERY child listener after a write, diffing the
+     * ordered window against the listener's last-fired window:
+     *
+     *   - a key that ENTERED the window emits `child_added` (window order);
+     *   - a key that LEFT the window emits `child_removed` (carrying its
+     *     prior value);
+     *   - a key that stayed in-window but changed value emits `child_changed`.
+     *
+     * `child_moved` (reorder within the window) is deliberately NOT emitted
+     * — the reorder / `previousChildName` semantics are held pending fresh
+     * oracle captures (matrix row `rtdb-modular#137`). The window is always
+     * advanced so a later real add/change/remove diffs correctly.
+     */
+    private fanOutQueryChild;
+    /** Serialize the whole tree as a plain JSON value for the persistence
+     *  snapshot. Defensive deep-copy (via `DataTree.snapshot`). */
+    exportTree(): JsonValue;
+    /**
+     * Replace the whole tree with a persisted snapshot, then fire listeners
+     * so any live UI (Studio's RTDB tab) converges on the restored data
+     * rather than showing a stale/empty view.
+     *
+     * REPLACE, not merge — the tree becomes EXACTLY the snapshot. On boot /
+     * late-registration the tree is empty so this is a pure load; for a
+     * runtime `loadSnapshot()` it clobbers divergent state, matching auth's
+     * restore policy.
+     *
+     * Notification: we capture each child-listener parent's prior children
+     * BEFORE the swap, then fan out value listeners from the root (every
+     * listener re-reads its path) and child listeners against the diff. The
+     * value-listener no-op suppression (DB-B8) means a listener whose subtree
+     * is byte-identical to the snapshot won't spuriously re-fire.
+     */
+    restoreTree(root: JsonValue): void;
+    /**
+     * Register a persistence change-subscriber. Returns an unsubscribe.
+     * Fired (best-effort, isolated) after every committed tree mutation so
+     * the controller schedules a debounced flush.
+     */
+    subscribeWrites(onChange: () => void): () => void;
+    /** Notify persistence subscribers that the tree changed. Best-effort +
+     *  isolated — a subscriber throw must never break the write. */
+    private notifyWrite;
+    /** Generate a key without writing (advisory — same key the next
+     *  `push(path)` would produce). Used by the `ref.push().key`
+     *  pattern. Each call returns a fresh key. */
+    mintKey(): string;
+    /** Test helper — count value listeners. */
+    listenerCount(): number;
+    /** Test helper — count child listeners. */
+    childListenerCount(): number;
+}
+export { cloneJson, pathSegments, joinPath } from './data-tree.js';
+export type { JsonValue } from './data-tree.js';
+export type { QuerySpec, QueryRow } from './query.js';
+//# sourceMappingURL=backend.d.ts.map

package/dist/database/sandbox/backend.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"backend.d.ts","sourceRoot":"","sources":["../../../src/database/sandbox/backend.ts"],"names":[],"mappings":"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"}