@noy-db/hub 0.3.0-pre.1 → 0.3.0-pre.11

package/dist/chunk-IUEN57TV.js

@@ -1,722 +0,0 @@
-import {
-  SyncScheduler
-} from "./chunk-VQNJ7UZL.js";
-import {
-  bufferToBase64,
-  decrypt,
-  derivePresenceKey,
-  encrypt,
-  generateIV
-} from "./chunk-5O3AOPDT.js";
-import {
-  NOYDB_SYNC_VERSION
-} from "./chunk-5TDJ56JE.js";
-import {
-  ConflictError
-} from "./chunk-ZYUC53LT.js";
-
-// src/with-party/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/with-party/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/with-party/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-IUEN57TV.js.map