joist-test-utils 2.3.0-next.7 → 2.3.0-next.71

package/build/RunPlugin.js

@@ -1,356 +1,218 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RunPlugin = void 0;
-const joist_core_1 = require("joist-core");
-/*
- * `run...` helpers use this plugin to mirror any changes made to their isolated entity manager inside to the original
- * entity manager they were passed.  This allows changes to be synchronously reflected between the two entity managers
- * without needing to query the database.
- */
-class RunPlugin extends joist_core_1.Plugin {
-    em;
-    // The em passed here is the target which we'll mirror changes to.  The plugin should not be added to it, but rather
-    // to the new em `run..` helpers create or by downstream ems created by implementation code
-    constructor(em) {
-        super();
-        this.em = em;
-    }
-    maybeCloneForNewEm() {
-        return this;
-    }
-    afterWrite(entityTodos, joinRowTodos) {
-        const api = (0, joist_core_1.getEmInternalApi)(this.em);
-        // We don't want any old preloaded data leaking into our changes, so we clear it out before we start as a precaution
-        api.clearPreloadedRelations();
-        // Likewise, any data loaders in memory will have stale data, so we clear them out as well
-        api.clearDataloaders();
-        this.#syncEntityData(entityTodos);
-        this.#syncReferences(entityTodos);
-        this.#syncManyToManys(joinRowTodos);
-        this.#syncEnumCollections(joinRowTodos);
-        this.#preloadUnloadedRelations(entityTodos);
-    }
-    #syncEntityData(entityTodos) {
-        const { em } = this;
-        Object.values(entityTodos).forEach((todo) => {
-            todo.inserts.forEach((newEntity) => {
-                const row = (0, joist_core_1.createRowFromEntityData)(newEntity, { preferOriginalData: false });
-                em.hydrate(newEntity.constructor, [row]);
-            });
-            todo.updates.forEach((newEntity) => {
-                const oldEntity = em.findExistingInstance(newEntity.idTagged);
-                // This fail shouldn't really be possible, since any entity should either have been created:
-                // * via factory or em.create in the original em
-                // * by the new em inside the `run` call, in which case it'd be an insert instead of an update
-                // * by a previous afterWrite call, which would have already been an insert and added to the original em
-                // * by a previous `run` call, which would have already been an insert as well
-                if (!oldEntity)
-                    fail(`Expected to find existing entity for $ {e.idTagged}`);
-                const { data: newData } = (0, joist_core_1.getInstanceData)(newEntity);
-                const { data: oldData } = (0, joist_core_1.getInstanceData)(oldEntity);
-                const meta = (0, joist_core_1.getMetadata)(newEntity);
-                newEntity.changes.fields
-                    .values()
-                    .filter((fieldName) => fieldName in newData)
-                    .filter((fieldName) => !!meta.allFields[fieldName].serde)
-                    .forEach((fieldName) => {
-                    // We're imitating a round trip to the database here, so we use our field's serde to map the value back
-                    // and forth.
-                    const serde = meta.allFields[fieldName].serde;
-                    let column;
-                    let value;
-                    if (serde instanceof joist_core_1.PolymorphicKeySerde) {
-                        [column, value] =
-                            serde.columns
-                                .values()
-                                .map((c) => [c, c.rowValue(newData)])
-                                .find(([, v]) => v !== undefined) ?? [];
-                    }
-                    else {
-                        [column] = serde.columns;
-                        // the 2nd and 3rd arguments are only used if the 4th argument is defined, so it's OK to pass undefined here
-                        value = column.rowValue(newData);
-                    }
-                    serde.setOnEntity(oldData, column ? { [column.columnName]: value } : {});
-                });
-            });
-            todo.deletes.forEach((newEntity) => {
-                const existing = em.findExistingInstance(newEntity.idTagged);
-                // Again it shouldn't really be possible for a deletion to happen without the entity being present in the
-                // original em, but just in case we'll skip if we don't find it
-                if (!existing)
-                    fail(`Expected to find existing entity for $ {e.idTagged}`);
-                (0, joist_core_1.getInstanceData)(existing).markDeletedBecauseNotFound();
-            });
-        });
-    }
-    // Ensure m2o/rr/poly changes from the new em are reflected in the original em
-    #syncReferences(entityTodos) {
-        const { em } = this;
-        Object.values(entityTodos).forEach((todo) => {
-            todo.inserts.forEach((newEntity) => {
-                const oldEntity = em.findExistingInstance(newEntity.idTagged);
-                getReferences(newEntity).forEach((r) => {
-                    const other = r.isSet ? em.findExistingInstance(r.idTaggedMaybe) : undefined;
-                    preloadReference(em, r.fieldName, oldEntity, other);
-                    if (other)
-                        maybePreloadOtherSide(em, r.fieldName, oldEntity, other);
-                });
-            });
-            todo.updates.forEach((newEntity) => {
-                const oldEntity = em.findExistingInstance(newEntity.idTagged);
-                getReferences(newEntity)
-                    .filter((r) => newEntity.changes[r.fieldName].hasChanged)
-                    .forEach((r) => {
-                    const other = r.isSet ? em.findExistingInstance(r.idTaggedMaybe) : undefined;
-                    preloadReference(em, r.fieldName, oldEntity, other);
-                    if (other)
-                        maybePreloadOtherSide(em, r.fieldName, oldEntity, other);
-                    const originalId = newEntity.changes[r.fieldName].originalValue;
-                    const originalOther = originalId ? em.findExistingInstance(originalId) : undefined;
-                    if (originalOther)
-                        maybePreloadOtherSide(em, r.fieldName, oldEntity, originalOther, true);
-                });
-                // If the entity was soft-deleted, then we need to clear out the caches for any o2m collections that contain it
-                if ("deletedAt" in newEntity && newEntity.changes.deletedAt.hasChanged) {
-                    getReferences(oldEntity).forEach((r) => {
-                        const other = r.isSet ? em.findExistingInstance(r.idTaggedMaybe) : undefined;
-                        if (other) {
-                            const otherSide = getOtherSide(r.fieldName, oldEntity, other);
-                            if (otherSide instanceof joist_core_1.OneToManyCollection)
-                                otherSide.resetIsLoaded();
-                        }
-                    });
-                }
-            });
-            todo.deletes.forEach((newEntity) => {
-                const oldEntity = em.findExistingInstance(newEntity.idTagged);
-                getReferences(newEntity).forEach((r) => {
-                    // Since both old and new entities are marked as deleted, we can't just go looking through their relations
-                    // for the other side's id since this will error.  Likewise, we only care about the collection that this
-                    // entity used to belong to in the old em so we can remove it.  So just grab the other id directly from the
-                    // old entity's data and then preload its other side relation.
-                    const entityOrId = (0, joist_core_1.getInstanceData)(oldEntity).data[r.fieldName];
-                    const originalOther = entityOrId
-                        ? em.findExistingInstance((0, joist_core_1.isEntity)(entityOrId) ? entityOrId.idTagged : entityOrId)
-                        : undefined;
-                    if (originalOther)
-                        maybePreloadOtherSide(em, r.fieldName, oldEntity, originalOther, true);
-                });
-            });
-        });
-    }
-    // Ensure m2m changes are propagated from the new em to the original em
-    #syncManyToManys(joinRowTodos) {
-        const { em } = this;
-        const api = (0, joist_core_1.getEmInternalApi)(em);
-        Object.entries(joinRowTodos).forEach(([joinTable, todo]) => {
-            // Enum m2ms (EnumCollections) aren't entity-to-entity, so there's nothing to mirror between ems.
-            if (todo.m2m.otherEnum)
-                return;
-            const preloads = new Set();
-            processJoinRows(em, joinTable, todo.newRows, preloads, (oldEntity, entities) => entities.push(oldEntity));
-            processJoinRows(em, joinTable, todo.deletedRows, preloads, (oldEntity, entities) => entities.splice(entities.indexOf(oldEntity), 1));
-            // Since multiple join rows could reference the same m2m, our processJoinRows doesn't actually call preload() so
-            // we need to do it now
-            preloads.values().forEach((r) => {
-                const id = r.entity.idTagged;
-                const entities = api.getPreloadedRelation(id, r.fieldName);
-                // unique our entities in case somehow an entity was inserted by multiple join rows
-                api.setPreloadedRelation(id, r.fieldName, [...new Set(entities)]);
-                r.preload();
-            });
-        });
-    }
-    // Ensure enum m2m (EnumCollection) membership changes are propagated from the new em to the original em
-    #syncEnumCollections(joinRowTodos) {
-        const { em } = this;
-        const api = (0, joist_core_1.getEmInternalApi)(em);
-        const touched = new Set();
-        Object.values(joinRowTodos).forEach((todo) => {
-            // Only enum m2ms; entity-to-entity m2ms are handled by `#syncManyToManys`.
-            if (!todo.m2m.otherEnum)
-                return;
-            const { columnName, otherColumnName, fieldName } = todo.m2m;
-            const sync = (rows, add) => {
-                rows.forEach((row) => {
-                    const newEntity = row.columns[columnName];
-                    const enumId = row.columns[otherColumnName];
-                    const oldEntity = em.findExistingInstance(newEntity.idTagged);
-                    if (!oldEntity || oldEntity.isDeletedEntity)
-                        return;
-                    const oldCollection = oldEntity[fieldName];
-                    // Only mirror collections the original em has loaded (or new entities, whose rows are all
-                    // adds); otherwise a later `.load()` will read the (same-txn) db and see the change itself.
-                    if (!oldCollection.isLoaded && !newEntity.isNewEntity)
-                        return;
-                    const joinRows = api.joinRows(oldCollection);
-                    if (add) {
-                        joinRows.addPreloadedRow(oldCollection, undefined, oldEntity, enumId);
-                    }
-                    else {
-                        joinRows.removePreloadedRow(oldCollection, oldEntity, enumId);
-                    }
-                    touched.add(oldCollection);
-                });
-            };
-            sync(todo.newRows, true);
-            sync(todo.deletedRows, false);
-        });
-        // Re-publish each touched collection's codes and mark it loaded.
-        touched.forEach((oldCollection) => {
-            const joinRows = api.joinRows(oldCollection);
-            const codes = joinRows.getOthers(oldCollection.columnName, oldCollection.entity).map((id) => oldCollection.otherEnum.findById(id).code);
-            api.setPreloadedRelation(oldCollection.entity.idTagged, oldCollection.fieldName, codes);
-            oldCollection.preload();
-        });
-    }
-    // Make sure any unloaded relations on net new entities are marked as loaded.  We should have already preloaded all
-    // concrete references in a previous step. So we just need to load collections (plus o2os) if they haven't already
-    // been preloaded by another step. Since nothing else preloaded them, they must have no data so we can just set
-    // them to an empty array.
-    #preloadUnloadedRelations(entityTodos) {
-        const { em } = this;
-        Object.entries(entityTodos).forEach(([, todo]) => {
-            todo.inserts.forEach((newEntity) => {
-                const oldEntity = em.findExistingInstance(newEntity.idTagged);
-                getCollections(oldEntity)
-                    .filter((r) => !r.isPreloaded)
-                    .forEach((r) => {
-                    (0, joist_core_1.getEmInternalApi)(em).setPreloadedRelation(oldEntity.idTagged, r.fieldName, []);
-                    r.preload();
-                });
-            });
-        });
-    }
-}
-exports.RunPlugin = RunPlugin;
+import { EnumCollectionImpl, ManyToManyCollection, ManyToOneReferenceImpl, OneToManyCollection, OneToOneReferenceImpl, Plugin, PojoRowData, PolymorphicKeySerde, PolymorphicReferenceImpl, ReactiveManyToManyImpl, ReactiveManyToManyOtherSideImpl, ReactiveReferenceImpl, assertNever, createRowFromEntityData, getEmInternalApi, getInstanceData, getMetadata, getRelations, isEntity } from "joist-core";
+//#region src/RunPlugin.ts
+var RunPlugin = class extends Plugin {
+	em;
+	constructor(em) {
+		super();
+		this.em = em;
+	}
+	maybeCloneForNewEm() {
+		return this;
+	}
+	afterWrite(entityTodos, joinRowTodos) {
+		const api = getEmInternalApi(this.em);
+		api.clearPreloadedRelations();
+		api.clearDataloaders();
+		this.#syncEntityData(entityTodos);
+		this.#syncReferences(entityTodos);
+		this.#syncManyToManys(joinRowTodos);
+		this.#syncEnumCollections(joinRowTodos);
+		this.#preloadUnloadedRelations(entityTodos);
+	}
+	#syncEntityData(entityTodos) {
+		const { em } = this;
+		Object.values(entityTodos).forEach((todo) => {
+			todo.inserts.forEach((newEntity) => {
+				const row = createRowFromEntityData(newEntity, { preferOriginalData: false });
+				em.hydrate(newEntity.constructor, [row]);
+			});
+			todo.updates.forEach((newEntity) => {
+				const oldEntity = em.findExistingInstance(newEntity.idTagged);
+				if (!oldEntity) fail(`Expected to find existing entity for $ {e.idTagged}`);
+				const { data: newData } = getInstanceData(newEntity);
+				const { data: oldData } = getInstanceData(oldEntity);
+				const meta = getMetadata(newEntity);
+				newEntity.changes.fields.values().filter((fieldName) => fieldName in newData).filter((fieldName) => !!meta.allFields[fieldName].serde).forEach((fieldName) => {
+					const serde = meta.allFields[fieldName].serde;
+					let column;
+					let value;
+					if (serde instanceof PolymorphicKeySerde) [column, value] = serde.columns.values().map((c) => [c, c.rowValue(newData)]).find(([, v]) => v !== void 0) ?? [];
+					else {
+						[column] = serde.columns;
+						value = column.rowValue(newData);
+					}
+					oldData[fieldName] = serde.fromRow(new PojoRowData([column ? { [column.columnName]: value } : {}]), 0);
+				});
+			});
+			todo.deletes.forEach((newEntity) => {
+				const existing = em.findExistingInstance(newEntity.idTagged);
+				if (!existing) fail(`Expected to find existing entity for $ {e.idTagged}`);
+				getInstanceData(existing).markDeletedBecauseNotFound();
+			});
+		});
+	}
+	#syncReferences(entityTodos) {
+		const { em } = this;
+		Object.values(entityTodos).forEach((todo) => {
+			todo.inserts.forEach((newEntity) => {
+				const oldEntity = em.findExistingInstance(newEntity.idTagged);
+				getReferences(newEntity).forEach((r) => {
+					const other = r.isSet ? em.findExistingInstance(r.idTaggedMaybe) : void 0;
+					preloadReference(em, r.fieldName, oldEntity, other);
+					if (other) maybePreloadOtherSide(em, r.fieldName, oldEntity, other);
+				});
+			});
+			todo.updates.forEach((newEntity) => {
+				const oldEntity = em.findExistingInstance(newEntity.idTagged);
+				getReferences(newEntity).filter((r) => newEntity.changes[r.fieldName].hasChanged).forEach((r) => {
+					const other = r.isSet ? em.findExistingInstance(r.idTaggedMaybe) : void 0;
+					preloadReference(em, r.fieldName, oldEntity, other);
+					if (other) maybePreloadOtherSide(em, r.fieldName, oldEntity, other);
+					const originalId = newEntity.changes[r.fieldName].originalValue;
+					const originalOther = originalId ? em.findExistingInstance(originalId) : void 0;
+					if (originalOther) maybePreloadOtherSide(em, r.fieldName, oldEntity, originalOther, true);
+				});
+				if ("deletedAt" in newEntity && newEntity.changes.deletedAt.hasChanged) getReferences(oldEntity).forEach((r) => {
+					const other = r.isSet ? em.findExistingInstance(r.idTaggedMaybe) : void 0;
+					if (other) {
+						const otherSide = getOtherSide(r.fieldName, oldEntity, other);
+						if (otherSide instanceof OneToManyCollection) otherSide.resetIsLoaded();
+					}
+				});
+			});
+			todo.deletes.forEach((newEntity) => {
+				const oldEntity = em.findExistingInstance(newEntity.idTagged);
+				getReferences(newEntity).forEach((r) => {
+					const entityOrId = getInstanceData(oldEntity).data[r.fieldName];
+					const originalOther = entityOrId ? em.findExistingInstance(isEntity(entityOrId) ? entityOrId.idTagged : entityOrId) : void 0;
+					if (originalOther) maybePreloadOtherSide(em, r.fieldName, oldEntity, originalOther, true);
+				});
+			});
+		});
+	}
+	#syncManyToManys(joinRowTodos) {
+		const { em } = this;
+		const api = getEmInternalApi(em);
+		Object.entries(joinRowTodos).forEach(([joinTable, todo]) => {
+			if (todo.m2m.otherEnum) return;
+			const preloads = /* @__PURE__ */ new Set();
+			processJoinRows(em, joinTable, todo.newRows, preloads, (oldEntity, entities) => entities.push(oldEntity));
+			processJoinRows(em, joinTable, todo.deletedRows, preloads, (oldEntity, entities) => entities.splice(entities.indexOf(oldEntity), 1));
+			preloads.values().forEach((r) => {
+				const id = r.entity.idTagged;
+				const entities = api.getPreloadedRelation(id, r.fieldName);
+				api.setPreloadedRelation(id, r.fieldName, [...new Set(entities)]);
+				r.preload();
+			});
+		});
+	}
+	#syncEnumCollections(joinRowTodos) {
+		const { em } = this;
+		const api = getEmInternalApi(em);
+		const touched = /* @__PURE__ */ new Set();
+		Object.values(joinRowTodos).forEach((todo) => {
+			if (!todo.m2m.otherEnum) return;
+			const { columnName, otherColumnName, fieldName } = todo.m2m;
+			const sync = (rows, add) => {
+				rows.forEach((row) => {
+					const newEntity = row.columns[columnName];
+					const enumId = row.columns[otherColumnName];
+					const oldEntity = em.findExistingInstance(newEntity.idTagged);
+					if (!oldEntity || oldEntity.isDeletedEntity) return;
+					const oldCollection = oldEntity[fieldName];
+					if (!oldCollection.isLoaded && !newEntity.isNewEntity) return;
+					const joinRows = api.joinRows(oldCollection);
+					if (add) joinRows.addPreloadedRow(oldCollection, void 0, oldEntity, enumId);
+					else joinRows.removePreloadedRow(oldCollection, oldEntity, enumId);
+					touched.add(oldCollection);
+				});
+			};
+			sync(todo.newRows, true);
+			sync(todo.deletedRows, false);
+		});
+		touched.forEach((oldCollection) => {
+			const codes = api.joinRows(oldCollection).getOthers(oldCollection.columnName, oldCollection.entity).map((id) => oldCollection.otherEnum.findById(id).code);
+			api.setPreloadedRelation(oldCollection.entity.idTagged, oldCollection.fieldName, codes);
+			oldCollection.preload();
+		});
+	}
+	#preloadUnloadedRelations(entityTodos) {
+		const { em } = this;
+		Object.entries(entityTodos).forEach(([, todo]) => {
+			todo.inserts.forEach((newEntity) => {
+				const oldEntity = em.findExistingInstance(newEntity.idTagged);
+				getCollections(oldEntity).filter((r) => !r.isPreloaded).forEach((r) => {
+					getEmInternalApi(em).setPreloadedRelation(oldEntity.idTagged, r.fieldName, []);
+					r.preload();
+				});
+			});
+		});
+	}
+};
 function preloadReference(em, fieldName, entity, other) {
-    // Preload for concrete references doesn't make us of the global preloaded cache.  It just looks at its owner's data
-    // to get a key, then checks if that entity is already in the em and uses that if so.  So we just need to set the
-    // owner's data to have the correct key then we can call preload since all entities should already be in the original
-    // em
-    const reference = entity[fieldName];
-    reference.unload();
-    const { data } = (0, joist_core_1.getInstanceData)(entity);
-    data[fieldName] = other?.idTagged;
-    if (!entity.isDeletedEntity)
-        reference.preload();
+	const reference = entity[fieldName];
+	reference.unload();
+	const { data } = getInstanceData(entity);
+	data[fieldName] = other?.idTagged;
+	if (!entity.isDeletedEntity) reference.preload();
 }
 function getOtherSide(fieldName, entity, other) {
-    const meta = (0, joist_core_1.getMetadata)(entity);
-    const metas = new Set([meta, ...meta.baseTypes]);
-    return (0, joist_core_1.getRelations)(other)
-        .values()
-        .filter((r) => r instanceof joist_core_1.OneToOneReferenceImpl || r instanceof joist_core_1.OneToManyCollection)
-        .find((r) => metas.has(r.otherMeta) && r.otherFieldName === fieldName);
+	const meta = getMetadata(entity);
+	const metas = /* @__PURE__ */ new Set([meta, ...meta.baseTypes]);
+	return getRelations(other).values().filter((r) => r instanceof OneToOneReferenceImpl || r instanceof OneToManyCollection).find((r) => metas.has(r.otherMeta) && r.otherFieldName === fieldName);
 }
 function maybePreloadOtherSide(em, fieldName, entity, other, remove = false) {
-    const meta = (0, joist_core_1.getMetadata)(entity);
-    const otherSide = getOtherSide(fieldName, entity, other);
-    // If our other side is a large o2m then we can just ignore it, since it isn't loadable regardless
-    if (!otherSide)
-        return;
-    // Since our preload scans the entire em, we only need to run it once per collection/o2o.  We clear out preloads
-    // when we start the afterWrite, so if anything is preloaded we know we put it there.
-    if (otherSide.isPreloaded)
-        return;
-    let otherEntities;
-    if (otherSide instanceof joist_core_1.OneToOneReferenceImpl) {
-        otherEntities = remove ? [] : [entity];
-    }
-    else if (otherSide instanceof joist_core_1.OneToManyCollection) {
-        // Scan the entire em for (non-deleted) entities of our type that reference the other side
-        otherEntities = em
-            .getEntities(meta.cstr)
-            .values()
-            .filter((e) => !e.isDeletedEntity)
-            .filter((e) => e[otherSide.otherFieldName].idTaggedMaybe === other.idTagged)
-            .toArray();
-    }
-    else {
-        (0, joist_core_1.assertNever)(otherSide);
-    }
-    // We don't need to worry about order here because o2ms do their own sorting internally and o2os are inherently
-    // unordered (since it's just a single entity)
-    (0, joist_core_1.getEmInternalApi)(em).setPreloadedRelation(other.idTagged, otherSide.fieldName, otherEntities);
-    otherSide.preload();
-    // This method is confusingly name, what it actually does is clear out the sorted caches that m2m uses to avoid
-    // sorting on every `.get` call.  Since we just preloaded the collection with new data, we know these caches need to
-    // be cleared
-    if (otherSide instanceof joist_core_1.OneToManyCollection)
-        otherSide.resetIsLoaded();
+	const meta = getMetadata(entity);
+	const otherSide = getOtherSide(fieldName, entity, other);
+	if (!otherSide) return;
+	if (otherSide.isPreloaded) return;
+	let otherEntities;
+	if (otherSide instanceof OneToOneReferenceImpl) otherEntities = remove ? [] : [entity];
+	else if (otherSide instanceof OneToManyCollection) otherEntities = em.getEntities(meta.cstr).values().filter((e) => !e.isDeletedEntity).filter((e) => e[otherSide.otherFieldName].idTaggedMaybe === other.idTagged).toArray();
+	else assertNever(otherSide);
+	getEmInternalApi(em).setPreloadedRelation(other.idTagged, otherSide.fieldName, otherEntities);
+	otherSide.preload();
+	if (otherSide instanceof OneToManyCollection) otherSide.resetIsLoaded();
 }
 function processJoinRows(em, joinTable, rows, preloads, callback) {
-    const api = (0, joist_core_1.getEmInternalApi)(em);
-    rows.forEach((row) => {
-        // A join row's `columns` is always an object with two key/value pairs, one for each side of the m2m.
-        // This only runs for entity-to-entity m2ms (enum m2ms are skipped by the caller), so both are entities.
-        const [[col1, e1], [col2, e2]] = Object.entries(row.columns);
-        [
-            // Each join row needs to append/remove from both sides of the m2m. So we need to do the same operation once for
-            // each side.
-            [col1, e1, e2],
-            [col2, e2, e1],
-        ].forEach(([column, newEntity, newOther]) => {
-            const { idTagged: id } = newEntity;
-            const oldEntity = em.findExistingInstance(id);
-            if (oldEntity.isDeletedEntity)
-                return;
-            const newM2m = getManyToManys(newEntity).find((r) => r.joinTableName === joinTable && r.columnName === column);
-            const { fieldName } = newM2m;
-            const oldM2m = oldEntity[fieldName];
-            let entities;
-            if (preloads.has(oldM2m)) {
-                // If a previous join row has already preloaded this relation, then we can just append/remove from the
-                // existing preloaded data.
-                entities = api.getPreloadedRelation(id, fieldName);
-            }
-            else if (oldM2m.isLoaded) {
-                // The order here is important.  M2ms are returned in the order their join rows were inserted, so we need to
-                // make sure we match that behavior here.  So we get all the extant rows first and then append each new row
-                // in order from there.  Removals are fine since they'll modify the array in place and the correct order will
-                // be preserved.
-                entities = oldM2m.get;
-            }
-            else if (newEntity.isNewEntity) {
-                // If this is a new entity, then all the join rows referencing it must also be inserts. So we can just use an
-                // empty array initially and inserts will be appended to it.
-                entities = [];
-            }
-            else {
-                fail(`Expected ${fieldName} to be loaded`);
-            }
-            callback(em.findExistingInstance(newOther.idTagged), entities);
-            api.setPreloadedRelation(id, fieldName, entities);
-            // We only need to preload the m2m once, but multiple join rows could reference it, so we keep track of which m2ms
-            // need to be preloaded as we work, then actually call preload() at the end once we're done.
-            preloads.add(oldM2m);
-        });
-    });
+	const api = getEmInternalApi(em);
+	rows.forEach((row) => {
+		const [[col1, e1], [col2, e2]] = Object.entries(row.columns);
+		[[
+			col1,
+			e1,
+			e2
+		], [
+			col2,
+			e2,
+			e1
+		]].forEach(([column, newEntity, newOther]) => {
+			const { idTagged: id } = newEntity;
+			const oldEntity = em.findExistingInstance(id);
+			if (oldEntity.isDeletedEntity) return;
+			const { fieldName } = getManyToManys(newEntity).find((r) => r.joinTableName === joinTable && r.columnName === column);
+			const oldM2m = oldEntity[fieldName];
+			let entities;
+			if (preloads.has(oldM2m)) entities = api.getPreloadedRelation(id, fieldName);
+			else if (oldM2m.isLoaded) entities = oldM2m.get;
+			else if (newEntity.isNewEntity) entities = [];
+			else fail(`Expected ${fieldName} to be loaded`);
+			callback(em.findExistingInstance(newOther.idTagged), entities);
+			api.setPreloadedRelation(id, fieldName, entities);
+			preloads.add(oldM2m);
+		});
+	});
 }
 function getReferences(entity) {
-    return (0, joist_core_1.getRelations)(entity)
-        .values()
-        .filter((r) => r instanceof joist_core_1.ManyToOneReferenceImpl ||
-        r instanceof joist_core_1.ReactiveReferenceImpl ||
-        r instanceof joist_core_1.PolymorphicReferenceImpl);
+	return getRelations(entity).values().filter((r) => r instanceof ManyToOneReferenceImpl || r instanceof ReactiveReferenceImpl || r instanceof PolymorphicReferenceImpl);
 }
 function getManyToManys(entity) {
-    return (0, joist_core_1.getRelations)(entity)
-        .values()
-        .filter((r) => r instanceof joist_core_1.ManyToManyCollection ||
-        r instanceof joist_core_1.ReactiveManyToManyImpl ||
-        r instanceof joist_core_1.ReactiveManyToManyOtherSideImpl);
+	return getRelations(entity).values().filter((r) => r instanceof ManyToManyCollection || r instanceof ReactiveManyToManyImpl || r instanceof ReactiveManyToManyOtherSideImpl);
 }
 function getCollections(entity) {
-    return (0, joist_core_1.getRelations)(entity)
-        .values()
-        .filter((r) => r instanceof joist_core_1.ManyToManyCollection ||
-        r instanceof joist_core_1.OneToManyCollection ||
-        r instanceof joist_core_1.OneToOneReferenceImpl ||
-        r instanceof joist_core_1.ReactiveManyToManyImpl ||
-        r instanceof joist_core_1.ReactiveManyToManyOtherSideImpl ||
-        r instanceof joist_core_1.EnumCollectionImpl);
+	return getRelations(entity).values().filter((r) => r instanceof ManyToManyCollection || r instanceof OneToManyCollection || r instanceof OneToOneReferenceImpl || r instanceof ReactiveManyToManyImpl || r instanceof ReactiveManyToManyOtherSideImpl || r instanceof EnumCollectionImpl);
 }
+//#endregion
+export { RunPlugin };
+
 //# sourceMappingURL=RunPlugin.js.map