joist-core 2.2.0-next.3 → 2.2.0-next.31

package/build/EntityManager.js

@@ -29,7 +29,6 @@ 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");
 const findByUniqueDataLoader_1 = require("./dataloaders/findByUniqueDataLoader");
@@ -43,6 +42,7 @@ const FlushLock_1 = require("./FlushLock");
 const index_1 = require("./index");
 const IsLoadedCache_1 = require("./IsLoadedCache");
 const JoinRows_1 = require("./JoinRows");
+const loadHints_1 = require("./loadHints");
 const newEntity_1 = require("./newEntity");
 const newTestInstance_1 = require("./newTestInstance");
 const PluginManager_1 = require("./PluginManager");
@@ -88,6 +88,8 @@ class EntityManager {
     txn;
     entityLimit = defaultEntityLimit;
     #entitiesArray = [];
+    // Incrementally track dirty entities so we don't have to scan `#entityArray` during flush
+    #maybePendingFlushEntities = new Set();
     // Indexes the currently loaded entities by their tagged ids and `toTaggedString` ids (i.e. `a#`). This fixes
     // real-world performance issues where `findExistingInstance` scanning `#entities` was an `O(n^2)`.
     #entitiesById = new Map();
@@ -106,6 +108,7 @@ class EntityManager {
      * so that both see the most accurate state.
      */
     #pendingDeletes = [];
+    #hasAnyDeletes = false;
     #dataloaders = {};
     #batchLoaders = {};
     #joinRows = {};
@@ -155,6 +158,20 @@ class EntityManager {
             indexManager: this.#indexManager,
             isLoadedCache: this.#isLoadedCache,
             pluginManager,
+            markMaybePending(entity) {
+                em.#maybePendingFlushEntities.add(entity);
+            },
+            unmarkMaybePending(entity) {
+                em.#maybePendingFlushEntities.delete(entity);
+            },
+            hasAnyDeletes() {
+                return em.#hasAnyDeletes;
+            },
+            pendingDeleteIds(type) {
+                return em.#pendingDeletes
+                    .filter((entity) => entity instanceof type && entity.idMaybe !== undefined)
+                    .map((entity) => (0, index_1.keyToNumber)((0, index_1.getMetadata)(entity), entity.id));
+            },
             isMerging(entity) {
                 return em.#merging?.has(entity) ?? false;
             },
@@ -248,12 +265,9 @@ class EntityManager {
     async find(type, where, options) {
         const { populate, ...rest } = options || {};
         const settings = { where, ...rest };
-        const loader = hasPaginationSettings(rest)
+        const result = await (hasPaginationSettings(rest)
             ? (0, findPaginatedDataLoader_1.findPaginatedDataLoader)(this, type, settings, populate)
-            : (0, findDataLoader_1.findDataLoader)(this, type, settings, populate);
-        const result = await loader
-            .load(settings)
-            .catch(function find(err) {
+            : (0, findDataLoader_1.findDataLoader)(this, type, settings, populate)).catch(function find(err) {
             throw appendStack(err, new Error());
         });
         if (populate) {
@@ -348,6 +362,9 @@ class EntityManager {
         }
         else {
             const [entity] = this.hydrate(type, [row]);
+            if (this.#hasAnyDeletes && entity.isDeletedEntity) {
+                return undefined;
+            }
             if (populate) {
                 await this.populate(entity, populate);
             }
@@ -364,16 +381,14 @@ class EntityManager {
      */
     async findCount(type, where, options = {}) {
         const settings = { where, ...options };
-        let count = await (0, findCountDataLoader_1.findCountDataLoader)(this, type, settings)
-            .load(settings)
-            .catch(function findCount(err) {
+        let count = await (0, findCountDataLoader_1.findCountDataLoader)(this, type, settings).catch(function findCount(err) {
             throw appendStack(err, new Error());
         });
         // If the user is do "count all", we can adjust the number up/down based on
         // WIP creates/deletes. We can't do this if the WHERE clause is populated b/c
         // then we'd also have to eval each created/deleted entity against the WHERE
         // clause before knowing if it should adjust teh amount.
-        const isSelectAll = Object.keys(where).length === 0;
+        const isSelectAll = Object.keys(where).length === 0 && options.conditions === undefined;
         if (isSelectAll) {
             const tagged = this.#entitiesByTag.get((0, index_1.getMetadata)(type).tagName) ?? [];
             for (const entity of tagged) {
@@ -398,9 +413,7 @@ class EntityManager {
      */
     async findIds(type, where, options = {}) {
         const settings = { where, ...options };
-        return (0, findIdsDataLoader_1.findIdsDataLoader)(this, type, settings)
-            .load(settings)
-            .catch(function findIds(err) {
+        return (0, findIdsDataLoader_1.findIdsDataLoader)(this, type, settings).catch(function findIds(err) {
             throw appendStack(err, new Error());
         });
     }
@@ -689,48 +702,86 @@ 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 idsToLoad = ids.filter((id) => !this.findExistingInstance(id));
-        if (idsToLoad.length > 0) {
+        // Use pre-allocated arrays/for loops instead of `.filter`s since this can be a hot spot
+        const ids = new Array(_ids.length);
+        const entities = new Array(_ids.length);
+        let idsToLoad;
+        let positionsToLoad;
+        for (let i = 0; i < _ids.length; i++) {
+            const id = (0, index_1.tagId)(meta, _ids[i]);
+            ids[i] = id;
+            const entity = this.findExistingInstance(id);
+            if (entity) {
+                entities[i] = entity;
+            }
+            else {
+                (idsToLoad ??= []).push(id);
+                (positionsToLoad ??= []).push(i);
+            }
+        }
+        if (idsToLoad && 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());
             });
+            for (const i of positionsToLoad) {
+                entities[i] = this.findExistingInstance(ids[i]);
+            }
         }
-        const entities = [];
-        for (const id of ids) {
-            const entity = this.findExistingInstance(id);
-            if (entity)
-                entities.push(entity);
+        let idsNotFound;
+        for (let i = 0; i < entities.length; i++) {
+            if (entities[i] === undefined) {
+                (idsNotFound ??= []).push(ids[i]);
+            }
         }
-        if (entities.length !== ids.length) {
-            const idsNotFound = ids.filter((_, i) => entities[i] === undefined);
+        if (idsNotFound) {
             throw new NotFoundError(`${idsNotFound.join(",")} were not found`);
         }
+        const loadedEntities = entities;
         if (hint) {
-            await this.populate(entities, hint);
+            await this.populate(loadedEntities, hint);
         }
         if (meta.inheritanceType === "sti" && meta.baseType) {
-            const wrongType = entities.filter((e) => !(e instanceof meta.cstr));
+            const wrongType = loadedEntities.filter((e) => !(e instanceof meta.cstr));
             if (wrongType.length > 0) {
                 throw new Error(`${wrongType.join(", ")} were not of type ${meta.cstr.name}`);
             }
         }
-        return entities;
+        return loadedEntities;
     }
     async loadAllIfExists(type, _ids, hint) {
         const meta = (0, index_1.getMetadata)(type);
-        const ids = _ids.map((id) => (0, index_1.tagId)(meta, id));
-        const idsToLoad = ids.filter((id) => !this.findExistingInstance(id));
-        if (idsToLoad.length > 0) {
+        // Use pre-allocated arrays/for loops instead of `.filter`s since this can be a hot spot
+        const ids = new Array(_ids.length);
+        const entities = [];
+        let idsToLoad;
+        // Ensure the ids are tagged, and find any not-yet-loaded
+        for (let i = 0; i < _ids.length; i++) {
+            const id = (0, index_1.tagId)(meta, _ids[i]);
+            ids[i] = id;
+            const entity = this.findExistingInstance(id);
+            if (entity) {
+                entities.push(entity);
+            }
+            else {
+                (idsToLoad ??= []).push(id);
+            }
+        }
+        if (idsToLoad && 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());
             });
+            // Now that everything is loaded, recalc `entities`
+            entities.length = 0;
+            for (const id of ids) {
+                const entity = this.findExistingInstance(id);
+                if (entity)
+                    entities.push(entity);
+            }
         }
-        const entities = ids.map((id) => this.findExistingInstance(id)).filter(Boolean);
         if (hint) {
             await this.populate(entities, hint);
         }
@@ -781,6 +832,12 @@ class EntityManager {
         if (list.length === 0) {
             return !fn ? entityOrList : fn(entityOrList);
         }
+        // Avoid building a HintTree/batchloader for persisted entities when everything is already loaded; in the phase 9
+        // benchmark this moved already-loaded populates from ~1.10ms to ~0.89ms, and nested already-loaded populates from
+        // ~2.39ms to ~1.94ms.
+        if (!opts.forceReload && list.every((entity) => !entity.isNewEntity && (0, loadHints_1.isLoadedForPopulate)(entity, hintOpt))) {
+            return fn ? fn(entityOrList) : entityOrList;
+        }
         const meta = (0, index_1.getMetadata)(list[0]);
         if (this.#preloader) {
             // If we can preload, prevent promise deadlocking by one large-batch preload populate (which can't have
@@ -829,9 +886,11 @@ class EntityManager {
     delete(entityOrArray) {
         for (const entity of (0, utils_1.toArray)(entityOrArray)) {
             // Early return if already deleted.
-            const alreadyMarked = (0, BaseEntity_1.getInstanceData)(entity).markDeleted(entity);
+            const alreadyMarked = (0, BaseEntity_1.getInstanceData)(entity).markDeleted();
             if (!alreadyMarked)
                 continue;
+            // This monotonic flag lets find hot paths skip scanning results until a delete has ever happened in this EM.
+            this.#hasAnyDeletes = true;
             // Any derived fields that read this entity will need recalc-d
             this.#rm.queueAllDownstreamFields(entity, "deleted");
             // Synchronously unhook the entity if the relations are loaded
@@ -925,7 +984,7 @@ class EntityManager {
                 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);
+                findPendingFlushEntities(this.#maybePendingFlushEntities, hooksInvoked, pendingFlush, pendingHooks, alreadyRanHooks);
                 // If we're re-looping for AsyncReactiveField, 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.
@@ -964,7 +1023,7 @@ class EntityManager {
                             hooksInvoked.add(e);
                         pendingHooks.clear();
                         // See if the hooks mutated any new, not-yet-hooksInvoked entities
-                        findPendingFlushEntities(this.entities, hooksInvoked, pendingFlush, pendingHooks, alreadyRanHooks);
+                        findPendingFlushEntities(this.#maybePendingFlushEntities, 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.
@@ -1099,7 +1158,7 @@ class EntityManager {
             for (const e of createdThenDeleted)
                 (0, BaseEntity_1.getInstanceData)(e).fixupCreatedThenDeleted();
             this.#merging?.clear();
-            return [...allFlushedEntities];
+            return [...allFlushedEntities].sort((a, b) => (0, BaseEntity_1.getInstanceData)(a).entityIndex - (0, BaseEntity_1.getInstanceData)(b).entityIndex);
         }
         catch (e) {
             if (e instanceof RecursiveCollection_1.RecursiveCycleError) {
@@ -1122,8 +1181,9 @@ class EntityManager {
                     throw new index_1.ValidationErrors(message);
                 }
             }
-            if (e instanceof InMemoryRollbackError)
-                return [...allFlushedEntities];
+            if (e instanceof InMemoryRollbackError) {
+                return [...allFlushedEntities].sort((a, b) => (0, BaseEntity_1.getInstanceData)(a).entityIndex - (0, BaseEntity_1.getInstanceData)(b).entityIndex);
+            }
             throw e;
         }
         finally {
@@ -1231,10 +1291,13 @@ class EntityManager {
      */
     hydrate(type, rows, options) {
         const maybeBaseMeta = (0, index_1.getMetadata)(type);
+        const taggedIdPrefix = `${maybeBaseMeta.tagName}:`;
+        const overwriteExisting = options?.overwriteExisting === true;
         let i = 0;
         const entities = new Array(rows.length);
         for (const row of rows) {
-            const taggedId = (0, index_1.keyToTaggedId)(maybeBaseMeta, row["id"]) || (0, utils_1.fail)("No id column was available");
+            const id = row["id"];
+            const taggedId = id === undefined || id === null ? (0, utils_1.fail)("No id column was available") : `${taggedIdPrefix}${id}`;
             // See if this is already in our UoW
             let entity = this.findExistingInstance(taggedId);
             if (!entity) {
@@ -1243,23 +1306,36 @@ class EntityManager {
                 // Pass id as a hint that we're in hydrate mode
                 entity = (0, newEntity_1.newEntity)(this, (0, index_1.asConcreteCstr)(meta.cstr), false);
                 (0, BaseEntity_1.getInstanceData)(entity).row = row;
-                this.#doRegister(entity, taggedId);
+                this.#doRegister(entity, taggedId, meta, true);
             }
-            else if (options?.overwriteExisting === true) {
+            else if (overwriteExisting) {
                 // Usually if the entity already exists, we don't write over it, but in this case we assume that
                 // `EntityManager.refresh` is telling us to explicitly load the latest data.
                 // First swap out the old row with the new row
-                (0, BaseEntity_1.getInstanceData)(entity).row = row;
+                const instanceData = (0, BaseEntity_1.getInstanceData)(entity);
+                instanceData.row = row;
                 // And then only refresh the data keys that have already been serde-d from rows
                 // (this keeps us from deserializing data out of rows that we don't need).
-                const { data, originalData } = (0, BaseEntity_1.getInstanceData)(entity);
-                const changedFields = entity.changes.fieldsWithoutRelations;
-                for (const fieldName of Object.keys(data)) {
-                    const serde = (0, index_1.getMetadata)(entity).allFields[fieldName].serde ?? (0, utils_1.fail)(`Missing serde for ${fieldName}`);
-                    serde.setOnEntity(data, row);
-                    // Make the field look not-dirty
-                    if (changedFields.includes(fieldName)) {
-                        delete originalData[fieldName];
+                const { data } = instanceData;
+                const dataKeys = Object.keys(data);
+                if (dataKeys.length > 0) {
+                    const allFields = (0, index_1.getMetadata)(entity).allFields;
+                    const changedFields = entity.changes.fieldsWithoutRelations;
+                    if (changedFields.length === 0) {
+                        for (const fieldName of dataKeys) {
+                            const serde = allFields[fieldName].serde ?? (0, utils_1.fail)(`Missing serde for ${fieldName}`);
+                            serde.setOnEntity(data, row);
+                        }
+                    }
+                    else {
+                        for (const fieldName of dataKeys) {
+                            const serde = allFields[fieldName].serde ?? (0, utils_1.fail)(`Missing serde for ${fieldName}`);
+                            serde.setOnEntity(data, row);
+                            // Make the field look not-dirty
+                            if (changedFields.includes(fieldName)) {
+                                instanceData.markFieldClean(fieldName);
+                            }
+                        }
                     }
                 }
             }
@@ -1268,8 +1344,9 @@ class EntityManager {
         return entities;
     }
     touch(entityOrEntities) {
-        for (const entity of (0, utils_1.toArray)(entityOrEntities))
-            (0, BaseEntity_1.getInstanceData)(entity).isTouched = true;
+        for (const entity of (0, utils_1.toArray)(entityOrEntities)) {
+            (0, BaseEntity_1.getInstanceData)(entity).markTouched();
+        }
     }
     async recalc(entityOrEntities) {
         // Look for async reactive fields
@@ -1346,9 +1423,16 @@ class EntityManager {
             // Run the beforeDelete hook before we unhook the entity
             const todos = (0, Todo_1.createTodos)(entities);
             await beforeDelete(this.ctx, todos);
-            // For all relations, unhook the entity from the other side
-            // (...we're using `concat` because `.push(...reallyBigArray)` with ~100k relations can blow the stack size
-            relationsToCleanup = relationsToCleanup.concat(entities.flatMap(index_1.getRelations));
+            // For all relations, unhook the entity from the other side; this append path is optimized for
+            // large deletes with ~100k relations by avoiding `flatMap` intermediates and `concat` copies.
+            for (const entity of entities) {
+                const relations = (0, index_1.getRelations)(entity);
+                const start = relationsToCleanup.length;
+                relationsToCleanup.length += relations.length;
+                for (let i = 0; i < relations.length; i++) {
+                    relationsToCleanup[start + i] = relations[i];
+                }
+            }
             entities = this.#pendingDeletes;
             this.#pendingDeletes = [];
         }
@@ -1404,9 +1488,9 @@ class EntityManager {
             return entities.filter((e) => e instanceof cstr && !e.isDeletedEntity);
         }
         if (this.#indexManager.shouldIndexType(entities.length)) {
-            this.#indexManager.enableIndexingForType(meta, entities);
+            this.#indexManager.enableIndexingForType(meta, entities, where);
             return (this.#indexManager
-                .findMatching(meta, where)
+                .findMatching(meta, entities, where)
                 // Still filter by `instanceof cstr` to handle subtyping
                 .filter((e) => e instanceof cstr && !e.isDeletedEntity));
         }
@@ -1506,7 +1590,8 @@ class EntityManager {
                     continue;
                 const { originalData: oldOriginalData, data: oldData } = oldInstanceData;
                 const newEntity = mapEntity(oldEntity);
-                const { originalData: newOriginalData, data: newData } = newEntity.__data;
+                const newInstanceData = newEntity.__data;
+                const { data: newData } = newInstanceData;
                 // for new entities, anything in `data` is changed and should be copied across. for existing entities, we
                 // only care about changed fields, which are enumerated by originalData
                 const maybeEntity = (value) => ((0, Entity_1.isEntity)(value) ? mapEntity(value) : value);
@@ -1514,7 +1599,7 @@ class EntityManager {
                 for (const field of fields) {
                     // copy over originalData so .changes is consistent across ems
                     if (field in oldOriginalData)
-                        newOriginalData[field] = maybeEntity(oldOriginalData[field]);
+                        newInstanceData.markFieldDirty(field, maybeEntity(oldOriginalData[field]));
                     newData[field] = maybeEntity(oldData[field]);
                 }
             }
@@ -1524,7 +1609,7 @@ class EntityManager {
             const newEntity = mapEntity(oldEntity);
             if (oldEntity.isDeletedEntity) {
                 // If the old entity was deleted, that should be persisted in the new em
-                newEntity.__data.markDeleted(newEntity);
+                newEntity.__data.markDeleted();
                 // deleted entities will fail if you try to `get` their relations, so skip them since they should be cleared
                 // out regardless
                 continue;
@@ -1669,11 +1754,11 @@ class EntityManager {
         }
     }
     /** Registers a newly-instantiated entity with our EntityManager; only called by #doCreate and hydrate. */
-    #doRegister(entity, id) {
+    #doRegister(entity, id, meta, skipDuplicateCheck = false) {
         // Keep our indexes up to date...
         const maybeId = id ?? entity.idTaggedMaybe;
         if (maybeId) {
-            if (this.findExistingInstance(maybeId) !== undefined) {
+            if (!skipDuplicateCheck && this.findExistingInstance(maybeId) !== undefined) {
                 throw new Error(`Entity ${entity} has a duplicate instance already loaded`);
             }
             this.#entitiesById.set(maybeId, entity);
@@ -1682,8 +1767,9 @@ class EntityManager {
             // Also register by the `a#1` style tagged string for new entities
             this.#entitiesById.set(entity.toTaggedString(), entity);
         }
+        (0, BaseEntity_1.getInstanceData)(entity).entityIndex = this.#entitiesArray.length;
         this.#entitiesArray.push(entity);
-        const meta = (0, index_1.getMetadata)(entity);
+        meta ??= (0, index_1.getMetadata)(entity);
         const set = this.#entitiesByTag.get(meta.tagName) ?? [];
         if (set.length === 0)
             this.#entitiesByTag.set(meta.tagName, set);
@@ -1697,8 +1783,6 @@ class EntityManager {
                 .join(", ");
             throw new Error(`More than ${this.entityLimit} entities have been instantiated (top entities: ${topTypes})`);
         }
-        // If indexing is enabled for this type, add it...
-        this.#indexManager.maybeIndexEntity(entity);
     }
 }
 exports.EntityManager = EntityManager;
@@ -1782,14 +1866,14 @@ async function validateReactiveRules(em, logger, todos, joinRowTodos) {
     const p1 = Object.values(todos).flatMap((todo) => {
         const entities = [...todo.inserts, ...todo.updates, ...todo.deletes];
         // Find each statically-declared reactive rule for the given entity type
-        const rules = (0, caches_1.getReactiveRules)(todo.metadata);
+        const rules = todo.metadata.reactiveRules;
         return rules.map((rule) => {
             // Of all changed entities of this type, how many specifically trigger this rule?
             const triggered = entities.filter((e) => {
                 // If the rule is for a different subtype, skip it
                 if (!(e instanceof rule.source))
                     return false;
-                // Any new-or-deleted entity fires every rule (getReactiveRules has already filtered out read-only)
+                // Any new-or-deleted entity fires every rule (reactiveRules has already filtered out read-only)
                 if (e.isNewEntity || e.isDeletedEntity)
                     return true;
                 // Otherwise see if the changed fields overlaps with the rule's fields
@@ -1807,15 +1891,15 @@ async function validateReactiveRules(em, logger, todos, joinRowTodos) {
     const p2 = Object.values(joinRowTodos).flatMap((todo) => {
         const entities = [...todo.newRows, ...todo.deletedRows].flatMap((jr) => Object.values(jr.columns));
         // Do the first side
-        const p1 = (0, caches_1.getReactiveRules)(todo.m2m.meta)
-            .filter((rule) => rule.fields.includes(todo.m2m.fieldName))
+        const p1 = todo.m2m.meta
+            .reactiveRules.filter((rule) => rule.fields.includes(todo.m2m.fieldName))
             .map((rule) => {
             const triggered = entities.filter((e) => e instanceof todo.m2m.meta.cstr);
             return followAndQueue(triggered, rule);
         });
         // And the second side
-        const p2 = (0, caches_1.getReactiveRules)(todo.m2m.otherMeta)
-            .filter((rule) => rule.fields.includes(todo.m2m.otherFieldName))
+        const p2 = todo.m2m.otherMeta
+            .reactiveRules.filter((rule) => rule.fields.includes(todo.m2m.otherFieldName))
             .map((rule) => {
             const triggered = entities.filter((e) => e instanceof todo.m2m.otherMeta.cstr);
             return followAndQueue(triggered, rule);
@@ -2044,7 +2128,7 @@ function maybeBumpUpdatedAt(rm, todos, now) {
                 // it has changed. This is technically true, but this will break the oplock SQL generation,
                 // so force the field to be dirty.
                 const orm = (0, BaseEntity_1.getInstanceData)(e);
-                orm.originalData[updatedAt] = (0, fields_1.getField)(e, updatedAt);
+                orm.markFieldDirty(updatedAt, (0, fields_1.getField)(e, updatedAt));
                 const serde = todo.metadata.fields[updatedAt].serde;
                 orm.data[updatedAt] = serde.mapFromNow(now);
                 rm.queueDownstreamReactables(e, updatedAt);
@@ -2081,17 +2165,13 @@ function findConcreteMeta(maybeBaseMeta, row) {
             throw new Error(`${maybeBaseMeta.type} ${(0, index_1.tagId)(maybeBaseMeta, row.id)} must be instantiated via a subtype`);
         }
         // Look for the CTI __class from the driver telling us which subtype to instantiate
-        return maybeBaseMeta.subTypes.find((st) => st.type === row.__class) ?? maybeBaseMeta;
+        return maybeBaseMeta.subTypesByType.get(row.__class) ?? maybeBaseMeta;
     }
     else if (maybeBaseMeta.inheritanceType === "sti") {
         // Look for the STI discriminator value
         const baseMeta = (0, index_1.getBaseMeta)(maybeBaseMeta);
-        const field = baseMeta.fields[baseMeta.stiDiscriminatorField];
-        if (field.kind !== "enum")
-            throw new Error("Discriminator field must be an enum");
-        const columnName = field.serde.columns[0].columnName;
-        const value = row[columnName];
-        return baseMeta.subTypes.find((st) => st.stiDiscriminatorValue === value) ?? baseMeta;
+        const value = row[baseMeta.stiDiscriminatorColumnName];
+        return baseMeta.subTypesByStiValue.get(value) ?? baseMeta;
     }
     else {
         throw new Error("Unknown inheritance type");
@@ -2100,7 +2180,7 @@ function findConcreteMeta(maybeBaseMeta, row) {
 /** Sets the `Animal.type` enum to the right subtype value. */
 function setStiDiscriminatorValue(baseMeta, entity) {
     const typeName = entity.constructor.name;
-    const st = baseMeta.subTypes.find((st) => st.type === typeName);
+    const st = baseMeta.subTypesByType.get(typeName);
     if (st) {
         const field = baseMeta.fields[baseMeta.stiDiscriminatorField];
         const code = field.enumDetailType.findById(st.stiDiscriminatorValue).code;
@@ -2110,17 +2190,19 @@ function setStiDiscriminatorValue(baseMeta, entity) {
         entity[baseMeta.stiDiscriminatorField] = undefined;
     }
 }
-function findPendingFlushEntities(entities, hooksInvoked, pendingFlush, pendingHooks, alreadyRanHooks) {
-    for (const e of entities) {
-        if ((0, BaseEntity_1.getInstanceData)(e).pendingOperation !== "none") {
-            if (!hooksInvoked.has(e)) {
-                pendingHooks.add(e);
-            }
-            else {
-                alreadyRanHooks.add(e);
-            }
-            pendingFlush.add(e);
+function findPendingFlushEntities(maybePendingFlushEntities, hooksInvoked, pendingFlush, pendingHooks, alreadyRanHooks) {
+    for (const e of maybePendingFlushEntities) {
+        if ((0, BaseEntity_1.getInstanceData)(e).pendingOperation === "none") {
+            maybePendingFlushEntities.delete(e);
+            continue;
+        }
+        if (!hooksInvoked.has(e)) {
+            pendingHooks.add(e);
+        }
+        else {
+            alreadyRanHooks.add(e);
         }
+        pendingFlush.add(e);
     }
 }
 /** Returns true if the caller explicitly asked `find` to use SQL pagination. */