@signaldb/core 1.7.2 → 1.8.0

package/dist/index.cjs2.js

@@ -2,7 +2,8 @@
 Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
 const sortItems = require("./index.cjs15.js");
 const project = require("./index.cjs16.js");
-const Observer = require("./index.cjs17.js");
+const deepClone = require("./index.cjs17.js");
+const Observer = require("./index.cjs18.js");
 function isInReactiveScope(reactivity) {
   if (!reactivity)
     return false;
@@ -30,6 +31,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.getFilteredItems = getItems;
@@ -65,12 +67,16 @@ class Cursor {
   }
   getItems() {
     const items = this.getFilteredItems();
-    const { sort, skip, limit } = this.options;
+    const { sort, skip, limit, transformAll, fields } = this.options;
     const sorted = sort ? sortItems(items, sort) : items;
     const skipped = skip ? sorted.slice(skip) : sorted;
     const limited = limit ? skipped.slice(0, limit) : skipped;
     const idExcluded = this.options.fields && this.options.fields.id === 0;
-    return limited.map((item) => {
+    let entries = limited;
+    if (transformAll) {
+      entries = transformAll(deepClone.default(limited), fields);
+    }
+    return entries.map((item) => {
       if (!this.options.fields)
         return item;
       return {

package/dist/index.cjs3.js

@@ -1,11 +1,11 @@
 "use strict";
 Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
 const EventEmitter = require("./index.cjs13.js");
-const match = require("./index.cjs18.js");
+const match = require("./index.cjs19.js");
 const modify = require("./index.cjs11.js");
 const isEqual = require("./index.cjs10.js");
 const randomId = require("./index.cjs12.js");
-const deepClone = require("./index.cjs19.js");
+const deepClone = require("./index.cjs17.js");
 const serializeValue = require("./index.cjs20.js");
 const createSignal = require("./index.cjs21.js");
 const Cursor = require("./index.cjs2.js");
@@ -94,6 +94,7 @@ class Collection extends EventEmitter {
   postBatchCallbacks = /* @__PURE__ */ new Set();
   fieldTracking = false;
   persistenceReadyPromise;
+  pendingUpdates = { added: [], modified: [], removed: [] };
   /**
    * Initializes a new instance of the `Collection` class with optional configuration.
    * Sets up memory, persistence, reactivity, and indices as specified in the options.
@@ -109,6 +110,7 @@ class Collection extends EventEmitter {
    * @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) {
     super();
@@ -143,48 +145,6 @@ class Collection extends EventEmitter {
     if (this.persistenceAdapter) {
       let ongoingSaves = 0;
       let isInitialized = false;
-      const pendingUpdates = { added: [], modified: [], removed: [] };
-      const loadPersistentData = async (data) => {
-        if (!this.persistenceAdapter)
-          throw new Error("Persistence adapter not found");
-        this.emit("persistence.pullStarted");
-        const { items, changes } = data ?? await this.persistenceAdapter.load();
-        if (items) {
-          if (ongoingSaves > 0)
-            return;
-          this.memory().splice(0, this.memoryArray().length, ...items);
-          this.idIndex.clear();
-          this.memory().map((item, index) => {
-            this.idIndex.set(serializeValue(item.id), /* @__PURE__ */ new Set([index]));
-          });
-        } else if (changes) {
-          changes.added.forEach((item) => {
-            const index = this.memory().findIndex((document) => document.id === item.id);
-            if (index !== -1) {
-              this.memory().splice(index, 1, item);
-              return;
-            }
-            this.memory().push(item);
-            const itemIndex = this.memory().findIndex((document) => document === item);
-            this.idIndex.set(serializeValue(item.id), /* @__PURE__ */ new Set([itemIndex]));
-          });
-          changes.modified.forEach((item) => {
-            const index = this.memory().findIndex((document) => document.id === item.id);
-            if (index === -1)
-              throw new Error("Cannot resolve index for item");
-            this.memory().splice(index, 1, item);
-          });
-          changes.removed.forEach((item) => {
-            const index = this.memory().findIndex((document) => document.id === item.id);
-            if (index === -1)
-              throw new Error("Cannot resolve index for item");
-            this.memory().splice(index, 1);
-          });
-        }
-        this.rebuildIndices();
-        this.emit("persistence.received");
-        setTimeout(() => this.emit("persistence.pullCompleted"), 0);
-      };
       const saveQueue = {
         added: [],
         modified: [],
@@ -221,7 +181,7 @@ class Collection extends EventEmitter {
       };
       this.on("added", (item) => {
         if (!isInitialized) {
-          pendingUpdates.added.push(item);
+          this.pendingUpdates.added.push(item);
           return;
         }
         saveQueue.added.push(item);
@@ -229,7 +189,7 @@ class Collection extends EventEmitter {
       });
       this.on("changed", (item) => {
         if (!isInitialized) {
-          pendingUpdates.modified.push(item);
+          this.pendingUpdates.modified.push(item);
           return;
         }
         saveQueue.modified.push(item);
@@ -237,27 +197,27 @@ class Collection extends EventEmitter {
       });
       this.on("removed", (item) => {
         if (!isInitialized) {
-          pendingUpdates.removed.push(item);
+          this.pendingUpdates.removed.push(item);
           return;
         }
         saveQueue.removed.push(item);
         flushQueue();
       });
-      this.persistenceAdapter.register((data) => loadPersistentData(data)).then(async () => {
+      this.persistenceAdapter.register((data) => this.loadPersistentData(data, ongoingSaves > 0)).then(async () => {
         if (!this.persistenceAdapter)
           throw new Error("Persistence adapter not found");
         let currentItems = this.memoryArray();
-        await loadPersistentData();
-        while (hasPendingUpdates(pendingUpdates)) {
-          const added = pendingUpdates.added.splice(0);
-          const modified = pendingUpdates.modified.splice(0);
-          const removed = pendingUpdates.removed.splice(0);
+        await this.loadPersistentData();
+        while (hasPendingUpdates(this.pendingUpdates)) {
+          const added = this.pendingUpdates.added.splice(0);
+          const modified = this.pendingUpdates.modified.splice(0);
+          const removed = this.pendingUpdates.removed.splice(0);
           currentItems = applyUpdates(this.memoryArray(), { added, modified, removed });
           await this.persistenceAdapter.save(currentItems, { added, modified, removed }).then(() => {
             this.emit("persistence.transmitted");
           });
         }
-        await loadPersistentData();
+        await this.loadPersistentData();
         isInitialized = true;
         setTimeout(() => this.emit("persistence.init"), 0);
       }).catch((error) => {
@@ -272,6 +232,66 @@ class Collection extends EventEmitter {
     });
     Collection.onCreationCallbacks.forEach((callback) => callback(this));
   }
+  /**
+   * Resets the collection's data by clearing the in-memory items and reloading from the persistence adapter.
+   * @returns A promise that resolves when the data has been reset and reloaded.
+   */
+  async resetData() {
+    if (hasPendingUpdates(this.pendingUpdates)) {
+      await new Promise((resolve) => {
+        this.on("persistence.transmitted", resolve);
+      });
+    }
+    this.options.memory = [];
+    await this.loadPersistentData();
+  }
+  /**
+   * Loads data from the persistence adapter and updates the in-memory collection accordingly.
+   * @param data - Optional data to load, containing either a full list of items or a set of changes. If not provided, data will be loaded from the persistence adapter.
+   * @param hasOngoingSaves - A boolean indicating whether there are ongoing save operations. If `true`, the method will skip loading data to avoid conflicts with pending updates.
+   * @returns A promise that resolves when the data has been loaded and the in-memory collection has been updated.
+   */
+  async loadPersistentData(data, hasOngoingSaves = false) {
+    if (!this.persistenceAdapter)
+      throw new Error("Persistence adapter not found");
+    this.emit("persistence.pullStarted");
+    const { items, changes } = data ?? await this.persistenceAdapter.load();
+    if (items) {
+      if (hasOngoingSaves)
+        return;
+      this.memory().splice(0, this.memoryArray().length, ...items);
+      this.idIndex.clear();
+      this.memory().map((item, index) => {
+        this.idIndex.set(serializeValue(item.id), /* @__PURE__ */ new Set([index]));
+      });
+    } else if (changes) {
+      changes.added.forEach((item) => {
+        const index = this.memory().findIndex((document) => document.id === item.id);
+        if (index !== -1) {
+          this.memory().splice(index, 1, item);
+          return;
+        }
+        this.memory().push(item);
+        const itemIndex = this.memory().findIndex((document) => document === item);
+        this.idIndex.set(serializeValue(item.id), /* @__PURE__ */ new Set([itemIndex]));
+      });
+      changes.modified.forEach((item) => {
+        const index = this.memory().findIndex((document) => document.id === item.id);
+        if (index === -1)
+          throw new Error("Cannot resolve index for item");
+        this.memory().splice(index, 1, item);
+      });
+      changes.removed.forEach((item) => {
+        const index = this.memory().findIndex((document) => document.id === item.id);
+        if (index === -1)
+          throw new Error("Cannot resolve index for item");
+        this.memory().splice(index, 1);
+      });
+    }
+    this.rebuildIndices();
+    this.emit("persistence.received");
+    setTimeout(() => this.emit("persistence.pullCompleted"), 0);
+  }
   /**
    * Checks whether the collection is currently performing a pull operation
    * ⚡️ this function is reactive!
@@ -426,6 +446,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(items, fields);
+  }
   getItems(selector) {
     return this.profile(() => {
       const indexInfo = this.getIndexInfo(selector);
@@ -485,6 +510,7 @@ class Collection extends EventEmitter {
       fieldTracking: this.fieldTracking,
       ...options,
       transform: this.transform.bind(this),
+      transformAll: this.transformAll.bind(this),
       bindEvents: (requery) => {
         const handleRequery = () => {
           if (this.batchOperationInProgress) {

package/dist/index.d.ts

@@ -3,7 +3,7 @@ export type { default as MemoryAdapter } from './types/MemoryAdapter';
 export type { default as PersistenceAdapter, Changeset, LoadResponse, } from './types/PersistenceAdapter';
 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 { default as Cursor } from './Collection/Cursor';
 export { default as Collection, createIndex } from './Collection';
 export { default as AutoFetchCollection } from './AutoFetchCollection';

package/dist/index11.mjs

@@ -1,5 +1,5 @@
 import { update } from "mingo";
-import deepClone from "./index19.mjs";
+import deepClone from "./index17.mjs";
 function modify(item, modifier) {
   const hasOperators = Object.keys(modifier).some((key) => key.startsWith("$"));
   if (!hasOperators)

package/dist/index17.mjs

@@ -1,143 +1,42 @@
-import isEqual from "./index10.mjs";
-import uniqueBy from "./index26.mjs";
-class Observer {
-  previousItems = [];
-  callbacks;
-  unbindEvents;
-  /**
-   * Creates a new instance of the `Observer` class.
-   * Sets up event bindings and initializes the callbacks for tracking changes in a collection.
-   * @param bindEvents - A function to bind external events to the observer. Must return a cleanup function to unbind those events.
-   */
-  constructor(bindEvents) {
-    this.callbacks = {
-      added: [],
-      addedBefore: [],
-      changed: [],
-      changedField: [],
-      movedBefore: [],
-      removed: []
-    };
-    this.unbindEvents = bindEvents();
-  }
-  call(event, ...args) {
-    this.callbacks[event].forEach(({ callback, options }) => {
-      if (!options.skipInitial || !options.isInitial) {
-        callback(...args);
-      }
-    });
-  }
-  hasCallbacks(events) {
-    return events.some((event) => this.callbacks[event].length > 0);
-  }
-  /**
-   * Determines if the observer has no active callbacks registered for any events.
-   * @returns A boolean indicating whether the observer is empty (i.e., no callbacks are registered).
-   */
-  isEmpty() {
-    return !this.hasCallbacks([
-      "added",
-      "addedBefore",
-      "changed",
-      "changedField",
-      "movedBefore",
-      "removed"
-    ]);
-  }
-  /**
-   * Compares the previous state of items with the new state and triggers the appropriate callbacks
-   * for events such as added, removed, changed, or moved items.
-   * @param newItems - The new list of items to compare against the previous state.
-   */
-  runChecks(newItems) {
-    const oldItemsMap = new Map(this.previousItems.map((item, index) => [
-      item.id,
-      { item, index, beforeItem: this.previousItems[index + 1] || null }
-    ]));
-    const newItemsMap = new Map(newItems.map((item, index) => [
-      item.id,
-      { item, index, beforeItem: newItems[index + 1] || null }
-    ]));
-    if (this.hasCallbacks(["changed", "changedField", "movedBefore", "removed"])) {
-      oldItemsMap.forEach(({ item: oldItem, index, beforeItem: oldBeforeItem }) => {
-        const newItem = newItemsMap.get(oldItem.id);
-        if (newItem) {
-          if (this.hasCallbacks(["changed", "changedField"]) && !isEqual(newItem.item, oldItem)) {
-            this.call("changed", newItem.item);
-            if (this.hasCallbacks(["changedField"])) {
-              const keys = uniqueBy([
-                ...Object.keys(newItem.item),
-                ...Object.keys(oldItem)
-              ], (value) => value);
-              keys.forEach((key) => {
-                if (isEqual(newItem.item[key], oldItem[key]))
-                  return;
-                this.call("changedField", newItem.item, key, oldItem[key], newItem.item[key]);
-              });
-            }
-          }
-          if (newItem.index !== index && newItem.beforeItem?.id !== oldBeforeItem?.id) {
-            this.call("movedBefore", newItem.item, newItem.beforeItem);
-          }
-        } else {
-          this.call("removed", oldItem);
-        }
-      });
-    }
-    if (this.hasCallbacks(["added", "addedBefore"])) {
-      newItems.forEach((newItem, index) => {
-        const oldItem = oldItemsMap.get(newItem.id);
-        if (oldItem)
-          return;
-        this.call("added", newItem);
-        this.call("addedBefore", newItem, newItems[index + 1] || null);
-      });
-    }
-    this.previousItems = newItems;
-    Object.keys(this.callbacks).forEach((key) => {
-      const event = key;
-      const callbacks = this.callbacks[event];
-      this.callbacks[event] = callbacks.map((callback) => ({
-        ...callback,
-        options: {
-          ...callback.options,
-          isInitial: false
-        }
-      }));
-    });
-  }
-  /**
-   * Stops the observer by unbinding all events and cleaning up resources.
-   */
-  stop() {
-    this.unbindEvents();
-  }
-  /**
-   * Registers callbacks for specific events to observe changes in the collection.
-   * @param callbacks - An object containing the callbacks for various events (e.g., 'added', 'removed').
-   * @param skipInitial - A boolean indicating whether to skip invoking the callbacks for the initial state of the collection.
-   */
-  addCallbacks(callbacks, skipInitial = false) {
-    Object.keys(callbacks).forEach((key) => {
-      const typedKey = key;
-      this.callbacks[typedKey].push({
-        callback: callbacks[typedKey],
-        options: { skipInitial, isInitial: true }
-      });
+function clone(value) {
+  if (typeof value === "function")
+    throw new Error("Cloning functions is not supported");
+  if (value === null || typeof value !== "object")
+    return value;
+  if (value instanceof Date)
+    return new Date(value);
+  if (Array.isArray(value))
+    return value.map((item) => clone(item));
+  if (value instanceof Map) {
+    const result2 = /* @__PURE__ */ new Map();
+    value.forEach((currentValue, key) => {
+      result2.set(key, clone(currentValue));
     });
+    return result2;
   }
-  /**
-   * Removes the specified callbacks for specific events, unregistering them from the observer.
-   * @param callbacks - An object containing the callbacks to be removed for various events.
-   */
-  removeCallbacks(callbacks) {
-    Object.keys(callbacks).forEach((key) => {
-      const typedKey = key;
-      const index = this.callbacks[typedKey].findIndex(({ callback }) => callback === callbacks[typedKey]);
-      this.callbacks[typedKey].splice(index, 1);
+  if (value instanceof Set) {
+    const result2 = /* @__PURE__ */ new Set();
+    value.forEach((currentValue) => {
+      result2.add(clone(currentValue));
     });
+    return result2;
+  }
+  if (value instanceof RegExp)
+    return new RegExp(value);
+  const result = {};
+  for (const key in value) {
+    if (Object.hasOwnProperty.call(value, key)) {
+      result[key] = clone(value[key]);
+    }
   }
+  return result;
+}
+function deepClone(object) {
+  if (typeof structuredClone === "function")
+    return structuredClone(object);
+  return clone(object);
 }
 export {
-  Observer as default
+  clone,
+  deepClone as default
 };

package/dist/index18.mjs

@@ -1,8 +1,143 @@
-import { Query } from "mingo";
-function match(item, selector) {
-  const query = new Query(selector);
-  return query.test(item);
+import isEqual from "./index10.mjs";
+import uniqueBy from "./index26.mjs";
+class Observer {
+  previousItems = [];
+  callbacks;
+  unbindEvents;
+  /**
+   * Creates a new instance of the `Observer` class.
+   * Sets up event bindings and initializes the callbacks for tracking changes in a collection.
+   * @param bindEvents - A function to bind external events to the observer. Must return a cleanup function to unbind those events.
+   */
+  constructor(bindEvents) {
+    this.callbacks = {
+      added: [],
+      addedBefore: [],
+      changed: [],
+      changedField: [],
+      movedBefore: [],
+      removed: []
+    };
+    this.unbindEvents = bindEvents();
+  }
+  call(event, ...args) {
+    this.callbacks[event].forEach(({ callback, options }) => {
+      if (!options.skipInitial || !options.isInitial) {
+        callback(...args);
+      }
+    });
+  }
+  hasCallbacks(events) {
+    return events.some((event) => this.callbacks[event].length > 0);
+  }
+  /**
+   * Determines if the observer has no active callbacks registered for any events.
+   * @returns A boolean indicating whether the observer is empty (i.e., no callbacks are registered).
+   */
+  isEmpty() {
+    return !this.hasCallbacks([
+      "added",
+      "addedBefore",
+      "changed",
+      "changedField",
+      "movedBefore",
+      "removed"
+    ]);
+  }
+  /**
+   * Compares the previous state of items with the new state and triggers the appropriate callbacks
+   * for events such as added, removed, changed, or moved items.
+   * @param newItems - The new list of items to compare against the previous state.
+   */
+  runChecks(newItems) {
+    const oldItemsMap = new Map(this.previousItems.map((item, index) => [
+      item.id,
+      { item, index, beforeItem: this.previousItems[index + 1] || null }
+    ]));
+    const newItemsMap = new Map(newItems.map((item, index) => [
+      item.id,
+      { item, index, beforeItem: newItems[index + 1] || null }
+    ]));
+    if (this.hasCallbacks(["changed", "changedField", "movedBefore", "removed"])) {
+      oldItemsMap.forEach(({ item: oldItem, index, beforeItem: oldBeforeItem }) => {
+        const newItem = newItemsMap.get(oldItem.id);
+        if (newItem) {
+          if (this.hasCallbacks(["changed", "changedField"]) && !isEqual(newItem.item, oldItem)) {
+            this.call("changed", newItem.item);
+            if (this.hasCallbacks(["changedField"])) {
+              const keys = uniqueBy([
+                ...Object.keys(newItem.item),
+                ...Object.keys(oldItem)
+              ], (value) => value);
+              keys.forEach((key) => {
+                if (isEqual(newItem.item[key], oldItem[key]))
+                  return;
+                this.call("changedField", newItem.item, key, oldItem[key], newItem.item[key]);
+              });
+            }
+          }
+          if (newItem.index !== index && newItem.beforeItem?.id !== oldBeforeItem?.id) {
+            this.call("movedBefore", newItem.item, newItem.beforeItem);
+          }
+        } else {
+          this.call("removed", oldItem);
+        }
+      });
+    }
+    if (this.hasCallbacks(["added", "addedBefore"])) {
+      newItems.forEach((newItem, index) => {
+        const oldItem = oldItemsMap.get(newItem.id);
+        if (oldItem)
+          return;
+        this.call("added", newItem);
+        this.call("addedBefore", newItem, newItems[index + 1] || null);
+      });
+    }
+    this.previousItems = newItems;
+    Object.keys(this.callbacks).forEach((key) => {
+      const event = key;
+      const callbacks = this.callbacks[event];
+      this.callbacks[event] = callbacks.map((callback) => ({
+        ...callback,
+        options: {
+          ...callback.options,
+          isInitial: false
+        }
+      }));
+    });
+  }
+  /**
+   * Stops the observer by unbinding all events and cleaning up resources.
+   */
+  stop() {
+    this.unbindEvents();
+  }
+  /**
+   * Registers callbacks for specific events to observe changes in the collection.
+   * @param callbacks - An object containing the callbacks for various events (e.g., 'added', 'removed').
+   * @param skipInitial - A boolean indicating whether to skip invoking the callbacks for the initial state of the collection.
+   */
+  addCallbacks(callbacks, skipInitial = false) {
+    Object.keys(callbacks).forEach((key) => {
+      const typedKey = key;
+      this.callbacks[typedKey].push({
+        callback: callbacks[typedKey],
+        options: { skipInitial, isInitial: true }
+      });
+    });
+  }
+  /**
+   * Removes the specified callbacks for specific events, unregistering them from the observer.
+   * @param callbacks - An object containing the callbacks to be removed for various events.
+   */
+  removeCallbacks(callbacks) {
+    Object.keys(callbacks).forEach((key) => {
+      const typedKey = key;
+      const index = this.callbacks[typedKey].findIndex(({ callback }) => callback === callbacks[typedKey]);
+      this.callbacks[typedKey].splice(index, 1);
+    });
+  }
 }
 export {
-  match as default
+  Observer as default
 };

package/dist/index19.mjs

@@ -1,42 +1,8 @@
-function clone(value) {
-  if (typeof value === "function")
-    throw new Error("Cloning functions is not supported");
-  if (value === null || typeof value !== "object")
-    return value;
-  if (value instanceof Date)
-    return new Date(value);
-  if (Array.isArray(value))
-    return value.map((item) => clone(item));
-  if (value instanceof Map) {
-    const result2 = /* @__PURE__ */ new Map();
-    value.forEach((currentValue, key) => {
-      result2.set(key, clone(currentValue));
-    });
-    return result2;
-  }
-  if (value instanceof Set) {
-    const result2 = /* @__PURE__ */ new Set();
-    value.forEach((currentValue) => {
-      result2.add(clone(currentValue));
-    });
-    return result2;
-  }
-  if (value instanceof RegExp)
-    return new RegExp(value);
-  const result = {};
-  for (const key in value) {
-    if (Object.hasOwnProperty.call(value, key)) {
-      result[key] = clone(value[key]);
-    }
-  }
-  return result;
-}
-function deepClone(object) {
-  if (typeof structuredClone === "function")
-    return structuredClone(object);
-  return clone(object);
+import { Query } from "mingo";
+function match(item, selector) {
+  const query = new Query(selector);
+  return query.test(item);
 }
 export {
-  clone,
-  deepClone as default
+  match as default
 };

package/dist/index2.mjs

@@ -1,6 +1,7 @@
 import sortItems from "./index15.mjs";
 import project from "./index16.mjs";
-import Observer from "./index17.mjs";
+import deepClone from "./index17.mjs";
+import Observer from "./index18.mjs";
 function isInReactiveScope(reactivity) {
   if (!reactivity)
     return false;
@@ -28,6 +29,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.getFilteredItems = getItems;
@@ -63,12 +65,16 @@ class Cursor {
   }
   getItems() {
     const items = this.getFilteredItems();
-    const { sort, skip, limit } = this.options;
+    const { sort, skip, limit, transformAll, fields } = this.options;
     const sorted = sort ? sortItems(items, sort) : items;
     const skipped = skip ? sorted.slice(skip) : sorted;
     const limited = limit ? skipped.slice(0, limit) : skipped;
     const idExcluded = this.options.fields && this.options.fields.id === 0;
-    return limited.map((item) => {
+    let entries = limited;
+    if (transformAll) {
+      entries = transformAll(deepClone(limited), fields);
+    }
+    return entries.map((item) => {
       if (!this.options.fields)
         return item;
       return {