@doubling/compound-sync 1.12.3 → 1.12.5

package/yjs-firestore-update-store.js

@@ -4,114 +4,110 @@
 // the web source tree. Keep the API identical to the web copy; a
 // follow-up will unify the two into a shared workspace package once
 // PR 4 finishes retiring the legacy blob path.
-
-import {
-  collection,
-  doc,
-  addDoc,
-  getDoc,
-  getDocs,
-  setDoc,
-  query,
-  where,
-  orderBy,
-  onSnapshot,
-  serverTimestamp,
-  writeBatch,
-  Bytes,
-  Timestamp,
-} from 'firebase/firestore';
-
+import { collection, doc, addDoc, getDoc, getDocs, setDoc, query, where, orderBy, onSnapshot, serverTimestamp, writeBatch, Bytes, Timestamp, } from 'firebase/firestore';
 function formatId(createdAt, docId) {
-  return `${createdAt.toMillis().toString().padStart(16, '0')}_${docId}`;
+    return `${createdAt.toMillis().toString().padStart(16, '0')}_${docId}`;
 }
-
 function parseTimestampFromId(id) {
-  return Timestamp.fromMillis(Number(id.split('_')[0]));
+    const [millisStr] = id.split('_');
+    return Timestamp.fromMillis(Number(millisStr));
 }
