@tanstack/db 0.0.14 → 0.0.15

package/dist/cjs/collection.cjs

@@ -1,6 +1,5 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const store = require("@tanstack/store");
 const proxy = require("./proxy.cjs");
 const transactions = require("./transactions.cjs");
 const SortedMap = require("./SortedMap.cjs");
@@ -34,8 +33,8 @@ class CollectionImpl {
   constructor(config) {
     this.pendingSyncedTransactions = [];
     this.syncedMetadata = /* @__PURE__ */ new Map();
-    this.derivedUpserts = /* @__PURE__ */ new Map();
-    this.derivedDeletes = /* @__PURE__ */ new Set();
+    this.optimisticUpserts = /* @__PURE__ */ new Map();
+    this.optimisticDeletes = /* @__PURE__ */ new Set();
     this._size = 0;
     this.changeListeners = /* @__PURE__ */ new Set();
     this.changeKeyListeners = /* @__PURE__ */ new Map();
@@ -46,6 +45,8 @@ class CollectionImpl {
     this.hasReceivedFirstCommit = false;
     this.isCommittingSyncTransactions = false;
     this.onFirstCommitCallbacks = [];
+    this.batchedEvents = [];
+    this.shouldBatchEvents = false;
     this._status = `idle`;
     this.activeSubscribersCount = 0;
     this.gcTimeoutId = null;
@@ -79,6 +80,7 @@ class CollectionImpl {
           }
         }
         const events = [];
+        const rowUpdateMode = this.config.sync.rowUpdateMode || `partial`;
         for (const transaction of this.pendingSyncedTransactions) {
           for (const operation of transaction.operations) {
             const key = operation.key;
@@ -106,12 +108,16 @@ class CollectionImpl {
                 this.syncedData.set(key, operation.value);
                 break;
               case `update`: {
-                const updatedValue = Object.assign(
-                  {},
-                  this.syncedData.get(key),
-                  operation.value
-                );
-                this.syncedData.set(key, updatedValue);
+                if (rowUpdateMode === `partial`) {
+                  const updatedValue = Object.assign(
+                    {},
+                    this.syncedData.get(key),
+                    operation.value
+                  );
+                  this.syncedData.set(key, updatedValue);
+                } else {
+                  this.syncedData.set(key, operation.value);
+                }
                 break;
               }
               case `delete`:
@@ -120,8 +126,8 @@ class CollectionImpl {
             }
           }
         }
-        this.derivedUpserts.clear();
-        this.derivedDeletes.clear();
+        this.optimisticUpserts.clear();
+        this.optimisticDeletes.clear();
         this.isCommittingSyncTransactions = false;
         for (const transaction of this.transactions.values()) {
           if (![`completed`, `failed`].includes(transaction.state)) {
@@ -130,12 +136,15 @@ class CollectionImpl {
                 switch (mutation.type) {
                   case `insert`:
                   case `update`:
-                    this.derivedUpserts.set(mutation.key, mutation.modified);
-                    this.derivedDeletes.delete(mutation.key);
+                    this.optimisticUpserts.set(
+                      mutation.key,
+                      mutation.modified
+                    );
+                    this.optimisticDeletes.delete(mutation.key);
                     break;
                   case `delete`:
-                    this.derivedUpserts.delete(mutation.key);
-                    this.derivedDeletes.add(mutation.key);
+                    this.optimisticUpserts.delete(mutation.key);
+                    this.optimisticDeletes.add(mutation.key);
                     break;
                 }
               }
@@ -184,7 +193,7 @@ class CollectionImpl {
           }
         }
         this._size = this.calculateSize();
-        this.emitEvents(events);
+        this.emitEvents(events, true);
         this.pendingSyncedTransactions = [];
         this.preSyncVisibleState.clear();
         Promise.resolve().then(() => {
@@ -238,7 +247,7 @@ class CollectionImpl {
         this.recomputeOptimisticState();
         return ambientTransaction;
       } else {
-        const directOpTransaction = new transactions.Transaction({
+        const directOpTransaction = transactions.createTransaction({
           mutationFn: async (params) => {
             return this.config.onInsert(params);
           }
@@ -292,7 +301,7 @@ class CollectionImpl {
         this.recomputeOptimisticState();
         return ambientTransaction;
       }
-      const directOpTransaction = new transactions.Transaction({
+      const directOpTransaction = transactions.createTransaction({
         autoCommit: true,
         mutationFn: async (params) => {
           return this.config.onDelete(params);
@@ -316,7 +325,7 @@ class CollectionImpl {
       throw new Error(`Collection requires a sync config`);
     }
     this.transactions = new SortedMap.SortedMap(
-      (a, b) => a.createdAt.getTime() - b.createdAt.getTime()
+      (a, b) => a.compareCreatedAt(b)
     );
     this.config = config;
     collectionsStore.set(this.id, this);
@@ -450,10 +459,10 @@ class CollectionImpl {
             );
           }
           pendingTransaction.committed = true;
-          this.commitPendingTransactions();
           if (this._status === `loading`) {
             this.setStatus(`ready`);
           }
+          this.commitPendingTransactions();
         }
       });
       this.syncCleanupFn = typeof cleanupFn === `function` ? cleanupFn : null;
@@ -525,14 +534,16 @@ class CollectionImpl {
     }
     this.syncedData.clear();
     this.syncedMetadata.clear();
-    this.derivedUpserts.clear();
-    this.derivedDeletes.clear();
+    this.optimisticUpserts.clear();
+    this.optimisticDeletes.clear();
     this._size = 0;
     this.pendingSyncedTransactions = [];
     this.syncedKeys.clear();
     this.hasReceivedFirstCommit = false;
     this.onFirstCommitCallbacks = [];
     this.preloadPromise = null;
+    this.batchedEvents = [];
+    this.shouldBatchEvents = false;
     this.setStatus(`cleaned-up`);
     return Promise.resolve();
   }
@@ -592,10 +603,10 @@ class CollectionImpl {
     if (this.isCommittingSyncTransactions) {
       return;
     }
-    const previousState = new Map(this.derivedUpserts);
-    const previousDeletes = new Set(this.derivedDeletes);
-    this.derivedUpserts.clear();
-    this.derivedDeletes.clear();
+    const previousState = new Map(this.optimisticUpserts);
+    const previousDeletes = new Set(this.optimisticDeletes);
+    this.optimisticUpserts.clear();
+    this.optimisticDeletes.clear();
     const activeTransactions = [];
     const completedTransactions = [];
     for (const transaction of this.transactions.values()) {
@@ -611,12 +622,12 @@ class CollectionImpl {
           switch (mutation.type) {
             case `insert`:
             case `update`:
-              this.derivedUpserts.set(mutation.key, mutation.modified);
-              this.derivedDeletes.delete(mutation.key);
+              this.optimisticUpserts.set(mutation.key, mutation.modified);
+              this.optimisticDeletes.delete(mutation.key);
               break;
             case `delete`:
-              this.derivedUpserts.delete(mutation.key);
-              this.derivedDeletes.add(mutation.key);
+              this.optimisticUpserts.delete(mutation.key);
+              this.optimisticDeletes.add(mutation.key);
               break;
           }
         }
@@ -666,10 +677,10 @@ class CollectionImpl {
    */
   calculateSize() {
     const syncedSize = this.syncedData.size;
-    const deletesFromSynced = Array.from(this.derivedDeletes).filter(
-      (key) => this.syncedData.has(key) && !this.derivedUpserts.has(key)
+    const deletesFromSynced = Array.from(this.optimisticDeletes).filter(
+      (key) => this.syncedData.has(key) && !this.optimisticUpserts.has(key)
     ).length;
-    const upsertsNotInSynced = Array.from(this.derivedUpserts.keys()).filter(
+    const upsertsNotInSynced = Array.from(this.optimisticUpserts.keys()).filter(
       (key) => !this.syncedData.has(key)
     ).length;
     return syncedSize - deletesFromSynced + upsertsNotInSynced;
@@ -680,9 +691,9 @@ class CollectionImpl {
   collectOptimisticChanges(previousUpserts, previousDeletes, events) {
     const allKeys = /* @__PURE__ */ new Set([
       ...previousUpserts.keys(),
-      ...this.derivedUpserts.keys(),
+      ...this.optimisticUpserts.keys(),
       ...previousDeletes,
-      ...this.derivedDeletes
+      ...this.optimisticDeletes
     ]);
     for (const key of allKeys) {
       const currentValue = this.get(key);
@@ -718,28 +729,39 @@ class CollectionImpl {
     return this.syncedData.get(key);
   }
   /**
-   * Emit multiple events at once to all listeners
+   * Emit events either immediately or batch them for later emission
    */
-  emitEvents(changes) {
-    if (changes.length > 0) {
-      for (const listener of this.changeListeners) {
-        listener(changes);
+  emitEvents(changes, endBatching = false) {
+    if (this.shouldBatchEvents && !endBatching) {
+      this.batchedEvents.push(...changes);
+      return;
+    }
+    let eventsToEmit = changes;
+    if (endBatching) {
+      if (this.batchedEvents.length > 0) {
+        eventsToEmit = [...this.batchedEvents, ...changes];
       }
-      if (this.changeKeyListeners.size > 0) {
-        const changesByKey = /* @__PURE__ */ new Map();
-        for (const change of changes) {
-          if (this.changeKeyListeners.has(change.key)) {
-            if (!changesByKey.has(change.key)) {
-              changesByKey.set(change.key, []);
-            }
-            changesByKey.get(change.key).push(change);
+      this.batchedEvents = [];
+      this.shouldBatchEvents = false;
+    }
+    if (eventsToEmit.length === 0) return;
+    for (const listener of this.changeListeners) {
+      listener(eventsToEmit);
+    }
+    if (this.changeKeyListeners.size > 0) {
+      const changesByKey = /* @__PURE__ */ new Map();
+      for (const change of eventsToEmit) {
+        if (this.changeKeyListeners.has(change.key)) {
+          if (!changesByKey.has(change.key)) {
+            changesByKey.set(change.key, []);
           }
+          changesByKey.get(change.key).push(change);
         }
-        for (const [key, keyChanges] of changesByKey) {
-          const keyListeners = this.changeKeyListeners.get(key);
-          for (const listener of keyListeners) {
-            listener(keyChanges);
-          }
+      }
+      for (const [key, keyChanges] of changesByKey) {
+        const keyListeners = this.changeKeyListeners.get(key);
+        for (const listener of keyListeners) {
+          listener(keyChanges);
         }
       }
     }
@@ -748,11 +770,11 @@ class CollectionImpl {
    * Get the current value for a key (virtual derived state)
    */
   get(key) {
-    if (this.derivedDeletes.has(key)) {
+    if (this.optimisticDeletes.has(key)) {
       return void 0;
     }
-    if (this.derivedUpserts.has(key)) {
-      return this.derivedUpserts.get(key);
+    if (this.optimisticUpserts.has(key)) {
+      return this.optimisticUpserts.get(key);
     }
     return this.syncedData.get(key);
   }
@@ -760,10 +782,10 @@ class CollectionImpl {
    * Check if a key exists in the collection (virtual derived state)
    */
   has(key) {
-    if (this.derivedDeletes.has(key)) {
+    if (this.optimisticDeletes.has(key)) {
       return false;
     }
-    if (this.derivedUpserts.has(key)) {
+    if (this.optimisticUpserts.has(key)) {
       return true;
     }
     return this.syncedData.has(key);
@@ -779,12 +801,12 @@ class CollectionImpl {
    */
   *keys() {
     for (const key of this.syncedData.keys()) {
-      if (!this.derivedDeletes.has(key)) {
+      if (!this.optimisticDeletes.has(key)) {
         yield key;
       }
     }
-    for (const key of this.derivedUpserts.keys()) {
-      if (!this.syncedData.has(key) && !this.derivedDeletes.has(key)) {
+    for (const key of this.optimisticUpserts.keys()) {
+      if (!this.syncedData.has(key) && !this.optimisticDeletes.has(key)) {
         yield key;
       }
     }
@@ -796,8 +818,7 @@ class CollectionImpl {
     for (const key of this.keys()) {
       const value = this.get(key);
       if (value !== void 0) {
-        const { _orderByIndex, ...copy } = value;
-        yield copy;
+        yield value;
       }
     }
   }
@@ -808,11 +829,38 @@ class CollectionImpl {
     for (const key of this.keys()) {
       const value = this.get(key);
       if (value !== void 0) {
-        const { _orderByIndex, ...copy } = value;
-        yield [key, copy];
+        yield [key, value];
       }
     }
   }
+  /**
+   * Get all entries (virtual derived state)
+   */
+  *[Symbol.iterator]() {
+    for (const [key, value] of this.entries()) {
+      yield [key, value];
+    }
+  }
+  /**
+   * Execute a callback for each entry in the collection
+   */
+  forEach(callbackfn) {
+    let index = 0;
+    for (const [key, value] of this.entries()) {
+      callbackfn(value, key, index++);
+    }
+  }
+  /**
+   * Create a new array with the results of calling a function for each entry in the collection
+   */
+  map(callbackfn) {
+    const result = [];
+    let index = 0;
+    for (const [key, value] of this.entries()) {
+      result.push(callbackfn(value, key, index++));
+    }
+    return result;
+  }
   ensureStandardSchema(schema) {
     if (schema && typeof schema === `object` && `~standard` in schema) {
       return schema;
@@ -970,7 +1018,7 @@ class CollectionImpl {
       };
     }).filter(Boolean);
     if (mutations.length === 0) {
-      const emptyTransaction = new transactions.Transaction({
+      const emptyTransaction = transactions.createTransaction({
         mutationFn: async () => {
         }
       });
@@ -983,7 +1031,7 @@ class CollectionImpl {
       this.recomputeOptimisticState();
       return ambientTransaction;
     }
-    const directOpTransaction = new transactions.Transaction({
+    const directOpTransaction = transactions.createTransaction({
       mutationFn: async (params) => {
         return this.config.onUpdate(params);
       }
@@ -1028,13 +1076,7 @@ class CollectionImpl {
    * @returns An Array containing all items in the collection
    */
   get toArray() {
-    const array = Array.from(this.values());
-    if (array[0] && array[0]._orderByIndex) {
-      return array.sort(
-        (a, b) => a._orderByIndex - b._orderByIndex
-      );
-    }
-    return array;
+    return Array.from(this.values());
   }
   /**
    * Gets the current state of the collection as an Array, but only resolves when data is available
@@ -1136,39 +1178,10 @@ class CollectionImpl {
    * This method should be called by the Transaction class when state changes
    */
   onTransactionStateChange() {
+    this.shouldBatchEvents = this.pendingSyncedTransactions.length > 0;
     this.capturePreSyncVisibleState();
     this.recomputeOptimisticState();
   }
-  /**
-   * Returns a Tanstack Store Map that is updated when the collection changes
-   * This is a temporary solution to enable the existing framework hooks to work
-   * with the new internals of Collection until they are rewritten.
-   * TODO: Remove this once the framework hooks are rewritten.
-   */
-  asStoreMap() {
-    if (!this._storeMap) {
-      this._storeMap = new store.Store(new Map(this.entries()));
-      this.changeListeners.add(() => {
-        this._storeMap.setState(() => new Map(this.entries()));
-      });
-    }
-    return this._storeMap;
-  }
-  /**
-   * Returns a Tanstack Store Array that is updated when the collection changes
-   * This is a temporary solution to enable the existing framework hooks to work
-   * with the new internals of Collection until they are rewritten.
-   * TODO: Remove this once the framework hooks are rewritten.
-   */
-  asStoreArray() {
-    if (!this._storeArray) {
-      this._storeArray = new store.Store(this.toArray);
-      this.changeListeners.add(() => {
-        this._storeArray.setState(() => this.toArray);
-      });
-    }
-    return this._storeArray;
-  }
 }
 exports.CollectionImpl = CollectionImpl;
 exports.SchemaValidationError = SchemaValidationError;