joist-core 2.3.0-next.2 → 2.3.0-next.20

package/build/AliasAssigner.d.ts

@@ -7,4 +7,3 @@ export declare class AliasAssigner {
     /** Returns an alias using the name as-is (no abbreviation), e.g. `"prequel"` → `"prequel"`. */
     getLiteralAlias(name: string): string;
 }
-//# sourceMappingURL=AliasAssigner.d.ts.map

package/build/Aliases.d.ts

@@ -114,4 +114,3 @@ export declare function getMaybeCtiAlias(meta: EntityMetadata, field: Field & {
     aliasSuffix: string;
 }, newMeta: EntityMetadata, newAlias: string): string;
 export {};
-//# sourceMappingURL=Aliases.d.ts.map

package/build/BaseEntity.d.ts

@@ -65,4 +65,3 @@ export declare abstract class BaseEntity<EM extends EntityManager, I extends IdT
  * on its `Object.create`-d instances.
  */
 export declare function baseEntityCstr(em: EntityManager, entity: BaseEntity<any, any>, isNew: boolean): void;
-//# sourceMappingURL=BaseEntity.d.ts.map

package/build/ConditionBuilder.d.ts

@@ -26,4 +26,3 @@ export declare class ConditionBuilder {
     toExpressionFilter(): ParsedExpressionFilter | undefined;
 }
 export {};
-//# sourceMappingURL=ConditionBuilder.d.ts.map

package/build/ConditionBuilder.js

