@tanstack/db 0.0.14 → 0.0.15

package/dist/esm/collection.d.ts

@@ -1,6 +1,5 @@
-import { Store } from '@tanstack/store';
-import { Transaction } from './transactions.js';
 import { SortedMap } from './SortedMap.js';
+import { Transaction } from './transactions.js';
 import { ChangeListener, ChangeMessage, CollectionConfig, CollectionStatus, Fn, InsertConfig, OperationConfig, OptimisticChangeMessage, ResolveType, Transaction as TransactionType, UtilsRecord } from './types.js';
 import { StandardSchemaV1 } from '@standard-schema/spec';
 export declare const collectionsStore: Map<string, CollectionImpl<any, any>>;
@@ -73,8 +72,8 @@ export declare class CollectionImpl<T extends object = Record<string, unknown>,
     pendingSyncedTransactions: Array<PendingSyncedTransaction<T>>;
     syncedData: Map<TKey, T> | SortedMap<TKey, T>;
     syncedMetadata: Map<TKey, unknown>;
-    derivedUpserts: Map<TKey, T>;
-    derivedDeletes: Set<TKey>;
+    optimisticUpserts: Map<TKey, T>;
+    optimisticDeletes: Set<TKey>;
     private _size;
     private changeListeners;
     private changeKeyListeners;
@@ -85,6 +84,8 @@ export declare class CollectionImpl<T extends object = Record<string, unknown>,
     private hasReceivedFirstCommit;
     private isCommittingSyncTransactions;
     private onFirstCommitCallbacks;
+    private batchedEvents;
+    private shouldBatchEvents;
     private _status;
     private activeSubscribersCount;
     private gcTimeoutId;
@@ -178,7 +179,7 @@ export declare class CollectionImpl<T extends object = Record<string, unknown>,
      */
     private getPreviousValue;
     /**
-     * Emit multiple events at once to all listeners
+     * Emit events either immediately or batch them for later emission
      */
     private emitEvents;
     /**
@@ -205,6 +206,18 @@ export declare class CollectionImpl<T extends object = Record<string, unknown>,
      * Get all entries (virtual derived state)
      */
     entries(): IterableIterator<[TKey, T]>;
+    /**
+     * Get all entries (virtual derived state)
+     */
+    [Symbol.iterator](): IterableIterator<[TKey, T]>;
+    /**
+     * Execute a callback for each entry in the collection
+     */
+    forEach(callbackfn: (value: T, key: TKey, index: number) => void): void;
+    /**
+     * Create a new array with the results of calling a function for each entry in the collection
+     */
+    map<U>(callbackfn: (value: T, key: TKey, index: number) => U): Array<U>;
     /**
      * Attempts to commit pending synced transactions if there are no active transactions
      * This method processes operations from pending transactions and applies them to the synced data
@@ -348,21 +361,5 @@ export declare class CollectionImpl<T extends object = Record<string, unknown>,
      * This method should be called by the Transaction class when state changes
      */
     onTransactionStateChange(): void;
-    private _storeMap;
-    /**
-     * 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(): Store<Map<TKey, T>>;
-    private _storeArray;
-    /**
-     * 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(): Store<Array<T>>;
 }
 export {};

package/dist/esm/collection.js

@@ -1,6 +1,5 @@
-import { Store } from "@tanstack/store";
 import { withArrayChangeTracking, withChangeTracking } from "./proxy.js";
-import { getActiveTransaction, Transaction } from "./transactions.js";
+import { getActiveTransaction, createTransaction } from "./transactions.js";
 import { SortedMap } from "./SortedMap.js";
 const collectionsStore = /* @__PURE__ */ new Map();
 function createCollection(options) {
@@ -32,8 +31,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();
@@ -44,6 +43,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;
@@ -77,6 +78,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;
@@ -104,12 +106,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`:
@@ -118,8 +124,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)) {
@@ -128,12 +134,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;
                 }
               }
@@ -182,7 +191,7 @@ class CollectionImpl {
           }
         }
         this._size = this.calculateSize();
-        this.emitEvents(events);
+        this.emitEvents(events, true);
         this.pendingSyncedTransactions = [];
         this.preSyncVisibleState.clear();
         Promise.resolve().then(() => {
@@ -236,7 +245,7 @@ class CollectionImpl {
         this.recomputeOptimisticState();
         return ambientTransaction;
       } else {
-        const directOpTransaction = new Transaction({
+        const directOpTransaction = createTransaction({
           mutationFn: async (params) => {
             return this.config.onInsert(params);
           }
@@ -290,7 +299,7 @@ class CollectionImpl {
         this.recomputeOptimisticState();
         return ambientTransaction;
       }
-      const directOpTransaction = new Transaction({
+      const directOpTransaction = createTransaction({
         autoCommit: true,
         mutationFn: async (params) => {
           return this.config.onDelete(params);
@@ -314,7 +323,7 @@ class CollectionImpl {
       throw new Error(`Collection requires a sync config`);
     }
     this.transactions = new SortedMap(
-      (a, b) => a.createdAt.getTime() - b.createdAt.getTime()
+      (a, b) => a.compareCreatedAt(b)
     );
     this.config = config;
     collectionsStore.set(this.id, this);
@@ -448,10 +457,10 @@ class CollectionImpl {
             );
           }
           pendingTransaction.committed = true;
-          this.commitPendingTransactions();
           if (this._status === `loading`) {
             this.setStatus(`ready`);
           }
+          this.commitPendingTransactions();
         }
       });
       this.syncCleanupFn = typeof cleanupFn === `function` ? cleanupFn : null;
@@ -523,14 +532,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();
   }
@@ -590,10 +601,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()) {
@@ -609,12 +620,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;
           }
         }
@@ -664,10 +675,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;
@@ -678,9 +689,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);
@@ -716,28 +727,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);
         }
       }
     }
@@ -746,11 +768,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);
   }
@@ -758,10 +780,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);
@@ -777,12 +799,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;
       }
     }
@@ -794,8 +816,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;
       }
     }
   }
@@ -806,11 +827,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;
@@ -968,7 +1016,7 @@ class CollectionImpl {
       };
     }).filter(Boolean);
     if (mutations.length === 0) {
-      const emptyTransaction = new Transaction({
+      const emptyTransaction = createTransaction({
         mutationFn: async () => {
         }
       });
@@ -981,7 +1029,7 @@ class CollectionImpl {
       this.recomputeOptimisticState();
       return ambientTransaction;
     }
-    const directOpTransaction = new Transaction({
+    const directOpTransaction = createTransaction({
       mutationFn: async (params) => {
         return this.config.onUpdate(params);
       }
@@ -1026,13 +1074,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
@@ -1134,39 +1176,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(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(this.toArray);
-      this.changeListeners.add(() => {
-        this._storeArray.setState(() => this.toArray);
-      });
-    }
-    return this._storeArray;
-  }
 }
 export {
   CollectionImpl,