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

package/build/EntityManager.d.ts

@@ -27,8 +27,8 @@ 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 { lazyColumnLoadOperation } from "./relations/LazyField";
 import { OptsOf, OrderOf } from "./typeMap";
 import { MaybePromise } from "./utils";
 /**

package/build/EntityManager.js

@@ -51,8 +51,8 @@ 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 LazyField_1 = require("./relations/LazyField");
 const RecursiveCollection_1 = require("./relations/RecursiveCollection");
 const scopes_1 = require("./scopes");
 const Todo_1 = require("./Todo");
@@ -725,14 +725,13 @@ class EntityManager {
     }
     async loadAll(type, _ids, hint) {
         const meta = (0, index_1.getMetadata)(type);
-        // Use pre-allocated arrays/for loops instead of `.filter`s since this can be a hot spot
-        const ids = new Array(_ids.length);
+        // Use pre-allocated arrays/for loops instead of `.filter`s since this can be a hot spot;
+        // misses remember their tagged id + position so the all-hit path skips the `ids` copy entirely
         const entities = new Array(_ids.length);
         let idsToLoad;
         let positionsToLoad;
         for (let i = 0; i < _ids.length; i++) {
             const id = (0, index_1.tagId)(meta, _ids[i]);
-            ids[i] = id;
             const entity = this.findExistingInstance(id);
             if (entity) {
                 entities[i] = entity;
@@ -742,25 +741,23 @@ class EntityManager {
                 (positionsToLoad ??= []).push(i);
             }
         }
-        if (idsToLoad && idsToLoad.length > 0) {
+        if (idsToLoad) {
             await (0, loadBatchLoader_1.loadBatchLoader)(this, meta)
                 .loadAll(idsToLoad.map((id) => ({ taggedId: id, hint })))
                 .catch(function loadAll(err) {
                 throw appendStack(err, new Error());
             });
-            for (const i of positionsToLoad) {
-                entities[i] = this.findExistingInstance(ids[i]);
+            let idsNotFound;
+            for (let j = 0; j < positionsToLoad.length; j++) {
+                const entity = this.findExistingInstance(idsToLoad[j]);
+                entities[positionsToLoad[j]] = entity;
+                if (entity === undefined)
+                    (idsNotFound ??= []).push(idsToLoad[j]);
             }
-        }
-        let idsNotFound;
-        for (let i = 0; i < entities.length; i++) {
-            if (entities[i] === undefined) {
-                (idsNotFound ??= []).push(ids[i]);
+            if (idsNotFound) {
+                throw new NotFoundError(`${idsNotFound.join(",")} were not found`);
             }
         }
-        if (idsNotFound) {
-            throw new NotFoundError(`${idsNotFound.join(",")} were not found`);
-        }
         const loadedEntities = entities;
         if (hint) {
             await this.populate(loadedEntities, hint);
@@ -775,36 +772,43 @@ class EntityManager {
     }
     async loadAllIfExists(type, _ids, hint) {
         const meta = (0, index_1.getMetadata)(type);
-        // Use pre-allocated arrays/for loops instead of `.filter`s since this can be a hot spot
-        const ids = new Array(_ids.length);
-        const entities = [];
+        // Use pre-allocated arrays/for loops instead of `.filter`s since this can be a hot spot;
+        // the all-hit path returns the single pre-sized array without any id copies or rebuilds
+        const maybeEntities = new Array(_ids.length);
         let idsToLoad;
+        let positionsToLoad;
         // Ensure the ids are tagged, and find any not-yet-loaded
         for (let i = 0; i < _ids.length; i++) {
             const id = (0, index_1.tagId)(meta, _ids[i]);
-            ids[i] = id;
             const entity = this.findExistingInstance(id);
             if (entity) {
-                entities.push(entity);
+                maybeEntities[i] = entity;
             }
             else {
                 (idsToLoad ??= []).push(id);
+                (positionsToLoad ??= []).push(i);
             }
         }
-        if (idsToLoad && idsToLoad.length > 0) {
+        let entities;
+        if (idsToLoad) {
             await (0, loadBatchLoader_1.loadBatchLoader)(this, meta)
                 .loadAll(idsToLoad.map((id) => ({ taggedId: id, hint })))
                 .catch(function loadAllIfExists(err) {
                 throw appendStack(err, new Error());
             });
-            // Now that everything is loaded, recalc `entities`
-            entities.length = 0;
-            for (const id of ids) {
-                const entity = this.findExistingInstance(id);
-                if (entity)
+            // Fill in whichever missed ids actually exist, then compact out the not-founds
+            for (let j = 0; j < positionsToLoad.length; j++) {
+                maybeEntities[positionsToLoad[j]] = this.findExistingInstance(idsToLoad[j]);
+            }
+            entities = [];
+            for (const entity of maybeEntities) {
+                if (entity !== undefined)
                     entities.push(entity);
             }
         }
+        else {
+            entities = maybeEntities;
+        }
         if (hint) {
             await this.populate(entities, hint);
         }
@@ -1012,12 +1016,12 @@ class EntityManager {
                 // each time, so that for an INSERT-then-UPDATE the triggers don't think the
                 // UPDATE forgot to self-bump updatedAt, and then "helpfully" bump it for us.
                 if (alreadyRanHooks.size > 0) {
-                    maybeBumpUpdatedAt(this.#rm, (0, Todo_1.createTodos)([...alreadyRanHooks]), now);
+                    maybeBumpUpdatedAt(this.#rm, (0, Todo_1.createTodos)(alreadyRanHooks), now);
                 }
                 // Run hooks in a series of loops until things "settle down"
                 while (pendingHooks.size > 0) {
                     await this.#fl.allowWrites(async () => {
-                        let todos = (0, Todo_1.createTodos)([...pendingHooks]);
+                        let todos = (0, Todo_1.createTodos)(pendingHooks);
                         await (0, defaults_1.setAsyncDefaults)(suppressedDefaultTypeErrors, this.ctx, Todo_1.Todo.groupInsertsByTypeAndSubType(todos));
                         maybeBumpUpdatedAt(this.#rm, todos, now);
                         // Run our hooks
@@ -1235,13 +1239,17 @@ class EntityManager {
                 await afterCommit(this.ctx, allFlushedEntities);
                 // Update the `#orm` field to reflect the new state
                 for (const e of allFlushedEntities) {
+                    const instanceData = (0, BaseEntity_1.getInstanceData)(e);
                     if (e.isNewEntity && !e.isDeletedEntity)
                         this.#entitiesById.set(e.idTagged, e);
-                    (0, BaseEntity_1.getInstanceData)(e).resetAfterFlushed();
+                    instanceData.resetAfterFlushed();
                     // 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 || rel instanceof LazyField_1.LazyFieldImpl)
-                            rel.resetAfterFlush();
+                    const { relations } = instanceData;
+                    if (relations) {
+                        for (const rel of Object.values(relations)) {
+                            if (rel instanceof AsyncProperty_1.AsyncPropertyImpl || rel instanceof LazyField_1.LazyFieldImpl)
+                                rel.resetAfterFlush();
+                        }
                     }
                 }
                 // Update the joinRows refs to reflect the new state
@@ -1421,7 +1429,10 @@ class EntityManager {
                 const meta = findConcreteMeta(maybeBaseMeta, row);
                 // Pass id as a hint that we're in hydrate mode
                 entity = (0, newEntity_1.newEntity)(this, (0, index_1.asConcreteCstr)(meta.cstr), false);
-                (0, BaseEntity_1.getInstanceData)(entity).row = row;
+                const instanceData = (0, BaseEntity_1.getInstanceData)(entity);
+                instanceData.row = row;
+                // Seed the id to share the identity-map key string and skip the id serde on first read
+                instanceData.data["id"] = taggedId;
                 this.#doRegister(entity, taggedId, meta, true);
             }
             else if (overwriteExisting) {
@@ -1434,17 +1445,25 @@ class EntityManager {
                 // (this keeps us from deserializing data out of rows that we don't need).
                 const { data } = instanceData;
                 const dataKeys = Object.keys(data);
-                if (dataKeys.length > 0) {
+                // `id` is seeded at hydrate and can never change, so it never needs refreshing
+                if (dataKeys.length > ("id" in data ? 1 : 0)) {
                     const allFields = (0, index_1.getMetadata)(entity).allFields;
-                    const changedFields = entity.changes.fieldsWithoutRelations;
+                    // For existing entities this is exactly `changes.fieldsWithoutRelations`, minus the proxy allocation
+                    const changedFields = instanceData.isNewEntity
+                        ? entity.changes.fieldsWithoutRelations
+                        : Object.keys(instanceData.originalData);
                     if (changedFields.length === 0) {
                         for (const fieldName of dataKeys) {
+                            if (fieldName === "id")
+                                continue;
                             const serde = allFields[fieldName].serde ?? (0, utils_1.fail)(`Missing serde for ${fieldName}`);
                             serde.setOnEntity(data, row);
                         }
                     }
                     else {
                         for (const fieldName of dataKeys) {
+                            if (fieldName === "id")
+                                continue;
                             const serde = allFields[fieldName].serde ?? (0, utils_1.fail)(`Missing serde for ${fieldName}`);
                             serde.setOnEntity(data, row);
                             // Make the field look not-dirty
@@ -1600,15 +1619,18 @@ class EntityManager {
         const entities = this.#entitiesByTag.get(meta.tagName) ?? [];
         // Don't bother filtering if there's no where clause (particularly b/c IndexManager.findMatching
         // really expects there to be at least 1 condition)
-        if (Object.entries(where).length === 0) {
+        if (!(0, utils_1.hasAnyKey)(where)) {
             return entities.filter((e) => e instanceof cstr && !e.isDeletedEntity);
         }
         if (this.#indexManager.shouldIndexType(entities.length)) {
             this.#indexManager.enableIndexingForType(meta, entities, where);
-            return (this.#indexManager
-                .findMatching(meta, entities, where)
-                // Still filter by `instanceof cstr` to handle subtyping
-                .filter((e) => e instanceof cstr && !e.isDeletedEntity));
+            // Build the final array in one pass, still filtering `instanceof cstr` to handle subtyping
+            const result = [];
+            for (const e of this.#indexManager.findMatching(meta, entities, where)) {
+                if (e instanceof cstr && !e.isDeletedEntity)
+                    result.push(e);
+            }
+            return result;
         }
         else {
             return entities
@@ -1731,6 +1753,8 @@ class EntityManager {
                 continue;
             }
             const { relations } = oldEntity.__data;
+            if (!relations)
+                continue;
             for (const [field, relation] of Object.entries(relations)) {
                 // With lazyRelation, custom relations are inserted into the `relations` map. Custom relations don't
                 // store any data, so we can ignore them by checking if the relation implements `import`
@@ -1982,9 +2006,12 @@ getRules = (meta) => meta.reactiveRules) {
         });
     }
     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 = getRules(todo.metadata);
+        // Skip the entities spread for rule-less types
+        if (rules.length === 0)
+            return [];
+        const entities = [...todo.inserts, ...todo.updates, ...todo.deletes];
         return rules.map((rule) => {
             // Of all changed entities of this type, how many specifically trigger this rule?
             const triggered = entities.filter((e) => {
@@ -1994,10 +2021,12 @@ getRules = (meta) => meta.reactiveRules) {
                 // Any new-or-deleted entity fires every rule (reactiveRules has already filtered out read-only)
                 if (e.isNewEntity || e.isDeletedEntity)
                     return true;
-                // Otherwise see if the changed fields overlaps with the rule's fields
-                const changedFields = e.changes.fieldsWithoutRelations;
-                for (const field of changedFields) {
-                    if (rule.fields.includes(field))
+                // Otherwise see if the changed fields overlap with the rule's fields; for existing entities
+                // `changes.fieldsWithoutRelations` is exactly `Object.keys(originalData)`, so probe originalData
+                // directly instead of allocating a proxy + keys array per entity per rule.
+                const { originalData } = (0, BaseEntity_1.getInstanceData)(e);
+                for (const field of rule.fields) {
+                    if (field in originalData)
                         return true;
                 }
                 return false;
@@ -2042,21 +2071,34 @@ getRules = (meta) => meta.reactiveRules) {
 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) => getRules(m.config.__data));
-            return rules
-                .filter((rule) => rule.hint === undefined)
-                .flatMap(async ({ fn }) => coerceError(entity, await fn(entity)));
-        });
-    });
+    let p = undefined;
+    for (const todoKey in todos) {
+        const { inserts, updates } = todos[todoKey];
+        for (const entities of [inserts, updates]) {
+            for (const entity of entities) {
+                if (entity.isDeletedEntity)
+                    continue;
+                for (const m of (0, index_1.getBaseAndSelfMetas)((0, index_1.getMetadata)(entity))) {
+                    for (const rule of getRules(m.config.__data)) {
+                        if (rule.hint !== undefined)
+                            continue;
+                        (p ??= []).push(invokeRule(entity, rule.fn));
+                    }
+                }
+            }
+        }
+    }
+    if (!p)
+        return;
     const errors = (0, utils_1.failIfAnyRejected)(await Promise.allSettled(p)).flat();
     if (errors.length > 0) {
         throw new index_1.ValidationErrors(errors);
     }
 }
+/** Invokes a single validation rule, coercing its result/sync throws into a promise. */
+async function invokeRule(entity, fn) {
+    return coerceError(entity, await fn(entity));
+}
 function driverBeforeBegin(em, txn) {
     return Promise.all(getEmInternalApi(em).hooks.beforeBegin.map((fn) => fn(em, txn)));
 }
