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

package/dist/.vite/manifest.json

@@ -59,6 +59,7 @@
       "src/DefaultDataAdapter.ts",
       "src/utils/modify.ts",
       "src/utils/deepClone.ts",
+      "src/utils/queryId.ts",
       "src/Collection/Cursor.ts"
     ]
   },
@@ -86,7 +87,8 @@
     "src": "src/WorkerDataAdapter.ts",
     "imports": [
       "src/utils/queryId.ts",
-      "src/utils/randomId.ts"
+      "src/utils/randomId.ts",
+      "src/utils/batchOnNextTick.ts"
     ]
   },
   "src/WorkerDataAdapterHost.ts": {
@@ -102,11 +104,12 @@
       "src/getIndexInfo.ts",
       "src/utils/getMatchingKeys.ts",
       "src/utils/sortItems.ts",
-      "src/utils/project.ts"
+      "src/utils/project.ts",
+      "src/utils/compact.ts"
     ]
   },
   "src/createIndex.ts": {
-    "file": "index.cjs20.js",
+    "file": "index.cjs21.js",
     "name": "createIndex",
     "src": "src/createIndex.ts",
     "imports": [
@@ -117,7 +120,7 @@
     ]
   },
   "src/createIndexProvider.ts": {
-    "file": "index.cjs27.js",
+    "file": "index.cjs33.js",
     "name": "createIndexProvider",
     "src": "src/createIndexProvider.ts"
   },
@@ -132,7 +135,7 @@
     "src": "src/createStorageAdapter.ts"
   },
   "src/getIndexInfo.ts": {
-    "file": "index.cjs21.js",
+    "file": "index.cjs22.js",
     "name": "getIndexInfo",
     "src": "src/getIndexInfo.ts",
     "imports": [
@@ -167,6 +170,16 @@
     "name": "utils/EventEmitter",
     "src": "src/utils/EventEmitter.ts"
   },
+  "src/utils/batchOnNextTick.ts": {
+    "file": "index.cjs27.js",
+    "name": "utils/batchOnNextTick",
+    "src": "src/utils/batchOnNextTick.ts"
+  },
+  "src/utils/compact.ts": {
+    "file": "index.cjs28.js",
+    "name": "utils/compact",
+    "src": "src/utils/compact.ts"
+  },
   "src/utils/createSignal.ts": {
     "file": "index.cjs18.js",
     "name": "utils/createSignal",
@@ -192,7 +205,7 @@
     ]
   },
   "src/utils/intersection.ts": {
-    "file": "index.cjs28.js",
+    "file": "index.cjs29.js",
     "name": "utils/intersection",
     "src": "src/utils/intersection.ts"
   },
@@ -207,7 +220,7 @@
     "src": "src/utils/isFieldExpression.ts"
   },
   "src/utils/match.ts": {
-    "file": "index.cjs22.js",
+    "file": "index.cjs23.js",
     "name": "utils/match",
     "src": "src/utils/match.ts"
   },
@@ -220,7 +233,7 @@
     ]
   },
   "src/utils/project.ts": {
-    "file": "index.cjs23.js",
+    "file": "index.cjs24.js",
     "name": "utils/project",
     "src": "src/utils/project.ts",
     "imports": [
@@ -229,7 +242,7 @@
     ]
   },
   "src/utils/queryId.ts": {
-    "file": "index.cjs24.js",
+    "file": "index.cjs20.js",
     "name": "utils/queryId",
     "src": "src/utils/queryId.ts"
   },
@@ -244,7 +257,7 @@
     "src": "src/utils/serializeValue.ts"
   },
   "src/utils/set.ts": {
-    "file": "index.cjs29.js",
+    "file": "index.cjs31.js",
     "name": "utils/set",
     "src": "src/utils/set.ts"
   },
@@ -257,7 +270,7 @@
     ]
   },
   "src/utils/uniqueBy.ts": {
-    "file": "index.cjs31.js",
+    "file": "index.cjs32.js",
     "name": "utils/uniqueBy",
     "src": "src/utils/uniqueBy.ts"
   }

package/dist/AsyncDataAdapter.d.ts

