@signaldb/core 2.0.0-beta.0 → 2.0.0-beta.2

package/dist/index.cjs14.js

@@ -1,18 +1,24 @@
 "use strict";
-const queryId = require("./index.cjs24.js");
+const queryId = require("./index.cjs20.js");
 const randomId = require("./index.cjs8.js");
+const batchOnNextTick = require("./index.cjs27.js");
 class WorkerDataAdapter {
   worker;
   options;
   id;
   isDisposed = false;
   workerReady;
+  log = () => {
+  };
   collectionReady = /* @__PURE__ */ new Map();
+  batchExecutionHelpers = /* @__PURE__ */ new Map();
   queries = {};
   constructor(worker, options) {
     this.worker = worker;
     this.options = options;
     this.id = this.options.id || "default-worker-data-adapter";
+    if (this.options.log)
+      this.log = this.options.log;
     this.workerReady = new Promise((resolve, reject) => {
       const timeoutId = setTimeout(() => {
         reject(new Error("WorkerDataAdapter initialization timed out"));
@@ -51,6 +57,7 @@ class WorkerDataAdapter {
           return;
         if (id !== messageId)
           return;
+        this.log(method, "result", data ?? error);
         if (error) {
           reject(error);
         } else {
@@ -67,88 +74,59 @@ class WorkerDataAdapter {
       });
     });
   }
-  queryListeners(collectionName, query, listeners) {
-    if (listeners != null) {
-      return this.updateQuery(collectionName, query, { listeners });
-    }
-    const id = queryId(query.selector, query.options);
-    const collectionQueries = this.queries[collectionName];
-    if (!collectionQueries)
-      return 0;
-    const existing = collectionQueries.get(id);
-    return existing?.listeners || 0;
+  enqueueBatched(collectionName, method, args) {
+    const helper = this.batchExecutionHelpers.get(collectionName);
+    if (!helper)
+      throw new Error(`Collection "${collectionName}" is not registered in WorkerDataAdapter`);
+    return helper.enqueue(method, args);
   }
+  // ---------- end batching integration ----------
   updateQuery(collectionName, query, update) {
     const id = queryId(query.selector, query.options);
     const collectionQueries = this.queries[collectionName];
     if (!collectionQueries)
       return;
     const existing = collectionQueries.get(id);
-    collectionQueries.set(id, {
-      listeners: 0,
+    const newState = {
       state: "active",
       error: null,
       items: [],
+      stateChangeCallbacks: [],
+      eventHandler: existing?.eventHandler,
       ...existing,
       ...update
-    });
+    };
+    collectionQueries.set(id, newState);
     this.queries[collectionName] = collectionQueries;
   }
-  createCollectionBackend(collection, indices = []) {
+  createCollectionBackend(collection, indices) {
     this.queries[collection.name] = /* @__PURE__ */ new Map();
     void this.exec("registerCollection", collection.name, indices);
     this.collectionReady.set(collection.name, this.exec("isReady", collection.name));
+    this.batchExecutionHelpers.set(collection.name, batchOnNextTick(async (method, args) => this.exec(method, collection.name, args)));
     return {
       insert: async (item) => {
-        return this.exec("insert", collection.name, item);
+        return this.enqueueBatched(collection.name, "insert", [item]);
       },
       updateOne: async (selector, modifier) => {
-        return this.exec("updateOne", collection.name, selector, modifier);
+        return this.enqueueBatched(collection.name, "updateOne", [selector, modifier]);
       },
       updateMany: async (selector, modifier) => {
-        return this.exec("updateMany", collection.name, selector, modifier);
+        return this.enqueueBatched(collection.name, "updateMany", [selector, modifier]);
       },
       replaceOne: async (selector, replacement) => {
-        return this.exec("replaceOne", collection.name, selector, replacement);
+        return this.enqueueBatched(collection.name, "replaceOne", [selector, replacement]);
       },
       removeOne: async (selector) => {
-        return this.exec("removeOne", collection.name, selector);
+        return this.enqueueBatched(collection.name, "removeOne", [selector]);
       },
       removeMany: async (selector) => {
-        return this.exec("removeMany", collection.name, selector);
+        return this.enqueueBatched(collection.name, "removeMany", [selector]);
       },
       // methods for registering and unregistering queries that will be called from the collection during find/findOne
       registerQuery: (selector, options) => {
-        const listeners = this.queryListeners(collection.name, { selector, options });
-        if (listeners === 0) {
-          this.updateQuery(collection.name, { selector, options }, { state: "active", error: null, items: [] });
-          void this.exec("registerQuery", collection.name, selector, options);
-        }
-        this.queryListeners(collection.name, { selector, options }, listeners + 1);
-      },
-      unregisterQuery: (selector, options) => {
-        setTimeout(() => {
-          const listeners = this.queryListeners(collection.name, { selector, options });
-          const newListeners = Math.max(0, listeners - 1);
-          if (newListeners === 0) {
-            this.queries[collection.name]?.delete(queryId(selector, options));
-            void this.exec("unregisterQuery", collection.name, selector, options);
-          }
-        }, 0);
-      },
-      getQueryState: (selector, options) => {
-        const query = this.queries[collection.name]?.get(queryId(selector, options));
-        return query?.state || "active";
-      },
-      getQueryError: (selector, options) => {
-        const query = this.queries[collection.name]?.get(queryId(selector, options));
-        return query?.error || null;
-      },
-      getQueryResult: (selector, options) => {
-        const query = this.queries[collection.name]?.get(queryId(selector, options));
-        return query?.items || [];
-      },
-      onQueryStateChange: (selector, options, callback) => {
+        this.updateQuery(collection.name, { selector, options }, { state: "active", error: null, items: [] });
+        void this.exec("registerQuery", collection.name, selector, options);
         const handler = (event) => {
           const { type, data, workerId, error } = event.data;
           if (type !== "queryUpdate")
@@ -160,21 +138,59 @@ class WorkerDataAdapter {
             return;
           if (collectionName !== collection.name)
             return;
-          if (JSON.stringify(responseSelector) !== JSON.stringify(selector))
-            return;
-          if (JSON.stringify(responseOptions) !== JSON.stringify(options))
+          if (queryId(responseSelector, responseOptions) !== queryId(selector, options))
             return;
+          this.log("queryUpdate", responseSelector, responseOptions, state, data ?? error);
           this.updateQuery(collection.name, {
             selector: responseSelector,
             options: responseOptions
           }, { state, error, items });
-          callback(state);
+          const query = this.queries[collection.name]?.get(queryId(selector, options));
+          if (!query)
+            return;
+          query.stateChangeCallbacks.forEach((callback) => callback(state));
         };
         this.worker.addEventListener("message", handler);
+        this.updateQuery(collection.name, { selector, options }, { eventHandler: handler });
+      },
+      unregisterQuery: (selector, options) => {
+        const qid = queryId(selector, options);
+        const query = this.queries[collection.name]?.get(qid);
+        if (query?.eventHandler) {
+          this.worker.removeEventListener("message", query.eventHandler);
+        }
+        this.queries[collection.name]?.delete(qid);
+        void this.exec("unregisterQuery", collection.name, selector, options);
+      },
+      getQueryState: (selector, options) => {
+        const query = this.queries[collection.name]?.get(queryId(selector, options));
+        return query?.state || "active";
+      },
+      getQueryError: (selector, options) => {
+        const query = this.queries[collection.name]?.get(queryId(selector, options));
+        return query?.error || null;
+      },
+      getQueryResult: (selector, options) => {
+        const query = this.queries[collection.name]?.get(queryId(selector, options));
+        return query?.items || [];
+      },
+      onQueryStateChange: (selector, options, callback) => {
+        this.updateQuery(collection.name, { selector, options }, {
+          stateChangeCallbacks: [
+            ...this.queries[collection.name]?.get(queryId(selector, options))?.stateChangeCallbacks || [],
+            callback
+          ]
+        });
         return () => {
-          this.worker.removeEventListener("message", handler);
+          const currentCallbacks = this.queries[collection.name]?.get(queryId(selector, options))?.stateChangeCallbacks;
+          if (!currentCallbacks)
+            throw new Error("State change callbacks are not defined!");
+          this.updateQuery(collection.name, { selector, options }, {
+            stateChangeCallbacks: currentCallbacks.filter((existingCallback) => existingCallback !== callback)
+          });
         };
       },
+      executeQuery: (selector, options) => this.exec("executeQuery", collection.name, selector, options),
       // lifecycle methods
       dispose: async () => {
         await this.exec("unregisterCollection", collection.name);

package/dist/index.cjs15.js

@@ -1,17 +1,20 @@
 "use strict";
 const deepClone = require("./index.cjs19.js");
-const match = require("./index.cjs22.js");
+const match = require("./index.cjs23.js");
 const modify = require("./index.cjs7.js");
-const queryId = require("./index.cjs24.js");
+const queryId = require("./index.cjs20.js");
 const isEqual = require("./index.cjs6.js");
-const getIndexInfo = require("./index.cjs21.js");
+const getIndexInfo = require("./index.cjs22.js");
 const getMatchingKeys = require("./index.cjs26.js");
 const sortItems = require("./index.cjs25.js");
-const project = require("./index.cjs23.js");
+const project = require("./index.cjs24.js");
+const compact = require("./index.cjs28.js");
 class WorkerDataAdapterHost {
   workerContext;
   options;
   id;
+  log = () => {
+  };
   storageAdapters = /* @__PURE__ */ new Map();
   storageAdapterReady = /* @__PURE__ */ new Map();
   collectionIndices = /* @__PURE__ */ new Map();
@@ -26,6 +29,8 @@ class WorkerDataAdapterHost {
     if (this.options.onError) {
       this.onError = this.options.onError;
     }
+    if (this.options.log)
+      this.log = this.options.log;
     if (typeof addEventListener === "undefined" || typeof postMessage === "undefined") {
       throw new TypeError("WorkerDataAdapterHost can only be used in a Web Worker context");
     }
@@ -50,6 +55,8 @@ class WorkerDataAdapterHost {
       this.respond(id, null, new Error(`Method ${method} not found`));
       return;
     }
+    this.log(method, ...args);
+    await this.isReady(args[0]);
     try {
       const result = await fn.apply(this, args);
       this.respond(id, result);
@@ -64,7 +71,7 @@ class WorkerDataAdapterHost {
     if (selector != null && Object.keys(selector).length === 1 && "id" in selector && typeof selector.id !== "object") {
       return {
         matched: true,
-        ids: [selector.id],
+        ids: compact([selector.id]),
         optimizedSelector: {}
       };
     }
@@ -149,6 +156,8 @@ class WorkerDataAdapterHost {
     }
   }
   async executeQuery(collectionName, selector, options) {
+    if (selector === null)
+      return [];
     const items = await this.queryItems(collectionName, selector || {});
     const { sort, skip, limit, fields } = options || {};
     const sorted = sort ? sortItems(items, sort) : items;
@@ -214,10 +223,7 @@ class WorkerDataAdapterHost {
     if (!storageAdapter)
       throw new Error(`No persistence adapter for collection ${collectionName}`);
     const setupPromise = (async () => {
-      await Promise.all([
-        storageAdapter.createIndex("id"),
-        ...indices.map((index) => storageAdapter.createIndex(index))
-      ]);
+      await Promise.all(indices.map((index) => storageAdapter.createIndex(index)));
       await storageAdapter.setup();
     })();
     this.storageAdapterReady.set(collectionName, setupPromise);
@@ -238,101 +244,142 @@ class WorkerDataAdapterHost {
       throw new Error(`Collection ${collectionName} not initialized!`);
     this.queries.get(collectionName)?.delete(id);
   };
-  insert = async (collectionName, newItem) => {
+  insert = async (collectionName, input) => {
     const storageAdapter = this.storageAdapters.get(collectionName);
     if (!storageAdapter)
       throw new Error(`No persistence adapter for collection ${collectionName}`);
-    const existingItems = await this.executeQuery(collectionName, { id: newItem.id }, { limit: 1 });
-    if (existingItems.length > 0) {
-      throw new Error(`Item with id ${newItem.id} already exists`);
-    }
-    await storageAdapter.insert([newItem]);
-    await this.checkQueryUpdates(collectionName, [newItem]);
-    return newItem;
-  };
-  updateOne = async (collectionName, selector, modifier) => {
-    const storageAdapter = this.storageAdapters.get(collectionName);
-    if (!storageAdapter)
-      throw new Error(`No persistence adapter for collection ${collectionName}`);
-    const item = await this.executeQuery(collectionName, selector, { limit: 1 }).then((items) => items[0] ?? null);
-    const { $setOnInsert, ...restModifier } = modifier;
-    if (item == null)
-      return [];
-    const modifiedItem = modify(deepClone.default(item), restModifier);
-    if (item.id !== modifiedItem.id) {
-      const existingItems = await this.executeQuery(collectionName, { id: modifiedItem.id }, { limit: 1 });
-      if (existingItems.length > 0) {
-        throw new Error(`Item with id ${modifiedItem.id} already exists`);
+    const existingItems = await this.executeQuery(collectionName, { id: { $in: input.map((i) => i[0].id) } });
+    const result = input.map(([item]) => {
+      if (item.id == null)
+        return new Error("Item must have an id");
+      if (existingItems.some((existing) => existing.id === item.id)) {
+        return new Error(`Item with id ${item.id} already exists`);
       }
-    }
-    await storageAdapter.replace([modifiedItem]);
-    await this.checkQueryUpdates(collectionName, [modifiedItem]);
-    return [modifiedItem];
+      return item;
+    });
+    const newItems = result.filter((item) => !(item instanceof Error));
+    await storageAdapter.insert(newItems);
+    await this.checkQueryUpdates(collectionName, newItems);
+    return result;
   };
-  updateMany = async (collectionName, selector, modifier) => {
+  updateOne = async (collectionName, parameters) => {
     const storageAdapter = this.storageAdapters.get(collectionName);
     if (!storageAdapter)
       throw new Error(`No persistence adapter for collection ${collectionName}`);
-    const items = await this.executeQuery(collectionName, selector);
-    if (items.length === 0)
-      return [];
-    const { $setOnInsert, ...restModifier } = modifier;
-    const changedItems = await Promise.all(items.map(async (item) => {
+    const previousItems = [];
+    const result = await Promise.all(parameters.map(async ([selector, modifier]) => {
+      const item = await this.executeQuery(collectionName, selector, { limit: 1 }).then((items) => items[0] ?? null);
+      const { $setOnInsert, ...restModifier } = modifier;
+      if (item == null)
+        return [];
+      previousItems.push(item);
       const modifiedItem = modify(deepClone.default(item), restModifier);
       if (item.id !== modifiedItem.id) {
         const existingItems = await this.executeQuery(collectionName, { id: modifiedItem.id }, { limit: 1 });
         if (existingItems.length > 0) {
-          throw new Error(`Item with id ${modifiedItem.id} already exists`);
+          return new Error(`Item with id ${modifiedItem.id} already exists`);
         }
       }
-      return modifiedItem;
+      return [modifiedItem];
     }));
-    await storageAdapter.replace(changedItems);
-    await this.checkQueryUpdates(collectionName, changedItems);
-    return changedItems;
+    const modifiedItems = compact(result.filter((item) => !(item instanceof Error)).flat());
+    if (modifiedItems.length > 0) {
+      await storageAdapter.replace(modifiedItems);
+      await this.checkQueryUpdates(collectionName, [...modifiedItems, ...previousItems]);
+    }
+    return result;
   };
-  replaceOne = async (collectionName, selector, replacement) => {
+  updateMany = async (collectionName, parameters) => {
     const storageAdapter = this.storageAdapters.get(collectionName);
     if (!storageAdapter)
       throw new Error(`No persistence adapter for collection ${collectionName}`);
-    const item = await this.executeQuery(collectionName, selector, { limit: 1 }).then((items) => items[0] ?? null);
-    if (item == null)
-      return [];
-    const modifiedItem = {
-      ...replacement,
-      id: replacement.id ?? item.id
-    };
-    if (item.id !== modifiedItem.id) {
-      const existingItems = await this.executeQuery(collectionName, { id: modifiedItem.id }, { limit: 1 });
-      if (existingItems.length > 0) {
-        throw new Error(`Item with id ${modifiedItem.id} already exists`);
+    const previousItems = [];
+    const result = await Promise.all(parameters.map(async ([selector, modifier]) => {
+      const items = await this.executeQuery(collectionName, selector);
+      if (items.length === 0)
+        return [];
+      const { $setOnInsert, ...restModifier } = modifier;
+      try {
+        const changedItems = await Promise.all(items.map(async (item) => {
+          const modifiedItem = modify(deepClone.default(item), restModifier);
+          if (item.id !== modifiedItem.id) {
+            const existingItems = await this.executeQuery(collectionName, { id: modifiedItem.id }, { limit: 1 });
+            if (existingItems.length > 0) {
+              throw new Error(`Item with id ${modifiedItem.id} already exists`);
+            }
+          }
+          previousItems.push(item);
+          return modifiedItem;
+        }));
+        return changedItems;
+      } catch (error) {
+        return error;
       }
+    }));
+    const modifiedItems = compact(result.filter((item) => !(item instanceof Error)).flat());
+    if (modifiedItems.length > 0) {
+      await storageAdapter.replace(modifiedItems);
+      await this.checkQueryUpdates(collectionName, [...modifiedItems, ...previousItems]);
     }
-    await storageAdapter.replace([modifiedItem]);
-    await this.checkQueryUpdates(collectionName, [modifiedItem]);
-    return [modifiedItem];
+    return result;
   };
-  removeOne = async (collectionName, selector) => {
+  replaceOne = async (collectionName, parameters) => {
     const storageAdapter = this.storageAdapters.get(collectionName);
     if (!storageAdapter)
       throw new Error(`No persistence adapter for collection ${collectionName}`);
-    const item = await this.executeQuery(collectionName, selector, { limit: 1 }).then((items) => items[0] ?? null);
-    if (item == null)
-      return [];
-    await storageAdapter.remove([item]);
-    await this.checkQueryUpdates(collectionName, [item]);
-    return [item];
+    const previousItems = [];
+    const result = await Promise.all(parameters.map(async ([selector, replacement]) => {
+      const item = await this.executeQuery(collectionName, selector, { limit: 1 }).then((items) => items[0] ?? null);
+      if (item == null)
+        return [];
+      previousItems.push(item);
+      const modifiedItem = {
+        ...replacement,
+        id: replacement.id ?? item.id
+      };
+      if (item.id !== modifiedItem.id) {
+        const existingItems = await this.executeQuery(collectionName, { id: modifiedItem.id }, { limit: 1 });
+        if (existingItems.length > 0) {
+          return new Error(`Item with id ${modifiedItem.id} already exists`);
+        }
+      }
+      return [modifiedItem];
+    }));
+    const modifiedItems = compact(result.filter((item) => !(item instanceof Error)).flat());
+    if (modifiedItems.length > 0) {
+      await storageAdapter.replace(modifiedItems);
+      await this.checkQueryUpdates(collectionName, [...modifiedItems, ...previousItems]);
+    }
+    return result;
   };
-  removeMany = async (collectionName, selector) => {
+  removeOne = async (collectionName, selectors) => {
     const storageAdapter = this.storageAdapters.get(collectionName);
     if (!storageAdapter)
       throw new Error(`No persistence adapter for collection ${collectionName}`);
-    const items = await this.executeQuery(collectionName, selector);
-    if (items.length === 0)
-      return [];
-    await storageAdapter.remove(items);
-    await this.checkQueryUpdates(collectionName, items);
-    return items;
+    const result = await Promise.all(selectors.map(async ([selector]) => {
+      const item = await this.executeQuery(collectionName, selector, { limit: 1 }).then((items2) => items2[0] ?? null);
+      if (item == null)
+        return [];
+      return [item];
+    }));
+    const items = result.flat();
+    if (items.length > 0) {
+      await storageAdapter.remove(items);
+      await this.checkQueryUpdates(collectionName, items);
+    }
+    return result;
+  };
+  removeMany = async (collectionName, selectors) => {
+    const storageAdapter = this.storageAdapters.get(collectionName);
+    if (!storageAdapter)
+      throw new Error(`No persistence adapter for collection ${collectionName}`);
+    const result = await Promise.all(selectors.map(async ([selector]) => this.executeQuery(collectionName, selector)));
+    const items = result.flat();
+    if (items.length > 0) {
+      await storageAdapter.remove(items);
+      await this.checkQueryUpdates(collectionName, items);
+    }
+    return result;
   };
   isReady = async (collectionName) => {
     return this.storageAdapterReady.get(collectionName);