joist-orm 0.1.538 → 1.0.0

package/build/{EntityManager.js → src/EntityManager.js}

@@ -1,62 +1,86 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TooManyError = exports.NotFoundError = exports.getMetadata = exports.sameEntity = exports.isKey = exports.isEntity = exports.setDefaultEntityLimit = exports.setEntityLimit = exports.entityLimit = exports.EntityManager = exports.currentFlushSecret = exports.currentlyInstantiatingEntity = void 0;
+exports.afterTransaction = exports.beforeTransaction = exports.TooManyError = exports.NotFoundError = exports.getMetadata = exports.sameEntity = exports.isKey = exports.isEntity = exports.setDefaultEntityLimit = exports.setEntityLimit = exports.entityLimit = exports.EntityManager = exports.currentFlushSecret = exports.currentlyInstantiatingEntity = exports.isId = void 0;
 const async_hooks_1 = require("async_hooks");
-const dataloader_1 = __importDefault(require("dataloader"));
-const object_hash_1 = __importDefault(require("object-hash"));
-const AbstractRelationImpl_1 = require("./collections/AbstractRelationImpl");
 const createOrUpdatePartial_1 = require("./createOrUpdatePartial");
-const EntityPersister_1 = require("./EntityPersister");
+const findDataLoader_1 = require("./dataloaders/findDataLoader");
+const loadDataLoader_1 = require("./dataloaders/loadDataLoader");
 const index_1 = require("./index");
-const QueryBuilder_1 = require("./QueryBuilder");
+const relations_1 = require("./relations");
+const Todo_1 = require("./Todo");
 const utils_1 = require("./utils");