@@ -27,7 +27,7 @@ export default class AsyncDataAdapter implements DataAdapter {
     private collectionIndices;
     private queries;
     constructor(options: AsyncDataAdapterOptions);
-    createCollectionBackend<T extends BaseItem<I>, I = any, U = T>(collection: Collection<T, I, U>, indices: string[]): CollectionBackend<T, I>;
+    createCollectionBackend<T extends BaseItem<I>, I = any, E extends BaseItem = T, U = E>(collection: Collection<T, I, E, U>, indices: string[]): CollectionBackend<T, I>;
     private setupStorage;
     private ensureStorageAdapter;
     /**

package/dist/AutoFetchDataAdapter.d.ts

@@ -71,8 +71,7 @@ export default class AutoFetchDataAdapter implements DataAdapter {
     private idRefCounts;
     private autoloadIds;
     constructor(options: AutoFetchDataAdapterOptions);
-    createCollectionBackend<T extends BaseItem<I>, I = any, U = T>(collection: Collection<T, I, U>, indices: string[]): CollectionBackend<T, I>;
-    private selectorKey;
+    createCollectionBackend<T extends BaseItem<I>, I = any, E extends BaseItem = T, U = E>(collection: Collection<T, I, E, U>, indices: string[]): CollectionBackend<T, I>;
     private forceRefetchAll;
     private fetchAndIngest;
     private purgeSelector;

package/dist/Collection/Cursor.d.ts

@@ -15,7 +15,7 @@ export interface CursorOptions<T extends BaseItem, U = T, Async extends boolean
  * Represents a cursor for querying and observing a filtered, sorted, and transformed
  * subset of items from a collection. Supports reactivity and field tracking.
  * @template T - The type of the items in the collection.
- * @template U - The transformed item type after applying transformations (default is T).
+ * @template U - The transformed item type after applying transform (default is T).
  */
 export default class Cursor<T extends BaseItem, U = T, Async extends boolean = false> {
     private observer;
@@ -37,6 +37,7 @@ export default class Cursor<T extends BaseItem, U = T, Async extends boolean = f
      * @param options.limit - The maximum number of items to return in the result set.
      * @param options.reactive - A reactivity adapter to enable observing changes in the cursor's result set.
      * @param options.fieldTracking - A boolean to enable fine-grained field tracking for reactivity.
+     * @param options.transformAll - A function that will be able to solve the n+1 problem
      */
     constructor(getItems: Async extends true ? () => Promise<T[]> : () => T[], options?: CursorOptions<T, U, Async>);
     private addGetters;
@@ -102,7 +103,7 @@ export default class Cursor<T extends BaseItem, U = T, Async extends boolean = f
      * @param skipInitial - A boolean indicating whether to skip the initial notification of the current result set.
      * @returns A function to stop observing changes.
      */
-    observeChanges(callbacks: ObserveCallbacks<U>, skipInitial?: boolean): () => void;
+    observeChanges(callbacks: ObserveCallbacks<T>, skipInitial?: boolean): () => void;
     /**
      * Forces the cursor to re-evaluate its result set by re-fetching items
      * from the collection. This is useful when the underlying data or query

package/dist/Collection/index.d.ts

@@ -6,12 +6,12 @@ import type DataAdapter from '../DataAdapter';
 import type { QueryOptions } from '../DataAdapter';
 import type StorageAdapter from '../types/StorageAdapter';
 import Cursor from './Cursor';
-import type { BaseItem, FindOptions, Transform } from './types';
-export type { BaseItem, Transform, SortSpecifier, FieldSpecifier, FindOptions } from './types';
+import type { BaseItem, FindOptions, Transform, TransformAll } from './types';
+export type { BaseItem, Transform, TransformAll, SortSpecifier, FieldSpecifier, FindOptions } from './types';
 export type { CursorOptions } from './Cursor';
 export type { ObserveCallbacks } from './Observer';
 export { default as createIndex } from '../createIndex';
-export interface CollectionOptions<T extends BaseItem<I>, I, U = T> {
+export interface CollectionOptions<T extends BaseItem<I>, I, E extends BaseItem = T, U = E> {
     /**
      * @deprecated Use new constructor parameters instead.
      */
@@ -22,19 +22,20 @@ export interface CollectionOptions<T extends BaseItem<I>, I, U = T> {
     persistence?: StorageAdapter<T, I>;
     primaryKeyGenerator?: (item: Omit<T, 'id'>) => I;
     reactivity?: ReactivityAdapter;
-    transform?: Transform<T, U>;
+    transform?: Transform<E, U>;
+    transformAll?: TransformAll<T, E>;
     indices?: string[];
     enableDebugMode?: boolean;
     fieldTracking?: boolean;
 }
-interface CollectionEvents<T extends BaseItem, U = T> {
+interface CollectionEvents<T extends BaseItem, E extends BaseItem = T, U = E> {
     'added': (item: T) => void;
     'changed': (item: T, modifier: Modifier<T>) => void;
     'removed': (item: T) => void;
     'observer.created': <O extends QueryOptions<T>>(selector?: Selector<T>, options?: O) => void;
     'observer.disposed': <O extends QueryOptions<T>>(selector?: Selector<T>, options?: O) => void;
     'getItems': (selector: Selector<T> | undefined) => void;
-    'find': <O extends FindOptions<T, Async>, Async extends boolean>(selector: Selector<T> | undefined, options: O | undefined, cursor: Cursor<T, U, Async>) => void;
+    'find': <O extends FindOptions<T, Async>, Async extends boolean>(selector: Selector<T> | undefined, options: O | undefined, cursor: Cursor<E, U, Async>) => void;
     'findOne': <O extends QueryOptions<T>>(selector: Selector<T>, options: O | undefined, item: U | undefined) => void;
     'insert': (item: Omit<T, 'id'> & Partial<Pick<T, 'id'>>) => void;
     'updateOne': (selector: Selector<T>, modifier: Modifier<T>) => void;
@@ -44,7 +45,7 @@ interface CollectionEvents<T extends BaseItem, U = T> {
     'removeMany': (selector: Selector<T>) => void;
     'validate': (item: T) => void;
     '_debug.getItems': (callstack: string, selector: Selector<T> | undefined, measuredTime: number) => void;
-    '_debug.find': <O extends FindOptions<T, Async>, Async extends boolean>(callstack: string, selector: Selector<T> | undefined, options: O | undefined, cursor: Cursor<T, U, Async>) => void;
+    '_debug.find': <O extends FindOptions<T, Async>, Async extends boolean>(callstack: string, selector: Selector<T> | undefined, options: O | undefined, cursor: Cursor<E, U, Async>) => void;
     '_debug.findOne': <O extends FindOptions<T, Async>, Async extends boolean>(callstack: string, selector: Selector<T>, options: O | undefined, item: U | undefined) => void;
     '_debug.insert': (callstack: string, item: Omit<T, 'id'> & Partial<Pick<T, 'id'>>) => void;
     '_debug.updateOne': (callstack: string, selector: Selector<T>, modifier: Modifier<T>) => void;
@@ -61,14 +62,14 @@ interface CollectionEvents<T extends BaseItem, U = T> {
  * @template I - The type of the unique identifier for the items.
  * @template U - The transformed item type after applying transformations (default is T).
  */
-export default class Collection<T extends BaseItem<I> = BaseItem, I = any, U = T> extends EventEmitter<CollectionEvents<T, U>> {
+export default class Collection<T extends BaseItem<I> = BaseItem, I = any, E extends BaseItem = T, U = E> extends EventEmitter<CollectionEvents<T, E, U>> {
     private static collections;
     private static debugMode;
     private static batchOperationInProgress;
     private static fieldTracking;
     private static onCreationCallbacks;
     private static onDisposeCallbacks;
-    static getCollections(): Collection<any, any, any>[];
+    static getCollections(): Collection<any, any, any, any>[];
     static onCreation(callback: (collection: Collection<any>) => void): void;
     static onDispose(callback: (collection: Collection<any>) => void): void;
     /**
@@ -102,6 +103,7 @@ export default class Collection<T extends BaseItem<I> = BaseItem, I = any, U = T
     private isDisposed;
     private postBatchCallbacks;
     private fieldTracking;
+    private queryListenersMap;
     /**
      * Initializes a new instance of the `Collection` class with optional configuration.
      * Sets up memory, persistence, reactivity, and indices as specified in the options.
@@ -119,9 +121,10 @@ export default class Collection<T extends BaseItem<I> = BaseItem, I = any, U = T
      * @param options.indices - An array of index providers for optimized querying.
      * @param options.enableDebugMode - A boolean to enable or disable debug mode.
      * @param options.fieldTracking - A boolean to enable or disable field tracking by default.
+     * @param options.transformAll - A function that will be able to solve the n+1 problem
      */
-    constructor(options?: CollectionOptions<T, I, U>);
-    constructor(name: string, dataAdapter: DataAdapter, options?: CollectionOptions<T, I, U>);
+    constructor(options?: CollectionOptions<T, I, E, U>);
+    constructor(name: string, dataAdapter: DataAdapter, options?: CollectionOptions<T, I, E, U>);
     isBatchOperationInProgress(): boolean;
     /**
      * Checks whether the collection is currently performing a pull operation
@@ -183,9 +186,11 @@ export default class Collection<T extends BaseItem<I> = BaseItem, I = any, U = T
     private profile;
     private executeInDebugMode;
     private transform;
+    private transformAll;
     private getItem;
     private getItems;
     private withPushState;
+    private queryListeners;
     /**
      * Disposes the collection, unregisters persistence adapters, clears memory, and
      * cleans up all resources used by the collection.
@@ -200,7 +205,7 @@ export default class Collection<T extends BaseItem<I> = BaseItem, I = any, U = T
      * @param [options] - Options for the find operation, such as limit and sort.
      * @returns A cursor to fetch and observe the matching items.
      */
-    find<Async extends boolean = false, O extends FindOptions<T, Async> = FindOptions<T, Async>>(selector?: Selector<T>, options?: O): Cursor<T, U, Async>;
+    find<Async extends boolean = false, O extends FindOptions<T, Async> = FindOptions<T, Async>>(selector?: Selector<T>, options?: O): Cursor<E, U, Async>;
     /**
      * Finds a single item in the collection based on a selector and optional options.
      * ⚡️ this function is reactive!

package/dist/Collection/types.d.ts

@@ -4,6 +4,7 @@ export type BaseItem<I = any> = {
     id: I;
 } & Record<string, any>;
 export type Transform<T, U = T> = ((document: T) => U) | null | undefined;
+export type TransformAll<T extends BaseItem, O extends BaseItem = T> = ((items: T[], fields: FieldSpecifier<O> | undefined) => O[]) | null | undefined;
 export type SortSpecifier<T> = {
     [P in keyof T]?: -1 | 1;
 } & Record<string, -1 | 1>;

package/dist/DataAdapter.d.ts

@@ -12,6 +12,7 @@ export interface QueryOptions<T extends BaseItem> {
     /** Dictionary of fields to return or exclude. */
     fields?: FieldSpecifier<T> | undefined;
 }
+export type StateChangeCallback = (state: 'active' | 'complete' | 'error') => void;
 export interface CollectionBackend<T extends BaseItem<I>, I> {
     insert(item: T): Promise<T>;
     updateOne(selector: Selector<T>, modifier: Modifier<T>): Promise<T[]>;
@@ -19,15 +20,16 @@ export interface CollectionBackend<T extends BaseItem<I>, I> {
     replaceOne(selector: Selector<T>, replacement: Omit<T, 'id'> & Partial<Pick<T, 'id'>>): Promise<T[]>;
     removeOne(selector: Selector<T>): Promise<T[]>;
     removeMany(selector: Selector<T>): Promise<T[]>;
-    registerQuery<O extends QueryOptions<T>>(selector: Selector<T>, options?: O): void;
-    unregisterQuery<O extends QueryOptions<T>>(selector: Selector<T>, options?: O): void;
-    getQueryState<O extends QueryOptions<T>>(selector: Selector<T>, options?: O): 'active' | 'complete' | 'error';
-    getQueryError<O extends QueryOptions<T>>(selector: Selector<T>, options?: O): Error | null;
-    getQueryResult<O extends QueryOptions<T>>(selector: Selector<T>, options?: O): T[];
-    onQueryStateChange<O extends QueryOptions<T>>(selector: Selector<T> | undefined, options: O | undefined, callback: (state: 'active' | 'complete' | 'error') => void): () => void;
+    registerQuery<O extends QueryOptions<T>>(selector: Selector<T>, options: O): void;
+    unregisterQuery<O extends QueryOptions<T>>(selector: Selector<T>, options: O): void;
+    getQueryState<O extends QueryOptions<T>>(selector: Selector<T>, options: O): 'active' | 'complete' | 'error';
+    getQueryError<O extends QueryOptions<T>>(selector: Selector<T>, options: O): Error | null;
+    getQueryResult<O extends QueryOptions<T>>(selector: Selector<T>, options: O): T[];
+    executeQuery<O extends QueryOptions<T>>(selector: Selector<T>, options: O): Promise<T[]>;
+    onQueryStateChange<O extends QueryOptions<T>>(selector: Selector<T>, options: O, callback: StateChangeCallback): () => void;
     dispose(): Promise<void>;
     isReady(): Promise<void>;
 }
 export default interface DataAdapter {
-    createCollectionBackend<T extends BaseItem<I>, I = any, U = T>(collection: Collection<T, I, U>, indices: string[]): CollectionBackend<T, I>;
+    createCollectionBackend<T extends BaseItem<I>, I = any, E extends BaseItem = T, U = E>(collection: Collection<T, I, E, U>, indices: string[]): CollectionBackend<T, I>;
 }

package/dist/DefaultDataAdapter.d.ts

@@ -26,7 +26,8 @@ export default class DefaultDataAdapter implements DataAdapter {
     private queryItems;
     private executeQuery;
     private flushQueuedQueryUpdates;
+    private executeAndCacheQuery;
     private updateQueries;
-    createCollectionBackend<T extends BaseItem<I>, I = any, U = T>(collection: Collection<T, I, U>, indices: string[]): CollectionBackend<T, I>;
+    createCollectionBackend<T extends BaseItem<I>, I = any, E extends BaseItem = T, U = E>(collection: Collection<T, I, E, U>, indices: string[]): CollectionBackend<T, I>;
 }
 export {};

package/dist/WorkerDataAdapter.d.ts

@@ -4,6 +4,7 @@ import type DataAdapter from './DataAdapter';
 import type { CollectionBackend } from './DataAdapter';
 interface WorkerDataAdapterOptions {
     id?: string;
+    log?: (message: string, ...args: any[]) => void;
 }
 export default class WorkerDataAdapter implements DataAdapter {
     private worker;
@@ -11,12 +12,14 @@ export default class WorkerDataAdapter implements DataAdapter {
     private id;
     private isDisposed;
     private workerReady;
+    private log;
     private collectionReady;
+    private batchExecutionHelpers;
     private queries;
     constructor(worker: Worker, options: WorkerDataAdapterOptions);
     private exec;
-    private queryListeners;
+    private enqueueBatched;
     private updateQuery;
-    createCollectionBackend<T extends BaseItem<I>, I = any, U = T>(collection: Collection<T, I, U>, indices?: string[]): CollectionBackend<T, I>;
+    createCollectionBackend<T extends BaseItem<I>, I = any, E extends BaseItem = T, U = E>(collection: Collection<T, I, E, U>, indices: string[]): CollectionBackend<T, I>;
 }
 export {};

package/dist/WorkerDataAdapterHost.d.ts

@@ -11,24 +11,27 @@ interface WorkerDataAdapterHostOptions {
     id?: string;
     storage: (name: string) => StorageAdapter<any, any>;
     onError?: (error: Error) => void;
+    log?: (message: string, ...args: any[]) => void;
 }
 type CollectionMethods<T extends BaseItem<I>, I = any> = {
     registerCollection: (collectionName: string, indices: string[]) => Promise<void>;
     unregisterCollection: (collectionName: string) => Promise<void>;
     registerQuery: <O extends QueryOptions<T>>(collectionName: string, selector: Selector<T>, options?: O) => Promise<void>;
     unregisterQuery: <O extends QueryOptions<T>>(collectionName: string, selector: Selector<T>, options?: O) => Promise<void>;
-    insert: (collectionName: string, item: T) => Promise<T>;
-    updateOne: (collectionName: string, selector: Selector<T>, modifier: Modifier<T>) => Promise<T[]>;
-    updateMany: (collectionName: string, selector: Selector<T>, modifier: Modifier<T>) => Promise<T[]>;
-    replaceOne: (collectionName: string, selector: Selector<T>, replacement: Omit<T, 'id'> & Partial<Pick<T, 'id'>>) => Promise<T[]>;
-    removeOne: (collectionName: string, selector: Selector<T>) => Promise<T[]>;
-    removeMany: (collectionName: string, selector: Selector<T>) => Promise<T[]>;
+    executeQuery: <O extends QueryOptions<T>>(collectionName: string, selector: Selector<T>, options?: O) => Promise<T[]>;
+    insert: (collectionName: string, items: [T][]) => Promise<(T | Error)[]>;
+    updateOne: (collectionName: string, args: [Selector<T>, Modifier<T>][]) => Promise<(T[] | Error)[]>;
+    updateMany: (collectionName: string, args: [Selector<T>, Modifier<T>][]) => Promise<(T[] | Error)[]>;
+    replaceOne: (collectionName: string, args: [Selector<T>, Omit<T, 'id'> & Partial<Pick<T, 'id'>>][]) => Promise<(T[] | Error)[]>;
+    removeOne: (collectionName: string, selectors: [Selector<T>][]) => Promise<(T[] | Error)[]>;
+    removeMany: (collectionName: string, selectors: [Selector<T>][]) => Promise<(T[] | Error)[]>;
     isReady: (collectionName: string) => Promise<void>;
 };
 export default class WorkerDataAdapterHost<T extends BaseItem<I>, I = any> {
     private workerContext;
     private options;
     private id;
+    private log;
     private storageAdapters;
     private storageAdapterReady;
     private collectionIndices;

package/dist/index.cjs12.js

@@ -1,13 +1,13 @@
 "use strict";
-const createIndex = require("./index.cjs20.js");
-const getIndexInfo = require("./index.cjs21.js");
+const createIndex = require("./index.cjs21.js");
+const getIndexInfo = require("./index.cjs22.js");
 const deepClone = require("./index.cjs19.js");
 const EventEmitter = require("./index.cjs9.js");
 const isEqual = require("./index.cjs6.js");
-const match = require("./index.cjs22.js");
+const match = require("./index.cjs23.js");
 const modify = require("./index.cjs7.js");
-const project = require("./index.cjs23.js");
-const queryId = require("./index.cjs24.js");
+const project = require("./index.cjs24.js");
+const queryId = require("./index.cjs20.js");
 const serializeValue = require("./index.cjs11.js");
 const sortItems = require("./index.cjs25.js");
 function hasPendingUpdates(pendingUpdates) {
@@ -143,14 +143,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);
@@ -162,6 +176,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);
@@ -207,7 +222,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.default(item), restModifier);
           const hasItemWithSameId = item.id !== modifiedItem.id && this.getItem(collection, { id: modifiedItem.id }) != null;
@@ -263,7 +278,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));
         });
@@ -283,10 +298,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))
@@ -299,7 +311,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);
         };
@@ -310,14 +322,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);

package/dist/index.cjs13.js

@@ -1,13 +1,13 @@
 "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");
 class AsyncDataAdapter {
   options;
   id;
@@ -120,6 +120,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);
@@ -135,11 +142,8 @@ 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 storage.setup();
+    await Promise.all(indices.map((index) => storage.createIndex(index)));
   }
   ensureStorageAdapter(name) {
     if (this.storageAdapters.has(name))
@@ -200,20 +204,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.default(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);
@@ -315,8 +327,8 @@ class AsyncDataAdapter {
     const storage = this.storageAdapters.get(collectionName);
     if (!storage)
       throw new Error(`No persistence adapter for collection ${collectionName}`);
-    const existing = await this.executeQuery(collectionName, { id: newItem.id }, { limit: 1 });
-    if (existing.length > 0)
+    const existingItems = await storage.readIds([newItem.id]);
+    if (existingItems.length > 0)
       throw new Error(`Item with id ${String(newItem.id)} already exists`);
     await storage.insert([newItem]);
     await this.checkQueryUpdates(collectionName, [newItem]);