@noy-db/hub 0.1.0-pre.3

package/dist/chunk-EXQRC2L4.js

@@ -0,0 +1,722 @@
+import {
+  SyncScheduler
+} from "./chunk-2QR2PQTT.js";
+import {
+  NOYDB_SYNC_VERSION
+} from "./chunk-ZRG4V3F5.js";
+import {
+  bufferToBase64,
+  decrypt,
+  derivePresenceKey,
+  encrypt,
+  generateIV
+} from "./chunk-MR4424N3.js";
+import {
+  ConflictError
+} from "./chunk-ACLDOTNQ.js";
+
+// src/team/presence.ts
+var PresenceHandle = class {
+  adapter;
+  syncAdapter;
+  vault;
+  collectionName;
+  userId;
+  encrypted;
+  getDEK;
+  staleMs;
+  pollIntervalMs;
+  channel;
+  storageCollection;
+  presenceKey = null;
+  subscribers = [];
+  unsubscribePubSub = null;
+  pollTimer = null;
+  stopped = false;
+  constructor(opts) {
+    this.adapter = opts.adapter;
+    this.syncAdapter = opts.syncAdapter;
+    this.vault = opts.vault;
+    this.collectionName = opts.collectionName;
+    this.userId = opts.userId;
+    this.encrypted = opts.encrypted;
+    this.getDEK = opts.getDEK;
+    this.staleMs = opts.staleMs ?? 3e4;
+    this.pollIntervalMs = opts.pollIntervalMs ?? 5e3;
+    this.channel = `${opts.vault}:${opts.collectionName}:presence`;
+    this.storageCollection = `_presence_${opts.collectionName}`;
+  }
+  /**
+   * Announce yourself (or update your cursor/status).
+   * Encrypts `payload` with the presence key and publishes it.
+   */
+  async update(payload) {
+    if (this.stopped) return;
+    const key = await this.getPresenceKey();
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const plaintext = JSON.stringify({ userId: this.userId, lastSeen: now, payload });
+    let encryptedPayload;
+    if (this.encrypted && key) {
+      const iv = generateIV();
+      const ivB64 = bufferToBase64(iv);
+      const { data } = await encrypt(plaintext, key);
+      encryptedPayload = JSON.stringify({ iv: ivB64, data });
+    } else {
+      encryptedPayload = plaintext;
+    }
+    const pubAdapter = this.getPubSubAdapter();
+    if (pubAdapter?.presencePublish) {
+      await pubAdapter.presencePublish(this.channel, encryptedPayload);
+    }
+    await this.writeStorageRecord(payload, now);
+  }
+  /**
+   * Subscribe to presence updates. The callback receives a filtered, decrypted
+   * list of all currently-active peers (excluding yourself, excluding stale).
+   *
+   * Returns an unsubscribe function. Also call `stop()` to release all resources.
+   */
+  subscribe(cb) {
+    if (this.stopped) return () => {
+    };
+    this.subscribers.push(cb);
+    if (this.subscribers.length === 1) {
+      this.startListening();
+    }
+    return () => {
+      this.subscribers = this.subscribers.filter((s) => s !== cb);
+      if (this.subscribers.length === 0) this.stopListening();
+    };
+  }
+  /** Stop all listening and clear resources. */
+  stop() {
+    this.stopped = true;
+    this.stopListening();
+    this.subscribers = [];
+  }
+  // ─── Private ────────────────────────────────────────────────────────
+  async getPresenceKey() {
+    if (!this.encrypted) return null;
+    if (!this.presenceKey) {
+      try {
+        const dek = await this.getDEK(this.collectionName);
+        this.presenceKey = await derivePresenceKey(dek, this.collectionName);
+      } catch {
+      }
+    }
+    return this.presenceKey;
+  }
+  getPubSubAdapter() {
+    if (this.syncAdapter?.presencePublish) return this.syncAdapter;
+    if (this.adapter.presencePublish) return this.adapter;
+    return void 0;
+  }
+  startListening() {
+    const pubAdapter = this.getPubSubAdapter();
+    if (pubAdapter?.presenceSubscribe) {
+      this.unsubscribePubSub = pubAdapter.presenceSubscribe(
+        this.channel,
+        (encryptedPayload) => {
+          void this.handlePubSubMessage(encryptedPayload);
+        }
+      );
+    } else {
+      this.pollTimer = setInterval(
+        () => {
+          void this.pollStoragePresence();
+        },
+        this.pollIntervalMs
+      );
+      void this.pollStoragePresence();
+    }
+  }
+  stopListening() {
+    if (this.unsubscribePubSub) {
+      this.unsubscribePubSub();
+      this.unsubscribePubSub = null;
+    }
+    if (this.pollTimer) {
+      clearInterval(this.pollTimer);
+      this.pollTimer = null;
+    }
+  }
+  async handlePubSubMessage(encryptedPayload) {
+    try {
+      const peer = await this.decryptPresencePayload(encryptedPayload);
+      if (!peer || peer.userId === this.userId) return;
+      const cutoff = new Date(Date.now() - this.staleMs).toISOString();
+      if (peer.lastSeen < cutoff) return;
+      await this.pollStoragePresence();
+    } catch {
+    }
+  }
+  async decryptPresencePayload(encryptedPayload) {
+    const key = await this.getPresenceKey();
+    if (!this.encrypted || !key) {
+      return JSON.parse(encryptedPayload);
+    }
+    const { iv: ivB64, data } = JSON.parse(encryptedPayload);
+    const plaintext = await decrypt(ivB64, data, key);
+    return JSON.parse(plaintext);
+  }
+  async writeStorageRecord(payload, now) {
+    const key = await this.getPresenceKey();
+    const plaintext = JSON.stringify(payload);
+    let iv = "";
+    let data;
+    if (this.encrypted && key) {
+      const ivBytes = generateIV();
+      iv = bufferToBase64(ivBytes);
+      const result = await encrypt(plaintext, key);
+      data = result.data;
+    } else {
+      data = plaintext;
+    }
+    const record = { userId: this.userId, lastSeen: now, iv, data };
+    const json = JSON.stringify(record);
+    const storeAdapter = this.syncAdapter ?? this.adapter;
+    const envelope = {
+      _noydb: 1,
+      _v: 1,
+      _ts: now,
+      _iv: "",
+      _data: json
+    };
+    try {
+      await storeAdapter.put(
+        this.vault,
+        this.storageCollection,
+        this.userId,
+        envelope
+      );
+    } catch {
+    }
+  }
+  async pollStoragePresence() {
+    if (this.stopped || this.subscribers.length === 0) return;
+    try {
+      const storeAdapter = this.syncAdapter ?? this.adapter;
+      const ids = await storeAdapter.list(this.vault, this.storageCollection);
+      const cutoff = new Date(Date.now() - this.staleMs).toISOString();
+      const peers = [];
+      for (const id of ids) {
+        if (id === this.userId) continue;
+        const envelope = await storeAdapter.get(this.vault, this.storageCollection, id);
+        if (!envelope) continue;
+        const record = JSON.parse(envelope._data);
+        if (record.lastSeen < cutoff) continue;
+        let peerPayload;
+        if (this.encrypted && this.presenceKey && record.iv) {
+          const plaintext = await decrypt(record.iv, record.data, this.presenceKey);
+          peerPayload = JSON.parse(plaintext);
+        } else {
+          peerPayload = JSON.parse(record.data);
+        }
+        peers.push({ userId: record.userId, payload: peerPayload, lastSeen: record.lastSeen });
+      }
+      for (const cb of this.subscribers) {
+        cb(peers);
+      }
+    } catch {
+    }
+  }
+};
+
+// src/team/sync.ts
+var SyncEngine = class {
+  local;
+  remote;
+  strategy;
+  emitter;
+  vault;
+  role;
+  label;
+  dirty = [];
+  lastPush = null;
+  lastPull = null;
+  loaded = false;
+  autoSyncInterval = null;
+  isOnline = true;
+  /** Sync scheduler. Manages push/pull timing. */
+  scheduler;
+  /** Per-collection conflict resolvers registered by Collection instances. */
+  conflictResolvers = /* @__PURE__ */ new Map();
+  constructor(opts) {
+    this.local = opts.local;
+    this.remote = opts.remote;
+    this.vault = opts.vault;
+    this.strategy = opts.strategy;
+    this.emitter = opts.emitter;
+    this.role = opts.role ?? "sync-peer";
+    this.label = opts.label;
+    const policy = opts.syncPolicy;
+    if (policy && policy.push.mode !== "manual") {
+      this.scheduler = new SyncScheduler(policy, {
+        push: () => this.push().then(() => {
+        }),
+        pull: () => this.pull().then(() => {
+        }),
+        getDirtyCount: () => this.dirty.length
+      });
+    } else {
+      this.scheduler = null;
+    }
+  }
+  /** Start the sync scheduler. Called after vault is fully opened. */
+  startScheduler() {
+    this.scheduler?.start();
+  }
+  /** Stop the sync scheduler. Called on close. */
+  stopScheduler() {
+    this.scheduler?.stop();
+  }
+  /**
+   * Register a per-collection conflict resolver.
+   * Called by Collection when `conflictPolicy` is set.
+   */
+  registerConflictResolver(collection, resolver) {
+    this.conflictResolvers.set(collection, resolver);
+  }
+  /** Record a local change for later push. */
+  async trackChange(collection, id, action, version) {
+    await this.ensureLoaded();
+    const idx = this.dirty.findIndex((d) => d.collection === collection && d.id === id);
+    const entry = {
+      vault: this.vault,
+      collection,
+      id,
+      action,
+      version,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    if (idx >= 0) {
+      this.dirty[idx] = entry;
+    } else {
+      this.dirty.push(entry);
+    }
+    await this.persistMeta();
+    this.scheduler?.notifyChange();
+  }
+  /** Push dirty records to remote adapter. Accepts optional `PushOptions` for partial sync. */
+  async push(options) {
+    await this.ensureLoaded();
+    let pushed = 0;
+    const conflicts = [];
+    const errors = [];
+    const completed = [];
+    for (let i = 0; i < this.dirty.length; i++) {
+      const entry = this.dirty[i];
+      if (options?.collections && !options.collections.includes(entry.collection)) {
+        continue;
+      }
+      try {
+        if (entry.action === "delete") {
+          await this.remote.delete(this.vault, entry.collection, entry.id);
+          completed.push(i);
+          pushed++;
+        } else {
+          const envelope = await this.local.get(this.vault, entry.collection, entry.id);
+          if (!envelope) {
+            completed.push(i);
+            continue;
+          }
+          try {
+            await this.remote.put(
+              this.vault,
+              entry.collection,
+              entry.id,
+              envelope,
+              entry.version - 1
+            );
+            completed.push(i);
+            pushed++;
+          } catch (err) {
+            if (err instanceof ConflictError) {
+              const remoteEnvelope = await this.remote.get(this.vault, entry.collection, entry.id);
+              if (remoteEnvelope) {
+                const { handled, conflict } = await this.handleConflict(
+                  entry.collection,
+                  entry.id,
+                  envelope,
+                  remoteEnvelope,
+                  "push"
+                );
+                conflicts.push(conflict);
+                if (handled === "local") {
+                  await this.remote.put(this.vault, entry.collection, entry.id, conflict.local);
+                  completed.push(i);
+                  pushed++;
+                } else if (handled === "remote") {
+                  await this.local.put(this.vault, entry.collection, entry.id, conflict.remote);
+                  completed.push(i);
+                } else if (handled === "merged" && conflict.local !== envelope) {
+                  const merged = conflict.local;
+                  await this.remote.put(this.vault, entry.collection, entry.id, merged);
+                  await this.local.put(this.vault, entry.collection, entry.id, merged);
+                  completed.push(i);
+                  pushed++;
+                }
+              }
+            } else {
+              throw err;
+            }
+          }
+        }
+      } catch (err) {
+        errors.push(err instanceof Error ? err : new Error(String(err)));
+      }
+    }
+    for (const i of completed.sort((a, b) => b - a)) {
+      this.dirty.splice(i, 1);
+    }
+    this.lastPush = (/* @__PURE__ */ new Date()).toISOString();
+    await this.persistMeta();
+    const result = { pushed, conflicts, errors };
+    this.emitter.emit("sync:push", result);
+    return result;
+  }
+  /** Pull remote records to local adapter. Accepts optional `PullOptions` for partial sync. */
+  async pull(options) {
+    await this.ensureLoaded();
+    let pulled = 0;
+    const conflicts = [];
+    const errors = [];
+    try {
+      const remoteSnapshot = await this.remote.loadAll(this.vault);
+      for (const [collName, records] of Object.entries(remoteSnapshot)) {
+        if (options?.collections && !options.collections.includes(collName)) {
+          continue;
+        }
+        for (const [id, remoteEnvelope] of Object.entries(records)) {
+          if (options?.modifiedSince && remoteEnvelope._ts <= options.modifiedSince) {
+            continue;
+          }
+          try {
+            const localEnvelope = await this.local.get(this.vault, collName, id);
+            if (!localEnvelope) {
+              await this.local.put(this.vault, collName, id, remoteEnvelope);
+              pulled++;
+            } else if (remoteEnvelope._v > localEnvelope._v) {
+              const isDirty = this.dirty.some((d) => d.collection === collName && d.id === id);
+              if (isDirty) {
+                const { handled, conflict } = await this.handleConflict(
+                  collName,
+                  id,
+                  localEnvelope,
+                  remoteEnvelope,
+                  "pull"
+                );
+                conflicts.push(conflict);
+                if (handled === "remote") {
+                  await this.local.put(this.vault, collName, id, conflict.remote);
+                  this.dirty = this.dirty.filter((d) => !(d.collection === collName && d.id === id));
+                  pulled++;
+                } else if (handled === "merged" && conflict.local !== localEnvelope) {
+                  const merged = conflict.local;
+                  await this.local.put(this.vault, collName, id, merged);
+                  this.dirty = this.dirty.filter((d) => !(d.collection === collName && d.id === id));
+                  pulled++;
+                }
+              } else {
+                await this.local.put(this.vault, collName, id, remoteEnvelope);
+                pulled++;
+              }
+            }
+          } catch (err) {
+            errors.push(err instanceof Error ? err : new Error(String(err)));
+          }
+        }
+      }
+    } catch (err) {
+      errors.push(err instanceof Error ? err : new Error(String(err)));
+    }
+    this.lastPull = (/* @__PURE__ */ new Date()).toISOString();
+    await this.persistMeta();
+    const result = { pulled, conflicts, errors };
+    this.emitter.emit("sync:pull", result);
+    return result;
+  }
+  /** Bidirectional sync: pull then push. */
+  async sync(options) {
+    const pullResult = await this.pull(options?.pull);
+    const pushResult = await this.push(options?.push);
+    return { pull: pullResult, push: pushResult };
+  }
+  /**
+   * Push a specific subset of dirty entries (for sync transactions, ).
+   * Entries are matched by collection+id from the dirty log; matched entries
+   * are removed from the dirty log on success.
+   */
+  async pushFiltered(predicate) {
+    await this.ensureLoaded();
+    let pushed = 0;
+    const conflicts = [];
+    const errors = [];
+    const completed = [];
+    for (let i = 0; i < this.dirty.length; i++) {
+      const entry = this.dirty[i];
+      if (!predicate(entry)) continue;
+      try {
+        if (entry.action === "delete") {
+          await this.remote.delete(this.vault, entry.collection, entry.id);
+          completed.push(i);
+          pushed++;
+        } else {
+          const envelope = await this.local.get(this.vault, entry.collection, entry.id);
+          if (!envelope) {
+            completed.push(i);
+            continue;
+          }
+          try {
+            await this.remote.put(
+              this.vault,
+              entry.collection,
+              entry.id,
+              envelope,
+              entry.version - 1
+            );
+            completed.push(i);
+            pushed++;
+          } catch (err) {
+            if (err instanceof ConflictError) {
+              const remoteEnvelope = await this.remote.get(this.vault, entry.collection, entry.id);
+              if (remoteEnvelope) {
+                const { handled, conflict } = await this.handleConflict(
+                  entry.collection,
+                  entry.id,
+                  envelope,
+                  remoteEnvelope,
+                  "push"
+                );
+                conflicts.push(conflict);
+                if (handled === "local") {
+                  await this.remote.put(this.vault, entry.collection, entry.id, conflict.local);
+                  completed.push(i);
+                  pushed++;
+                } else if (handled === "remote") {
+                  await this.local.put(this.vault, entry.collection, entry.id, conflict.remote);
+                  completed.push(i);
+                } else if (handled === "merged" && conflict.local !== envelope) {
+                  const merged = conflict.local;
+                  await this.remote.put(this.vault, entry.collection, entry.id, merged);
+                  await this.local.put(this.vault, entry.collection, entry.id, merged);
+                  completed.push(i);
+                  pushed++;
+                }
+              }
+            } else {
+              throw err;
+            }
+          }
+        }
+      } catch (err) {
+        errors.push(err instanceof Error ? err : new Error(String(err)));
+      }
+    }
+    for (const i of completed.sort((a, b) => b - a)) {
+      this.dirty.splice(i, 1);
+    }
+    this.lastPush = (/* @__PURE__ */ new Date()).toISOString();
+    await this.persistMeta();
+    const result = { pushed, conflicts, errors };
+    this.emitter.emit("sync:push", result);
+    return result;
+  }
+  /** Get current sync status. */
+  status() {
+    return {
+      dirty: this.dirty.length,
+      lastPush: this.lastPush,
+      lastPull: this.lastPull,
+      online: this.isOnline
+    };
+  }
+  // ─── Auto-Sync ───────────────────────────────────────────────────
+  /** Start auto-sync: listen for online/offline events, optional periodic sync. */
+  startAutoSync(intervalMs) {
+    if (typeof globalThis.addEventListener === "function") {
+      globalThis.addEventListener("online", this.handleOnline);
+      globalThis.addEventListener("offline", this.handleOffline);
+    }
+    if (intervalMs && intervalMs > 0) {
+      this.autoSyncInterval = setInterval(() => {
+        if (this.isOnline) {
+          void this.sync();
+        }
+      }, intervalMs);
+    }
+  }
+  /** Stop auto-sync and scheduler. */
+  stopAutoSync() {
+    this.stopScheduler();
+    if (typeof globalThis.removeEventListener === "function") {
+      globalThis.removeEventListener("online", this.handleOnline);
+      globalThis.removeEventListener("offline", this.handleOffline);
+    }
+    if (this.autoSyncInterval) {
+      clearInterval(this.autoSyncInterval);
+      this.autoSyncInterval = null;
+    }
+  }
+  handleOnline = () => {
+    this.isOnline = true;
+    this.emitter.emit("sync:online", void 0);
+    void this.sync();
+  };
+  handleOffline = () => {
+    this.isOnline = false;
+    this.emitter.emit("sync:offline", void 0);
+  };
+  /**
+   * Resolve a conflict, checking per-collection resolvers first,
+   * then falling back to the db-level `ConflictStrategy`.
+   *
+   * Returns the resolved `Conflict` object (possibly with `resolve` set for
+   * manual mode) and a `handled` discriminant:
+   * - `'local'` — keep the local envelope; push it to remote.
+   * - `'remote'` — keep the remote envelope; update local.
+   * - `'merged'` — a custom merge fn produced a new envelope stored as `conflict.local`.
+   * - `'deferred'` — manual mode, resolve was not called synchronously.
+   */
+  async handleConflict(collection, id, local, remote, _phase) {
+    const resolver = this.conflictResolvers.get(collection);
+    if (resolver) {
+      const winner = await resolver(id, local, remote);
+      const base = {
+        vault: this.vault,
+        collection,
+        id,
+        local,
+        remote,
+        localVersion: local._v,
+        remoteVersion: remote._v
+      };
+      if (winner === null) return { handled: "deferred", conflict: base };
+      if (winner === local) return { handled: "local", conflict: base };
+      if (winner === remote) return { handled: "remote", conflict: base };
+      return {
+        handled: "merged",
+        conflict: { ...base, local: winner, localVersion: winner._v }
+      };
+    }
+    const baseConflict = {
+      vault: this.vault,
+      collection,
+      id,
+      local,
+      remote,
+      localVersion: local._v,
+      remoteVersion: remote._v
+    };
+    this.emitter.emit("sync:conflict", baseConflict);
+    const side = this.legacyResolve(baseConflict);
+    return { handled: side, conflict: baseConflict };
+  }
+  /** DB-level ConflictStrategy resolution (legacy, kept for backward compat). */
+  legacyResolve(conflict) {
+    if (typeof this.strategy === "function") {
+      return this.strategy(conflict);
+    }
+    switch (this.strategy) {
+      case "local-wins":
+        return "local";
+      case "remote-wins":
+        return "remote";
+      case "version":
+      default:
+        return conflict.localVersion >= conflict.remoteVersion ? "local" : "remote";
+    }
+  }
+  // ─── Persistence ─────────────────────────────────────────────────
+  async ensureLoaded() {
+    if (this.loaded) return;
+    const envelope = await this.local.get(this.vault, "_sync", "meta");
+    if (envelope) {
+      const meta = JSON.parse(envelope._data);
+      this.dirty = [...meta.dirty];
+      this.lastPush = meta.last_push;
+      this.lastPull = meta.last_pull;
+    }
+    this.loaded = true;
+  }
+  async persistMeta() {
+    const meta = {
+      _noydb_sync: NOYDB_SYNC_VERSION,
+      last_push: this.lastPush,
+      last_pull: this.lastPull,
+      dirty: this.dirty
+    };
+    const envelope = {
+      _noydb: 1,
+      _v: 1,
+      _ts: (/* @__PURE__ */ new Date()).toISOString(),
+      _iv: "",
+      _data: JSON.stringify(meta)
+    };
+    await this.local.put(this.vault, "_sync", "meta", envelope);
+  }
+};
+
+// src/team/sync-transaction.ts
+var SyncTransaction = class {
+  comp;
+  engine;
+  ops = [];
+  /** @internal — constructed by `Noydb.transaction()` */
+  constructor(comp, engine) {
+    this.comp = comp;
+    this.engine = engine;
+  }
+  /** Stage a record write. Does not write to any adapter until `commit()`. */
+  put(collection, id, record) {
+    this.ops.push({ type: "put", collection, id, record });
+    return this;
+  }
+  /** Stage a record delete. Does not write to any adapter until `commit()`. */
+  delete(collection, id) {
+    this.ops.push({ type: "delete", collection, id });
+    return this;
+  }
+  /**
+   * Commit the transaction.
+   *
+   * Phase 1 — writes all staged operations to the local adapter via the
+   * collection layer (encryption + dirty-log tracking).
+   *
+   * Phase 2 — pushes only the records that were written in this
+   * transaction to the remote adapter. Existing dirty entries from
+   * outside this transaction are not affected.
+   *
+   * If any record conflicts during the push, `status` is `'conflict'`
+   * and `conflicts` lists the affected records. No automatic rollback is
+   * performed.
+   */
+  async commit() {
+    for (const op of this.ops) {
+      if (op.type === "put") {
+        await this.comp.collection(op.collection).put(op.id, op.record);
+      } else {
+        await this.comp.collection(op.collection).delete(op.id);
+      }
+    }
+    const opSet = /* @__PURE__ */ new Set();
+    for (const op of this.ops) {
+      opSet.add(`${op.collection}::${op.id}`);
+    }
+    const pushResult = await this.engine.pushFiltered(
+      (entry) => opSet.has(`${entry.collection}::${entry.id}`)
+    );
+    return {
+      status: pushResult.conflicts.length > 0 ? "conflict" : "committed",
+      pushed: pushResult.pushed,
+      conflicts: pushResult.conflicts
+    };
+  }
+};
+
+export {
+  PresenceHandle,
+  SyncEngine,
+  SyncTransaction
+};
+//# sourceMappingURL=chunk-EXQRC2L4.js.map