+function isId(value) {
+    return value && typeof value === "string";
+}
+exports.isId = isId;
+/**
+ * A marker to prevent setter calls during `flush` calls.
+ *
+ * The `flush` process does a dirty check + SQL flush and generally doesn't want
+ * entities to re-dirtied after it's done the initial dirty check. So we'd like
+ * to prevent all setter calls while `flush` is running.
+ *
+ * That said, lifecycle code like hooks actually can make setter calls b/c `flush`
+ * invokes them at a specific point in its process.
+ *
+ * We solve this by using node's `AsyncLocalStorage` to mark certain callbacks (promise
+ * handlers) as blessed / invoked-from-`flush`-itself, and they are allowed to call setters,
+ * but any external callers (i.e. application code) will be rejected.
+ */
 exports.currentFlushSecret = new async_hooks_1.AsyncLocalStorage();
 class EntityManager {
-    constructor(emOrCtx) {
+    constructor(emOrCtx, driver) {
         this._entities = [];
         // Indexes the currently loaded entities by their tagged ids. This fixes a real-world
         // performance issue where `findExistingInstance` scanning `_entities` was an `O(n^2)`.
         this._entityIndex = new Map();
-        this.findLoaders = {};
         this.flushSecret = 0;
         this._isFlushing = false;
+        // TODO Make these private
+        this.loadLoaders = {};
+        this.findLoaders = {};
         // This is attempting to be internal/module private
         this.__data = {
-            loaders: {},
             joinRows: {},
         };
         this.hooks = {
             beforeTransaction: [],
+            afterTransaction: [],
         };
         if (emOrCtx instanceof EntityManager) {
             const em = emOrCtx;
-            this.knex = em.knex;
-            this.hooks = { beforeTransaction: [...em.hooks.beforeTransaction] };
+            this.driver = em.driver;
+            this.hooks = {
+                beforeTransaction: [...em.hooks.beforeTransaction],
+                afterTransaction: [...em.hooks.afterTransaction],
+            };
             this.ctx = em.ctx;
         }
         else {
             this.ctx = emOrCtx;
-            this.knex = emOrCtx.knex;
+            this.driver = driver;
         }
     }
+    /** Returns a read-only shallow copy of the currently-loaded entities. */
     get entities() {
         return [...this._entities];
     }
+    /** Looks up `id` in the list of already-loaded entities. */
+    getEntity(id) {
+        return this._entityIndex.get(id);
+    }
     async find(type, where, options) {
-        const rows = await this.loaderForFind(type).load({ where, ...options });
+        const rows = await (0, findDataLoader_1.findDataLoader)(this, type).load({ where, ...options });
         const result = rows.map((row) => this.hydrate(type, row, { overwriteExisting: false }));
-        if (options === null || options === void 0 ? void 0 : options.populate) {
+        if (options?.populate) {
             await this.populate(result, options.populate);
         }
         return result;
     }
     async findGql(type, where, options) {
-        const rows = await this.loaderForFind(type).load({ where, ...options });
+        const rows = await (0, findDataLoader_1.findDataLoader)(this, type).load({ where, ...options });
         const result = rows.map((row) => this.hydrate(type, row, { overwriteExisting: false }));
-        if (options === null || options === void 0 ? void 0 : options.populate) {
+        if (options?.populate) {
             await this.populate(result, options.populate);
         }
         return result;
@@ -115,20 +139,99 @@ class EntityManager {
         // `calledFromConstructor` because this is _basically_ like calling `new`.
         const entity = new type(this, undefined);
         // Could remove the `as OptsOf<T>` by adding a method overload on `partial: true`
-        index_1.setOpts(entity, opts, { partial: true, calledFromConstructor: true });
+        (0, index_1.setOpts)(entity, opts, { partial: true, calledFromConstructor: true });
         return entity;
     }
     /** Creates a new `type` but with `opts` that are nullable, to accept partial-update-style input. */
     createOrUpdatePartial(type, opts) {
-        return createOrUpdatePartial_1.createOrUpdatePartial(this, type, opts);
+        return (0, createOrUpdatePartial_1.createOrUpdatePartial)(this, type, opts);
     }
-    async load(type, id, hint) {
+    /**
+     * Utility to clone an entity and its nested relations, as determined by a populate hint
+     *
+     * @param entity - Any entity
+     * @param hint - A populate hint
+     *
+     * @example
+     * // This will duplicate the author
+     * const duplicatedAuthor = await em.clone(author)
+     *
+     * @example
+     * // This will duplicate the author and all their related book entities
+     * const duplicatedAuthorAndBooks = await em.clone(author, "books")
+     *
+     * @exmaple
+     * // This will duplicate the author, all their books, and the images for those books
+     * const duplicatedAuthorAndBooksAndImages = await em.clone(author, {books: "image"})
+     */
+    async clone(entity, hint) {
+        const meta = getMetadata(entity);
+        const { id, ...data } = entity.__orm.data;
+        const clone = this.create(meta.cstr, {});
+        clone.__orm.data = data;
+        if (hint) {
+            if (typeof hint === "string") {
+                hint = { [hint]: {} };
+            }
+            else if (Array.isArray(hint)) {
+                hint = Object.fromEntries(hint.map((relation) => [relation, {}]));
+            }
+            await Promise.all(Object.entries(hint).map(async ([relationName, nested]) => {
+                const relation = entity[relationName];
+                if (relation instanceof index_1.OneToManyCollection) {
+                    const relatedEntities = await relation.load();
+                    await Promise.all(relatedEntities.map(async (related) => {
+                        const clonedRelated = await this.clone(related, nested);
+                        // Clear to avoid `set` mutating the original/source entity's relationship
+                        clonedRelated.__orm.data[relation.otherFieldName] = undefined;
+                        const relationToClone = clonedRelated[relation.otherFieldName];
+                        relationToClone.set(clone);
+                    }));
+                }
+                else if (relation instanceof relations_1.OneToOneReferenceImpl) {
+                    const related = await relation.load();
+                    if (related) {
+                        const clonedRelated = await this.clone(related, nested);
+                        // Clear to avoid `set` mutating the original/source entity's relationship
+                        clonedRelated.__orm.data[relation.otherFieldName] = undefined;
+                        const relationToClone = clone[relation.fieldName];
+                        relationToClone.set(clonedRelated);
+                    }
+                }
+                else if (relation instanceof relations_1.ManyToOneReferenceImpl) {
+                    const related = await relation.load();
+                    if (related) {
+                        const clonedRelated = await this.clone(related, nested);
+                        // Clear to avoid `set` mutating the original/source entity's relationship
+                        clone.__orm.data[relationName] = undefined;
+                        const relationToClone = clone[relationName];
+                        relationToClone.set(clonedRelated);
+                    }
+                }
+                else {
+                    (0, utils_1.fail)(`Uncloneable relation: ${relationName}`);
+                }
+            }));
+        }
+        return clone;
+    }
+    async load(typeOrId, id, hint) {
+        // Handle the `typeOrId` overload
+        let type;
+        if (typeof typeOrId === "string") {
+            type = (0, index_1.getConstructorFromTaggedId)(typeOrId);
+            id = typeOrId;
+        }
+        else {
+            type = typeOrId;
+            id = id || (0, utils_1.fail)();
+        }
         if (typeof id !== "string") {
             throw new Error(`Expected ${id} to be a string`);
         }
         const meta = getMetadata(type);
-        const tagged = index_1.tagIfNeeded(meta, id);
-        const entity = this.findExistingInstance(tagged) || (await this.loaderForEntity(meta).load(tagged));
+        const tagged = (0, index_1.tagId)(meta, id);
+        const entity = this.findExistingInstance(tagged) || (await (0, loadDataLoader_1.loadDataLoader)(this, meta).load(tagged));
         if (!entity) {
             throw new Error(`${tagged} was not found`);
         }
@@ -139,9 +242,9 @@ class EntityManager {
     }
     async loadAll(type, _ids, hint) {
         const meta = getMetadata(type);
-        const ids = _ids.map((id) => index_1.tagIfNeeded(meta, id));
+        const ids = _ids.map((id) => (0, index_1.tagId)(meta, id));
         const entities = await Promise.all(ids.map((id) => {
-            return this.findExistingInstance(id) || this.loaderForEntity(meta).load(id);
+            return this.findExistingInstance(id) || (0, loadDataLoader_1.loadDataLoader)(this, meta).load(id);
         }));
         const idsNotFound = ids.filter((id, i) => entities[i] === undefined);
         if (idsNotFound.length > 0) {
@@ -152,6 +255,17 @@ class EntityManager {
         }
         return entities;
     }
+    async loadAllIfExists(type, _ids, hint) {
+        const meta = 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(id);
+        }))).filter(Boolean);
+        if (hint) {
+            await this.populate(entities, hint);
+        }
+        return entities;
+    }
     async loadFromQuery(type, query, populate) {
         const rows = await query;
         const entities = rows.map((row) => this.hydrate(type, row, { overwriteExisting: false }));
@@ -161,7 +275,7 @@ class EntityManager {
         return entities;
     }
     async populate(entityOrList, hint) {
-        const list = Array.isArray(entityOrList) ? entityOrList : [entityOrList];
+        const list = (0, utils_1.toArray)(entityOrList);
         const promises = list
             .filter((e) => e !== undefined && (e.isPendingDelete || !e.isDeletedEntity))
             .flatMap((entity) => {
@@ -198,28 +312,18 @@ class EntityManager {
      * cannot be enforced with database-level constraints.
      */
     async transaction(fn) {
-        const originalKnex = this.knex;
-        const txn = await this.knex.transaction();
-        this.knex = txn;
-        try {
-            await txn.raw("set transaction isolation level serializable;");
-            await beforeTransaction(this, txn);
-            const result = await fn(txn);
+        return this.driver.transaction(this, async (knex) => {
+            const result = await fn(knex);
             // The lambda may have done some interstitial flushes (that would not
             // have committed the transaction), but go ahead and do a final one
             // in case they didn't explicitly call flush.
             await this.flush();
-            await txn.commit();
             return result;
-        }
-        finally {
-            if (!txn.isCompleted()) {
-                txn.rollback().catch((e) => {
-                    console.error(e, "Error rolling back");
-                });
-            }
-            this.knex = originalKnex;
-        }
+        }, 
+        // Application-enforced unique constraints (i.e. custom find + conditional insert) can be
+        // serialization anomalies, so we use the highest isolation level b/c it prevents this.
+        // See the EntityManager.txns.test.ts file.
+        "serializable");
     }
     /** Registers a newly-instantiated entity with our EntityManager; only called by entity constructors. */
     register(meta, entity) {
@@ -231,7 +335,7 @@ class EntityManager {
         entity.__orm.data["updatedAt"] = new Date();
         this._entities.push(entity);
         if (entity.id) {
-            index_1.assertIdsAreTagged([entity.id]);
+            (0, index_1.assertIdsAreTagged)([entity.id]);
             this._entityIndex.set(entity.id, entity);
         }
         if (this._entities.length >= exports.entityLimit) {
@@ -256,11 +360,7 @@ class EntityManager {
             return;
         }
         deletedEntity.__orm.deleted = "pending";
-        Object.values(deletedEntity)
-            .filter((v) => v instanceof AbstractRelationImpl_1.AbstractRelationImpl)
-            .map((relation) => {
-            relation.onEntityDelete();
-        });
+        (0, index_1.getRelations)(deletedEntity).forEach((relation) => relation.maybeCascadeDelete());
     }
     /**
      * Flushes the SQL for any changed entities to the database.
@@ -272,8 +372,11 @@ class EntityManager {
      * If this is run within an existing transaction, i.e. `EntityManager.transaction`,
      * then it will only issue `INSERT`s/etc. and defer to the caller to `COMMIT`
      * the transaction.
+     *
+     * It returns entities that have changed (an entity is considered changed if it has been deleted, inserted, or updated)
      */
-    async flush() {
+    async flush(flushOptions = {}) {
+        const { skipValidation = false } = flushOptions;
         if (this.isFlushing) {
             throw new Error("Cannot flush while another flush is already in progress");
         }
@@ -282,61 +385,64 @@ class EntityManager {
         let pendingEntities = this.entities.filter((e) => e.isPendingFlush);
         try {
             while (pendingEntities.length > 0) {
-                await new Promise((resolve, reject) => {
-                    exports.currentFlushSecret.run({ flushSecret: this.flushSecret }, async () => {
-                        try {
-                            const todos = EntityPersister_1.sortEntities(pendingEntities);
-                            // add objects to todos that have reactive hooks
-                            await addReactiveAsyncDerivedValues(todos);
-                            await addReactiveValidations(todos);
-                            // run our hooks
-                            await beforeDelete(this.ctx, todos);
-                            // We defer doing this cascade logic until flush() so that delete() can remain synchronous.
-                            await cascadeDeletesIntoRelations(todos);
-                            await beforeFlush(this.ctx, todos);
-                            recalcDerivedFields(todos);
-                            await recalcAsyncDerivedFields(this, todos);
-                            await validate(todos);
-                            await afterValidation(this.ctx, todos);
-                            entitiesToFlush.push(...pendingEntities);
-                            pendingEntities = this.entities.filter((e) => e.isPendingFlush && !entitiesToFlush.includes(e));
-                            this.flushSecret += 1;
-                            resolve();
-                        }
-                        catch (e) {
-                            reject(e);
-                        }
-                    });
+                await exports.currentFlushSecret.run({ flushSecret: this.flushSecret }, async () => {
+                    const todos = (0, Todo_1.createTodos)(pendingEntities);
+                    // Add objects to todos that have reactive hooks.
+                    // Note that, if we're on the 2nd loop, we might actually re-add entities that were already-validated
+                    // and already-flushed on the 1st loop, if those entities happen to be marked as derived from the
+                    // current loop's entities. In theory this is a good thing, b/c the current loop's entities have
+                    // been changed since/during the 1st loop, so we want the derived validation rules + derived values
+                    // to run again to see the latest & greatest data.
+                    await addReactiveAsyncDerivedValues(todos);
+                    await addReactiveValidations(todos);
+                    // run our hooks
+                    await beforeDelete(this.ctx, todos);
+                    // We defer doing this cascade logic until flush() so that delete() can remain synchronous.
+                    await cleanupDeletedRelations(todos);
+                    await beforeFlush(this.ctx, todos);
+                    await beforeCreate(this.ctx, todos);
+                    await beforeUpdate(this.ctx, todos);
+                    recalcDerivedFields(todos);
+                    await recalcAsyncDerivedFields(this, todos);
+                    if (!skipValidation) {
+                        await validate(todos);
+                        await afterValidation(this.ctx, todos);
+                    }
+                    entitiesToFlush.push(...pendingEntities);
+                    pendingEntities = this.entities.filter((e) => e.isPendingFlush && !entitiesToFlush.includes(e));
+                    this.flushSecret += 1;
                 });
             }
-            const entityTodos = EntityPersister_1.sortEntities(entitiesToFlush);
-            const joinRowTodos = EntityPersister_1.sortJoinRows(this.__data.joinRows);
+            const entityTodos = (0, Todo_1.createTodos)(entitiesToFlush);
+            const joinRowTodos = (0, Todo_1.combineJoinRows)(this.__data.joinRows);
             if (Object.keys(entityTodos).length > 0 || Object.keys(joinRowTodos).length > 0) {
-                const alreadyInTxn = "commit" in this.knex;
-                if (!alreadyInTxn) {
-                    await this.knex.transaction(async (knex) => {
-                        await beforeTransaction(this, knex);
-                        await EntityPersister_1.flushEntities(knex, entityTodos);
-                        await EntityPersister_1.flushJoinTables(knex, joinRowTodos);
-                        // When using `.transaction` with a lambda, we don't explicitly call commit
-                        // await knex.commit();
-                    });
-                }
-                else {
-                    await EntityPersister_1.flushEntities(this.knex, entityTodos);
-                    await EntityPersister_1.flushJoinTables(this.knex, joinRowTodos);
-                    // Defer to the caller to commit the transaction
-                }
+                // The driver will handle  the right thing if we're already in an existing transaction.
+                // We also purposefully don't pass an isolation level b/c if we're only doing
+                // INSERTs and UPDATEs, then we don't really care about overlapping SELECT-then-INSERT
+                // serialization anomalies. (Although should we? Maybe we should run the flush hooks
+                // in this same transaction just as a matter of principle / safest default.)
+                await this.driver.transaction(this, async () => {
+                    await this.driver.flushEntities(this, entityTodos);
+                    await this.driver.flushJoinTables(this, joinRowTodos);
+                });
                 // TODO: This is really "after flush" if we're being called from a transaction that
                 // is going to make multiple `em.flush()` calls?
                 await afterCommit(this.ctx, entityTodos);
                 Object.values(entityTodos).forEach((todo) => {
-                    todo.inserts.forEach((e) => this._entityIndex.set(e.id, e));
+                    todo.inserts.forEach((e) => {
+                        this._entityIndex.set(e.id, e);
+                        e.__orm.isNew = false;
+                    });
+                    [todo.inserts, todo.updates, todo.deletes].flat().forEach((e) => {
+                        e.__orm.originalData = {};
+                        e.__orm.isTouched = false;
+                    });
                 });
                 // Reset the find caches b/c data will have changed in the db
+                this.loadLoaders = {};
                 this.findLoaders = {};
-                this.__data.loaders = {};
             }
+            return entitiesToFlush;
         }
         finally {
             this._isFlushing = false;
@@ -356,6 +462,7 @@ class EntityManager {
         return `<EntityManager ${this.entities.length}>`;
     }
     async refresh(entityOrListOrUndefined) {
+        this.loadLoaders = {};
         this.findLoaders = {};
         const list = entityOrListOrUndefined === undefined
             ? this._entities
@@ -365,17 +472,10 @@ class EntityManager {
         await Promise.all(list.map(async (entity) => {
             if (entity.id) {
                 // Clear the original cached loader result and fetch the new primitives
-                const loader = this.loaderForEntity(getMetadata(entity));
-                loader.clear(entity.id);
-                await loader.load(entity.id);
+                await (0, loadDataLoader_1.loadDataLoader)(this, getMetadata(entity)).load(entity.id);
                 if (entity.__orm.deleted === undefined) {
                     // Then refresh any loaded collections
-                    await Promise.all(Object.values(entity).map((c) => {
-                        if (c instanceof AbstractRelationImpl_1.AbstractRelationImpl) {
-                            return c.refreshIfLoaded();
-                        }
-                        return undefined;
-                    }));
+                    await Promise.all((0, index_1.getRelations)(entity).map((r) => r.refreshIfLoaded()));
                 }
             }
         }));
@@ -383,118 +483,10 @@ class EntityManager {
     get numberOfEntities() {
         return this.entities.length;
     }
-    loaderForFind(type) {
-        return utils_1.getOrSet(this.findLoaders, type.name, () => {
-            return new dataloader_1.default(async (queries) => {
-                function ensureUnderLimit(rows) {
-                    if (rows.length >= exports.entityLimit) {
-                        throw new Error(`Query returned more than ${exports.entityLimit} rows`);
-                    }
-                    return rows;
-                }
-                // If there is only 1 query, we can skip the tagging step.
-                if (queries.length === 1) {
-                    return [ensureUnderLimit(await QueryBuilder_1.buildQuery(this.knex, type, queries[0]))];
-                }
-                const { knex } = this;
-                // Map each incoming query[i] to itself or a previous dup
-                const uniqueQueries = [];
-                const queryToUnique = {};
-                queries.forEach((q, i) => {
-                    let j = uniqueQueries.findIndex((uq) => whereFilterHash(uq) === whereFilterHash(q));
-                    if (j === -1) {
-                        uniqueQueries.push(q);
-                        j = uniqueQueries.length - 1;
-                    }
-                    queryToUnique[i] = j;
-                });
-                // There are duplicate queries, but only one unique query, so we can execute just it w/o tagging.
-                if (uniqueQueries.length === 1) {
-                    const rows = ensureUnderLimit(await QueryBuilder_1.buildQuery(this.knex, type, queries[0]));
-                    // Reuse this same result for however many callers asked for it.
-                    return queries.map(() => rows);
-                }
-                // TODO: Instead of this tagged approach, we could probably check if the each
-                // where cause: a) has the same structure for joins, and b) has conditions that
-                // we can evaluate client-side, and then combine it into a query like:
-                //
-                // SELECT entity.*, t1.foo as condition1, t2.bar as condition2 FROM ...
-                // WHERE t1.foo (union of each queries condition)
-                //
-                // And then use the `condition1` and `condition2` to tease the combined result set
-                // back apart into each condition's result list.
-                // For each query, add an additional `__tag` column that will identify that query's
-                // corresponding rows in the combined/UNION ALL'd result set.
-                //
-                // We also add a `__row` column with that queries order, so that after we `UNION ALL`,
-                // we can order by `__tag` + `__row` and ensure we're getting back the combined rows
-                // exactly as they would be in done individually (i.e. per the docs `UNION ALL` does
-                // not gaurantee order).
-                const tagged = uniqueQueries.map((queryAndSettings, i) => {
-                    const query = QueryBuilder_1.buildQuery(this.knex, type, queryAndSettings);
-                    return query.select(knex.raw(`${i} as __tag`), knex.raw("row_number() over () as __row"));
-                });
-                const meta = getMetadata(type);
-                // Kind of dumb, but make a dummy row to start our query with
-                let query = knex
-                    .select("*", knex.raw("-1 as __tag"), knex.raw("-1 as __row"))
-                    .from(meta.tableName)
-                    .orderBy("__tag", "__row")
-                    .where({ id: -1 });
-                // Use the dummy query as a base, then `UNION ALL` in all the rest
-                tagged.forEach((add) => {
-                    query = query.unionAll(add, true);
-                });
-                // Issue a single SQL statement for all of them
-                const rows = ensureUnderLimit(await query);
-                const resultForUniques = [];
-                uniqueQueries.forEach((q, i) => {
-                    resultForUniques[i] = [];
-                });
-                rows.forEach((row) => {
-                    resultForUniques[row["__tag"]].push(row);
-                });
-                // We return an array-of-arrays, where result[i] is the rows for queries[i]
-                const result = [];
-                queries.forEach((q, i) => {
-                    result[i] = resultForUniques[queryToUnique[i]];
-                });
-                return result;
-            }, {
-                // Our filter/order tuple is a complex object, so object-hash it to ensure caching works
-                cacheKeyFn: whereFilterHash,
-            });
-        });
-    }
-    loaderForEntity(meta) {
-        return utils_1.getOrSet(this.__data.loaders, meta.type, () => {
-            return new dataloader_1.default(async (_keys) => {
-                index_1.assertIdsAreTagged(_keys);
-                const keys = index_1.deTagIds(meta, _keys);
-                const rows = await this.knex.select("*").from(meta.tableName).whereIn("id", keys);
-                // Pass overwriteExisting (which is the default anyway) because it might be EntityManager.refresh calling us.
-                const entities = rows.map((row) => this.hydrate(meta.cstr, row, { overwriteExisting: true }));
-                const entitiesById = utils_1.indexBy(entities, (e) => e.id);
-                // Return the results back in the same order as the keys
-                return _keys.map((k) => {
-                    const entity = entitiesById.get(k);
-                    // We generally expect all of our entities to be found, but they may not for API calls like
-                    // `findOneOrFail` or for `EntityManager.refresh` when the entity has been deleted out from
-                    // under us.
-                    if (entity === undefined) {
-                        const existingEntity = this.findExistingInstance(k);
-                        if (existingEntity) {
-                            existingEntity.__orm.deleted = "deleted";
-                        }
-                    }
-                    return entity;
-                });
-            });
-        });
-    }
     // Handles our Unit of Work-style look up / deduplication of entity instances.
+    // Currently only public for the driver impls
     findExistingInstance(id) {
-        index_1.assertIdsAreTagged([id]);
+        (0, index_1.assertIdsAreTagged)([id]);
         return this._entityIndex.get(id);
     }
     /**
@@ -508,25 +500,34 @@ class EntityManager {
      */
     hydrate(type, row, options) {
         const meta = getMetadata(type);
-        const id = index_1.keyToString(meta, row["id"]) || utils_1.fail("No id column was available");
+        const id = (0, index_1.keyToString)(meta, row["id"]) || (0, utils_1.fail)("No id column was available");
         // See if this is already in our UoW
         let entity = this.findExistingInstance(id);
         if (!entity) {
             // Pass id as a hint that we're in hydrate mode
             entity = new type(this, id);
-            meta.columns.forEach((c) => c.serde.setOnEntity(entity.__orm.data, row));
+            Object.values(meta.fields).forEach((f) => f.serde?.setOnEntity(entity.__orm.data, row));
         }
-        else if ((options === null || options === void 0 ? void 0 : options.overwriteExisting) !== false) {
-            // Usually if the entity alrady exists, we don't write over it, but in this case
+        else if (options?.overwriteExisting !== false) {
+            // 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.
-            meta.columns.forEach((c) => c.serde.setOnEntity(entity.__orm.data, row));
+            Object.values(meta.fields).forEach((f) => f.serde?.setOnEntity(entity.__orm.data, row));
         }
         return entity;
     }
+    /**
+     * Mark an entity as needing to be flushed regardless of its state
+     */
+    touch(entity) {
+        entity.__orm.isTouched = true;
+    }
     beforeTransaction(fn) {
         this.hooks.beforeTransaction.push(fn);
     }
+    afterTransaction(fn) {
+        this.hooks.afterTransaction.push(fn);
+    }
     toString() {
         return "EntityManager";
     }
@@ -550,17 +551,16 @@ function isKey(k) {
 }
 exports.isKey = isKey;
 /** Compares `a` to `b`, where `b` might be an id. B/c ids can overlap, we need to know `b`'s metadata type. */
-function sameEntity(a, bMeta, bCurrent) {
-    if (a === undefined || bCurrent === undefined) {
-        return false;
+function sameEntity(a, meta, b) {
+    if (a === undefined || b === undefined) {
+        return a === undefined && b === undefined;
     }
-    return (a === bCurrent || (getMetadata(a) === bMeta && index_1.maybeResolveReferenceToId(a) === index_1.maybeResolveReferenceToId(bCurrent)));
+    return (a === b ||
+        (!a.isNewEntity && getMetadata(a) === meta && (0, index_1.maybeResolveReferenceToId)(a) === (0, index_1.maybeResolveReferenceToId)(b)));
 }
 exports.sameEntity = sameEntity;
-function getMetadata(entityOrType) {
-    return (typeof entityOrType === "function"
-        ? entityOrType.metadata
-        : entityOrType.__orm.metadata);
+function getMetadata(param) {
+    return (typeof param === "function" ? param.metadata : "cstr" in param ? param : param.__orm.metadata);
 }
 exports.getMetadata = getMetadata;
 /** Thrown by `findOneOrFail` if an entity is not found. */
@@ -575,6 +575,10 @@ exports.TooManyError = TooManyError;
  * For the entities currently in `todos`, find any reactive validation rules that point
  * from the currently-changed entities back to each rule's originally-defined-in entity,
  * and ensure those entities are added to `todos`.
+ *
+ * Note that we don't check whether `entitiesToFlush` already the entities we're adding,
+ * because rules should be side effect free, so invoking them twice, if that does happen
+ * to occur, should be fine (and desirable given something about the entity has changed).
  */
 async function addReactiveValidations(todos) {
     const p = Object.values(todos).flatMap((todo) => {
@@ -583,8 +587,11 @@ async function addReactiveValidations(todos) {
         return todo.metadata.config.__data.reactiveRules.map(async (reverseHint) => {
             // Add the resulting "found" entities to the right todos to be validated
             (await followReverseHint(entities, reverseHint)).forEach((entity) => {
-                const todo = EntityPersister_1.getTodo(todos, entity);
-                if (!todo.inserts.includes(entity) && !todo.updates.includes(entity) && !entity.isDeletedEntity) {
+                const todo = (0, Todo_1.getTodo)(todos, entity);
+                if (!todo.inserts.includes(entity) &&
+                    !todo.updates.includes(entity) &&
+                    !todo.validates.includes(entity) &&
+                    !entity.isDeletedEntity) {
                     todo.validates.push(entity);
                 }
             });
@@ -601,7 +608,7 @@ async function addReactiveAsyncDerivedValues(todos) {
         const entities = [...todo.inserts, ...todo.updates];
         return todo.metadata.config.__data.reactiveDerivedValues.map(async (reverseHint) => {
             (await followReverseHint(entities, reverseHint)).forEach((entity) => {
-                const todo = EntityPersister_1.getTodo(todos, entity);
+                const todo = (0, Todo_1.getTodo)(todos, entity);
                 if (!todo.inserts.includes(entity) && !todo.updates.includes(entity) && !entity.isDeletedEntity) {
                     todo.updates.push(entity);
                 }
@@ -611,14 +618,9 @@ async function addReactiveAsyncDerivedValues(todos) {
     await Promise.all(p);
 }
 /** Find all deleted entities and ensure their references all know about their deleted-ness. */
-async function cascadeDeletesIntoRelations(todos) {
+async function cleanupDeletedRelations(todos) {
     const entities = Object.values(todos).flatMap((todo) => todo.deletes);
-    await Promise.all(entities
-        .flatMap((e) => Object.values(e))
-        .filter((v) => v instanceof AbstractRelationImpl_1.AbstractRelationImpl)
-        .map((relation) => {
-        return relation.onEntityDeletedAndFlushing();
-    }));
+    await Promise.all(entities.flatMap(index_1.getRelations).map((relation) => relation.cleanupOnEntityDeleted()));
 }
 async function validate(todos) {
     const p = Object.values(todos).flatMap((todo) => {
@@ -634,31 +636,49 @@ async function validate(todos) {
         throw new index_1.ValidationErrors(errors);
     }
 }
-async function beforeTransaction(em, knex) {
-    await Promise.all(em["hooks"].beforeTransaction.map((fn) => fn(em, knex)));
+function beforeTransaction(em, knex) {
+    return Promise.all(em["hooks"].beforeTransaction.map((fn) => fn(em, knex)));
+}
+exports.beforeTransaction = beforeTransaction;
+function afterTransaction(em, knex) {
+    return Promise.all(em["hooks"].afterTransaction.map((fn) => fn(em, knex)));
 }
+exports.afterTransaction = afterTransaction;
 async function runHook(ctx, hook, todos, keys) {
     const p = Object.values(todos).flatMap((todo) => {
         const hookFns = todo.metadata.config.__data.hooks[hook];
         return keys
             .flatMap((k) => todo[k].filter((e) => k === "deletes" || !e.isDeletedEntity))
             .flatMap((entity) => {
+            // Use an explicit `async` here to ensure all hooks are promises, i.e. so that a non-promise
+            // hook blowing up doesn't orphan the others .
             return hookFns.map(async (fn) => fn(entity, ctx));
         });
     });
-    await Promise.all(p);
+    // Use `allSettled` so that even if 1 hook blows up, we don't orphan other hooks mid-flush
+    const rejects = (await Promise.allSettled(p)).filter((r) => r.status === "rejected");
+    // For now just throw the 1st rejection; this should be pretty rare
+    if (rejects.length > 0 && rejects[0].status === "rejected") {
+        throw rejects[0].reason;
+    }
+}
+function beforeDelete(ctx, todos) {
+    return runHook(ctx, "beforeDelete", todos, ["deletes"]);
 }
-async function beforeDelete(ctx, todos) {
-    await runHook(ctx, "beforeDelete", todos, ["deletes"]);
+function beforeFlush(ctx, todos) {
+    return runHook(ctx, "beforeFlush", todos, ["inserts", "updates"]);
 }
-async function beforeFlush(ctx, todos) {
-    await runHook(ctx, "beforeFlush", todos, ["inserts", "updates"]);
+function beforeCreate(ctx, todos) {
+    return runHook(ctx, "beforeCreate", todos, ["inserts"]);
 }
-async function afterValidation(ctx, todos) {
-    await runHook(ctx, "afterValidation", todos, ["inserts", "updates"]);
+function beforeUpdate(ctx, todos) {
+    return runHook(ctx, "beforeUpdate", todos, ["updates"]);
 }
-async function afterCommit(ctx, todos) {
-    await runHook(ctx, "afterCommit", todos, ["inserts", "updates"]);
+function afterValidation(ctx, todos) {
+    return runHook(ctx, "afterValidation", todos, ["inserts", "updates"]);
+}
+function afterCommit(ctx, todos) {
+    return runHook(ctx, "afterCommit", todos, ["inserts", "updates"]);
 }
 function coerceError(entity, maybeError) {
     if (maybeError === undefined) {
@@ -668,10 +688,10 @@ function coerceError(entity, maybeError) {
         return [{ entity, message: maybeError }];
     }
     else if (Array.isArray(maybeError)) {
-        return maybeError;
+        return maybeError.map((ve) => ({ entity, ...ve }));
     }
     else {
-        return [maybeError];
+        return [{ entity, ...maybeError }];
     }
 }
 /**
@@ -686,13 +706,18 @@ function recalcDerivedFields(todos) {
         .flatMap((todo) => [...todo.inserts, ...todo.updates])
         .filter((e) => !e.isDeletedEntity);
     const derivedFieldsByMeta = new Map([...new Set(entities.map(getMetadata))].map((m) => {
-        return [m, m.fields.filter((f) => f.kind === "primitive" && f.derived === "sync").map((f) => f.fieldName)];
+        return [
+            m,
+            Object.values(m.fields)
+                .filter((f) => f.kind === "primitive" && f.derived === "sync")
+                .map((f) => f.fieldName),
+        ];
     }));
     for (const entity of entities) {
         const derivedFields = derivedFieldsByMeta.get(entity.__orm.metadata);
-        derivedFields === null || derivedFields === void 0 ? void 0 : derivedFields.forEach((fieldName) => {
+        derivedFields?.forEach((fieldName) => {
             // setField will intelligently mark/not mark the field as dirty.
-            index_1.setField(entity, fieldName, entity[fieldName]);
+            (0, index_1.setField)(entity, fieldName, entity[fieldName]);
         });
     }
 }
@@ -710,18 +735,13 @@ async function recalcAsyncDerivedFields(em, todos) {
             if (entry) {
                 const [hint, fn] = entry;
                 await em.populate(changed, hint);
-                await Promise.all(changed.map((entity) => index_1.setField(entity, key, fn(entity))));
+                await Promise.all(changed.map((entity) => (0, index_1.setField)(entity, key, fn(entity))));
             }
         });
         await Promise.all(p);
     });
     await Promise.all(p);
 }
-// If a where clause includes an entity, object-hash cannot hash it, so just use the id.
-const replacer = (v) => (isEntity(v) ? v.id : v);
-function whereFilterHash(where) {
-    return object_hash_1.default(where, { replacer });
-}
 /**
  * Walks `reverseHint` for every entity in `entities`.
  *
@@ -736,18 +756,17 @@ async function followReverseHint(entities, reverseHint) {
         const fieldName = paths.shift();
         // The path might touch either a reference or a collection
         const entitiesOrLists = await Promise.all(current.flatMap((c) => {
-            var _a;
             const currentValuePromise = c[fieldName].load();
             // If we're going from Book.author back to Author to re-validate the Author.books collection,
             // see if Book.author has changed so we can re-validate both the old author's books and the
             // new author's books.
-            const isReference = ((_a = getMetadata(c).fields.find((f) => f.fieldName === fieldName)) === null || _a === void 0 ? void 0 : _a.kind) === "m2o";
+            const isReference = getMetadata(c).fields[fieldName]?.kind === "m2o";
             const hasChanged = isReference && c.changes[fieldName].hasChanged;
             const originalValue = c.changes[fieldName].originalValue;
             if (hasChanged && originalValue) {
                 const originalEntityMaybePromise = isEntity(originalValue)
                     ? originalValue
-                    : index_1.getEm(c).load(c[fieldName].otherMeta.cstr, originalValue);
+                    : c.em.load(c[fieldName].otherMeta.cstr, originalValue);
                 return [currentValuePromise, originalEntityMaybePromise];
             }
             return [currentValuePromise];