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

package/dist/.vite/manifest.json

@@ -120,7 +120,7 @@
     ]
   },
   "src/createIndexProvider.ts": {
-    "file": "index.cjs30.js",
+    "file": "index.cjs33.js",
     "name": "createIndexProvider",
     "src": "src/createIndexProvider.ts"
   },
@@ -205,7 +205,7 @@
     ]
   },
   "src/utils/intersection.ts": {
-    "file": "index.cjs31.js",
+    "file": "index.cjs30.js",
     "name": "utils/intersection",
     "src": "src/utils/intersection.ts"
   },
@@ -215,7 +215,7 @@
     "src": "src/utils/isEqual.ts"
   },
   "src/utils/isFieldExpression.ts": {
-    "file": "index.cjs33.js",
+    "file": "index.cjs31.js",
     "name": "utils/isFieldExpression",
     "src": "src/utils/isFieldExpression.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,7 +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>;
+    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;
     /**
@@ -120,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
@@ -184,6 +186,7 @@ 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;
@@ -202,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[]>;
@@ -25,10 +26,10 @@ export interface CollectionBackend<T extends BaseItem<I>, I> {
     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: (state: 'active' | 'complete' | 'error') => void): () => void;
+    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

@@ -28,6 +28,6 @@ export default class DefaultDataAdapter implements DataAdapter {
     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

@@ -20,6 +20,6 @@ export default class WorkerDataAdapter implements DataAdapter {
     private exec;
     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/index.cjs12.js

@@ -324,7 +324,10 @@ class DefaultDataAdapter {
       getQueryResult: (selector, options) => {
         const isQueryActive = this.activeQueries.get(collection.name)?.has(queryId(selector, options));
         if (isQueryActive) {
-          return this.cachedQueryResults.get(collection.name)?.get(queryId(selector, options)) ?? [];
+          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 this.executeQuery(collection, selector, options);
       },

package/dist/index.cjs13.js

@@ -142,8 +142,8 @@ class AsyncDataAdapter {
     const storage = this.storageAdapters.get(collectionName);
     if (!storage)
       throw new Error(`No persistence adapter for collection ${collectionName}`);
-    await Promise.all(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))
@@ -327,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]);

package/dist/index.cjs14.js

@@ -91,13 +91,15 @@ class WorkerDataAdapter {
       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));
@@ -125,24 +127,6 @@ class WorkerDataAdapter {
       registerQuery: (selector, options) => {
         this.updateQuery(collection.name, { selector, options }, { state: "active", error: null, items: [] });
         void this.exec("registerQuery", collection.name, selector, options);
-      },
-      unregisterQuery: (selector, options) => {
-        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));
-        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) => {
         const handler = (event) => {
           const { type, data, workerId, error } = event.data;
           if (type !== "queryUpdate")
@@ -161,11 +145,49 @@ class WorkerDataAdapter {
             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),

package/dist/index.cjs15.js

@@ -156,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;
@@ -249,7 +251,7 @@ class WorkerDataAdapterHost {
     const existingItems = await this.executeQuery(collectionName, { id: { $in: input.map((i) => i[0].id) } });
     const result = input.map(([item]) => {
       if (item.id == null)
-        throw new Error("Item must have an id");
+        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`);
       }

package/dist/index.cjs17.js

@@ -53,7 +53,9 @@ class Observer {
   runChecks(getItems) {
     const result = getItems();
     if (result instanceof Promise) {
-      void result.then((newItems) => this.checkItems(newItems));
+      result.then((newItems) => this.checkItems(newItems)).catch((error) => {
+        console.error("Error while asynchronously querying items", error);
+      });
     } else {
       this.checkItems(result);
     }

package/dist/index.cjs19.js

@@ -36,7 +36,6 @@ function clone(value) {
 function deepClone(object) {
   if (typeof structuredClone === "function")
     return structuredClone(object);
-  /* istanbul ignore next -- @preserve */
   return clone(object);
 }
 exports.clone = clone;

package/dist/index.cjs2.js

