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

package/dist/index.cjs22.js

@@ -1,7 +1,129 @@
 "use strict";
-const mingo = require("mingo");
-function match(item, selector) {
-  const query = new mingo.Query(selector);
-  return query.test(item);
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const intersection = require("./index.cjs29.js");
+function getMergedIndexInfo(queryFunctions, selector) {
+  return queryFunctions.reduce((memoOrPromise, queryFunction) => {
+    const resultOrPromise = queryFunction(selector);
+    const processResult = (memo2, result) => {
+      if (!result.matched)
+        return memo2;
+      const optimizedSelector = result.keepSelector ? memo2.optimizedSelector : Object.fromEntries(Object.entries(memo2.optimizedSelector).filter(([key]) => !result.fields.includes(key)));
+      return {
+        matched: true,
+        ids: [...new Set(memo2.matched ? intersection(memo2.ids, result.ids) : result.ids)],
+        optimizedSelector
+      };
+    };
+    if (resultOrPromise instanceof Promise) {
+      return resultOrPromise.then(async (result) => {
+        const memo2 = memoOrPromise instanceof Promise ? await memoOrPromise : memoOrPromise;
+        return processResult(memo2, result);
+      });
+    }
+    const memo = memoOrPromise;
+    if (memo instanceof Promise)
+      throw new Error("Mixing async and sync index providers is not supported");
+    return processResult(memo, resultOrPromise);
+  }, {
+    matched: false,
+    ids: [],
+    optimizedSelector: { ...selector }
+  });
 }
-module.exports = match;
+function optimizeLogicGate(queryFunctions, logicGate, idsCallback) {
+  return logicGate.reduce((memoOrPromise, sel) => {
+    const getSelector = (indexInfo) => {
+      const { matched: selMatched, ids: selIds, optimizedSelector: optimizedSelector2 } = indexInfo;
+      if (selMatched) {
+        idsCallback(true, selIds);
+        if (Object.keys(optimizedSelector2).length > 0) {
+          return optimizedSelector2;
+        }
+      } else {
+        idsCallback(false, []);
+        return sel;
+      }
+    };
+    const indexInfoOrPromise = getIndexInfo(queryFunctions, sel);
+    if (indexInfoOrPromise instanceof Promise) {
+      return indexInfoOrPromise.then(async (indexInfo) => {
+        const memo2 = memoOrPromise instanceof Promise ? await memoOrPromise : memoOrPromise;
+        const optimizedSelector2 = getSelector(indexInfo);
+        if (optimizedSelector2)
+          memo2.push(optimizedSelector2);
+        return memo2;
+      });
+    }
+    const memo = memoOrPromise;
+    if (memo instanceof Promise)
+      throw new Error("Mixing async and sync index providers is not supported");
+    const optimizedSelector = getSelector(indexInfoOrPromise);
+    if (optimizedSelector)
+      memo.push(optimizedSelector);
+    return memo;
+  }, []);
+}
+function getIndexInfo(queryFunctions, selector) {
+  if (selector == null || Object.keys(selector).length <= 0) {
+    return {
+      matched: false,
+      ids: [],
+      optimizedSelector: selector
+    };
+  }
+  const { $and, $or, ...rest } = selector;
+  const flatInfoOrPromise = getMergedIndexInfo(queryFunctions, rest);
+  const processFlatInfo = (flatInfo) => {
+    let { matched, ids } = flatInfo;
+    const newSelector = flatInfo.optimizedSelector;
+    const $andNewOrPromise = Array.isArray($and) ? optimizeLogicGate(queryFunctions, $and, (match, selIds) => {
+      if (!match)
+        return;
+      ids = matched ? intersection(ids, selIds) : selIds;
+      matched = true;
+    }) : void 0;
+    const process$and = ($andNew) => {
+      if ($andNew && $andNew.length > 0)
+        newSelector.$and = $andNew;
+      let hasNonIndexField = false;
+      const matchedBefore = matched;
+      const idsBefore = ids;
+      const process$or = ($orNew) => {
+        if ($orNew && $orNew.length > 0)
+          newSelector.$or = $orNew;
+        if (hasNonIndexField) {
+          newSelector.$or = $or;
+          matched = matchedBefore;
+          ids = idsBefore;
+        }
+        return {
+          matched,
+          ids: ids || [],
+          optimizedSelector: newSelector
+        };
+      };
+      const $orNewOrPromise = Array.isArray($or) ? optimizeLogicGate(queryFunctions, $or, (match, selIds) => {
+        if (match) {
+          ids = [.../* @__PURE__ */ new Set([...ids, ...selIds])];
+          matched = true;
+        } else {
+          hasNonIndexField = true;
+        }
+      }) : void 0;
+      if ($orNewOrPromise instanceof Promise) {
+        return $orNewOrPromise.then(($orNew) => process$or($orNew));
+      }
+      return process$or($orNewOrPromise);
+    };
+    if ($andNewOrPromise instanceof Promise) {
+      return $andNewOrPromise.then(($andNew) => process$and($andNew));
+    }
+    return process$and($andNewOrPromise);
+  };
+  if (flatInfoOrPromise instanceof Promise) {
+    return flatInfoOrPromise.then(processFlatInfo);
+  }
+  return processFlatInfo(flatInfoOrPromise);
+}
+exports.default = getIndexInfo;
+exports.getMergedIndexInfo = getMergedIndexInfo;

package/dist/index.cjs23.js

@@ -1,27 +1,7 @@
 "use strict";
-const get = require("./index.cjs10.js");
-const set = require("./index.cjs29.js");
-function project(item, fields) {
-  const allFieldsDeactivated = Object.values(fields).every((value) => value === 0);
-  if (allFieldsDeactivated) {
-    const result2 = { ...item };
-    Object.keys(fields).forEach((key) => {
-      const fieldValue = get(item, key);
-      if (fieldValue === void 0)
-        return;
-      set(result2, key, void 0, true);
-    });
-    return result2;
-  }
-  const result = {};
-  Object.entries(fields).forEach(([key, value]) => {
-    const fieldValue = get(item, key);
-    if (fieldValue === void 0)
-      return;
-    if (fieldValue == null && value !== 1)
-      return;
-    set(result, key, value === 1 ? fieldValue : void 0);
-  });
-  return result;
+const mingo = require("mingo");
+function match(item, selector) {
+  const query = new mingo.Query(selector);
+  return query.test(item);
 }
-module.exports = project;
+module.exports = match;

package/dist/index.cjs24.js

@@ -1,7 +1,27 @@
 "use strict";
-function queryId(selector, options) {
-  const selectorId = JSON.stringify(selector);
-  const optionsId = options == null ? -1 : JSON.stringify(options);
-  return `${selectorId}:${optionsId}`;
+const get = require("./index.cjs10.js");
+const set = require("./index.cjs31.js");
+function project(item, fields) {
+  const allFieldsDeactivated = Object.values(fields).every((value) => value === 0);
+  if (allFieldsDeactivated) {
+    const result2 = { ...item };
+    Object.keys(fields).forEach((key) => {
+      const fieldValue = get(item, key);
+      if (fieldValue === void 0)
+        return;
+      set(result2, key, void 0, true);
+    });
+    return result2;
+  }
+  const result = {};
+  Object.entries(fields).forEach(([key, value]) => {
+    const fieldValue = get(item, key);
+    if (fieldValue === void 0)
+      return;
+    if (fieldValue == null && value !== 1)
+      return;
+    set(result, key, value === 1 ? fieldValue : void 0);
+  });
+  return result;
 }
-module.exports = queryId;
+module.exports = project;

package/dist/index.cjs27.js

@@ -1,5 +1,46 @@
 "use strict";
-function createIndexProvider(definition) {
-  return definition;
+function batchOnNextTick(onFlush) {
+  const queues = /* @__PURE__ */ new Map();
+  function enqueue(key, args) {
+    return new Promise((resolve, reject) => {
+      let q = queues.get(key);
+      if (!q) {
+        q = {
+          timer: null,
+          items: [],
+          flush: () => flush(key)
+        };
+        queues.set(key, q);
+      }
+      q.items.push({ args, resolve, reject });
+      if (q.timer == null) {
+        q.timer = setTimeout(() => {
+          q.timer = null;
+          void q.flush();
+        }, 0);
+      }
+    });
+  }
+  async function flush(key) {
+    const q = queues.get(key);
+    if (!q || q.items.length === 0)
+      return;
+    if (q.timer != null) {
+      clearTimeout(q.timer);
+      q.timer = null;
+    }
+    const items = q.items.splice(0);
+    onFlush(key, items.map((i) => i.args)).then((results) => {
+      for (const [index, result] of results.entries()) {
+        const { resolve } = items[index];
+        resolve(result);
+      }
+    }).catch((error) => {
+      for (const { reject } of items) {
+        reject(error);
+      }
+    });
+  }
+  return { enqueue, flush };
 }
-module.exports = createIndexProvider;
+module.exports = batchOnNextTick;

package/dist/index.cjs28.js

@@ -1,7 +1,8 @@
 "use strict";
-function intersection(...arrays) {
-  if (arrays.length === 0)
-    return [];
-  return [...new Set(arrays.reduce((a, b) => a.filter((c) => b.includes(c))))];
+function truthy(value) {
+  return !!value;
 }
-module.exports = intersection;
+function compact(array) {
+  return array.filter(truthy);
+}
+module.exports = compact;

package/dist/index.cjs29.js

@@ -1,29 +1,7 @@
 "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;
+function intersection(...arrays) {
+  if (arrays.length === 0)
+    return [];
+  return [...new Set(arrays.reduce((a, b) => a.filter((c) => b.includes(c))))];
 }
-module.exports = set;
+module.exports = intersection;

package/dist/index.cjs3.js

@@ -6,6 +6,7 @@ const randomId = require("./index.cjs8.js");
 const DefaultDataAdapter = require("./index.cjs12.js");
 const modify = require("./index.cjs7.js");
 const deepClone = require("./index.cjs19.js");
+const queryId = require("./index.cjs20.js");
 const Cursor = require("./index.cjs2.js");
 class Collection extends EventEmitter {
   static collections = [];
@@ -68,6 +69,7 @@ class Collection extends EventEmitter {
   isDisposed = false;
   postBatchCallbacks = /* @__PURE__ */ new Set();
   fieldTracking = false;
+  queryListenersMap = /* @__PURE__ */ new Map();
   constructor(nameOrOptions, maybeDataAdapter, maybeOptions) {
     super();
     const name = typeof nameOrOptions === "string" ? nameOrOptions : nameOrOptions?.name || `${this.constructor.name}-${randomId()}`;
@@ -192,6 +194,11 @@ class Collection extends EventEmitter {
       return item;
     return this.options.transform(item);
   }
+  transformAll(items, fields) {
+    if (!this.options.transformAll)
+      return items;
+    return this.options.transformAll(deepClone.default(items), fields);
+  }
   getItem(selector, options) {
     const itemsOrPromise = this.getItems(selector, { ...options, limit: 1 });
     if (itemsOrPromise instanceof Promise) {
@@ -206,21 +213,9 @@ class Collection extends EventEmitter {
     return this.profile(() => {
       if (!options?.async)
         return this.backend.getQueryResult(selector, options);
-      return new Promise((resolve, reject) => {
-        this.isPullingSignal.set(true);
-        const cleanup = this.backend.onQueryStateChange(selector, options, (state) => {
-          if (state === "error") {
-            cleanup();
-            reject(this.backend.getQueryError(selector, options) || new Error("Unknown error"));
-          } else if (state === "complete") {
-            cleanup();
-            resolve(this.backend.getQueryResult(selector, options) || []);
-          }
-        });
-        this.backend.registerQuery(selector, options);
-      }).finally(() => {
+      this.isPullingSignal.set(true);
+      return this.backend.executeQuery(selector, options).finally(() => {
         this.isPullingSignal.set(false);
-        this.backend.unregisterQuery(selector, options);
       });
     }, (measuredTime) => this.executeInDebugMode((callstack) => this.emit("_debug.getItems", callstack, selector, measuredTime)));
   }
@@ -232,6 +227,13 @@ class Collection extends EventEmitter {
       this.isPushingSignal.set(false);
     }
   }
+  queryListeners(query, listeners) {
+    const id = queryId(query.selector, query.options);
+    if (listeners != null) {
+      return this.queryListenersMap.set(id, listeners);
+    }
+    return this.queryListenersMap.get(id) ?? 0;
+  }
   /**
    * Disposes the collection, unregisters persistence adapters, clears memory, and
    * cleans up all resources used by the collection.
@@ -257,7 +259,17 @@ class Collection extends EventEmitter {
       throw new Error("Collection is disposed");
     if (selector !== void 0 && (!selector || typeof selector !== "object"))
       throw new Error("Invalid selector");
-    const cursor = new Cursor.default((() => this.getItems(selector, options || {})), {
+    const getTransformedItems = () => {
+      const itemsOrPromise = this.getItems(selector, options || {});
+      if (itemsOrPromise instanceof Promise) {
+        return itemsOrPromise.then((items2) => {
+          return this.transformAll(items2, options?.fields);
+        });
+      }
+      const items = itemsOrPromise;
+      return this.transformAll(items, options?.fields);
+    };
+    const cursor = new Cursor.default(getTransformedItems, {
       reactive: this.options.reactivity,
       fieldTracking: this.fieldTracking,
       ...options,
@@ -270,17 +282,25 @@ class Collection extends EventEmitter {
           }
           requery();
         };
-        this.backend.registerQuery(selector, options);
-        const queryStateChangeCleanup = this.backend.onQueryStateChange(selector, options, (state) => {
+        const listeners = this.queryListeners({ selector, options });
+        if (listeners === 0)
+          this.backend.registerQuery(selector, options || {});
+        this.queryListeners({ selector, options }, listeners + 1);
+        const queryStateChangeCleanup = this.backend.onQueryStateChange(selector, options || {}, (state) => {
           if (state !== "complete")
             return;
           handleRequery();
         });
         this.emit("observer.created", selector, options);
         return () => {
-          this.backend.unregisterQuery(selector, options);
-          queryStateChangeCleanup();
-          this.emit("observer.disposed", selector, options);
+          setTimeout(() => {
+            const newListeners = Math.max(0, this.queryListeners({ selector, options }) - 1);
+            if (newListeners === 0)
+              this.backend.unregisterQuery(selector, options || {});
+            this.queryListeners({ selector, options }, newListeners);
+            queryStateChangeCleanup();
+            this.emit("observer.disposed", selector, options);
+          }, 0);
         };
       }
     });
@@ -373,9 +393,8 @@ class Collection extends EventEmitter {
       throw new Error("Collection is disposed");
     if (!items)
       throw new Error("Invalid items");
-    if (items.length === 0) {
+    if (items.length === 0)
       return [];
-    }
     const ids = [];
     await this.batch(async () => {
       await Promise.all(items.map(async (item) => {

package/dist/index.cjs31.js

@@ -1,9 +1,29 @@
 "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 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 = uniqueBy;
+module.exports = set;

package/dist/index.cjs32.js

@@ -0,0 +1,9 @@
+"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);
+  });
+}
+module.exports = uniqueBy;

package/dist/index.cjs33.js

@@ -0,0 +1,5 @@
+"use strict";
+function createIndexProvider(definition) {
+  return definition;
+}
+module.exports = createIndexProvider;

package/dist/index.d.ts

@@ -2,7 +2,8 @@ export type { default as ReactivityAdapter } from './types/ReactivityAdapter';
 export type { default as StorageAdapter, Changeset, } from './types/StorageAdapter';
 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 { BaseItem, ObserveCallbacks, CursorOptions, Transform, TransformAll, 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,16 @@ 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);
+          const results = this.cachedQueryResults.get(collection.name)?.get(queryId(selector, options));
+          if (!results)
+            throw new Error("Cached query results are not defined!");
+          return results;
         }
-        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);