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

package/dist/index.cjs31.js

@@ -1,9 +1,7 @@
 "use strict";
-function uniqueBy(array, fn) {
-  const set = /* @__PURE__ */ new Set();
-  return array.filter((element) => {
-    const value = typeof fn === "function" ? fn(element) : element[fn];
-    return !set.has(value) && set.add(value);
-  });
+function intersection(...arrays) {
+  if (arrays.length === 0)
+    return [];
+  return [...new Set(arrays.reduce((a, b) => a.filter((c) => b.includes(c))))];
 }
-module.exports = uniqueBy;
+module.exports = intersection;

package/dist/index.cjs32.js

@@ -0,0 +1,29 @@
+"use strict";
+function set(object, path, value, deleteIfUndefined = false) {
+  if (object == null)
+    return object;
+  const segments = path.split(/[.[\]]/g);
+  if (segments[0] === "")
+    segments.shift();
+  if (segments.at(-1) === "")
+    segments.pop();
+  const apply = (node) => {
+    if (segments.length > 1) {
+      const key = segments.shift();
+      const nextIsNumber = !Number.isNaN(Number.parseInt(segments[0], 10));
+      if (node[key] === void 0) {
+        node[key] = nextIsNumber ? [] : {};
+      }
+      apply(node[key]);
+    } else {
+      if (deleteIfUndefined && value === void 0) {
+        delete node[segments[0]];
+        return;
+      }
+      node[segments[0]] = value;
+    }
+  };
+  apply(object);
+  return object;
+}
+module.exports = set;

package/dist/index.cjs33.js

@@ -0,0 +1,42 @@
+"use strict";
+const expressionKeys = /* @__PURE__ */ new Set([
+  "$eq",
+  "$gt",
+  "$gte",
+  "$lt",
+  "$lte",
+  "$in",
+  "$nin",
+  "$ne",
+  "$exists",
+  "$not",
+  "$expr",
+  "$jsonSchema",
+  "$mod",
+  "$regex",
+  "$options",
+  "$text",
+  "$where",
+  "$all",
+  "$elemMatch",
+  "$size",
+  "$bitsAllClear",
+  "$bitsAllSet",
+  "$bitsAnyClear",
+  "$bitsAnySet"
+]);
+function isFieldExpression(expression) {
+  if (typeof expression !== "object" || expression == null) {
+    return false;
+  }
+  const keys = Object.keys(expression);
+  if (keys.length === 0) {
+    return false;
+  }
+  const hasInvalidKeys = keys.some((key) => !expressionKeys.has(key));
+  if (hasInvalidKeys)
+    return false;
+  const hasValidKeys = keys.every((key) => expressionKeys.has(key));
+  return hasValidKeys;
+}
+module.exports = isFieldExpression;

package/dist/index.d.ts

@@ -3,6 +3,7 @@ export type { default as StorageAdapter, Changeset, } from './types/StorageAdapt
 export type { default as Selector } from './types/Selector';
 export type { default as Modifier } from './types/Modifier';
 export type { BaseItem, ObserveCallbacks, CursorOptions, Transform, SortSpecifier, FieldSpecifier, FindOptions, CollectionOptions, } from './Collection';
+export type { default as DataAdapter } from './DataAdapter';
 export { default as Cursor } from './Collection/Cursor';
 export { default as Collection } from './Collection';
 export { default as createStorageAdapter } from './createStorageAdapter';

package/dist/index12.mjs

@@ -1,12 +1,12 @@
-import createIndex from "./index20.mjs";
-import getIndexInfo from "./index21.mjs";
+import createIndex from "./index21.mjs";
+import getIndexInfo from "./index22.mjs";
 import deepClone from "./index19.mjs";
 import EventEmitter from "./index9.mjs";
 import isEqual from "./index6.mjs";
-import match from "./index22.mjs";
+import match from "./index23.mjs";
 import modify from "./index7.mjs";
-import project from "./index23.mjs";
-import queryId from "./index24.mjs";
+import project from "./index24.mjs";
+import queryId from "./index20.mjs";
 import serializeValue from "./index11.mjs";
 import sortItems from "./index25.mjs";
 function hasPendingUpdates(pendingUpdates) {
@@ -142,14 +142,28 @@ class DefaultDataAdapter {
       return;
     this.queuedQueryUpdates.set(collection.name, { added: [], modified: [], removed: [] });
     const flatItems = [...changes.added, ...changes.modified, ...changes.removed];
-    const queries = [...this.activeQueries.get(collection.name)?.values() ?? []].filter(({ selector }) => flatItems.some((item) => match(item, selector)));
+    const itemIds = new Set(flatItems.map((i) => i.id));
+    const queries = [
+      ...this.activeQueries.get(collection.name)?.values() ?? []
+    ].filter(({ selector, options }) => {
+      const idsInQuery = this.cachedQueryResults.get(collection.name)?.get(queryId(selector, options))?.map((i) => i.id) ?? [];
+      if (idsInQuery.some((id) => itemIds.has(id)))
+        return true;
+      return flatItems.some((item) => match(item, selector));
+    });
     queries.forEach(({ selector, options }) => {
-      const emitter = this.queryEmitters.get(collection.name);
-      if (!emitter)
-        return;
-      emitter.emit("change", selector, options, "complete");
+      this.executeAndCacheQuery(collection, selector, options);
     });
   }
+  executeAndCacheQuery(collection, selector, options) {
+    const result = this.executeQuery(collection, selector, options);
+    this.cachedQueryResults.set(collection.name, this.cachedQueryResults.get(collection.name) || /* @__PURE__ */ new Map());
+    this.cachedQueryResults.get(collection.name)?.set(queryId(selector, options), result);
+    const emitter = this.queryEmitters.get(collection.name);
+    if (!emitter)
+      return;
+    emitter.emit("change", selector, options, "complete");
+  }
   updateQueries(collection, changes) {
     this.queuedQueryUpdates.set(collection.name, this.queuedQueryUpdates.get(collection.name) || { added: [], modified: [], removed: [] });
     this.queuedQueryUpdates.get(collection.name)?.added.push(...changes.added);
@@ -161,6 +175,7 @@ class DefaultDataAdapter {
     this.ensureStorageAdapter(collection.name);
     this.items.set(collection.name, this.items.get(collection.name) ?? /* @__PURE__ */ new Map());
     this.queryEmitters.set(collection.name, this.queryEmitters.get(collection.name) ?? new EventEmitter());
+    this.queryEmitters.get(collection.name)?.setMaxListeners(Infinity);
     this.activeQueries.set(collection.name, this.activeQueries.get(collection.name) || /* @__PURE__ */ new Map());
     this.indices.set(collection.name, indices.map((field) => createIndex(field)));
     this.rebuildIndices(collection);
@@ -206,7 +221,7 @@ class DefaultDataAdapter {
       },
       updateMany: async (selector, modifier) => {
         const { $setOnInsert, ...restModifier } = modifier;
-        const items = backend.getQueryResult(selector);
+        const items = this.executeQuery(collection, selector, {});
         const changedItems = items.map((item) => {
           const modifiedItem = modify(deepClone(item), restModifier);
           const hasItemWithSameId = item.id !== modifiedItem.id && this.getItem(collection, { id: modifiedItem.id }) != null;
@@ -262,7 +277,7 @@ class DefaultDataAdapter {
         return [item];
       },
       removeMany: async (selector) => {
-        const items = backend.getQueryResult(selector);
+        const items = backend.getQueryResult(selector, {});
         items.forEach((item) => {
           this.items.get(collection.name)?.delete(serializeValue(item.id));
         });
@@ -282,10 +297,7 @@ class DefaultDataAdapter {
           selector,
           options
         });
-        const emitter = this.queryEmitters.get(collection.name);
-        if (!emitter)
-          throw new Error(`Query emitter not found for collection ${collection.name}`);
-        emitter.emit("change", selector, options, "complete");
+        this.executeAndCacheQuery(collection, selector, options);
       },
       unregisterQuery: (selector, options) => {
         if (!this.activeQueries.get(collection.name))
@@ -298,7 +310,7 @@ class DefaultDataAdapter {
         if (!emitter)
           throw new Error(`Query emitter not found for collection ${collection.name}`);
         const handler = (querySelector, queryOptions, state) => {
-          if (querySelector !== selector || queryOptions !== options)
+          if (queryId(querySelector, queryOptions) !== queryId(selector, options))
             return;
           callback(state);
         };
@@ -309,14 +321,13 @@ class DefaultDataAdapter {
       },
       getQueryError: () => null,
       getQueryResult: (selector, options) => {
-        const result = this.executeQuery(collection, selector, options);
         const isQueryActive = this.activeQueries.get(collection.name)?.has(queryId(selector, options));
         if (isQueryActive) {
-          this.cachedQueryResults.set(collection.name, this.cachedQueryResults.get(collection.name) || /* @__PURE__ */ new Map());
-          this.cachedQueryResults.get(collection.name)?.set(queryId(selector, options), result);
+          return this.cachedQueryResults.get(collection.name)?.get(queryId(selector, options)) ?? [];
         }
-        return result;
+        return this.executeQuery(collection, selector, options);
       },
+      executeQuery: (selector, options) => Promise.resolve(this.executeQuery(collection, selector, options)),
       // lifecycle methods
       dispose: async () => {
         const adapter = this.storageAdapters.get(collection.name);

package/dist/index13.mjs

@@ -1,12 +1,12 @@
 import deepClone from "./index19.mjs";
-import match from "./index22.mjs";
+import match from "./index23.mjs";
 import modify from "./index7.mjs";
-import queryId from "./index24.mjs";
+import queryId from "./index20.mjs";
 import isEqual from "./index6.mjs";
-import getIndexInfo from "./index21.mjs";
+import getIndexInfo from "./index22.mjs";
 import getMatchingKeys from "./index26.mjs";
 import sortItems from "./index25.mjs";
-import project from "./index23.mjs";
+import project from "./index24.mjs";
 class AsyncDataAdapter {
   options;
   id;
@@ -119,6 +119,13 @@ class AsyncDataAdapter {
       getQueryError,
       getQueryResult,
       onQueryStateChange,
+      executeQuery: async (selector, options) => {
+        await ready;
+        registerQuery(selector, options);
+        const result = getQueryResult(selector, options);
+        unregisterQuery(selector, options);
+        return result;
+      },
       dispose: async () => {
         this.storageAdapters.delete(collection.name);
         this.queries.delete(collection.name);
@@ -134,10 +141,7 @@ class AsyncDataAdapter {
     const storage = this.storageAdapters.get(collectionName);
     if (!storage)
       throw new Error(`No persistence adapter for collection ${collectionName}`);
-    await Promise.all([
-      storage.createIndex("id"),
-      ...indices.map((index) => storage.createIndex(index))
-    ]);
+    await Promise.all(indices.map((index) => storage.createIndex(index)));
     await storage.setup();
   }
   ensureStorageAdapter(name) {
@@ -199,20 +203,28 @@ class AsyncDataAdapter {
     rec.items = items;
   }
   async getIndexInfo(collectionName, selector) {
-    const storage = this.storageAdapters.get(collectionName);
-    if (!storage)
+    const storageAdapter = this.storageAdapters.get(collectionName);
+    if (!storageAdapter)
       throw new Error(`No persistence adapter for collection ${collectionName}`);
     if (selector != null && Object.keys(selector).length === 1 && "id" in selector && typeof selector.id !== "object") {
-      return { matched: true, ids: [selector.id], optimizedSelector: {} };
+      return {
+        matched: true,
+        ids: [selector.id].filter(Boolean),
+        optimizedSelector: {}
+      };
     }
     if (selector == null) {
-      return { matched: false, ids: [], optimizedSelector: {} };
+      return {
+        matched: false,
+        ids: [],
+        optimizedSelector: {}
+      };
     }
     const indices = this.collectionIndices.get(collectionName) ?? [];
     return getIndexInfo(indices.map((field) => async (flatSelector) => {
       if (!Object.hasOwnProperty.call(flatSelector, field))
         return { matched: false };
-      const index = await storage.readIndex(field);
+      const index = await storageAdapter.readIndex(field);
       const fieldSelector = flatSelector[field];
       const filtersForNull = fieldSelector == null || fieldSelector.$exists === false;
       const keys = filtersForNull ? { include: null, exclude: [...index.keys()].filter((key) => key != null) } : getMatchingKeys(field, flatSelector);

package/dist/index14.mjs

@@ -1,17 +1,23 @@
-import queryId from "./index24.mjs";
+import queryId from "./index20.mjs";
 import randomId from "./index8.mjs";
+import batchOnNextTick from "./index27.mjs";
 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"));
@@ -50,6 +56,7 @@ class WorkerDataAdapter {
           return;
         if (id !== messageId)
           return;
+        this.log(method, "result", data ?? error);
         if (error) {
           reject(error);
         } else {
@@ -66,74 +73,61 @@ 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: [],
       ...existing,
       ...update
-    });
+    };
+    collectionQueries.set(id, newState);
     this.queries[collectionName] = collectionQueries;
   }
   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);
+        this.updateQuery(collection.name, { selector, options }, { state: "active", error: null, items: [] });
+        void this.exec("registerQuery", collection.name, selector, options);
       },
       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);
+        this.queries[collection.name]?.delete(queryId(selector, options));
+        void this.exec("unregisterQuery", collection.name, selector, options);
       },
       getQueryState: (selector, options) => {
         const query = this.queries[collection.name]?.get(queryId(selector, options));
@@ -159,10 +153,9 @@ 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
@@ -174,6 +167,7 @@ class WorkerDataAdapter {
           this.worker.removeEventListener("message", handler);
         };
       },
+      executeQuery: (selector, options) => this.exec("executeQuery", collection.name, selector, options),
       // lifecycle methods
       dispose: async () => {
         await this.exec("unregisterCollection", collection.name);