@tanstack/db/dist/cjs/query/live/bucket-facade-adapter.cjs

A reactive client store for building super fast apps on sync

"use strict";
Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
const dbIvm = require("@tanstack/db-ivm");
const typeGuards = require("../../utils/type-guards.cjs");
const getOrCreate = require("../../utils/get-or-create.cjs");
const index = require("../../collection/index.cjs");
const routeMetadata = require("../compiler/route-metadata.cjs");
const materializedPipeline = require("./materialized-pipeline.cjs");
const PRIVATE_RESULT_KEYS = /* @__PURE__ */ new Set([routeMetadata.INCLUDES_ROUTING]);
class BucketFacadeAdapter {
  constructor(parentId, compilations, onMessages) {
    this.parentId = parentId;
    this.compilations = compilations;
    this.pending = /* @__PURE__ */ new Map();
    this.pendingActivity = /* @__PURE__ */ new Map();
    this.activeBuckets = /* @__PURE__ */ new Map();
    this.entries = /* @__PURE__ */ new Map();
    this.retiredEntries = /* @__PURE__ */ new Map();
    this.resolvedValues = /* @__PURE__ */ new WeakMap();
    for (const compilation of compilations) {
      compilation.rows.pipe(
        dbIvm.output((data) => {
          const messages = data.getInner();
          onMessages(messages.length);
          for (const [[bucketKey, row], multiplicity] of messages) {
            this.accumulate(compilation.edgeId, bucketKey, row, multiplicity);
          }
        })
      );
      compilation.activeBuckets.pipe(
        dbIvm.output((data) => {
          const messages = data.getInner();
          onMessages(messages.length);
          for (const [[bucketKey], multiplicity] of messages) {
            this.accumulateActivity(compilation.edgeId, bucketKey, multiplicity);
          }
        })
      );
    }
  }
  hasPendingChanges() {
    return this.pending.size > 0 || this.pendingActivity.size > 0;
  }
  flush() {
    const snapshot = this.snapshot();
    const deferredEntries = /* @__PURE__ */ new Set();
    const publications = [];
    const deferPublication = (entry) => {
      if (deferredEntries.has(entry)) return;
      deferredEntries.add(entry);
      publications.push(entry.collection._deferPublication());
    };
    const newBaselines = [];
    try {
      for (const compilation of this.compilations) {
        const activity = this.pendingActivity.get(compilation.edgeId);
        const active = this.getActiveBuckets(compilation.edgeId);
        for (const [bucketKey, multiplicity] of activity ?? []) {
          if (multiplicity > 0 && !active.has(bucketKey)) {
            active.add(bucketKey);
            newBaselines.push(this.getEntry(compilation.edgeId, bucketKey));
          }
        }
        const buckets = this.pending.get(compilation.edgeId);
        for (const [bucketKey, changes] of buckets ?? []) {
          const existing = this.entries.get(compilation.edgeId)?.get(bucketKey);
          if (!active.has(bucketKey) && !existing) continue;
          const entry = this.getEntry(compilation.edgeId, bucketKey);
          const sync = entry.sync;
          if (!sync || changes.size === 0) continue;
          for (const change of changes.values()) {
            this.prepareChange(entry, change);
          }
          deferPublication(entry);
          sync.begin();
          for (const change of changes.values()) {
            this.applyChange(entry, sync, change, compilation.hasOrderBy);
          }
          sync.commit();
        }
        for (const [bucketKey, multiplicity] of activity ?? []) {
          if (multiplicity >= 0) continue;
          active.delete(bucketKey);
          this.retireEntry(compilation.edgeId, bucketKey, deferPublication);
        }
      }
    } catch (error) {
      this.restore(snapshot, deferredEntries);
      this.retiredEntries.clear();
      for (const publication of publications) publication.discard();
      throw error;
    }
    this.pending.clear();
    this.pendingActivity.clear();
    let closed = false;
    let prepared = false;
    const prepare = () => {
      if (closed || prepared) return;
      prepared = true;
      for (const entry of newBaselines) entry.sync?.markReady();
    };
    return {
      prepare,
      publish: () => {
        if (closed) return;
        prepare();
        closed = true;
        for (const publication of publications) publication.publish();
        this.retiredEntries.clear();
      },
      rollback: () => {
        if (closed) return;
        closed = true;
        this.restore(snapshot, deferredEntries);
        this.retiredEntries.clear();
        for (const publication of publications) publication.discard();
      }
    };
  }
  resolve(value) {
    return this.resolveValue(value);
  }
  cleanup() {
    for (const byBucket of this.entries.values()) {
      for (const entry of byBucket.values()) {
        void entry.collection.cleanup();
      }
    }
    this.entries.clear();
    this.cleanupRetiredEntries();
    this.pending.clear();
    this.pendingActivity.clear();
    this.activeBuckets.clear();
  }
  accumulate(edgeId, bucketKey, row, multiplicity) {
    const buckets = getOrCreate.getOrCreate(this.pending, edgeId, () => /* @__PURE__ */ new Map());
    const rows = getOrCreate.getOrCreate(buckets, bucketKey, () => /* @__PURE__ */ new Map());
    const key = dbIvm.serializeValue(row.publicKey);
    const change = rows.get(key) ?? {
      deletes: 0,
      inserts: 0,
      value: row
    };
    if (multiplicity < 0) {
      change.deletes += -multiplicity;
    } else if (multiplicity > 0) {
      change.inserts += multiplicity;
      change.value = row;
    }
    rows.set(key, change);
  }
  snapshot() {
    const rows = /* @__PURE__ */ new Map();
    for (const byBucket of this.entries.values()) {
      for (const entry of byBucket.values()) {
        rows.set(
          entry,
          [...entry.collection._state.syncedData].map(([key, value]) => ({
            key,
            value,
            order: entry.currentOrder.get(key)
          }))
        );
      }
    }
    return {
      activeBuckets: new Map(
        [...this.activeBuckets].map(([edgeId, buckets]) => [
          edgeId,
          new Set(buckets)
        ])
      ),
      entries: new Map(
        [...this.entries].map(([edgeId, byBucket]) => [
          edgeId,
          new Map(byBucket)
        ])
      ),
      rows
    };
  }
  restore(snapshot, changedEntries) {
    const previousEntries = new Set(
      [...snapshot.entries.values()].flatMap((byBucket) => [
        ...byBucket.values()
      ])
    );
    const currentEntries = new Set(
      [...this.entries.values()].flatMap((byBucket) => [...byBucket.values()])
    );
    for (const entry of changedEntries) {
      if (!previousEntries.has(entry)) continue;
      const sync = entry.sync;
      if (!sync) continue;
      const rows = snapshot.rows.get(entry) ?? [];
      const restoredKeys = new Set(rows.map((row) => row.key));
      sync.begin();
      for (const key of entry.collection.keys()) {
        if (!restoredKeys.has(key)) sync.write({ type: `delete`, key });
      }
      entry.currentOrder.clear();
      for (const row of rows) {
        entry.keys.set(row.value, row.key);
        if (row.order !== void 0) entry.order.set(row.value, row.order);
        entry.currentOrder.set(row.key, row.order);
        sync.write({
          type: entry.collection.has(row.key) ? `update` : `insert`,
          value: row.value
        });
      }
      sync.commit();
    }
    this.entries.clear();
    for (const [edgeId, byBucket] of snapshot.entries) {
      this.entries.set(edgeId, new Map(byBucket));
    }
    this.activeBuckets.clear();
    for (const [edgeId, buckets] of snapshot.activeBuckets) {
      this.activeBuckets.set(edgeId, new Set(buckets));
    }
    this.resolvedValues = /* @__PURE__ */ new WeakMap();
    for (const entry of currentEntries) {
      if (!previousEntries.has(entry)) void entry.collection.cleanup();
    }
  }
  accumulateActivity(edgeId, bucketKey, multiplicity) {
    const activity = getOrCreate.getOrCreate(this.pendingActivity, edgeId, () => /* @__PURE__ */ new Map());
    activity.set(bucketKey, (activity.get(bucketKey) ?? 0) + multiplicity);
  }
  getActiveBuckets(edgeId) {
    return getOrCreate.getOrCreate(this.activeBuckets, edgeId, () => /* @__PURE__ */ new Set());
  }
  retireEntry(edgeId, bucketKey, deferPublication) {
    const byBucket = this.entries.get(edgeId);
    const entry = byBucket?.get(bucketKey);
    if (!entry) return;
    const sync = entry.sync;
    const keys = [...entry.collection.keys()];
    if (sync && keys.length > 0) {
      deferPublication(entry);
      sync.begin();
      for (const key of keys) sync.write({ type: `delete`, key });
      sync.commit();
    }
    byBucket.delete(bucketKey);
    if (byBucket.size === 0) this.entries.delete(edgeId);
    const retired = getOrCreate.getOrCreate(this.retiredEntries, edgeId, () => /* @__PURE__ */ new Map());
    retired.set(bucketKey, entry);
  }
  getEntry(edgeId, bucketKey) {
    const byBucket = getOrCreate.getOrCreate(this.entries, edgeId, () => /* @__PURE__ */ new Map());
    const existing = byBucket.get(bucketKey);
    if (existing) return existing;
    const keys = /* @__PURE__ */ new WeakMap();
    const order = /* @__PURE__ */ new WeakMap();
    let sync;
    const collection = index.createCollection({
      id: `__bucket-facade:${this.parentId}:${edgeId}:${bucketKey}`,
      getKey: (row) => {
        const key = keys.get(row) ?? row?.$key;
        if (typeof key !== `string` && typeof key !== `number`) {
          throw new Error(`Bucket facade row has no public key`);
        }
        return key;
      },
      compare: (left, right) => {
        const leftOrder = order.get(left);
        const rightOrder = order.get(right);
        if (leftOrder === rightOrder) return 0;
        if (leftOrder === void 0) return 1;
        if (rightOrder === void 0) return -1;
        return leftOrder < rightOrder ? -1 : 1;
      },
      sync: {
        rowUpdateMode: `full`,
        sync: (methods) => {
          sync = methods;
          return () => {
            sync = void 0;
          };
        }
      },
      startSync: true,
      gcTime: 0
    });
    const entry = {
      collection,
      get sync() {
        return sync;
      },
      keys,
      order,
      currentOrder: /* @__PURE__ */ new Map()
    };
    byBucket.set(bucketKey, entry);
    return entry;
  }
  applyChange(entry, sync, change, hasOrderBy) {
    const key = change.value.publicKey;
    const previousOrder = entry.currentOrder.get(key);
    const nextOrder = change.value.order;
    const orderChanged = sync.collection.has(key) && previousOrder !== nextOrder;
    const resolvedRow = this.resolve(change.value.value);
    const row = orderChanged ? { ...resolvedRow } : resolvedRow;
    entry.keys.set(row, key);
    if (nextOrder !== void 0) {
      entry.order.set(row, nextOrder);
    }
    if (change.inserts > change.deletes) {
      sync.write({
        type: sync.collection.has(key) ? `update` : `insert`,
        value: row
      });
    } else if (change.inserts === change.deletes && sync.collection.has(key)) {
      sync.write({ type: `update`, value: row });
    } else if (change.deletes > 0) {
      sync.write({ type: `delete`, key });
      entry.currentOrder.delete(key);
      return;
    }
    entry.currentOrder.set(key, nextOrder);
    if (hasOrderBy && orderChanged) sync.collection._markLayoutChange();
  }
  /** Resolve and validate every public key before opening a sync transaction. */
  prepareChange(entry, change) {
    const key = change.value.publicKey;
    const row = this.resolve(change.value.value);
    entry.keys.set(row, key);
    entry.collection.getKeyFromItem(row);
  }
  resolveValue(value) {
    if (value === null || typeof value !== `object`) return value;
    const cached = this.resolvedValues.get(value);
    if (cached !== void 0) return cached;
    if (isBucketFacadeRef(value)) {
      const { edgeId, bucketKey } = value[materializedPipeline.BUCKET_FACADE_REF];
      const facade = this.entries.get(edgeId)?.get(bucketKey)?.collection ?? this.retiredEntries.get(edgeId)?.get(bucketKey)?.collection ?? this.getEntry(edgeId, bucketKey).collection;
      this.resolvedValues.set(value, facade);
      return facade;
    }
    if (Array.isArray(value) || typeGuards.isPlainObject(value)) {
      const result = routeMetadata.transformPublicContainers(
        value,
        (leaf) => isBucketFacadeRef(leaf) ? this.resolveValue(leaf) : leaf,
        PRIVATE_RESULT_KEYS
      );
      this.resolvedValues.set(value, result);
      return result;
    }
    return value;
  }
  cleanupRetiredEntries() {
    for (const byBucket of this.retiredEntries.values()) {
      for (const entry of byBucket.values()) {
        void entry.collection.cleanup();
      }
    }
    this.retiredEntries.clear();
  }
}
function isBucketFacadeRef(value) {
  return value !== null && typeof value === `object` && materializedPipeline.BUCKET_FACADE_REF in value;
}
exports.BucketFacadeAdapter = BucketFacadeAdapter;
//# sourceMappingURL=bucket-facade-adapter.cjs.map