@@ -2070,23 +2112,54 @@ function driverAfterCommit(em, txn) {
     return Promise.all(getEmInternalApi(em).hooks.afterCommit.map((fn) => fn(em, txn)));
 }
 async function runHookOnTodos(ctx, hook, todos, keys) {
-    const entities = Object.values(todos).flatMap((todo) => {
-        return keys.flatMap((k) => todo[k].filter((e) => k === "deletes" || !e.isDeletedEntity));
-    });
-    return runHook(ctx, hook, entities);
+    // Only collect entities for todos whose type hierarchy actually has this hook, so that
+    // hook-less bulk flushes skip the per-entity array building entirely.
+    let entities = undefined;
+    for (const todoKey in todos) {
+        const todo = todos[todoKey];
+        if (!metaHasHook(todo.metadata, hook))
+            continue;
+        for (const k of keys) {
+            for (const e of todo[k]) {
+                if (k !== "deletes" && e.isDeletedEntity)
+                    continue;
+                (entities ??= []).push(e);
+            }
+        }
+    }
+    if (entities)
+        return runHook(ctx, hook, entities);
+}
+/** Returns whether `meta`'s base/self/sub hierarchy has any `hook` functions registered. */
+function metaHasHook(meta, hook) {
+    for (const m of (0, index_1.getBaseSelfAndSubMetas)(meta)) {
+        if (m.config.__data.hooks[hook].length > 0)
+            return true;
+    }
+    return false;
 }
 async function runHook(ctx, hook, entities) {
-    const p = entities.flatMap((entity) => {
-        const hookFns = (0, index_1.getBaseAndSelfMetas)((0, index_1.getMetadata)(entity)).flatMap((m) => m.config.__data.hooks[hook]);
-        // 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));
-    });
+    let p = undefined;
+    for (const entity of entities) {
+        for (const m of (0, index_1.getBaseAndSelfMetas)((0, index_1.getMetadata)(entity))) {
+            for (const fn of m.config.__data.hooks[hook]) {
+                // Use an explicit `async` invoke to ensure all hooks are promises, i.e. so that a
+                // non-promise hook blowing up doesn't orphan the others.
+                (p ??= []).push(invokeHook(fn, entity, ctx));
+            }
+        }
+    }
+    if (!p)
+        return;
     // Use `allSettled` so that even if 1 hook blows up, we don't orphan other hooks mid-flush
     // (causes weird errors when/if they try to access the EntityManager that has "moved on")
     const results = await Promise.allSettled(p);
     (0, utils_1.failIfAnyRejected)(results);
 }