@@ -100,7 +100,7 @@ function parseExpression(expression) {
         ? ["and", expression.and]
         : "or" in expression && expression.or
             ? ["or", expression.or]
-            : fail(`Invalid expression ${expression}`);
+            : (0, utils_1.fail)(`Invalid expression ${expression}`);
     // Potentially recurse into nested expressions
     const conditions = expressions.map((exp) => (exp && ("and" in exp || "or" in exp) ? parseExpression(exp) : exp));
     const [skip, valid] = (0, utils_1.partition)(conditions, (cond) => cond === undefined || cond === QueryParser_1.skipCondition);

package/build/ConditionBuilder.js.map

@@ -1 +1 @@
-{"version":3,"file":"ConditionBuilder.js","sourceRoot":"","sources":["../src/ConditionBuilder.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"ConditionBuilder.js","sourceRoot":"","sources":["../src/ConditionBuilder.ts"],"names":[],"mappings":"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"}

package/build/Entity.d.ts

@@ -36,4 +36,3 @@ export interface Entity {
      */
     toTaggedString(): string;
 }
-//# sourceMappingURL=Entity.d.ts.map

package/build/EntityFields.d.ts

@@ -34,4 +34,3 @@ export type SettableFields<F> = {
         derived: false;
     } ? F[K] : never;
 };
-//# sourceMappingURL=EntityFields.d.ts.map

package/build/EntityFilter.d.ts

@@ -131,4 +131,3 @@ export declare function mergeFindOptions<T extends Entity>(where: FindFilter<T>,
     where: FindFilter<T>;
     options: FindFilterOptions<T>;
 };
-//# sourceMappingURL=EntityFilter.d.ts.map

package/build/EntityGraphQLFilter.d.ts

@@ -53,4 +53,3 @@ export type Operator = (typeof operators)[number];
 export declare const opToFn: Record<Exclude<Operator, "in" | "nin" | "between">, string>;
 /** A GraphQL version of EntityFilter. */
 export type EntityGraphQLFilter<T extends Entity, I, F, N> = EntityFilter<T, I, F, N> | null;
-//# sourceMappingURL=EntityGraphQLFilter.d.ts.map

package/build/EntityManager.d.ts

@@ -27,6 +27,7 @@ import { PendingChange } from "./PendingChanges";
 import { PluginManager } from "./PluginManager";
 import { PreloadPlugin } from "./plugins/PreloadPlugin";
 import { ReactionsManager } from "./ReactionsManager";
+import { lazyColumnLoadOperation } from "./relations/LazyField";
 import { Collection } from "./relations/Collection";
 import { OptsOf, OrderOf } from "./typeMap";
 import { MaybePromise } from "./utils";
@@ -106,7 +107,7 @@ export interface FlushOptions {
  * - `writes` -- allows entity mutations and `em.flush` will `COMMIT` writes
  */
 export type EntityManagerMode = "read-only" | "in-memory-writes" | "writes";
-export type FindOperation = typeof findOperation | typeof findByUniqueOperation | typeof findCountOperation | typeof findIdsOperation | typeof lensOperation | typeof loadOperation | typeof manyToManyLoadOperation | typeof manyToManyFindOperation | typeof enumCollectionLoadOperation | typeof oneToManyLoadOperation | typeof oneToManyFindOperation | typeof oneToOneLoadOperation | typeof populateOperation | typeof recursiveChildrenOperation | typeof recursiveM2mOperation | typeof recursiveParentsOperation;
+export type FindOperation = typeof findOperation | typeof findByUniqueOperation | typeof findCountOperation | typeof findIdsOperation | typeof lensOperation | typeof loadOperation | typeof manyToManyLoadOperation | typeof manyToManyFindOperation | typeof enumCollectionLoadOperation | typeof oneToManyLoadOperation | typeof oneToManyFindOperation | typeof oneToOneLoadOperation | typeof populateOperation | typeof recursiveChildrenOperation | typeof recursiveM2mOperation | typeof recursiveParentsOperation | typeof lazyColumnLoadOperation;
 /**
  * The EntityManager is the primary way nearly all code, i.e. anything that finds/creates/updates/deletes entities,
  * will interact with the database.
@@ -689,7 +690,7 @@ export interface EntityManagerInternalApi {
     isValidating: boolean;
     checkWritesAllowed: () => void;
     isMerging: (entity: Entity) => boolean;
-    get fieldLogger(): FieldLogger | undefined;
+    get fieldLogger(): FieldLogger;
     get isLoadedCache(): IsLoadedCache;
     pluginManager: PluginManager;
     clearDataloaders(): void;
@@ -737,4 +738,3 @@ export declare function createRowFromEntityData(e: Entity, opts?: {
     preferOriginalData?: boolean;
 }): Record<string, any>;
 export {};
-//# sourceMappingURL=EntityManager.d.ts.map

package/build/EntityManager.js

@@ -43,6 +43,7 @@ const index_1 = require("./index");
 const IsLoadedCache_1 = require("./IsLoadedCache");
 const JoinRows_1 = require("./JoinRows");
 const loadHints_1 = require("./loadHints");
+const FieldLogger_1 = require("./logging/FieldLogger");
 const newEntity_1 = require("./newEntity");
 const newTestInstance_1 = require("./newTestInstance");
 const PluginManager_1 = require("./PluginManager");
@@ -50,6 +51,7 @@ const ReactionsManager_1 = require("./ReactionsManager");
 const reactiveHints_1 = require("./reactiveHints");
 const relations_1 = require("./relations");
 const AsyncProperty_1 = require("./relations/AsyncProperty");
+const LazyField_1 = require("./relations/LazyField");
 const hasAsyncMethod_1 = require("./relations/hasAsyncMethod");
 const RecursiveCollection_1 = require("./relations/RecursiveCollection");
 const scopes_1 = require("./scopes");
@@ -98,6 +100,8 @@ class EntityManager {
     // Provides field-based indexing for entity types with >1000 entities to optimize findWithNewOrChanged
     #indexManager = new IndexManager_1.IndexManager();
     #isValidating = false;
+    // Set while regular (pre-flush) validation rules run, so `em.find*` can fail fast (see #assertFindAllowed)
+    #findRestricted = false;
     #pendingPercolate = new Map();
     #preloadedRelations = new Map();
     /**
@@ -124,7 +128,7 @@ class EntityManager {
         afterCommit: [],
     };
     #preloader;
-    #fieldLogger;
+    #fieldLogger = FieldLogger_1.noopFieldLogger;
     #isLoadedCache = new IsLoadedCache_1.IsLoadedCache();
     #merging;
     /** Track `a#1`, `a#2`, etc indexes for `em.create`-d entities. */
@@ -265,6 +269,7 @@ class EntityManager {
         return this.#entitiesById.get(id);
     }
     async find(type, where, options) {
+        this.#assertFindAllowed("find");
         const { populate, ...rest } = options || {};
         const normalized = (0, index_1.mergeFindOptions)(where, rest);
         const settings = { where: normalized.where, ...normalized.options };
@@ -278,6 +283,14 @@ class EntityManager {
         }
         return result;
     }
+    /** Fails fast if `em.${method}` is called from a regular validation rule, i.e. steers to `config.addCommitRule`. */
+    #assertFindAllowed(method) {
+        if (this.#findRestricted) {
+            throw new Error(`em.${method} cannot be called from a validation rule (added via config.addRule), because rules run ` +
+                `before the flush and would query stale, pre-flush data. Use config.addCommitRule instead, which runs ` +
+                `after the INSERT/UPDATE/DELETEs are flushed (within the same transaction) and so sees the changed state.`);
+        }
+    }
     /** Runs the post-parse find pipeline: plugins mutate the logical AST, then Joist optimizes/prunes before SQL. */
     async executeFind(meta, operation, parsed, settings) {
         const { checkLimit, findSettings } = this.prepareFind(meta, operation, parsed, settings);
@@ -348,6 +361,7 @@ class EntityManager {
         return list[0];
     }
     async findByUnique(type, where, options = {}) {
+        this.#assertFindAllowed("findByUnique");
         const { populate, softDeletes = "exclude" } = options;
         const entries = Object.entries(where);
         if (entries.length !== 1) {
@@ -383,6 +397,7 @@ class EntityManager {
      * Note: this method is not currently auto-batched, so it will cause N+1s if called in a loop.
      */
     async findCount(type, where, options = {}) {
+        this.#assertFindAllowed("findCount");
         const normalized = (0, findCountDataLoader_1.mergeCountOptions)(where, options);
         const settings = { where: normalized.where, ...normalized.options };
         let count = await (0, findCountDataLoader_1.findCountDataLoader)(this, type, settings).catch(function findCount(err) {
@@ -416,6 +431,7 @@ class EntityManager {
      * as `em.find`.
      */
     async findIds(type, where, options = {}) {
+        this.#assertFindAllowed("findIds");
         const normalized = (0, findCountDataLoader_1.mergeCountOptions)(where, options);
         const settings = { where: normalized.where, ...normalized.options };
         return (0, findIdsDataLoader_1.findIdsDataLoader)(this, type, settings).catch(function findIds(err) {
@@ -1059,16 +1075,25 @@ class EntityManager {
                     this.#isValidating = true;
                     await pluginManager.beforeValidate(changedEntities);
                     if (validate) {
-                        // Run simple rules first b/c it includes not-null/required rules, so that then when we run
-                        // `validateReactiveRules` next, the app's lambdas won't see fundamentally invalid entities & NPE.
-                        await validateSimpleRules(entityTodos);
-                        // After we've let any "author is not set" simple rules fail before prematurely throwing
-                        // the "of course that caused an NPE" `TypeError`s, if all the authors *were* valid/set,
-                        // and we still have TypeErrors (from derived valeus), they were real, unrelated errors
-                        // that the user should see.
-                        if (suppressedDefaultTypeErrors.length > 0)
-                            throw suppressedDefaultTypeErrors[0];
-                        await validateReactiveRules(this, this.#rm.logger, entityTodos, joinRowTodos);
+                        // Regular rules run pre-flush, so `em.find*` would query stale data; block it and steer
+                        // users to `config.addCommitRule` (which runs post-flush). Only rules are restricted —
+                        // `afterValidation` hooks & plugins below are left free to query.
+                        this.#findRestricted = true;
+                        try {
+                            // Run simple rules first b/c it includes not-null/required rules, so that then when we run
+                            // `validateReactiveRules` next, the app's lambdas won't see fundamentally invalid entities & NPE.
+                            await validateSimpleRules(entityTodos);
+                            // After we've let any "author is not set" simple rules fail before prematurely throwing
+                            // the "of course that caused an NPE" `TypeError`s, if all the authors *were* valid/set,
+                            // and we still have TypeErrors (from derived valeus), they were real, unrelated errors
+                            // that the user should see.
+                            if (suppressedDefaultTypeErrors.length > 0)
+                                throw suppressedDefaultTypeErrors[0];
+                            await validateReactiveRules(this, this.#rm.logger, entityTodos, joinRowTodos);
+                        }
+                        finally {
+                            this.#findRestricted = false;
+                        }
                         await afterValidation(this.ctx, entityTodos);
                     }
                     await pluginManager.afterValidate(changedEntities);
@@ -1077,6 +1102,61 @@ class EntityManager {
                     this.#isValidating = false;
                 }
             };
+            // Runs `addCommitRule`s, which look exactly like regular validation rules but fire here,
+            // after the INSERT/UPDATE/DELETEs have hit the db (but before COMMIT), so that any
+            // `em.find`s they make query the just-flushed/changed state within the transaction.
+            const runCommitValidation = async (entityTodos, joinRowTodos) => {
+                // Drop the pre-flush find/query caches so commit rules' `em.find`s re-query and see the
+                // just-flushed rows, instead of stale results cached earlier in this same flush.
+                this.#dataloaders = {};
+                this.#batchLoaders = {};
+                this.#preloadedRelations = new Map();
+                try {
+                    // `isValidating` keeps derived-field reads from creating (now-unflushable) dirty state.
+                    this.#isValidating = true;
+                    await validateSimpleRules(entityTodos, (config) => config.commitRules);
+                    await validateReactiveRules(this, this.#rm.logger, entityTodos, joinRowTodos, (meta) => meta.reactiveCommitRules);
+                }
+                finally {
+                    this.#isValidating = false;
+                }
+            };
+            // Commit rules run once, at the end, over just the flushed entities/join-rows whose type has
+            // commit rules (see `meta.hasCommitRules`). We accumulate that subset here as we flush — deduping
+            // across the RQF loop below (which resets entity dirty-state) — so we neither keep every todo
+            // nor re-scan/merge them afterwards; apps without commit rules leave these empty and pay ~nothing.
+            const commitRuleTodos = {};
+            const commitRuleJoinRowTodos = {};
+            const commitRuleSeen = new Set();
+            function collectCommitRuleTodos(entityTodos, joinRowTodos) {
+                if (skipValidation)
+                    return;
+                for (const todo of Object.values(entityTodos)) {
+                    if (!todo.metadata.hasCommitRules)
+                        continue;
+                    for (const key of ["inserts", "updates", "deletes"]) {
+                        for (const e of todo[key]) {
+                            if (!commitRuleSeen.has(e)) {
+                                commitRuleSeen.add(e);
+                                (0, Todo_1.getTodo)(commitRuleTodos, e)[key].push(e);
+                            }
+                        }
+                    }
+                }
+                for (const [table, todo] of Object.entries(joinRowTodos)) {
+                    if (!todo.m2m.meta.hasCommitRules && !todo.m2m.otherMeta?.hasCommitRules)
+                        continue;
+                    const into = (commitRuleJoinRowTodos[table] ??= { ...todo, newRows: [], deletedRows: [] });
+                    for (const key of ["newRows", "deletedRows"]) {
+                        for (const r of todo[key]) {
+                            if (!commitRuleSeen.has(r)) {
+                                commitRuleSeen.add(r);
+                                into[key].push(r);
+                            }
+                        }
+                    }
+                }
+            }
             // Run hooks (in iterative loops if hooks mutate new entities) on pending entities
             let entitiesToFlush = await runHooksOnPendingEntities();
             for (const e of entitiesToFlush)
@@ -1095,6 +1175,8 @@ class EntityManager {
                     do {
                         if (Object.keys(entityTodos).length > 0 || Object.keys(joinRowTodos).length > 0) {
                             await this.driver.flush(this, entityTodos, joinRowTodos);
+                            // Accumulate the commit-rule-relevant subset before the RQF loop clobbers/resets these
+                            collectCommitRuleTodos(entityTodos, joinRowTodos);
                         }
                         // Now that we've flushed, we can let plugins know what we've done.
                         pluginManager.afterWrite(entityTodos, joinRowTodos);
@@ -1130,6 +1212,18 @@ class EntityManager {
                             entityTodos = {};
                         }
                     } while (Object.keys(entityTodos).length > 0);
+                    // Now that all SQL has hit the db (but before COMMIT), run any `addCommitRule`s so their
+                    // `em.find`s see the changed state. `commitRuleTodos` is only non-empty if a flushed entity
+                    // actually has commit rules, so apps without them skip this (and its logging) entirely.
+                    if (Object.keys(commitRuleTodos).length > 0 || Object.keys(commitRuleJoinRowTodos).length > 0) {
+                        // Make just-inserted entities findable by id (like the RQF loop does) so commit rules'
+                        // `em.find`s return these same instances rather than hydrating duplicate ones.
+                        for (const e of allFlushedEntities) {
+                            if (e.isNewEntity && !e.isDeletedEntity)
+                                this.#entitiesById.set(e.idTagged, e);
+                        }
+                        await runCommitValidation(commitRuleTodos, commitRuleJoinRowTodos);
+                    }
                     // Run `beforeCommit once right before COMMIT
                     await beforeCommit(this.ctx, allFlushedEntities);
                     if (this.mode === "in-memory-writes") {
@@ -1144,9 +1238,9 @@ class EntityManager {
                     if (e.isNewEntity && !e.isDeletedEntity)
                         this.#entitiesById.set(e.idTagged, e);
                     (0, BaseEntity_1.getInstanceData)(e).resetAfterFlushed();
-                    // Reset AsyncQueryProperties since DB state may have changed
+                    // Reset AsyncQueryProperties & LazyFields since DB state may have changed
                     for (const rel of Object.values((0, BaseEntity_1.getInstanceData)(e).relations)) {
-                        if (rel instanceof AsyncProperty_1.AsyncPropertyImpl)
+                        if (rel instanceof AsyncProperty_1.AsyncPropertyImpl || rel instanceof LazyField_1.LazyFieldImpl)
                             rel.resetAfterFlush();
                     }
                 }
@@ -1185,16 +1279,28 @@ class EntityManager {
                     }
                 }
             }
+            // node-pg keeps the DETAIL line (i.e. "Key (identity_id, final_id)=(102591, null) already exists")
+            // on a separate `detail` field, so keep it to suffix onto messages to help debugging.
+            const detail = e && typeof e === "object" && "detail" in e && typeof e.detail === "string" ? e.detail : undefined;
             if (e && typeof e === "object" && "constraint" in e && typeof e.constraint === "string") {
                 // node-pg errors use `constraint` to indicate the constraint name
                 const message = config_1.constraintNameToValidationError[e.constraint];
                 if (message) {
-                    throw new index_1.ValidationErrors(message);
+                    const errors = new index_1.ValidationErrors(message);
+                    // Keep the user-facing `errors[].message` pretty, but suffix the DETAIL onto the top-level
+                    // `message` so the debugging context survives into logs/stack traces.
+                    if (detail)
+                        errors.message = `${message} — ${detail}`;
+                    throw errors;
                 }
             }
             if (e instanceof InMemoryRollbackError) {
                 return [...allFlushedEntities].sort((a, b) => (0, BaseEntity_1.getInstanceData)(a).entityIndex - (0, BaseEntity_1.getInstanceData)(b).entityIndex);
             }
+            // For raw (non-pretty) pg errors, fold the DETAIL into `message` so it survives into logs.
+            if (detail && e instanceof Error) {
+                e.message = `${e.message} — ${detail}`;
+            }
             throw e;
         }
         finally {
@@ -1302,13 +1408,12 @@ 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 id = row["id"];
-            const taggedId = id === undefined || id === null ? (0, utils_1.fail)("No id column was available") : `${taggedIdPrefix}${id}`;
+            const taggedId = id === undefined || id === null ? (0, utils_1.fail)("No id column was available") : (0, index_1.keyToTaggedId)(maybeBaseMeta, id);
             // See if this is already in our UoW
             let entity = this.findExistingInstance(taggedId);
             if (!entity) {
@@ -1460,7 +1565,7 @@ class EntityManager {
         }
         const writeFn = getDefaultWriteFn(this.ctx);
         if (typeof arg === "boolean") {
-            this.#fieldLogger = arg ? new index_1.FieldLogger([], writeFn) : undefined;
+            this.#fieldLogger = arg ? new index_1.FieldLogger([], writeFn) : FieldLogger_1.noopFieldLogger;
         }
         else if (typeof arg === "string" || Array.isArray(arg)) {
             const specs = Array.isArray(arg) ? arg : [arg];
@@ -1742,7 +1847,7 @@ class EntityManager {
         }
         // api will be undefined during getFakeInstance
         const api = getEmInternalApi(this);
-        api?.fieldLogger?.logCreate(entity);
+        api?.fieldLogger.logCreate(entity);
         (0, index_1.setOpts)(entity, opts, { partial, calledFromConstructor: true });
         // Apply any synchronous defaults, after the opts have been applied
         if (!this.fakeInstance) {
@@ -1851,8 +1956,10 @@ exports.TooManyError = TooManyError;
  * from the currently-changed entities back to each rule's originally-defined-in entity,
  * and ensure those entities are added to `todos`.
  */
-async function validateReactiveRules(em, logger, todos, joinRowTodos) {
-    logger?.logStartingValidate(em, todos);
+async function validateReactiveRules(em, logger, todos, joinRowTodos, 
+// Which list of reactive rules to run, i.e. the pre-flush `reactiveRules` or the post-flush `reactiveCommitRules`
+getRules = (meta) => meta.reactiveRules) {
+    logger.logStartingValidate(em, todos);
     // Use a map of rule -> Set<Entity> so that we only invoke a rule once per entity,
     // even if it was triggered by multiple changed fields.
     const fns = new Map();
@@ -1869,7 +1976,7 @@ async function validateReactiveRules(em, logger, todos, joinRowTodos) {
             entities = new Set();
             fns.set(rule.fn, entities);
         }
-        logger?.logWalked(triggered, rule, found, "validate");
+        logger.logWalked(triggered, rule, found, "validate");
         found.forEach((entity) => {
             entities.add(entity);
         });
@@ -1877,7 +1984,7 @@ 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 = todo.metadata.reactiveRules;
+        const rules = getRules(todo.metadata);
         return rules.map((rule) => {
             // Of all changed entities of this type, how many specifically trigger this rule?
             const triggered = entities.filter((e) => {
@@ -1903,8 +2010,8 @@ async function validateReactiveRules(em, logger, todos, joinRowTodos) {
         // For enum m2ms the columns include the enum's numeric id, so keep only the entity values.
         const entities = [...todo.newRows, ...todo.deletedRows].flatMap((jr) => Object.values(jr.columns)).filter(Entity_1.isEntity);
         // The owning-entity side (applies to both entity-to-entity and entity-to-enum m2ms).
-        const a = todo.m2m.meta
-            .reactiveRules.filter((rule) => rule.fields.includes(todo.m2m.fieldName))
+        const a = getRules(todo.m2m.meta)
+            .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);
@@ -1912,8 +2019,8 @@ async function validateReactiveRules(em, logger, todos, joinRowTodos) {
         // The "other" side only exists for entity-to-entity m2ms; enums have no reverse field.
         const { otherMeta, otherFieldName } = todo.m2m;
         const b = otherMeta
-            ? otherMeta
-                .reactiveRules.filter((rule) => rule.fields.includes(otherFieldName))
+            ? getRules(otherMeta)
+                .filter((rule) => rule.fields.includes(otherFieldName))
                 .map((rule) => {
                 const triggered = entities.filter((e) => e instanceof otherMeta.cstr);
                 return followAndQueue(triggered, rule);
@@ -1932,12 +2039,14 @@ async function validateReactiveRules(em, logger, todos, joinRowTodos) {
 // Run *non-reactive* (those with `fields: undefined`) rules of explicitly mutated entities,
 // because even for reactive validations on mutated entities, we defer to addReactiveValidations
 // to mark only the rules that need to run.
-async function validateSimpleRules(todos) {
+async function validateSimpleRules(todos, 
+// Which config list to pull rules from, i.e. the pre-flush `rules` or the post-flush `commitRules`
+getRules = (config) => config.rules) {
     const p = Object.values(todos).flatMap(({ inserts, updates }) => {
         return [...inserts, ...updates]
             .filter((e) => !e.isDeletedEntity)
             .flatMap((entity) => {
-            const rules = (0, index_1.getBaseAndSelfMetas)((0, index_1.getMetadata)(entity)).flatMap((m) => m.config.__data.rules);
+            const rules = (0, index_1.getBaseAndSelfMetas)((0, index_1.getMetadata)(entity)).flatMap((m) => getRules(m.config.__data));
             return rules
                 .filter((rule) => rule.hint === undefined)
                 .flatMap(async ({ fn }) => coerceError(entity, await fn(entity)));