@tanstack/db 0.1.1 → 0.1.4

package/dist/cjs/collection.cjs

@@ -61,7 +61,10 @@ class CollectionImpl {
           break;
         }
       }
-      if (!hasPersistingTransaction) {
+      const hasTruncateSync = this.pendingSyncedTransactions.some(
+        (t) => t.truncate === true
+      );
+      if (!hasPersistingTransaction || hasTruncateSync) {
         this.isCommittingSyncTransactions = true;
         const changedKeys = /* @__PURE__ */ new Set();
         for (const transaction of this.pendingSyncedTransactions) {
@@ -82,6 +85,18 @@ class CollectionImpl {
         const events = [];
         const rowUpdateMode = this.config.sync.rowUpdateMode || `partial`;
         for (const transaction of this.pendingSyncedTransactions) {
+          if (transaction.truncate) {
+            for (const key of this.syncedData.keys()) {
+              if (this.optimisticDeletes.has(key)) continue;
+              const previousValue = this.optimisticUpserts.get(key) || this.syncedData.get(key);
+              if (previousValue !== void 0) {
+                events.push({ type: `delete`, key, value: previousValue });
+              }
+            }
+            this.syncedData.clear();
+            this.syncedMetadata.clear();
+            this.syncedKeys.clear();
+          }
           for (const operation of transaction.operations) {
             const key = operation.key;
             this.syncedKeys.add(key);
@@ -126,6 +141,78 @@ class CollectionImpl {
             }
           }
         }
+        const hadTruncate = this.pendingSyncedTransactions.some(
+          (t) => t.truncate === true
+        );
+        if (hadTruncate) {
+          const syncedInsertedOrUpdatedKeys = /* @__PURE__ */ new Set();
+          for (const t of this.pendingSyncedTransactions) {
+            for (const op of t.operations) {
+              if (op.type === `insert` || op.type === `update`) {
+                syncedInsertedOrUpdatedKeys.add(op.key);
+              }
+            }
+          }
+          const reapplyUpserts = /* @__PURE__ */ new Map();
+          const reapplyDeletes = /* @__PURE__ */ new Set();
+          for (const tx of this.transactions.values()) {
+            if ([`completed`, `failed`].includes(tx.state)) continue;
+            for (const mutation of tx.mutations) {
+              if (mutation.collection !== this || !mutation.optimistic) continue;
+              const key = mutation.key;
+              switch (mutation.type) {
+                case `insert`:
+                  reapplyUpserts.set(key, mutation.modified);
+                  reapplyDeletes.delete(key);
+                  break;
+                case `update`: {
+                  const base = this.syncedData.get(key);
+                  const next = base ? Object.assign({}, base, mutation.changes) : mutation.modified;
+                  reapplyUpserts.set(key, next);
+                  reapplyDeletes.delete(key);
+                  break;
+                }
+                case `delete`:
+                  reapplyUpserts.delete(key);
+                  reapplyDeletes.add(key);
+                  break;
+              }
+            }
+          }
+          for (const [key, value] of reapplyUpserts) {
+            if (reapplyDeletes.has(key)) continue;
+            if (syncedInsertedOrUpdatedKeys.has(key)) {
+              let foundInsert = false;
+              for (let i = events.length - 1; i >= 0; i--) {
+                const evt = events[i];
+                if (evt.key === key && evt.type === `insert`) {
+                  evt.value = value;
+                  foundInsert = true;
+                  break;
+                }
+              }
+              if (!foundInsert) {
+                events.push({ type: `insert`, key, value });
+              }
+            } else {
+              events.push({ type: `insert`, key, value });
+            }
+          }
+          if (events.length > 0 && reapplyDeletes.size > 0) {
+            const filtered = [];
+            for (const evt of events) {
+              if (evt.type === `insert` && reapplyDeletes.has(evt.key)) {
+                continue;
+              }
+              filtered.push(evt);
+            }
+            events.length = 0;
+            events.push(...filtered);
+          }
+          if (!this.isReady()) {
+            this.setStatus(`ready`);
+          }
+        }
         this.optimisticUpserts.clear();
         this.optimisticDeletes.clear();
         this.isCommittingSyncTransactions = false;
@@ -406,7 +493,7 @@ class CollectionImpl {
         const callbacks = [...this.onFirstReadyCallbacks];
         this.onFirstReadyCallbacks = [];
         callbacks.forEach((callback) => callback());
-        if (this.size === 0 && this.changeListeners.size > 0) {
+        if (this.changeListeners.size > 0) {
           this.emitEmptyReadyEvent();
         }
       }
@@ -499,9 +586,12 @@ class CollectionImpl {
           }
           const key = this.getKeyFromItem(messageWithoutKey.value);
           if (messageWithoutKey.type === `insert`) {
-            if (this.syncedData.has(key) && !pendingTransaction.operations.some(
+            const insertingIntoExistingSynced = this.syncedData.has(key);
+            const hasPendingDeleteForKey = pendingTransaction.operations.some(
               (op) => op.key === key && op.type === `delete`
-            )) {
+            );
+            const isTruncateTransaction = pendingTransaction.truncate === true;
+            if (insertingIntoExistingSynced && !hasPendingDeleteForKey && !isTruncateTransaction) {
               throw new errors.DuplicateKeySyncError(key, this.id);
             }
           }
@@ -527,6 +617,17 @@ class CollectionImpl {
         },
         markReady: () => {
           this.markReady();
+        },
+        truncate: () => {
+          const pendingTransaction = this.pendingSyncedTransactions[this.pendingSyncedTransactions.length - 1];
+          if (!pendingTransaction) {
+            throw new errors.NoPendingSyncTransactionWriteError();
+          }
+          if (pendingTransaction.committed) {
+            throw new errors.SyncTransactionAlreadyCommittedWriteError();
+          }
+          pendingTransaction.operations = [];
+          pendingTransaction.truncate = true;
         }
       });
       this.syncCleanupFn = typeof cleanupFn === `function` ? cleanupFn : null;
@@ -796,6 +897,11 @@ class CollectionImpl {
     for (const listener of this.changeListeners) {
       listener([]);
     }
+    for (const [_key, keyListeners] of this.changeKeyListeners) {
+      for (const listener of keyListeners) {
+        listener([]);
+      }
+    }
   }
   /**
    * Emit events either immediately or batch them for later emission
@@ -959,8 +1065,8 @@ class CollectionImpl {
   }
   /**
    * Creates an index on a collection for faster queries.
-   * Indexes significantly improve query performance by allowing binary search
-   * and range queries instead of full scans.
+   * Indexes significantly improve query performance by allowing constant time lookups
+   * and logarithmic time range queries instead of full scans.
    *
    * @template TResolver - The type of the index resolver (constructor or async loader)
    * @param indexCallback - Function that extracts the indexed value from each item