+/** Invokes a single hook fn, coercing sync throws into rejections. */
+async function invokeHook(fn, entity, ctx) {
+    return fn(entity, ctx);
+}
 function beforeDelete(ctx, todos) {
     return runHookOnTodos(ctx, "beforeDelete", todos, ["deletes"]);
 }
@@ -2106,16 +2179,21 @@ function afterValidation(ctx, todos) {
 function entitiesFromTodos(entityTodos, joinRowTodos) {
     const entities = new Set();
     for (const todo of Object.values(entityTodos)) {
-        [...todo.inserts, ...todo.updates, ...todo.deletes].forEach((entity) => entities.add(entity));
+        for (const list of [todo.inserts, todo.updates, todo.deletes]) {
+            for (const entity of list)
+                entities.add(entity);
+        }
     }
     for (const todo of Object.values(joinRowTodos)) {
-        [...todo.newRows, ...todo.deletedRows].forEach((row) => {
-            // For enum m2ms, a column value is the enum's numeric id rather than an entity.
-            Object.values(row.columns).forEach((value) => {
-                if ((0, Entity_1.isEntity)(value))
-                    entities.add(value);
-            });
-        });
+        for (const rows of [todo.newRows, todo.deletedRows]) {
+            for (const row of rows) {
+                // For enum m2ms, a column value is the enum's numeric id rather than an entity.
+                for (const value of Object.values(row.columns)) {
+                    if ((0, Entity_1.isEntity)(value))
+                        entities.add(value);
+                }
+            }
+        }
     }
     return [...entities];
 }
@@ -2149,23 +2227,19 @@ function coerceError(entity, maybeError) {
 }
 /** Evaluates each (non-async) derived field to see if it's value has changed. */
 function recalcSynchronousDerivedFields(todos) {
-    const entities = Object.values(todos)
-        .flatMap((todo) => [...todo.inserts, ...todo.updates])
-        .filter((e) => !e.isDeletedEntity);
-    const derivedFieldsByMeta = new Map([...new Set(entities.map(index_1.getMetadata))].map((m) => {
-        return [
-            m,
-            Object.values(m.allFields)
-                .filter((f) => (f.kind === "primitive" || f.kind === "enum") && f.derived === "sync")
-                .map((f) => f.fieldName),
-        ];
-    }));
-    for (const entity of entities) {
-        const derivedFields = derivedFieldsByMeta.get((0, index_1.getMetadata)(entity)) || [];
-        derivedFields.forEach((fieldName) => {
-            // setField will intelligently mark/not mark the field as dirty.
-            (0, fields_1.setField)(entity, fieldName, entity[fieldName]);
-        });
+    for (const todoKey in todos) {
+        const todo = todos[todoKey];
+        for (const entities of [todo.inserts, todo.updates]) {
+            for (const entity of entities) {
+                if (entity.isDeletedEntity)
+                    continue;
+                // Use the per-meta cached field list instead of rebuilding a map per hook loop
+                for (const fieldName of (0, index_1.getMetadata)(entity).syncDerivedFields) {
+                    // setField will intelligently mark/not mark the field as dirty.
+                    (0, fields_1.setField)(entity, fieldName, entity[fieldName]);
+                }
+            }
+        }
     }
 }
 /** Recursively crawls through `entity`, with the given populate `deep` hint, and adds anything found to `found`. */