@tanstack/db 0.0.4 → 0.0.6

package/dist/cjs/collection.cjs

@@ -6,7 +6,13 @@ const transactions = require("./transactions.cjs");
 const SortedMap = require("./SortedMap.cjs");
 const collectionsStore = new store.Store(/* @__PURE__ */ new Map());
 const loadingCollections = /* @__PURE__ */ new Map();
+function createCollection(config) {
+  return new Collection(config);
+}
 function preloadCollection(config) {
+  if (!config.id) {
+    throw new Error(`The id property is required for preloadCollection`);
+  }
   if (collectionsStore.state.has(config.id) && !loadingCollections.has(config.id)) {
     return Promise.resolve(
       collectionsStore.state.get(config.id)
@@ -18,10 +24,14 @@ function preloadCollection(config) {
   if (!collectionsStore.state.has(config.id)) {
     collectionsStore.setState((prev) => {
       const next = new Map(prev);
+      if (!config.id) {
+        throw new Error(`The id property is required for preloadCollection`);
+      }
       next.set(
         config.id,
         new Collection({
           id: config.id,
+          getId: config.getId,
           sync: config.sync,
           schema: config.schema
         })
@@ -37,6 +47,9 @@ function preloadCollection(config) {
     };
   });
   collection.onFirstCommit(() => {
+    if (!config.id) {
+      throw new Error(`The id property is required for preloadCollection`);
+    }
     if (loadingCollections.has(config.id)) {
       loadingCollections.delete(config.id);
       resolveFirstCommit();
@@ -70,18 +83,15 @@ class Collection {
     this.pendingSyncedTransactions = [];
     this.syncedKeys = /* @__PURE__ */ new Set();
     this.hasReceivedFirstCommit = false;
-    this.objectKeyMap = /* @__PURE__ */ new WeakMap();
     this.onFirstCommitCallbacks = [];
-    this.id = crypto.randomUUID();
+    this.id = ``;
     this.commitPendingTransactions = () => {
       if (!Array.from(this.transactions.state.values()).some(
         ({ state }) => state === `persisting`
       )) {
-        const keys = /* @__PURE__ */ new Set();
         store.batch(() => {
           for (const transaction of this.pendingSyncedTransactions) {
             for (const operation of transaction.operations) {
-              keys.add(operation.key);
               this.syncedKeys.add(operation.key);
               this.syncedMetadata.setState((prevData) => {
                 switch (operation.type) {
@@ -120,12 +130,6 @@ class Collection {
             }
           }
         });
-        keys.forEach((key) => {
-          const curValue = this.state.get(key);
-          if (curValue) {
-            this.objectKeyMap.set(curValue, key);
-          }
-        });
         this.pendingSyncedTransactions = [];
         if (!this.hasReceivedFirstCommit) {
           this.hasReceivedFirstCommit = true;
@@ -136,26 +140,25 @@ class Collection {
       }
     };
     this.insert = (data, config2) => {
-      const transaction = transactions.getActiveTransaction();
-      if (typeof transaction === `undefined`) {
-        throw `no transaction found when calling collection.insert`;
+      const ambientTransaction = transactions.getActiveTransaction();
+      if (!ambientTransaction && !this.config.onInsert) {
+        throw new Error(
+          `Collection.insert called directly (not within an explicit transaction) but no 'onInsert' handler is configured.`
+        );
       }
       const items = Array.isArray(data) ? data : [data];
       const mutations = [];
-      let keys;
-      if (config2 == null ? void 0 : config2.key) {
-        const configKeys = Array.isArray(config2.key) ? config2.key : [config2.key];
-        if (Array.isArray(config2.key) && configKeys.length > items.length) {
-          throw new Error(`More keys provided than items to insert`);
-        }
-        keys = items.map((_, i) => configKeys[i] ?? this.generateKey(items[i]));
-      } else {
-        keys = items.map((item) => this.generateKey(item));
-      }
+      const keys = items.map(
+        (item) => this.generateObjectKey(this.config.getId(item), item)
+      );
       items.forEach((item, index) => {
         var _a, _b;
         const validatedData = this.validateData(item, `insert`);
         const key = keys[index];
+        const id = this.config.getId(item);
+        if (this.state.has(this.getKeyFromId(id))) {
+          throw `Cannot insert document with ID "${id}" because it already exists in the collection`;
+        }
         const mutation = {
           mutationId: crypto.randomUUID(),
           original: {},
@@ -171,45 +174,48 @@ class Collection {
         };
         mutations.push(mutation);
       });
-      transaction.applyMutations(mutations);
-      this.transactions.setState((sortedMap) => {
-        sortedMap.set(transaction.id, transaction);
-        return sortedMap;
-      });
-      return transaction;
+      if (ambientTransaction) {
+        ambientTransaction.applyMutations(mutations);
+        this.transactions.setState((sortedMap) => {
+          sortedMap.set(ambientTransaction.id, ambientTransaction);
+          return sortedMap;
+        });
+        return ambientTransaction;
+      } else {
+        const directOpTransaction = new transactions.Transaction({
+          mutationFn: async (params) => {
+            return this.config.onInsert(params);
+          }
+        });
+        directOpTransaction.applyMutations(mutations);
+        directOpTransaction.commit();
+        this.transactions.setState((sortedMap) => {
+          sortedMap.set(directOpTransaction.id, directOpTransaction);
+          return sortedMap;
+        });
+        return directOpTransaction;
+      }
     };
-    this.delete = (items, config2) => {
-      const transaction = transactions.getActiveTransaction();
-      if (typeof transaction === `undefined`) {
-        throw `no transaction found when calling collection.delete`;
+    this.delete = (ids, config2) => {
+      const ambientTransaction = transactions.getActiveTransaction();
+      if (!ambientTransaction && !this.config.onDelete) {
+        throw new Error(
+          `Collection.delete called directly (not within an explicit transaction) but no 'onDelete' handler is configured.`
+        );
       }
-      const itemsArray = Array.isArray(items) ? items : [items];
+      const idsArray = (Array.isArray(ids) ? ids : [ids]).map(
+        (id) => this.getKeyFromId(id)
+      );
       const mutations = [];
-      for (const item of itemsArray) {
-        let key;
-        if (typeof item === `object` && item !== null) {
-          const objectKey = this.objectKeyMap.get(item);
-          if (objectKey === void 0) {
-            throw new Error(
-              `Object not found in collection: ${JSON.stringify(item)}`
-            );
-          }
-          key = objectKey;
-        } else if (typeof item === `string`) {
-          key = item;
-        } else {
-          throw new Error(
-            `Invalid item type for delete - must be an object or string key`
-          );
-        }
+      for (const id of idsArray) {
         const mutation = {
           mutationId: crypto.randomUUID(),
-          original: this.state.get(key) || {},
-          modified: { _deleted: true },
-          changes: { _deleted: true },
-          key,
+          original: this.state.get(id) || {},
+          modified: this.state.get(id) || {},
+          changes: this.state.get(id) || {},
+          key: id,
           metadata: config2 == null ? void 0 : config2.metadata,
-          syncMetadata: this.syncedMetadata.state.get(key) || {},
+          syncMetadata: this.syncedMetadata.state.get(id) || {},
           type: `delete`,
           createdAt: /* @__PURE__ */ new Date(),
           updatedAt: /* @__PURE__ */ new Date(),
@@ -217,20 +223,37 @@ class Collection {
         };
         mutations.push(mutation);
       }
-      mutations.forEach((mutation) => {
-        const curValue = this.state.get(mutation.key);
-        if (curValue) {
-          this.objectKeyMap.delete(curValue);
+      if (ambientTransaction) {
+        ambientTransaction.applyMutations(mutations);
+        this.transactions.setState((sortedMap) => {
+          sortedMap.set(ambientTransaction.id, ambientTransaction);
+          return sortedMap;
+        });
+        return ambientTransaction;
+      }
+      const directOpTransaction = new transactions.Transaction({
+        autoCommit: true,
+        mutationFn: async (transaction) => {
+          return this.config.onDelete(transaction);
         }
       });
-      transaction.applyMutations(mutations);
+      directOpTransaction.applyMutations(mutations);
+      directOpTransaction.commit();
       this.transactions.setState((sortedMap) => {
-        sortedMap.set(transaction.id, transaction);
+        sortedMap.set(directOpTransaction.id, directOpTransaction);
         return sortedMap;
       });
-      return transaction;
+      return directOpTransaction;
     };
-    if (!(config == null ? void 0 : config.sync)) {
+    if (!config) {
+      throw new Error(`Collection requires a config`);
+    }
+    if (config.id) {
+      this.id = config.id;
+    } else {
+      this.id = crypto.randomUUID();
+    }
+    if (!config.sync) {
       throw new Error(`Collection requires a sync config`);
     }
     this.transactions = new store.Store(
@@ -265,9 +288,7 @@ class Collection {
     this.derivedState = new store.Derived({
       fn: ({ currDepVals: [syncedData, operations] }) => {
         const combined = new Map(syncedData);
-        const optimisticKeys = /* @__PURE__ */ new Set();
         for (const operation of operations) {
-          optimisticKeys.add(operation.key);
           if (operation.isActive) {
             switch (operation.type) {
               case `insert`:
@@ -282,11 +303,6 @@ class Collection {
             }
           }
         }
-        optimisticKeys.forEach((key) => {
-          if (combined.has(key)) {
-            this.objectKeyMap.set(combined.get(key), key);
-          }
-        });
         return combined;
       },
       deps: [this.syncedData, this.optimisticOperations]
@@ -363,7 +379,7 @@ class Collection {
           operations: []
         });
       },
-      write: (message) => {
+      write: (messageWithoutKey) => {
         const pendingTransaction = this.pendingSyncedTransactions[this.pendingSyncedTransactions.length - 1];
         if (!pendingTransaction) {
           throw new Error(`No pending sync transaction to write to`);
@@ -373,6 +389,24 @@ class Collection {
             `The pending sync transaction is already committed, you can't still write to it.`
           );
         }
+        const key = this.generateObjectKey(
+          this.config.getId(messageWithoutKey.value),
+          messageWithoutKey.value
+        );
+        if (messageWithoutKey.type === `insert`) {
+          if (this.syncedData.state.has(key) && !pendingTransaction.operations.some(
+            (op) => op.key === key && op.type === `delete`
+          )) {
+            const id = this.config.getId(messageWithoutKey.value);
+            throw new Error(
+              `Cannot insert document with ID "${id}" from sync because it already exists in the collection "${this.id}"`
+            );
+          }
+        }
+        const message = {
+          ...messageWithoutKey,
+          key
+        };
         pendingTransaction.operations.push(message);
       },
       commit: () => {
@@ -406,6 +440,24 @@ class Collection {
       `Schema must either implement the standard-schema interface or be a Zod schema`
     );
   }
+  getKeyFromId(id) {
+    if (typeof id === `undefined`) {
+      throw new Error(`id is undefined`);
+    }
+    if (typeof id === `string` && id.startsWith(`KEY::`)) {
+      return id;
+    } else {
+      return this.generateObjectKey(id, null);
+    }
+  }
+  generateObjectKey(id, item) {
+    if (typeof id === `undefined`) {
+      throw new Error(
+        `An object was created without a defined id: ${JSON.stringify(item)}`
+      );
+    }
+    return `KEY::${this.id}/${id}`;
+  }
   validateData(data, type, key) {
     if (!this.config.schema) return data;
     const standardSchema = this.ensureStandardSchema(this.config.schema);
@@ -446,39 +498,31 @@ class Collection {
     }
     return result.value;
   }
-  generateKey(data) {
-    const str = JSON.stringify(data);
-    let h = 0;
-    for (let i = 0; i < str.length; i++) {
-      h = Math.imul(31, h) + str.charCodeAt(i) | 0;
-    }
-    return `${this.id}/${Math.abs(h).toString(36)}`;
-  }
-  update(items, configOrCallback, maybeCallback) {
-    if (typeof items === `undefined`) {
+  update(ids, configOrCallback, maybeCallback) {
+    if (typeof ids === `undefined`) {
       throw new Error(`The first argument to update is missing`);
     }
-    const transaction = transactions.getActiveTransaction();
-    if (typeof transaction === `undefined`) {
-      throw `no transaction found when calling collection.update`;
+    const ambientTransaction = transactions.getActiveTransaction();
+    if (!ambientTransaction && !this.config.onUpdate) {
+      throw new Error(
+        `Collection.update called directly (not within an explicit transaction) but no 'onUpdate' handler is configured.`
+      );
     }
-    const isArray = Array.isArray(items);
-    const itemsArray = Array.isArray(items) ? items : [items];
+    const isArray = Array.isArray(ids);
+    const idsArray = (Array.isArray(ids) ? ids : [ids]).map(
+      (id) => this.getKeyFromId(id)
+    );
     const callback = typeof configOrCallback === `function` ? configOrCallback : maybeCallback;
     const config = typeof configOrCallback === `function` ? {} : configOrCallback;
-    const keys = itemsArray.map((item) => {
-      if (typeof item === `object` && item !== null) {
-        const key = this.objectKeyMap.get(item);
-        if (key === void 0) {
-          throw new Error(`Object not found in collection`);
-        }
-        return key;
+    const currentObjects = idsArray.map((id) => {
+      const item = this.state.get(id);
+      if (!item) {
+        throw new Error(
+          `The id "${id}" was passed to update but an object for this ID was not found in the collection`
+        );
       }
-      throw new Error(`Invalid item type for update - must be an object`);
+      return item;
     });
-    const currentObjects = keys.map((key) => ({
-      ...this.state.get(key) || {}
-    }));
     let changesArray;
     if (isArray) {
       changesArray = proxy.withArrayChangeTracking(
@@ -492,23 +536,33 @@ class Collection {
       );
       changesArray = [result];
     }
-    const mutations = keys.map((key, index) => {
-      const changes = changesArray[index];
-      if (!changes || Object.keys(changes).length === 0) {
+    const mutations = idsArray.map((id, index) => {
+      const itemChanges = changesArray[index];
+      if (!itemChanges || Object.keys(itemChanges).length === 0) {
         return null;
       }
-      const validatedData = this.validateData(changes, `update`, key);
+      const originalItem = currentObjects[index];
+      const validatedUpdatePayload = this.validateData(
+        itemChanges,
+        `update`,
+        id
+      );
+      const modifiedItem = { ...originalItem, ...validatedUpdatePayload };
+      const originalItemId = this.config.getId(originalItem);
+      const modifiedItemId = this.config.getId(modifiedItem);
+      if (originalItemId !== modifiedItemId) {
+        throw new Error(
+          `Updating the ID of an item is not allowed. Original ID: "${originalItemId}", Attempted new ID: "${modifiedItemId}". Please delete the old item and create a new one if an ID change is necessary.`
+        );
+      }
       return {
         mutationId: crypto.randomUUID(),
-        original: this.state.get(key) || {},
-        modified: {
-          ...this.state.get(key) || {},
-          ...validatedData
-        },
-        changes: validatedData,
-        key,
+        original: originalItem,
+        modified: modifiedItem,
+        changes: validatedUpdatePayload,
+        key: id,
         metadata: config.metadata,
-        syncMetadata: this.syncedMetadata.state.get(key) || {},
+        syncMetadata: this.syncedMetadata.state.get(id) || {},
         type: `update`,
         createdAt: /* @__PURE__ */ new Date(),
         updatedAt: /* @__PURE__ */ new Date(),
@@ -518,12 +572,26 @@ class Collection {
     if (mutations.length === 0) {
       throw new Error(`No changes were made to any of the objects`);
     }
-    transaction.applyMutations(mutations);
+    if (ambientTransaction) {
+      ambientTransaction.applyMutations(mutations);
+      this.transactions.setState((sortedMap) => {
+        sortedMap.set(ambientTransaction.id, ambientTransaction);
+        return sortedMap;
+      });
+      return ambientTransaction;
+    }
+    const directOpTransaction = new transactions.Transaction({
+      mutationFn: async (transaction) => {
+        return this.config.onUpdate(transaction);
+      }
+    });
+    directOpTransaction.applyMutations(mutations);
+    directOpTransaction.commit();
     this.transactions.setState((sortedMap) => {
-      sortedMap.set(transaction.id, transaction);
+      sortedMap.set(directOpTransaction.id, directOpTransaction);
       return sortedMap;
     });
-    return transaction;
+    return directOpTransaction;
   }
   /**
    * Gets the current state of the collection as a Map
@@ -601,5 +669,6 @@ class Collection {
 exports.Collection = Collection;
 exports.SchemaValidationError = SchemaValidationError;
 exports.collectionsStore = collectionsStore;
+exports.createCollection = createCollection;
 exports.preloadCollection = preloadCollection;
 //# sourceMappingURL=collection.cjs.map