joist-core 2.0.3 → 2.1.0

package/build/EntityManager.js

@@ -22,10 +22,13 @@ exports.appendStack = appendStack;
 exports.createRowFromEntityData = createRowFromEntityData;
 const dataloader_1 = __importDefault(require("dataloader"));
 const BaseEntity_1 = require("./BaseEntity");
+const BatchLoader_1 = require("./batchloaders/BatchLoader");
 const defaults_1 = require("./defaults");
 const fields_1 = require("./fields");
 const IndexManager_1 = require("./IndexManager");
 // We alias `Entity => EntityW` to denote "Entity wide" i.e. the non-narrowed Entity
+const loadBatchLoader_1 = require("./batchloaders/loadBatchLoader");
+const populateBatchLoader_1 = require("./batchloaders/populateBatchLoader");
 const caches_1 = require("./caches");
 const config_1 = require("./config");
 const configure_1 = require("./configure");
@@ -34,8 +37,6 @@ const findCountDataLoader_1 = require("./dataloaders/findCountDataLoader");
 const findDataLoader_1 = require("./dataloaders/findDataLoader");
 const findIdsDataLoader_1 = require("./dataloaders/findIdsDataLoader");
 const findOrCreateDataLoader_1 = require("./dataloaders/findOrCreateDataLoader");
-const loadDataLoader_1 = require("./dataloaders/loadDataLoader");
-const populateDataLoader_1 = require("./dataloaders/populateDataLoader");
 const Entity_1 = require("./Entity");
 const FlushLock_1 = require("./FlushLock");
 const index_1 = require("./index");
@@ -48,6 +49,7 @@ const ReactionsManager_1 = require("./ReactionsManager");
 const reactiveHints_1 = require("./reactiveHints");
 const relations_1 = require("./relations");
 const hasAsyncMethod_1 = require("./relations/hasAsyncMethod");
+const RecursiveCollection_1 = require("./relations/RecursiveCollection");
 const Todo_1 = require("./Todo");
 const trusted_1 = require("./trusted");
 const upsert_1 = require("./upsert");