@@ -28,6 +28,7 @@ class Cursor {
    * @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, options) {
     this.getItems = getItems;

package/dist/index.cjs20.js

@@ -1,7 +1,16 @@
 "use strict";
+function isEmptyOptions(options) {
+  if (options == null)
+    return true;
+  if (typeof options !== "object")
+    return false;
+  if (Array.isArray(options))
+    return false;
+  return Object.keys(options).length === 0;
+}
 function queryId(selector, options) {
   const selectorId = JSON.stringify(selector);
-  const optionsId = options == null ? -1 : JSON.stringify(options);
+  const optionsId = isEmptyOptions(options) ? -1 : JSON.stringify(options);
   return `${selectorId}:${optionsId}`;
 }
 module.exports = queryId;

package/dist/index.cjs21.js

@@ -1,5 +1,5 @@
 "use strict";
-const createIndexProvider = require("./index.cjs30.js");
+const createIndexProvider = require("./index.cjs33.js");
 const get = require("./index.cjs10.js");
 const getMatchingKeys = require("./index.cjs26.js");
 const serializeValue = require("./index.cjs11.js");

package/dist/index.cjs22.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
-const intersection = require("./index.cjs31.js");
+const intersection = require("./index.cjs30.js");
 function getMergedIndexInfo(queryFunctions, selector) {
   return queryFunctions.reduce((memoOrPromise, queryFunction) => {
     const resultOrPromise = queryFunction(selector);

package/dist/index.cjs26.js

@@ -1,5 +1,5 @@
 "use strict";
-const isFieldExpression = require("./index.cjs33.js");
+const isFieldExpression = require("./index.cjs31.js");
 const serializeValue = require("./index.cjs11.js");
 function getMatchingKeys(field, selector) {
   const result = { include: null, exclude: null };

package/dist/index.cjs3.js

@@ -194,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) {
@@ -254,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,

package/dist/index.cjs30.js

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

package/dist/index.cjs31.js

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

package/dist/index.cjs33.js

@@ -1,42 +1,5 @@
 "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;
+function createIndexProvider(definition) {
+  return definition;
 }
-module.exports = isFieldExpression;
+module.exports = createIndexProvider;

package/dist/index.d.ts

@@ -2,7 +2,7 @@ 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';

package/dist/index12.mjs

@@ -323,7 +323,10 @@ class DefaultDataAdapter {
       getQueryResult: (selector, options) => {
         const isQueryActive = this.activeQueries.get(collection.name)?.has(queryId(selector, options));
         if (isQueryActive) {
-          return this.cachedQueryResults.get(collection.name)?.get(queryId(selector, options)) ?? [];
+          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 this.executeQuery(collection, selector, options);
       },

package/dist/index13.mjs

@@ -141,8 +141,8 @@ class AsyncDataAdapter {
     const storage = this.storageAdapters.get(collectionName);
     if (!storage)
       throw new Error(`No persistence adapter for collection ${collectionName}`);
-    await Promise.all(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))
@@ -326,8 +326,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]);

package/dist/index14.mjs

@@ -90,13 +90,15 @@ class WorkerDataAdapter {
       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));
@@ -124,24 +126,6 @@ class WorkerDataAdapter {
       registerQuery: (selector, options) => {
         this.updateQuery(collection.name, { selector, options }, { state: "active", error: null, items: [] });
         void this.exec("registerQuery", collection.name, selector, options);
-      },
-      unregisterQuery: (selector, options) => {
-        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));
-        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) => {
         const handler = (event) => {
           const { type, data, workerId, error } = event.data;
           if (type !== "queryUpdate")
@@ -160,11 +144,49 @@ class WorkerDataAdapter {
             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),

package/dist/index15.mjs

@@ -155,6 +155,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;
@@ -248,7 +250,7 @@ class WorkerDataAdapterHost {
     const existingItems = await this.executeQuery(collectionName, { id: { $in: input.map((i) => i[0].id) } });
     const result = input.map(([item]) => {
       if (item.id == null)
-        throw new Error("Item must have an id");
+        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`);
       }

package/dist/index17.mjs

@@ -52,7 +52,9 @@ class Observer {
   runChecks(getItems) {
     const result = getItems();
     if (result instanceof Promise) {
-      void result.then((newItems) => this.checkItems(newItems));
+      result.then((newItems) => this.checkItems(newItems)).catch((error) => {
+        console.error("Error while asynchronously querying items", error);
+      });
     } else {
       this.checkItems(result);
     }

package/dist/index19.mjs

@@ -34,7 +34,6 @@ function clone(value) {
 function deepClone(object) {
   if (typeof structuredClone === "function")
     return structuredClone(object);
-  /* istanbul ignore next -- @preserve */
   return clone(object);
 }
 export {

package/dist/index2.mjs

@@ -26,6 +26,7 @@ class Cursor {
    * @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, options) {
     this.getItems = getItems;

package/dist/index20.mjs

@@ -1,6 +1,15 @@
+function isEmptyOptions(options) {
+  if (options == null)
+    return true;
+  if (typeof options !== "object")
+    return false;
+  if (Array.isArray(options))
+    return false;
+  return Object.keys(options).length === 0;
+}
 function queryId(selector, options) {
   const selectorId = JSON.stringify(selector);
-  const optionsId = options == null ? -1 : JSON.stringify(options);
+  const optionsId = isEmptyOptions(options) ? -1 : JSON.stringify(options);
   return `${selectorId}:${optionsId}`;
 }
 export {

package/dist/index21.mjs

@@ -1,4 +1,4 @@
-import createIndexProvider from "./index30.mjs";
+import createIndexProvider from "./index33.mjs";
 import get from "./index10.mjs";
 import getMatchingKeys from "./index26.mjs";
 import serializeValue from "./index11.mjs";

package/dist/index22.mjs

@@ -1,4 +1,4 @@
-import intersection from "./index31.mjs";
+import intersection from "./index30.mjs";
 function getMergedIndexInfo(queryFunctions, selector) {
   return queryFunctions.reduce((memoOrPromise, queryFunction) => {
     const resultOrPromise = queryFunction(selector);

package/dist/index26.mjs

@@ -1,4 +1,4 @@
-import isFieldExpression from "./index33.mjs";
+import isFieldExpression from "./index31.mjs";
 import serializeValue from "./index11.mjs";
 function getMatchingKeys(field, selector) {
   const result = { include: null, exclude: null };

package/dist/index3.mjs

@@ -192,6 +192,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(items), fields);
+  }
   getItem(selector, options) {
     const itemsOrPromise = this.getItems(selector, { ...options, limit: 1 });
     if (itemsOrPromise instanceof Promise) {
@@ -252,7 +257,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((() => 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(getTransformedItems, {
       reactive: this.options.reactivity,
       fieldTracking: this.fieldTracking,
       ...options,

package/dist/index30.mjs

@@ -1,6 +1,8 @@
-function createIndexProvider(definition) {
-  return definition;
+function intersection(...arrays) {
+  if (arrays.length === 0)
+    return [];
+  return [...new Set(arrays.reduce((a, b) => a.filter((c) => b.includes(c))))];
 }
 export {
-  createIndexProvider as default
+  intersection as default
 };

package/dist/index31.mjs

@@ -1,8 +1,43 @@
-function intersection(...arrays) {
-  if (arrays.length === 0)
-    return [];
-  return [...new Set(arrays.reduce((a, b) => a.filter((c) => b.includes(c))))];
+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;
 }
 export {
-  intersection as default
+  isFieldExpression as default
 };

package/dist/index33.mjs

@@ -1,43 +1,6 @@
-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;
+function createIndexProvider(definition) {
+  return definition;
 }
 export {
-  isFieldExpression as default
+  createIndexProvider as default
 };

package/dist/utils/deepClone.d.ts

@@ -4,7 +4,7 @@
  * @template T - The type of the value to clone.
  * @param value - The value to deep clone.
  * @returns A deep copy of the provided value.
- * @throws An error if the value is a function, as cloning functions is not supported.
+ * @throws {Error} An error if the value is a function, as cloning functions is not supported.
  */
 export declare function clone<T>(value: T): T;
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@signaldb/core",
-  "version": "2.0.0-beta.1",
+  "version": "2.0.0-beta.3",
   "description": "SignalDB is a client-side database that provides a simple MongoDB-like interface to the data with first-class typescript support to achieve an optimistic UI. Data persistence can be achieved by using storage providers that store the data through a JSON interface to places such as localStorage.",
   "scripts": {
     "build": "rimraf dist && vite build",
@@ -55,9 +55,9 @@
   ],
   "dependencies": {
     "fast-sort": "^3.4.1",
-    "mingo": "^6.5.1"
+    "mingo": "^7.1.1"
   },
   "devDependencies": {
-    "zod": "^4.0.14"
+    "zod": "^4.3.5"
   }
 }