-
 export class FirestoreUpdateStore {
-  constructor(db, orgId, fileId) {
-    this.updatesCol = collection(db, 'orgs', orgId, 'files', fileId, 'yupdates');
-    this.snapshotDoc = doc(db, 'orgs', orgId, 'files', fileId, 'yjs', 'state');
-  }
-
-  async loadSnapshot() {
-    const snap = await getDoc(this.snapshotDoc);
-    if (!snap.exists()) return null;
-    const data = snap.data();
-    return {
-      state: data.state.toUint8Array(),
-      baselineId: data.baselineId ?? null,
-    };
-  }
-
-  async loadUpdatesAfter(baselineId) {
-    const q =
-      baselineId === null
-        ? query(this.updatesCol, orderBy('createdAt', 'asc'))
-        : query(
-            this.updatesCol,
-            where('createdAt', '>', parseTimestampFromId(baselineId)),
-            orderBy('createdAt', 'asc'),
-          );
-    const snap = await getDocs(q);
-    return snap.docs
-      .map((d) => {
-        const data = d.data();
-        if (!data.createdAt) return null;
-        return { id: formatId(data.createdAt, d.id), update: data.update.toUint8Array() };
-      })
-      .filter((r) => r !== null);
-  }
-
-  async appendUpdate(update) {
-    const docRef = await addDoc(this.updatesCol, {
-      update: Bytes.fromUint8Array(update),
-      createdAt: serverTimestamp(),
-    });
-    const fresh = await getDoc(docRef);
-    const data = fresh.data();
-    if (!data || !data.createdAt) {
-      throw new Error('FirestoreUpdateStore.appendUpdate: createdAt unresolved');
+    updatesCol;
+    snapshotDoc;
+    constructor(db, orgId, fileId) {
+        this.updatesCol = collection(db, 'orgs', orgId, 'files', fileId, 'yupdates');
+        this.snapshotDoc = doc(db, 'orgs', orgId, 'files', fileId, 'yjs', 'state');
     }
-    return { id: formatId(data.createdAt, docRef.id), update };
-  }
-
-  subscribeUpdates(onUpdate) {
-    const q = query(this.updatesCol, orderBy('createdAt', 'asc'));
-    // includeMetadataChanges + emitted-id dedup: see the web copy for
-    // the full rationale. Skipping pending writes alone drops the
-    // server-ack delivery because that fire is metadata-only.
-    const emitted = new Set();
-    return onSnapshot(q, { includeMetadataChanges: true }, (snap) => {
-      for (const change of snap.docChanges({ includeMetadataChanges: true })) {
-        if (change.type !== 'added' && change.type !== 'modified') continue;
-        const data = change.doc.data();
-        if (!data.createdAt) continue;
-        if (emitted.has(change.doc.id)) continue;
-        emitted.add(change.doc.id);
-        onUpdate({
-          id: formatId(data.createdAt, change.doc.id),
-          update: data.update.toUint8Array(),
+    async loadSnapshot() {
+        const snap = await getDoc(this.snapshotDoc);
+        if (!snap.exists())
+            return null;
+        const data = snap.data();
+        const state = data['state'];
+        if (!state)
+            return null;
+        // Pre-DOU-204 snapshot docs may not carry baselineId; surface that
+        // as null instead of coercing to '' (which would then crash
+        // parseTimestampFromId on the next loadUpdatesAfter call). null
+        // tells the provider "no known baseline" and loadUpdatesAfter
+        // takes the unfiltered query path.
+        const baselineId = data['baselineId'];
+        return {
+            state: state.toUint8Array(),
+            baselineId: typeof baselineId === 'string' && baselineId ? baselineId : null,
+        };
+    }
+    async loadUpdatesAfter(baselineId) {
+        const q = baselineId === null
+            ? query(this.updatesCol, orderBy('createdAt', 'asc'))
+            : query(this.updatesCol, where('createdAt', '>', parseTimestampFromId(baselineId)), orderBy('createdAt', 'asc'));
+        const snap = await getDocs(q);
+        const out = [];
+        for (const d of snap.docs) {
+            const data = d.data();
+            const createdAt = data['createdAt'];
+            const update = data['update'];
+            if (!createdAt || !update)
+                continue;
+            out.push({ id: formatId(createdAt, d.id), update: update.toUint8Array() });
+        }
+        return out;
+    }
+    async appendUpdate(update) {
+        const docRef = await addDoc(this.updatesCol, {
+            update: Bytes.fromUint8Array(update),
+            createdAt: serverTimestamp(),
+        });
+        const fresh = await getDoc(docRef);
+        const data = fresh.data();
+        const createdAt = data?.['createdAt'];
+        if (!createdAt) {
+            throw new Error('FirestoreUpdateStore.appendUpdate: createdAt unresolved');
+        }
+        return { id: formatId(createdAt, docRef.id), update };
+    }
+    subscribeUpdates(onUpdate) {
+        const q = query(this.updatesCol, orderBy('createdAt', 'asc'));
+        // includeMetadataChanges + emitted-id dedup: see the web copy for
+        // the full rationale. Skipping pending writes alone drops the
+        // server-ack delivery because that fire is metadata-only.
+        const emitted = new Set();
+        return onSnapshot(q, { includeMetadataChanges: true }, (snap) => {
+            for (const change of snap.docChanges({ includeMetadataChanges: true })) {
+                if (change.type !== 'added' && change.type !== 'modified')
+                    continue;
+                const data = change.doc.data();
+                const createdAt = data['createdAt'];
+                const update = data['update'];
+                if (!createdAt || !update)
+                    continue;
+                if (emitted.has(change.doc.id))
+                    continue;
+                emitted.add(change.doc.id);
+                onUpdate({
+                    id: formatId(createdAt, change.doc.id),
+                    update: update.toUint8Array(),
+                });
+            }
         });
-      }
-    });
-  }
-
-  async saveSnapshotAndCompact(state, newBaselineId) {
-    const baselineTs = parseTimestampFromId(newBaselineId);
-    await setDoc(this.snapshotDoc, {
-      state: Bytes.fromUint8Array(state),
-      baselineId: newBaselineId,
-      baselineCreatedAt: baselineTs,
-      updatedAt: serverTimestamp(),
-    });
-    const q = query(this.updatesCol, where('createdAt', '<=', baselineTs));
-    const stale = await getDocs(q);
-    if (stale.empty) return;
-    const batch = writeBatch(this.snapshotDoc.firestore);
-    for (const d of stale.docs) batch.delete(d.ref);
-    await batch.commit();
-  }
+    }
+    async saveSnapshotAndCompact(state, newBaselineId) {
+        const baselineTs = parseTimestampFromId(newBaselineId);
+        await setDoc(this.snapshotDoc, {
+            state: Bytes.fromUint8Array(state),
+            baselineId: newBaselineId,
+            baselineCreatedAt: baselineTs,
+            updatedAt: serverTimestamp(),
+        });
+        const q = query(this.updatesCol, where('createdAt', '<=', baselineTs));
+        const stale = await getDocs(q);
+        if (stale.empty)
+            return;
+        const batch = writeBatch(this.snapshotDoc.firestore);
+        for (const d of stale.docs)
+            batch.delete(d.ref);
+        await batch.commit();
+    }
 }
+//# sourceMappingURL=yjs-firestore-update-store.js.map

package/yjs-provider.d.ts

@@ -0,0 +1,43 @@
+import * as Y from 'yjs';
+export interface YjsUpdateRecord {
+    id: string;
+    update: Uint8Array;
+}
+export interface YjsSnapshot {
+    state: Uint8Array;
+    baselineId: string | null;
+}
+export type YjsUpdateListener = (record: YjsUpdateRecord) => void;
+export interface YjsUpdateStore {
+    loadSnapshot(): Promise<YjsSnapshot | null>;
+    loadUpdatesAfter(baselineId: string | null): Promise<YjsUpdateRecord[]>;
+    appendUpdate(update: Uint8Array): Promise<YjsUpdateRecord>;
+    subscribeUpdates(onUpdate: YjsUpdateListener): () => void;
+    saveSnapshotAndCompact(state: Uint8Array, newBaselineId: string): Promise<void>;
+}
+export declare class YjsProvider {
+    private readonly doc;
+    private readonly store;
+    private unsubscribeStore;
+    private updateHandler;
+    private loaded;
+    private subscribed;
+    private stopped;
+    constructor(doc: Y.Doc, store: YjsUpdateStore);
+    /** Phase 1: snapshot + initial updates → Y.Doc. No remote
+     * subscription yet. Callers that intend to attach a Y.Text observer
+     * (e.g. a disk-write debouncer here, yCollab on the web) should
+     * install that observer between `loadInitial()` and
+     * `startSubscription()` so the first remote update routes through
+     * to it instead of mutating Y.Text silently in the gap (DOU-204). */
+    loadInitial(): Promise<void>;
+    /** Phase 2: subscribe to remote updates and push local Y.Doc
+     * mutations back to the store. */
+    startSubscription(): void;
+    /** Convenience: load + subscribe in one call. Use only when no
+     * view-layer observer needs to attach between the phases. */
+    start(): Promise<void>;
+    stop(): void;
+    compact(): Promise<void>;
+}
+//# sourceMappingURL=yjs-provider.d.ts.map

package/yjs-provider.js

@@ -3,83 +3,87 @@
 // (echo handling, snapshot replay, compaction semantics, two-phase
 // start lifecycle from DOU-204). API kept identical so the two copies
 // can be unified into a shared workspace package in a follow-up.
-
 import * as Y from 'yjs';
-
 export class YjsProvider {
-  constructor(doc, store) {
-    this.doc = doc;
-    this.store = store;
-    this.unsubscribeStore = null;
-    this.updateHandler = null;
-    this.loaded = false;
-    this.subscribed = false;
-    this.stopped = false;
-  }
-
-  /** Phase 1: snapshot + initial updates → Y.Doc. No remote
-   * subscription yet. Callers that intend to attach a Y.Text observer
-   * (e.g. a disk-write debouncer here, yCollab on the web) should
-   * install that observer between `loadInitial()` and
-   * `startSubscription()` so the first remote update routes through
-   * to it instead of mutating Y.Text silently in the gap (DOU-204). */
-  async loadInitial() {
-    if (this.loaded) throw new Error('YjsProvider.loadInitial() called twice');
-    this.loaded = true;
-
-    const snapshot = await this.store.loadSnapshot();
-    if (snapshot) Y.applyUpdate(this.doc, snapshot.state, this);
-
-    const initial = await this.store.loadUpdatesAfter(snapshot?.baselineId ?? null);
-    for (const record of initial) Y.applyUpdate(this.doc, record.update, this);
-  }
-
-  /** Phase 2: subscribe to remote updates and push local Y.Doc
-   * mutations back to the store. */
-  startSubscription() {
-    if (!this.loaded) throw new Error('YjsProvider.startSubscription() before loadInitial()');
-    if (this.subscribed) throw new Error('YjsProvider.startSubscription() called twice');
-    this.subscribed = true;
-
-    this.unsubscribeStore = this.store.subscribeUpdates((record) => {
-      if (this.stopped) return;
-      Y.applyUpdate(this.doc, record.update, this);
-    });
-
-    this.updateHandler = (update, origin) => {
-      if (this.stopped) return;
-      if (origin === this) return;
-      this.store.appendUpdate(update).catch((err) => {
-        console.error('YjsProvider: appendUpdate failed:', err && err.message);
-      });
-    };
-    this.doc.on('update', this.updateHandler);
-  }
-
-  /** Convenience: load + subscribe in one call. Use only when no
-   * view-layer observer needs to attach between the phases. */
-  async start() {
-    await this.loadInitial();
-    this.startSubscription();
-  }
-
-  stop() {
-    this.stopped = true;
-    if (this.unsubscribeStore) {
-      this.unsubscribeStore();
-      this.unsubscribeStore = null;
+    doc;
+    store;
+    unsubscribeStore = null;
+    updateHandler = null;
+    loaded = false;
+    subscribed = false;
+    stopped = false;
+    constructor(doc, store) {
+        this.doc = doc;
+        this.store = store;
     }
-    if (this.updateHandler) {
-      this.doc.off('update', this.updateHandler);
-      this.updateHandler = null;
+    /** Phase 1: snapshot + initial updates → Y.Doc. No remote
+     * subscription yet. Callers that intend to attach a Y.Text observer
+     * (e.g. a disk-write debouncer here, yCollab on the web) should
+     * install that observer between `loadInitial()` and
+     * `startSubscription()` so the first remote update routes through
+     * to it instead of mutating Y.Text silently in the gap (DOU-204). */
+    async loadInitial() {
+        if (this.loaded)
+            throw new Error('YjsProvider.loadInitial() called twice');
+        this.loaded = true;
+        const snapshot = await this.store.loadSnapshot();
+        if (snapshot)
+            Y.applyUpdate(this.doc, snapshot.state, this);
+        const initial = await this.store.loadUpdatesAfter(snapshot?.baselineId ?? null);
+        for (const record of initial)
+            Y.applyUpdate(this.doc, record.update, this);
+    }
+    /** Phase 2: subscribe to remote updates and push local Y.Doc
+     * mutations back to the store. */
+    startSubscription() {
+        if (!this.loaded)
+            throw new Error('YjsProvider.startSubscription() before loadInitial()');
+        if (this.subscribed)
+            throw new Error('YjsProvider.startSubscription() called twice');
+        this.subscribed = true;
+        this.unsubscribeStore = this.store.subscribeUpdates((record) => {
+            if (this.stopped)
+                return;
+            Y.applyUpdate(this.doc, record.update, this);
+        });
+        this.updateHandler = (update, origin) => {
+            if (this.stopped)
+                return;
+            if (origin === this)
+                return;
+            this.store.appendUpdate(update).catch((err) => {
+                // Log the full error so non-Error throws and stack traces
+                // survive into ops dashboards instead of being silently
+                // truncated to a `.message` string.
+                console.error('YjsProvider: appendUpdate failed:', err);
+            });
+        };
+        this.doc.on('update', this.updateHandler);
+    }
+    /** Convenience: load + subscribe in one call. Use only when no
+     * view-layer observer needs to attach between the phases. */
+    async start() {
+        await this.loadInitial();
+        this.startSubscription();
+    }
+    stop() {
+        this.stopped = true;
+        if (this.unsubscribeStore) {
+            this.unsubscribeStore();
+            this.unsubscribeStore = null;
+        }
+        if (this.updateHandler) {
+            this.doc.off('update', this.updateHandler);
+            this.updateHandler = null;
+        }
+    }
+    async compact() {
+        const state = Y.encodeStateAsUpdate(this.doc);
+        const records = await this.store.loadUpdatesAfter(null);
+        const last = records[records.length - 1];
+        if (!last)
+            return;
+        await this.store.saveSnapshotAndCompact(state, last.id);
     }
-  }
-
-  async compact() {
-    const state = Y.encodeStateAsUpdate(this.doc);
-    const records = await this.store.loadUpdatesAfter(null);
-    const last = records[records.length - 1];
-    if (!last) return;
-    await this.store.saveSnapshotAndCompact(state, last.id);
-  }
 }
+//# sourceMappingURL=yjs-provider.js.map