@@ -91,7 +93,7 @@ class EntityManager {
     // Provides field-based indexing for entity types with >1000 entities to optimize findWithNewOrChanged
     #indexManager = new IndexManager_1.IndexManager();
     #isValidating = false;
-    #pendingChildren = new Map();
+    #pendingPercolate = new Map();
     #preloadedRelations = new Map();
     /**
      * Tracks cascade deletes.
@@ -103,6 +105,7 @@ class EntityManager {
      */
     #pendingDeletes = [];
     #dataloaders = {};
+    #batchLoaders = {};
     #joinRows = {};
     /** Stores any `source -> downstream` reactions to recalc during `em.flush`. */
     #rm = new ReactionsManager_1.ReactionsManager(this);
@@ -142,8 +145,9 @@ class EntityManager {
         const em = this;
         this.__api = {
             preloader: this.#preloader,
-            pendingChildren: this.#pendingChildren,
+            pendingPercolate: this.#pendingPercolate,
             mutatedCollections: new Set(),
+            pendingLoads: new Set(),
             hooks: this.#hooks,
             rm: this.#rm,
             indexManager: this.#indexManager,
@@ -181,6 +185,7 @@ class EntityManager {
             },
             clearDataloaders() {
                 em.#dataloaders = {};
+                em.#batchLoaders = {};
             },
             clearPreloadedRelations() {
                 em.#preloadedRelations = new Map();
@@ -194,6 +199,38 @@ class EntityManager {
     get entities() {
         return [...this.#entitiesArray];
     }
+    /** Returns a list of all pending creates, updates, deletes, and m2m changes that would be flushed. */
+    get pendingChanges() {
+        const changes = [];
+        for (const entity of this.#entitiesArray) {
+            const op = (0, BaseEntity_1.getInstanceData)(entity).pendingOperation;
+            switch (op) {
+                case "insert":
+                    changes.push({ kind: "create", entity });
+                    break;
+                case "update":
+                    changes.push({ kind: "update", entity });
+                    break;
+                case "delete":
+                    changes.push({ kind: "delete", entity });
+                    break;
+            }
+        }
+        for (const joinRows of Object.values(this.#joinRows)) {
+            const todo = joinRows.toTodo();
+            if (todo) {
+                for (const row of todo.newRows) {
+                    const entities = Object.values(row.columns);
+                    changes.push({ kind: "m2m", op: "add", joinTableName: todo.m2m.joinTableName, entities });
+                }
+                for (const row of todo.deletedRows) {
+                    const entities = Object.values(row.columns);
+                    changes.push({ kind: "m2m", op: "remove", joinTableName: todo.m2m.joinTableName, entities });
+                }
+            }
+        }
+        return changes;
+    }
     /** Returns a read-only list of the currently-loaded entities of `type`. */
     getEntities(type) {
         const meta = (0, index_1.getMetadata)(type);
@@ -602,15 +639,18 @@ class EntityManager {
             id = id || (0, utils_1.fail)(`Invalid ${typeOrId.name} id: ${id}`);
         }
         const meta = (0, index_1.getMetadata)(type);
-        const tagged = (0, index_1.toTaggedId)(meta, id);
-        const entity = this.findExistingInstance(tagged) ||
-            (await (0, loadDataLoader_1.loadDataLoader)(this, meta)
-                .load({ entity: tagged, hint })
+        const taggedId = (0, index_1.toTaggedId)(meta, id);
+        let entity = this.findExistingInstance(taggedId);
+        if (!entity) {
+            await (0, loadBatchLoader_1.loadBatchLoader)(this, meta)
+                .load({ taggedId, hint })
                 .catch(function load(err) {
                 throw appendStack(err, new Error());
-            }));
+            });
+            entity = this.findExistingInstance(taggedId);
+        }
         if (!entity) {
-            throw new NotFoundError(`${tagged} was not found`);
+            throw new NotFoundError(`${taggedId} was not found`);
         }
         if (hint) {
             await this.populate(entity, hint);
@@ -623,16 +663,22 @@ class EntityManager {
     async loadAll(type, _ids, hint) {
         const meta = (0, index_1.getMetadata)(type);
         const ids = _ids.map((id) => (0, index_1.tagId)(meta, id));
-        const entities = await Promise.all(ids.map((id) => {
-            return (this.findExistingInstance(id) ||
-                (0, loadDataLoader_1.loadDataLoader)(this, meta)
-                    .load({ entity: id, hint })
-                    .catch(function loadAll(err) {
-                    throw appendStack(err, new Error());
-                }));
-        }));
-        const idsNotFound = ids.filter((_, i) => entities[i] === undefined);
-        if (idsNotFound.length > 0) {
+        const idsToLoad = ids.filter((id) => !this.findExistingInstance(id));
+        if (idsToLoad.length > 0) {
+            await (0, loadBatchLoader_1.loadBatchLoader)(this, meta)
+                .loadAll(idsToLoad.map((id) => ({ taggedId: id, hint })))
+                .catch(function loadAll(err) {
+                throw appendStack(err, new Error());
+            });
+        }
+        const entities = [];
+        for (const id of ids) {
+            const entity = this.findExistingInstance(id);
+            if (entity)
+                entities.push(entity);
+        }
+        if (entities.length !== ids.length) {
+            const idsNotFound = ids.filter((_, i) => entities[i] === undefined);
             throw new NotFoundError(`${idsNotFound.join(",")} were not found`);
         }
         if (hint) {
@@ -649,14 +695,15 @@ class EntityManager {
     async loadAllIfExists(type, _ids, hint) {
         const meta = (0, index_1.getMetadata)(type);
         const ids = _ids.map((id) => (0, index_1.tagId)(meta, id));
-        const entities = (await Promise.all(ids.map((id) => {
-            return (this.findExistingInstance(id) ||
-                (0, loadDataLoader_1.loadDataLoader)(this, meta)
-                    .load({ entity: id, hint })
-                    .catch(function loadAllIfExists(err) {
-                    throw appendStack(err, new Error());
-                }));
-        }))).filter(Boolean);
+        const idsToLoad = ids.filter((id) => !this.findExistingInstance(id));
+        if (idsToLoad.length > 0) {
+            await (0, loadBatchLoader_1.loadBatchLoader)(this, meta)
+                .loadAll(idsToLoad.map((id) => ({ taggedId: id, hint })))
+                .catch(function loadAllIfExists(err) {
+                throw appendStack(err, new Error());
+            });
+        }
+        const entities = ids.map((id) => this.findExistingInstance(id)).filter(Boolean);
         if (hint) {
             await this.populate(entities, hint);
         }
@@ -713,23 +760,23 @@ class EntityManager {
             // intra dependencies), then a 2nd small-batch non-preload populate.
             const [preload, non] = this.#preloader.partitionHint(meta, hintOpt);
             if (preload) {
-                const loader = (0, populateDataLoader_1.populateDataLoader)(this, meta, preload, "preload", opts);
-                await Promise.all(list.map((entity) => loader.load({ entity, hint: preload }).catch(function populate(err) {
+                const loader = (0, populateBatchLoader_1.populateBatchLoader)(this, meta, preload, "preload", opts);
+                await loader.loadAll(list.map((entity) => ({ entity, hint: preload }))).catch(function populate(err) {
                     throw appendStack(err, new Error());
-                })));
+                });
             }
             if (non) {
-                const loader = (0, populateDataLoader_1.populateDataLoader)(this, meta, non, "intermixed", opts);
-                await Promise.all(list.map((entity) => loader.load({ entity, hint: non }).catch(function populate(err) {
+                const loader = (0, populateBatchLoader_1.populateBatchLoader)(this, meta, non, "intermixed", opts);
+                await loader.loadAll(list.map((entity) => ({ entity, hint: non }))).catch(function populate(err) {
                     throw appendStack(err, new Error());
-                })));
+                });
             }
         }
         else {
-            const loader = (0, populateDataLoader_1.populateDataLoader)(this, meta, hintOpt, "intermixed", opts);
-            await Promise.all(list.map((entity) => loader.load({ entity, hint: hintOpt }).catch(function populate(err) {
+            const loader = (0, populateBatchLoader_1.populateBatchLoader)(this, meta, hintOpt, "intermixed", opts);
+            await loader.loadAll(list.map((entity) => ({ entity, hint: hintOpt }))).catch(function populate(err) {
                 throw appendStack(err, new Error());
-            })));
+            });
         }
         return fn ? fn(entityOrList) : entityOrList;
     }
@@ -817,110 +864,116 @@ class EntityManager {
             throw new ReadOnlyError();
         const { skipValidation = false } = flushOptions;
         this.#fl.startLock();
-        await this.#fl.allowWrites(async () => {
-            // Cascade deletes now that we're async (i.e. to keep `em.delete` synchronous).
-            // Also do this before calling `recalcPendingReactables` to avoid recalculating
-            // fields on entities that will be deleted (and probably have unset/invalid FKs
-            // that would NPE their logic anyway).
-            await this.flushDeletes();
-            // Recalc before we run hooks, so the hooks will see the latest calculated values.
-            await this.#rm.recalcPendingReactables("reactables");
-        });
-        const createdThenDeleted = new Set();
-        // We'll only invoke hooks once/entity (the 1st time that entity goes through runHooksOnPendingEntities)
-        const hooksInvoked = new Set();
-        // Make sure two ReactiveQueryFields don't ping-pong each other forever
-        let hookLoops = 0;
-        let now = getNow();
-        const suppressedDefaultTypeErrors = [];
-        // Make a lambda that we can invoke multiple times, if we loop for ReactiveQueryFields
-        const runHooksOnPendingEntities = async () => {
-            if (hookLoops++ >= 10)
-                throw new Error("runHooksOnPendingEntities has ran 10 iterations, aborting");
-            // Any dirty entities we find, even if we skipped firing their hooks on this loop
-            const pendingFlush = new Set();
-            // Subset of pendingFlush entities that we will run hooks on
-            const pendingHooks = new Set();
-            // Subset of pendingFlush entities that had hooks invoked in a prior `runHooksOnPendingEntities`
-            const alreadyRanHooks = new Set();
-            findPendingFlushEntities(this.entities, hooksInvoked, pendingFlush, pendingHooks, alreadyRanHooks);
-            // If we're re-looping for ReactiveQueryField, make sure to bump updatedAt
-            // each time, so that for an INSERT-then-UPDATE the triggers don't think the
-            // UPDATE forgot to self-bump updatedAt, and then "helpfully" bump it for us.
-            if (alreadyRanHooks.size > 0) {
-                maybeBumpUpdatedAt((0, Todo_1.createTodos)([...alreadyRanHooks]), now);
-            }
-            // Run hooks in a series of loops until things "settle down"
-            while (pendingHooks.size > 0) {
-                await this.#fl.allowWrites(async () => {
-                    // Run our hooks
-                    let todos = (0, Todo_1.createTodos)([...pendingHooks]);
-                    await (0, defaults_1.setAsyncDefaults)(suppressedDefaultTypeErrors, this.ctx, Todo_1.Todo.groupInsertsByTypeAndSubType(todos));
-                    maybeBumpUpdatedAt(todos, now);
-                    for (const group of maybeSetupHookOrdering(todos)) {
-                        await beforeCreate(this.ctx, group);
-                        await beforeUpdate(this.ctx, group);
-                        await beforeFlush(this.ctx, group);
-                    }
-                    // Call `setField` just to get the column marked as dirty if needed.
-                    // This can come after the hooks, b/c if the hooks read any of these
-                    // fields, they'd be via the synchronous getter and would not be stale.
-                    recalcSynchronousDerivedFields(todos);
-                    // The hooks could have deleted this-loop or prior-loop entities, so re-cascade again.
-                    await this.flushDeletes();
-                    // The hooks could have changed fields, so recalc again.
-                    await this.#rm.recalcPendingReactables("reactables");
-                    // We may have reactables that failed earlier, but will succeed now that hooks have been run and cascade
-                    // deletes have been processed
-                    if (this.#rm.hasPendingTypeErrors) {
-                        await this.#rm.recalcPendingTypeErrors();
-                        // We need to re-run reactables again if we dirtied something while retrying type errors
-                        if (this.#rm.needsRecalc("reactables"))
-                            await this.#rm.recalcPendingReactables("reactables");
-                    }
-                    for (const e of pendingHooks)
-                        hooksInvoked.add(e);
-                    pendingHooks.clear();
-                    // See if the hooks mutated any new, not-yet-hooksInvoked entities
-                    findPendingFlushEntities(this.entities, hooksInvoked, pendingFlush, pendingHooks, alreadyRanHooks);
-                    // The final run of recalcPendingReactables could have left us with pending type errors and no entities in
-                    // pendingHooks.  If so, we need to re-run recalcPendingTypeErrors to get those errors to transition into
-                    // suppressed errors so that we will fail after simpleValidation.
-                    if (pendingHooks.size === 0 && this.#rm.hasPendingTypeErrors)
-                        await this.#rm.recalcPendingTypeErrors();
-                });
-            }
-            // We might have invoked hooks that immediately deleted a new entity (weird but allowed);
-            // if so, filter it out so that we don't flush it, but keep track for later fixing up
-            // it's `#orm.deleted` field.
-            return [...pendingFlush].filter((e) => {
-                const createThenDelete = e.isDeletedEntity && e.isNewEntity;
-                if (createThenDelete)
-                    createdThenDeleted.add(e);
-                return !createThenDelete;
-            });
-        };
-        const runValidation = async (entityTodos, joinRowTodos) => {
-            try {
-                this.#isValidating = true;
-                // Run simple rules first b/c it includes not-null/required rules, so that then when we run
-                // `validateReactiveRules` next, the app's lambdas won't see fundamentally invalid entities & NPE.
-                await validateSimpleRules(entityTodos);
-                // After we've let any "author is not set" simple rules fail before prematurely throwing
-                // the "of course that caused an NPE" `TypeError`s, if all the authors *were* valid/set,
-                // and we still have TypeErrors (from derived valeus), they were real, unrelated errors
-                // that the user should see.
-                if (suppressedDefaultTypeErrors.length > 0)
-                    throw suppressedDefaultTypeErrors[0];
-                await validateReactiveRules(entityTodos, joinRowTodos);
-            }
-            finally {
-                this.#isValidating = false;
-            }
-            await afterValidation(this.ctx, entityTodos);
-        };
         const allFlushedEntities = new Set();
         try {
+            await this.#fl.allowWrites(async () => {
+                // Cascade deletes now that we're async (i.e. to keep `em.delete` synchronous).
+                // Also do this before calling `recalcPendingReactables` to avoid recalculating
+                // fields on entities that will be deleted (and probably have unset/invalid FKs
+                // that would NPE their logic anyway).
+                await this.flushDeletes();
+                // Recalc before we run hooks, so the hooks will see the latest calculated values.
+                await this.#rm.recalcPendingReactables("reactables");
+            });
+            const createdThenDeleted = new Set();
+            // We'll only invoke hooks once/entity (the 1st time that entity goes through runHooksOnPendingEntities)
+            const hooksInvoked = new Set();
+            // Make sure two ReactiveQueryFields don't ping-pong each other forever
+            let hookLoops = 0;
+            let now = getNow();
+            const suppressedDefaultTypeErrors = [];
+            // Make a lambda that we can invoke multiple times, if we loop for ReactiveQueryFields
+            const runHooksOnPendingEntities = async () => {
+                if (hookLoops++ >= 10)
+                    throw new Error("runHooksOnPendingEntities has ran 10 iterations, aborting");
+                // Resolve any pending o2m/m2m sets (set() called before load — need to load from DB to diff)
+                const pendingLoads = [...getEmInternalApi(this).pendingLoads];
+                if (pendingLoads.length > 0) {
+                    getEmInternalApi(this).pendingLoads.clear();
+                    await Promise.all(pendingLoads.map((collection) => collection.load()));
+                }
+                // Any dirty entities we find, even if we skipped firing their hooks on this loop
+                const pendingFlush = new Set();
+                // Subset of pendingFlush entities that we will run hooks on
+                const pendingHooks = new Set();
+                // Subset of pendingFlush entities that had hooks invoked in a prior `runHooksOnPendingEntities`
+                const alreadyRanHooks = new Set();
+                findPendingFlushEntities(this.entities, hooksInvoked, pendingFlush, pendingHooks, alreadyRanHooks);
+                // If we're re-looping for ReactiveQueryField, make sure to bump updatedAt
+                // each time, so that for an INSERT-then-UPDATE the triggers don't think the
+                // UPDATE forgot to self-bump updatedAt, and then "helpfully" bump it for us.
+                if (alreadyRanHooks.size > 0) {
+                    maybeBumpUpdatedAt((0, Todo_1.createTodos)([...alreadyRanHooks]), now);
+                }
+                // Run hooks in a series of loops until things "settle down"
+                while (pendingHooks.size > 0) {
+                    await this.#fl.allowWrites(async () => {
+                        let todos = (0, Todo_1.createTodos)([...pendingHooks]);
+                        await (0, defaults_1.setAsyncDefaults)(suppressedDefaultTypeErrors, this.ctx, Todo_1.Todo.groupInsertsByTypeAndSubType(todos));
+                        maybeBumpUpdatedAt(todos, now);
+                        // Run our hooks
+                        for (const group of maybeSetupHookOrdering(todos)) {
+                            await beforeCreate(this.ctx, group);
+                            await beforeUpdate(this.ctx, group);
+                            await beforeFlush(this.ctx, group);
+                        }
+                        // Call `setField` just to get the column marked as dirty if needed.
+                        // This can come after the hooks, b/c if the hooks read any of these
+                        // fields, they'd be via the synchronous getter and would not be stale.
+                        recalcSynchronousDerivedFields(todos);
+                        // The hooks could have deleted this-loop or prior-loop entities, so re-cascade again.
+                        await this.flushDeletes();
+                        // The hooks could have changed fields, so recalc again.
+                        await this.#rm.recalcPendingReactables("reactables");
+                        // We may have reactables that failed earlier, but will succeed now that hooks have been run and cascade
+                        // deletes have been processed
+                        if (this.#rm.hasPendingTypeErrors) {
+                            await this.#rm.recalcPendingTypeErrors();
+                            // We need to re-run reactables again if we dirtied something while retrying type errors
+                            if (this.#rm.needsRecalc("reactables"))
+                                await this.#rm.recalcPendingReactables("reactables");
+                        }
+                        for (const e of pendingHooks)
+                            hooksInvoked.add(e);
+                        pendingHooks.clear();
+                        // See if the hooks mutated any new, not-yet-hooksInvoked entities
+                        findPendingFlushEntities(this.entities, hooksInvoked, pendingFlush, pendingHooks, alreadyRanHooks);
+                        // The final run of recalcPendingReactables could have left us with pending type errors and no entities in
+                        // pendingHooks.  If so, we need to re-run recalcPendingTypeErrors to get those errors to transition into
+                        // suppressed errors so that we will fail after simpleValidation.
+                        if (pendingHooks.size === 0 && this.#rm.hasPendingTypeErrors)
+                            await this.#rm.recalcPendingTypeErrors();
+                    });
+                }
+                // We might have invoked hooks that immediately deleted a new entity (weird but allowed);
+                // if so, filter it out so that we don't flush it, but keep track for later fixing up
+                // it's `#orm.deleted` field.
+                return [...pendingFlush].filter((e) => {
+                    const createThenDelete = e.isDeletedEntity && e.isNewEntity;
+                    if (createThenDelete)
+                        createdThenDeleted.add(e);
+                    return !createThenDelete;
+                });
+            };
+            const runValidation = async (entityTodos, joinRowTodos) => {
+                try {
+                    this.#isValidating = true;
+                    // Run simple rules first b/c it includes not-null/required rules, so that then when we run
+                    // `validateReactiveRules` next, the app's lambdas won't see fundamentally invalid entities & NPE.
+                    await validateSimpleRules(entityTodos);
+                    // After we've let any "author is not set" simple rules fail before prematurely throwing
+                    // the "of course that caused an NPE" `TypeError`s, if all the authors *were* valid/set,
+                    // and we still have TypeErrors (from derived valeus), they were real, unrelated errors
+                    // that the user should see.
+                    if (suppressedDefaultTypeErrors.length > 0)
+                        throw suppressedDefaultTypeErrors[0];
+                    await validateReactiveRules(this, this.#rm.logger, entityTodos, joinRowTodos);
+                }
+                finally {
+                    this.#isValidating = false;
+                }
+                await afterValidation(this.ctx, entityTodos);
+            };
             // Run hooks (in iterative loops if hooks mutate new entities) on pending entities
             let entitiesToFlush = await runHooksOnPendingEntities();
             for (const e of entitiesToFlush)
@@ -1001,8 +1054,10 @@ class EntityManager {
                     o2m.resetAddedRemoved();
                 }
                 mutatedCollections.clear();
-                // Reset the find caches b/c data will have changed in the db
+                // Reset the find/preload caches b/c data will have changed in the db
                 this.#dataloaders = {};
+                this.#batchLoaders = {};
+                this.#preloadedRelations = new Map();
                 this.#rm.clear();
             }
             // Fixup the `deleted` field on entities that were created then immediately deleted
@@ -1012,6 +1067,19 @@ class EntityManager {
             return [...allFlushedEntities];
         }
         catch (e) {
+            if (e instanceof RecursiveCollection_1.RecursiveCycleError) {
+                const entity = e.entities[0];
+                // Look up a custom cycle message — check both the exact field name and its opposite
+                // direction, since the cycle may be detected from either side (e.g. walking
+                // childrenRecursive during reactive hint reversal when parentsRecursive was configured).
+                for (const meta of (0, index_1.getBaseAndSelfMetas)((0, index_1.getMetadata)(entity))) {
+                    const messageFn = meta.config.__data.cycleMessages[e.fieldName] ??
+                        meta.config.__data.cycleMessages[entity[e.fieldName]?.otherFieldName];
+                    if (messageFn) {
+                        throw new index_1.ValidationErrors([{ entity, message: messageFn(entity, e.entities) }]);
+                    }
+                }
+            }
             if (e && typeof e === "object" && "constraint" in e && typeof e.constraint === "string") {
                 // node-pg errors use `constraint` to indicate the constraint name
                 const message = config_1.constraintNameToValidationError[e.constraint];
@@ -1042,6 +1110,7 @@ class EntityManager {
     async refresh(param) {
         this.#isRefreshing = true;
         this.#dataloaders = {};
+        this.#batchLoaders = {};
         this.#preloadedRelations = new Map();
         const deepLoad = param && "deepLoad" in param && param.deepLoad;
         let todo = param === undefined
@@ -1057,23 +1126,22 @@ class EntityManager {
             copy.forEach((e) => done.add(e));
             todo = [];
             // For any non-deleted entity with an id, get its latest data + relations from the database
-            const entities = await Promise.all(copy
-                .filter((e) => e.idTaggedMaybe && !e.isDeletedEntity)
-                .map((entity) => {
-                // Pass these as a hint to potentially preload them
+            const entitiesToRefresh = copy.filter((e) => e.idTaggedMaybe && !e.isDeletedEntity);
+            await Promise.all(entitiesToRefresh.map((entity) => {
+                // Pass loaded/all relation names as a hint so the preloader can inject JOINs
                 const hint = (0, index_1.getRelationEntries)(entity)
                     .filter(([_, r]) => deepLoad || r.isLoaded)
                     .map(([k]) => k);
-                return (0, loadDataLoader_1.loadDataLoader)(this, (0, index_1.getMetadata)(entity), true)
-                    .load({ entity: entity.idTagged, hint })
+                return (0, loadBatchLoader_1.loadBatchLoader)(this, (0, index_1.getMetadata)(entity), true)
+                    .load({ taggedId: entity.idTagged, hint })
                     .catch(function refresh(err) {
                     throw appendStack(err, new Error());
                 });
             }));
-            // Then refresh any loaded relations (the `loadDataLoader.load` only populates the
-            // preloader cache, if in use, it doesn't actually get each relation into a loaded state.)
-            const [custom, builtin] = (0, utils_1.partition)(entities
-                .filter((e) => e && !(0, BaseEntity_1.getInstanceData)(e).isDeletedEntity)
+            // Then refresh any loaded relations (the loadBatchLoader only hydrates the entity
+            // data, it doesn't get each relation into a loaded state.)
+            const [custom, builtin] = (0, utils_1.partition)(entitiesToRefresh
+                .filter((e) => !(0, BaseEntity_1.getInstanceData)(e).isDeletedEntity)
                 .flatMap((entity) => (0, index_1.getRelations)(entity).filter((r) => deepLoad || r.isLoaded)), isCustomRelation);
             // Call `.load` on builtin relations first, because if we hit an already-loaded custom relation
             // first, it will call `.get` internally, and might access built-in relations that we've not had a
@@ -1215,6 +1283,16 @@ class EntityManager {
         const loadersForKind = (this.#dataloaders[operation] ??= {});
         return (0, utils_1.getOrSet)(loadersForKind, batchKey, () => new dataloader_1.default(fn, opts));
     }
+    /**
+     * Like `getLoader`, but returns a `BatchLoader` where all callers in the same tick
+     * share a single `Promise<void>` instead of getting per-key promises.
+     *
+     * The batch function should write results via side channels (e.g. `setPreloadedRelation`).
+     */
+    getBatchLoader(operation, batchKey, fn) {
+        const loadersForKind = (this.#batchLoaders[operation] ??= {});
+        return (0, utils_1.getOrSet)(loadersForKind, batchKey, () => new BatchLoader_1.BatchLoader(fn));
+    }
     toString() {
         return "EntityManager";
     }
@@ -1485,6 +1563,7 @@ class EntityManager {
                 this.importEntity(source, loadHint);
             }
             else if ("import" in relationOrProp) {
+                // Tell our version of the entity (result) to accept/copy the relation state of the source
                 relationOrProp.import(source[fieldName], (e) => this.importEntity(e, subHint, subHint), (entities) => {
                     if (entities === undefined)
                         return undefined;
@@ -1642,22 +1721,26 @@ exports.TooManyError = TooManyError;
  * from the currently-changed entities back to each rule's originally-defined-in entity,
  * and ensure those entities are added to `todos`.
  */
-async function validateReactiveRules(todos, joinRowTodos) {
+async function validateReactiveRules(em, logger, todos, joinRowTodos) {
+    logger?.logStartingValidate(em, todos);
     // Use a map of rule -> Set<Entity> so that we only invoke a rule once per entity,
     // even if it was triggered by multiple changed fields.
     const fns = new Map();
     // From the given triggered entities, follow the entity's ReactiveRule back
     // to the reactive rules that need ran, and queue them in the `fn` map
     async function followAndQueue(triggered, rule) {
-        (await (0, reactiveHints_1.followReverseHint)(rule.name, triggered, rule.path))
+        if (triggered.length === 0)
+            return;
+        const found = (await (0, reactiveHints_1.followReverseHint)(rule.name, triggered, rule.path))
             .filter((entity) => !entity.isDeletedEntity)
-            .filter((e) => e instanceof rule.cstr)
-            .forEach((entity) => {
-            let entities = fns.get(rule.fn);
-            if (!entities) {
-                entities = new Set();
-                fns.set(rule.fn, entities);
-            }
+            .filter((e) => e instanceof rule.cstr);
+        let entities = fns.get(rule.fn);
+        if (!entities) {
+            entities = new Set();
+            fns.set(rule.fn, entities);
+        }
+        logger?.logWalked(triggered, rule, found, "validate");
+        found.forEach((entity) => {
             entities.add(entity);
         });
     }