@bunyad/orm 0.1.0-alpha.0

package/dist/eager.js

@@ -0,0 +1,854 @@
+/**
+ * Eager-load relations and aggregates onto models.
+ */
+import { wrapSqlName } from "@bunyad/database";
+import { OrmCollection } from "./orm-collection.js";
+import { softDeleteAliasSql, uniqueKeys, coerceEagerRelations, } from "./model-helpers.js";
+import { eagerFetchByKeys } from "./eager-fetch.js";
+import { Model } from "./model.js";
+import { enterEagerLoad, leaveEagerLoad } from "./model-strictness.js";
+import { BelongsTo, BelongsToMany, HasMany, HasManyThrough, HasOne, HasOneThrough, MorphMany, MorphOne, MorphTo, MorphToMany, aggregateRelation, applyPivotAttributes, resolveMorphType, resolveRelation, } from "./relations.js";
+/** Eager-load named relations onto models (`with` / `load` / collections).
+ * Batches BelongsTo / HasMany / HasOne / BelongsToMany / Morph* / ofMany with
+ * `WHERE IN`. Nested paths like `parent.children` are supported.
+ * Independent top-level relations load in parallel.
+ * Constraints from `with({ posts: (q) => q.where(…) })` are applied per relation.
+ */
+/**
+ * Eager-load relations onto models.
+ * Returns void when all work is synchronous (SQLite BelongsTo fast-find),
+ * otherwise a Promise — callers must branch like `get()` hydrate does.
+ */
+export function eagerLoadModels(models, relations) {
+    const list = models;
+    const entries = coerceEagerRelations(relations);
+    if (entries.length === 0 || list.length === 0)
+        return;
+    enterEagerLoad();
+    let asyncWork;
+    try {
+        asyncWork = eagerLoadModelsBody(list, entries);
+    }
+    catch (err) {
+        leaveEagerLoad();
+        throw err;
+    }
+    if (asyncWork && typeof asyncWork.then === "function") {
+        return asyncWork.finally(() => {
+            leaveEagerLoad();
+        });
+    }
+    leaveEagerLoad();
+    return asyncWork;
+}
+function eagerLoadModelsBody(list, entries) {
+    const grouped = new Map();
+    for (const entry of entries) {
+        if (typeof entry.name !== "string" || !entry.name.trim())
+            continue;
+        const [head, ...rest] = entry.name.split(".");
+        if (!head)
+            continue;
+        let group = grouped.get(head);
+        if (!group) {
+            group = { nested: [] };
+            grouped.set(head, group);
+        }
+        if (rest.length > 0) {
+            group.nested.push({
+                name: rest.join("."),
+                constraint: entry.constraint,
+            });
+        }
+        else if (entry.constraint) {
+            group.constraint = entry.constraint;
+        }
+    }
+    const pending = [];
+    for (const [relation, group] of grouped) {
+        const result = eagerLoadOneRelation(list, relation, group.constraint);
+        if (result)
+            pending.push(result);
+    }
+    const finishNested = () => {
+        const nestedPending = [];
+        for (const [relation, group] of grouped) {
+            if (group.nested.length === 0)
+                continue;
+            const children = [];
+            for (const model of list) {
+                const value = model[relation];
+                if (value == null)
+                    continue;
+                if (value instanceof OrmCollection) {
+                    for (const child of value)
+                        children.push(child);
+                }
+                else if (Array.isArray(value)) {
+                    children.push(...value);
+                }
+                else if (typeof value === "object") {
+                    children.push(value);
+                }
+            }
+            if (children.length > 0) {
+                const nestedResult = eagerLoadModels(children, group.nested);
+                if (nestedResult)
+                    nestedPending.push(nestedResult);
+            }
+        }
+        if (nestedPending.length === 0)
+            return;
+        return Promise.all(nestedPending).then(() => undefined);
+    };
+    if (pending.length === 0)
+        return finishNested();
+    return Promise.all(pending).then(() => finishNested());
+}
+function applyConstraint(q, constraint) {
+    if (constraint)
+        constraint(q);
+    return q;
+}
+function relationFromModel(model, relation) {
+    try {
+        return model.related(relation);
+    }
+    catch {
+        return null;
+    }
+}
+/** Keep `WHERE IN` under common driver bind limits. */
+const EAGER_IN_CHUNK = 900;
+/** Max concurrent IN-chunk queries (bulk eager / sync). Pages ≤900 ids stay single-query. */
+const EAGER_IN_CONCURRENCY = 3;
+async function forEachIdChunk(ids, run) {
+    if (ids.length === 0)
+        return;
+    if (ids.length <= EAGER_IN_CHUNK) {
+        await run(ids);
+        return;
+    }
+    const chunks = [];
+    for (let i = 0; i < ids.length; i += EAGER_IN_CHUNK) {
+        chunks.push(ids.slice(i, i + EAGER_IN_CHUNK));
+    }
+    // Bounded pool — avoids pool stampede when stacking on parallel with() relations.
+    let next = 0;
+    const workers = Array.from({ length: Math.min(EAGER_IN_CONCURRENCY, chunks.length) }, async () => {
+        while (next < chunks.length) {
+            const index = next++;
+            await run(chunks[index]);
+        }
+    });
+    await Promise.all(workers);
+}
+function eagerLoadOneRelation(models, relation, constraint) {
+    const sampleRel = relationFromModel(models[0], relation);
+    if (!sampleRel)
+        return;
+    if (sampleRel instanceof HasOne && sampleRel.isOfMany()) {
+        return eagerLoadHasOneOfMany(models, relation, sampleRel, constraint);
+    }
+    if (sampleRel instanceof MorphOne && sampleRel.isOfMany()) {
+        return eagerLoadMorphOneOfMany(models, relation, sampleRel, constraint);
+    }
+    if (sampleRel instanceof BelongsTo) {
+        return eagerLoadBelongsTo(models, relation, sampleRel, constraint);
+    }
+    if (sampleRel instanceof HasMany) {
+        return eagerLoadHasMany(models, relation, sampleRel, constraint);
+    }
+    if (sampleRel instanceof HasOne) {
+        return eagerLoadHasOne(models, relation, sampleRel, constraint);
+    }
+    if (sampleRel instanceof BelongsToMany) {
+        return eagerLoadBelongsToMany(models, relation, sampleRel, constraint);
+    }
+    if (sampleRel instanceof MorphToMany) {
+        return eagerLoadMorphToMany(models, relation, sampleRel, constraint);
+    }
+    if (sampleRel instanceof MorphMany) {
+        return eagerLoadMorphMany(models, relation, sampleRel, constraint);
+    }
+    if (sampleRel instanceof MorphOne) {
+        return eagerLoadMorphOne(models, relation, sampleRel, constraint);
+    }
+    if (sampleRel instanceof MorphTo) {
+        return eagerLoadMorphTo(models, relation, sampleRel, constraint);
+    }
+    if (sampleRel instanceof HasManyThrough) {
+        return eagerLoadHasManyThrough(models, relation, sampleRel, constraint);
+    }
+    if (sampleRel instanceof HasOneThrough) {
+        return eagerLoadHasOneThrough(models, relation, sampleRel, constraint);
+    }
+}
+/** Single-query ofMany via GROUP BY join (avoids per-row correlated subqueries). */
+async function eagerLoadHasOneOfMany(models, relation, sample, constraint) {
+    const foreignKey = sample.getForeignKeyName();
+    const localKey = sample.getLocalKeyName();
+    const Related = sample.getRelated();
+    const ofManyColumn = sample.getOfManyColumn();
+    const ofManyAggregate = sample.getOfManyAggregate();
+    const parentIds = uniqueKeys(models.map((model) => model[localKey]));
+    const byParent = new Map();
+    if (parentIds.length > 0 && constraint) {
+        await forEachIdChunk(parentIds, async (chunk) => {
+            let q = Related.whereIn(foreignKey, chunk);
+            applyConstraint(q, constraint);
+            const related = await q.get();
+            const pick = ofManyAggregate === "max"
+                ? (a, b) => (a > b ? a : b)
+                : (a, b) => (a < b ? a : b);
+            const best = new Map();
+            for (const row of related.all()) {
+                const key = String(row[foreignKey]);
+                const value = row[ofManyColumn];
+                const prev = best.get(key);
+                if (!prev || pick(value, prev.value) === value) {
+                    best.set(key, { value, model: row });
+                }
+            }
+            for (const [key, entry] of best) {
+                if (!byParent.has(key))
+                    byParent.set(key, entry.model);
+            }
+        });
+    }
+    else if (parentIds.length > 0) {
+        const dialect = Related.getConnection().dialect;
+        const table = wrapSqlName(dialect, Related.table);
+        const col = wrapSqlName(dialect, ofManyColumn);
+        const fk = wrapSqlName(dialect, foreignKey);
+        const agg = ofManyAggregate.toUpperCase();
+        const softOuter = softDeleteAliasSql(Related, table);
+        const softSub = softDeleteAliasSql(Related, "bunyad_of_many");
+        await forEachIdChunk(parentIds, async (chunk) => {
+            const placeholders = chunk.map(() => "?").join(", ");
+            const rows = await Related.getConnection().all(`SELECT ${table}.*
+         FROM ${table}
+         INNER JOIN (
+           SELECT bunyad_of_many.${fk} AS __bunyad_fk, ${agg}(bunyad_of_many.${col}) AS __bunyad_agg
+           FROM ${table} AS bunyad_of_many
+           WHERE bunyad_of_many.${fk} IN (${placeholders})${softSub}
+           GROUP BY bunyad_of_many.${fk}
+         ) AS bunyad_agg
+           ON ${table}.${fk} = bunyad_agg.__bunyad_fk
+          AND ${table}.${col} = bunyad_agg.__bunyad_agg
+         WHERE ${table}.${fk} IN (${placeholders})${softOuter}`, [...chunk, ...chunk]);
+            for (const row of rows) {
+                const key = String(row[foreignKey]);
+                if (!byParent.has(key))
+                    byParent.set(key, new Related(row));
+            }
+        });
+    }
+    for (const model of models) {
+        const id = model[localKey];
+        model[relation] =
+            id == null ? null : (byParent.get(String(id)) ?? null);
+    }
+}
+async function eagerLoadMorphOneOfMany(models, relation, sample, constraint) {
+    const Related = sample.getRelated();
+    const typeColumn = sample.getTypeColumn();
+    const idColumn = sample.getIdColumn();
+    const morphType = sample.getMorphType();
+    const localKey = sample.getLocalKeyName();
+    const ofManyColumn = sample.getOfManyColumn();
+    const ofManyAggregate = sample.getOfManyAggregate();
+    const parentIds = uniqueKeys(models.map((model) => model[localKey]));
+    const byParent = new Map();
+    if (parentIds.length > 0 && constraint) {
+        await forEachIdChunk(parentIds, async (chunk) => {
+            let q = Related.where(typeColumn, morphType).whereIn(idColumn, chunk);
+            applyConstraint(q, constraint);
+            const related = await q.get();
+            const pick = ofManyAggregate === "max"
+                ? (a, b) => (a > b ? a : b)
+                : (a, b) => (a < b ? a : b);
+            const best = new Map();
+            for (const row of related.all()) {
+                const key = String(row[idColumn]);
+                const value = row[ofManyColumn];
+                const prev = best.get(key);
+                if (!prev || pick(value, prev.value) === value) {
+                    best.set(key, { value, model: row });
+                }
+            }
+            for (const [key, entry] of best) {
+                if (!byParent.has(key))
+                    byParent.set(key, entry.model);
+            }
+        });
+    }
+    else if (parentIds.length > 0) {
+        const dialect = Related.getConnection().dialect;
+        const table = wrapSqlName(dialect, Related.table);
+        const col = wrapSqlName(dialect, ofManyColumn);
+        const typeCol = wrapSqlName(dialect, typeColumn);
+        const idCol = wrapSqlName(dialect, idColumn);
+        const agg = ofManyAggregate.toUpperCase();
+        const softOuter = softDeleteAliasSql(Related, table);
+        const softSub = softDeleteAliasSql(Related, "bunyad_of_many");
+        await forEachIdChunk(parentIds, async (chunk) => {
+            const placeholders = chunk.map(() => "?").join(", ");
+            const rows = await Related.getConnection().all(`SELECT ${table}.*
+         FROM ${table}
+         INNER JOIN (
+           SELECT bunyad_of_many.${idCol} AS __bunyad_fk, ${agg}(bunyad_of_many.${col}) AS __bunyad_agg
+           FROM ${table} AS bunyad_of_many
+           WHERE bunyad_of_many.${typeCol} = ?
+             AND bunyad_of_many.${idCol} IN (${placeholders})${softSub}
+           GROUP BY bunyad_of_many.${idCol}
+         ) AS bunyad_agg
+           ON ${table}.${idCol} = bunyad_agg.__bunyad_fk
+          AND ${table}.${col} = bunyad_agg.__bunyad_agg
+         WHERE ${table}.${typeCol} = ?
+           AND ${table}.${idCol} IN (${placeholders})${softOuter}`, [morphType, ...chunk, morphType, ...chunk]);
+            for (const row of rows) {
+                const key = String(row[idColumn]);
+                if (!byParent.has(key))
+                    byParent.set(key, new Related(row));
+            }
+        });
+    }
+    for (const model of models) {
+        const id = model[localKey];
+        model[relation] =
+            id == null ? null : (byParent.get(String(id)) ?? null);
+    }
+}
+function eagerLoadBelongsTo(models, relation, sample, constraint) {
+    const foreignKey = sample.getForeignKeyName();
+    const ownerKey = sample.getOwnerKeyName();
+    const Related = sample.getRelated();
+    const ids = uniqueKeys(models.map((model) => model[foreignKey]));
+    if (ids.length === 0) {
+        for (const model of models) {
+            model[relation] = null;
+        }
+        return;
+    }
+    const byOwner = new Map();
+    return (async () => {
+        await forEachIdChunk(ids, async (chunk) => {
+            let related;
+            if (constraint) {
+                let q = Related.whereIn(ownerKey, chunk);
+                applyConstraint(q, constraint);
+                related = (await q.get()).all();
+            }
+            else {
+                related = await eagerFetchByKeys(Related, ownerKey, chunk);
+            }
+            for (const row of related) {
+                byOwner.set(String(row[ownerKey]), row);
+            }
+        });
+        for (const model of models) {
+            const id = model[foreignKey];
+            model[relation] =
+                id == null ? null : (byOwner.get(String(id)) ?? null);
+        }
+    })();
+}
+async function eagerLoadHasMany(models, relation, sample, constraint) {
+    const foreignKey = sample.getForeignKeyName();
+    const localKey = sample.getLocalKeyName();
+    const Related = sample.getRelated();
+    const parentIds = uniqueKeys(models.map((model) => model[localKey]));
+    const byParent = new Map();
+    await forEachIdChunk(parentIds, async (chunk) => {
+        let related;
+        if (constraint) {
+            let q = Related.whereIn(foreignKey, chunk);
+            applyConstraint(q, constraint);
+            related = (await q.get()).all();
+        }
+        else {
+            related = await eagerFetchByKeys(Related, foreignKey, chunk);
+        }
+        for (const row of related) {
+            const key = String(row[foreignKey]);
+            const list = byParent.get(key) ?? [];
+            list.push(row);
+            byParent.set(key, list);
+        }
+    });
+    for (const model of models) {
+        const id = model[localKey];
+        model[relation] = new OrmCollection(id == null ? [] : (byParent.get(String(id)) ?? []), { owned: true });
+    }
+}
+async function eagerLoadHasOne(models, relation, sample, constraint) {
+    const foreignKey = sample.getForeignKeyName();
+    const localKey = sample.getLocalKeyName();
+    const Related = sample.getRelated();
+    const parentIds = uniqueKeys(models.map((model) => model[localKey]));
+    const byParent = new Map();
+    await forEachIdChunk(parentIds, async (chunk) => {
+        let related;
+        if (constraint) {
+            let q = Related.whereIn(foreignKey, chunk);
+            applyConstraint(q, constraint);
+            related = (await q.get()).all();
+        }
+        else {
+            related = await eagerFetchByKeys(Related, foreignKey, chunk);
+        }
+        for (const row of related) {
+            const key = String(row[foreignKey]);
+            if (!byParent.has(key))
+                byParent.set(key, row);
+        }
+    });
+    for (const model of models) {
+        const id = model[localKey];
+        model[relation] =
+            id == null ? null : (byParent.get(String(id)) ?? null);
+    }
+}
+async function eagerLoadHasManyThrough(models, relation, sample, constraint) {
+    const Through = sample.getThrough();
+    const Related = sample.getRelated();
+    const firstKey = sample.getFirstKeyName();
+    const secondKey = sample.getSecondKeyName();
+    const localKey = sample.getLocalKeyName();
+    const secondLocalKey = sample.getSecondLocalKeyName();
+    const parentIds = uniqueKeys(models.map((model) => model[localKey]));
+    const throughByParent = new Map();
+    const throughIdToParent = new Map();
+    await forEachIdChunk(parentIds, async (chunk) => {
+        const throughRows = await eagerFetchByKeys(Through, firstKey, chunk);
+        for (const row of throughRows) {
+            const rec = row;
+            const parentKey = String(rec[firstKey]);
+            const throughId = rec[secondLocalKey];
+            if (throughId == null)
+                continue;
+            const list = throughByParent.get(parentKey) ?? [];
+            list.push(throughId);
+            throughByParent.set(parentKey, list);
+            throughIdToParent.set(String(throughId), parentKey);
+        }
+    });
+    const throughIds = uniqueKeys([...throughIdToParent.keys()]);
+    const byParent = new Map();
+    await forEachIdChunk(throughIds, async (chunk) => {
+        let relatedRows;
+        if (constraint) {
+            let q = Related.whereIn(secondKey, chunk);
+            applyConstraint(q, constraint);
+            relatedRows = (await q.get()).all();
+        }
+        else {
+            relatedRows = await eagerFetchByKeys(Related, secondKey, chunk);
+        }
+        for (const row of relatedRows) {
+            const throughFk = row[secondKey];
+            if (throughFk == null)
+                continue;
+            const parentKey = throughIdToParent.get(String(throughFk));
+            if (parentKey == null)
+                continue;
+            const list = byParent.get(parentKey) ?? [];
+            list.push(row);
+            byParent.set(parentKey, list);
+        }
+    });
+    for (const model of models) {
+        const id = model[localKey];
+        model[relation] = new OrmCollection(id == null ? [] : (byParent.get(String(id)) ?? []), { owned: true });
+    }
+}
+async function eagerLoadHasOneThrough(models, relation, sample, constraint) {
+    await eagerLoadHasManyThrough(models, relation, sample.asHasManyThrough(), constraint);
+    for (const model of models) {
+        const collection = model[relation];
+        if (collection && typeof collection.first === "function") {
+            model[relation] =
+                collection.first() ?? null;
+        }
+    }
+}
+async function eagerLoadBelongsToMany(models, relation, sample, constraint) {
+    const Related = sample.getRelated();
+    const parent = models[0].constructor;
+    const parentKey = parent.primaryKey;
+    const pivotTable = sample.getPivotTable();
+    const foreignPivotKey = sample.getForeignPivotKeyName();
+    const relatedPivotKey = sample.getRelatedPivotKeyName();
+    const pivotColumns = sample.getPivotColumns();
+    const pivotKeys = pivotColumns.length > 0
+        ? [foreignPivotKey, relatedPivotKey, ...pivotColumns.filter((c) => c !== foreignPivotKey && c !== relatedPivotKey)]
+        : [];
+    const parentIds = uniqueKeys(models.map((model) => model[parentKey]));
+    const byParent = new Map();
+    if (parentIds.length > 0) {
+        const dialect = parent.getConnection().dialect;
+        const qRelated = wrapSqlName(dialect, Related.table);
+        const qPivot = wrapSqlName(dialect, pivotTable);
+        const qRelatedPk = wrapSqlName(dialect, Related.primaryKey);
+        const qForeignPivot = wrapSqlName(dialect, foreignPivotKey);
+        const qRelatedPivot = wrapSqlName(dialect, relatedPivotKey);
+        const soft = softDeleteAliasSql(Related, qRelated);
+        const pivotSelect = pivotKeys.length > 0
+            ? `, ${pivotKeys
+                .map((col) => `${qPivot}.${wrapSqlName(dialect, col)} AS __pivot_${col}`)
+                .join(", ")}`
+            : "";
+        await forEachIdChunk(parentIds, async (chunk) => {
+            if (constraint) {
+                let q = Related.newQuery()
+                    .join(pivotTable, `${pivotTable}.${relatedPivotKey}`, "=", `${Related.table}.${Related.primaryKey}`)
+                    .whereIn(`${pivotTable}.${foreignPivotKey}`, chunk)
+                    .select(`${Related.table}.*`)
+                    .selectRaw(`${pivotTable}.${foreignPivotKey} as __bunyad_parent_id`);
+                for (const col of pivotKeys) {
+                    q = q.selectRaw(`${pivotTable}.${col} as __pivot_${col}`);
+                }
+                applyConstraint(q, constraint);
+                const related = await q.get();
+                for (const row of related.all()) {
+                    const rec = row;
+                    const parentId = rec.__bunyad_parent_id;
+                    delete rec.__bunyad_parent_id;
+                    applyPivotAttributes(row, rec, pivotKeys);
+                    const key = String(parentId);
+                    const list = byParent.get(key) ?? [];
+                    list.push(row);
+                    byParent.set(key, list);
+                }
+                return;
+            }
+            const placeholders = chunk.map(() => "?").join(", ");
+            const rows = await parent.getConnection().all(`SELECT ${qRelated}.*, ${qPivot}.${qForeignPivot} AS __bunyad_parent_id${pivotSelect}
+         FROM ${qRelated}
+         INNER JOIN ${qPivot}
+           ON ${qPivot}.${qRelatedPivot} = ${qRelated}.${qRelatedPk}
+         WHERE ${qPivot}.${qForeignPivot} IN (${placeholders})${soft}`, chunk);
+            for (const row of rows) {
+                const parentId = row.__bunyad_parent_id;
+                const { __bunyad_parent_id: _, ...attrs } = row;
+                const model = new Related(attrs);
+                model.exists = true;
+                applyPivotAttributes(model, attrs, pivotKeys);
+                const key = String(parentId);
+                const list = byParent.get(key) ?? [];
+                list.push(model);
+                byParent.set(key, list);
+            }
+        });
+    }
+    for (const model of models) {
+        const id = model[parentKey];
+        model[relation] = new OrmCollection(id == null ? [] : (byParent.get(String(id)) ?? []), { owned: true });
+    }
+}
+async function eagerLoadMorphToMany(models, relation, sample, constraint) {
+    const Related = sample.getRelated();
+    const parent = models[0].constructor;
+    const parentKey = parent.primaryKey;
+    const pivotTable = sample.getPivotTable();
+    const foreignPivotKey = sample.getForeignPivotKeyName();
+    const relatedPivotKey = sample.getRelatedPivotKeyName();
+    const morphTypeColumn = sample.getMorphTypeColumn();
+    const morphTypes = sample.getMorphTypes();
+    const pivotTenantKey = sample.getPivotTenantKey();
+    const parentTenantKey = sample.getParentTenantKey();
+    const parentIds = uniqueKeys(models.map((model) => model[parentKey]));
+    const byParent = new Map();
+    if (parentIds.length > 0 && morphTypes.length > 0) {
+        const dialect = parent.getConnection().dialect;
+        const qRelated = wrapSqlName(dialect, Related.table);
+        const qPivot = wrapSqlName(dialect, pivotTable);
+        const qRelatedPk = wrapSqlName(dialect, Related.primaryKey);
+        const qForeignPivot = wrapSqlName(dialect, foreignPivotKey);
+        const qRelatedPivot = wrapSqlName(dialect, relatedPivotKey);
+        const qMorphType = wrapSqlName(dialect, morphTypeColumn);
+        const soft = softDeleteAliasSql(Related, qRelated);
+        const morphPlaceholders = morphTypes.map(() => "?").join(", ");
+        await forEachIdChunk(parentIds, async (chunk) => {
+            if (constraint) {
+                let q = Related.newQuery()
+                    .join(pivotTable, `${pivotTable}.${relatedPivotKey}`, "=", `${Related.table}.${Related.primaryKey}`)
+                    .whereIn(`${pivotTable}.${foreignPivotKey}`, chunk)
+                    .whereIn(`${pivotTable}.${morphTypeColumn}`, morphTypes)
+                    .select(`${Related.table}.*`)
+                    .selectRaw(`${pivotTable}.${foreignPivotKey} as __bunyad_parent_id`);
+                if (pivotTenantKey && parentTenantKey) {
+                    const tenantIds = uniqueKeys(models.map((model) => model[parentTenantKey]));
+                    if (tenantIds.length > 0) {
+                        q = q.whereIn(`${pivotTable}.${pivotTenantKey}`, tenantIds);
+                    }
+                }
+                applyConstraint(q, constraint);
+                const related = await q.get();
+                for (const row of related.all()) {
+                    const rec = row;
+                    const parentId = rec.__bunyad_parent_id;
+                    delete rec.__bunyad_parent_id;
+                    const key = String(parentId);
+                    const list = byParent.get(key) ?? [];
+                    list.push(row);
+                    byParent.set(key, list);
+                }
+                return;
+            }
+            const idPlaceholders = chunk.map(() => "?").join(", ");
+            const params = [...chunk, ...morphTypes];
+            let tenantSql = "";
+            if (pivotTenantKey && parentTenantKey) {
+                const tenantIds = uniqueKeys(models.map((model) => model[parentTenantKey]));
+                if (tenantIds.length > 0) {
+                    const qTenant = wrapSqlName(dialect, pivotTenantKey);
+                    tenantSql = ` AND ${qPivot}.${qTenant} IN (${tenantIds.map(() => "?").join(", ")})`;
+                    params.push(...tenantIds);
+                }
+            }
+            const rows = await parent.getConnection().all(`SELECT ${qRelated}.*, ${qPivot}.${qForeignPivot} AS __bunyad_parent_id
+         FROM ${qRelated}
+         INNER JOIN ${qPivot}
+           ON ${qPivot}.${qRelatedPivot} = ${qRelated}.${qRelatedPk}
+         WHERE ${qPivot}.${qForeignPivot} IN (${idPlaceholders})
+           AND ${qPivot}.${qMorphType} IN (${morphPlaceholders})${tenantSql}${soft}`, params);
+            for (const row of rows) {
+                const parentId = row.__bunyad_parent_id;
+                const { __bunyad_parent_id: _, ...attrs } = row;
+                const key = String(parentId);
+                const list = byParent.get(key) ?? [];
+                list.push(new Related(attrs));
+                byParent.set(key, list);
+            }
+        });
+    }
+    for (const model of models) {
+        const id = model[parentKey];
+        model[relation] = new OrmCollection(id == null ? [] : (byParent.get(String(id)) ?? []), { owned: true });
+    }
+}
+async function eagerLoadMorphMany(models, relation, sample, constraint) {
+    const Related = sample.getRelated();
+    const typeColumn = sample.getTypeColumn();
+    const idColumn = sample.getIdColumn();
+    const morphType = sample.getMorphType();
+    const localKey = sample.getLocalKeyName();
+    const parentIds = uniqueKeys(models.map((model) => model[localKey]));
+    const byParent = new Map();
+    await forEachIdChunk(parentIds, async (chunk) => {
+        let q = Related.where(typeColumn, morphType).whereIn(idColumn, chunk);
+        applyConstraint(q, constraint);
+        const related = await q.get();
+        for (const row of related.all()) {
+            const key = String(row[idColumn]);
+            const list = byParent.get(key) ?? [];
+            list.push(row);
+            byParent.set(key, list);
+        }
+    });
+    for (const model of models) {
+        const id = model[localKey];
+        model[relation] = new OrmCollection(id == null ? [] : (byParent.get(String(id)) ?? []), { owned: true });
+    }
+}
+async function eagerLoadMorphOne(models, relation, sample, constraint) {
+    const Related = sample.getRelated();
+    const typeColumn = sample.getTypeColumn();
+    const idColumn = sample.getIdColumn();
+    const morphType = sample.getMorphType();
+    const localKey = sample.getLocalKeyName();
+    const parentIds = uniqueKeys(models.map((model) => model[localKey]));
+    const byParent = new Map();
+    await forEachIdChunk(parentIds, async (chunk) => {
+        let q = Related.where(typeColumn, morphType).whereIn(idColumn, chunk);
+        applyConstraint(q, constraint);
+        const related = await q.get();
+        for (const row of related.all()) {
+            const key = String(row[idColumn]);
+            if (!byParent.has(key))
+                byParent.set(key, row);
+        }
+    });
+    for (const model of models) {
+        const id = model[localKey];
+        model[relation] =
+            id == null ? null : (byParent.get(String(id)) ?? null);
+    }
+}
+async function eagerLoadMorphTo(models, relation, sample, constraint) {
+    const typeColumn = sample.getTypeColumn();
+    const idColumn = sample.getIdColumn();
+    const ownerKey = sample.getOwnerKeyName();
+    const byType = new Map();
+    for (const model of models) {
+        const row = model;
+        const type = row[typeColumn];
+        const id = row[idColumn];
+        if (type == null || id == null)
+            continue;
+        const list = byType.get(String(type)) ?? [];
+        list.push(id);
+        byType.set(String(type), list);
+    }
+    const loaded = new Map();
+    await Promise.all([...byType.entries()].map(async ([type, ids]) => {
+        const Related = resolveMorphType(type);
+        const key = ownerKey ?? Related.primaryKey;
+        await forEachIdChunk(uniqueKeys(ids), async (chunk) => {
+            let q = Related.whereIn(key, chunk);
+            applyConstraint(q, constraint);
+            const related = await q.get();
+            for (const row of related.all()) {
+                loaded.set(`${type}:${String(row[key])}`, row);
+            }
+        });
+    }));
+    for (const model of models) {
+        const row = model;
+        const type = row[typeColumn];
+        const id = row[idColumn];
+        row[relation] =
+            type == null || id == null
+                ? null
+                : (loaded.get(`${String(type)}:${String(id)}`) ?? null);
+    }
+}
+/** Batch `loadCount` / `loadSum` / … onto many models (one GROUP BY query per relation). */
+export async function eagerLoadAggregates(models, specs) {
+    const list = models;
+    if (list.length === 0 || specs.length === 0)
+        return;
+    const Parent = list[0].constructor;
+    await Promise.all(specs.map((spec) => eagerLoadOneAggregate(list, Parent, spec)));
+}
+function aggregateDefault(fn) {
+    if (fn === "exists" || fn === "count" || fn === "sum")
+        return 0;
+    return null;
+}
+async function eagerLoadOneAggregate(models, Parent, spec) {
+    const meta = resolveRelation(Parent, spec.relation);
+    if (!meta) {
+        for (const model of models) {
+            const value = await aggregateRelation(model, spec.relation, spec.fn, spec.column);
+            model[spec.alias] = value;
+        }
+        return;
+    }
+    const defaults = aggregateDefault(spec.fn);
+    for (const model of models) {
+        model[spec.alias] = defaults;
+    }
+    if (meta.kind === "has") {
+        const parentIds = uniqueKeys(models.map((model) => model[meta.localKey]));
+        if (parentIds.length === 0)
+            return;
+        const dialect = meta.related.getConnection().dialect;
+        const fk = wrapSqlName(dialect, meta.foreignKey);
+        let q = meta.related.whereIn(meta.foreignKey, parentIds).selectRaw(`${fk} as __bunyad_k`);
+        if (spec.fn === "exists") {
+            q = q.selectRaw("1 as __bunyad_v");
+        }
+        else if (spec.fn === "count") {
+            q = q.selectRaw("COUNT(*) as __bunyad_v");
+        }
+        else {
+            const col = wrapSqlName(dialect, spec.column);
+            q = q.selectRaw(`${spec.fn.toUpperCase()}(${col}) as __bunyad_v`);
+        }
+        const rows = await q.groupBy(meta.foreignKey).toBase().getRows();
+        const byParent = new Map();
+        for (const row of rows) {
+            byParent.set(String(row.__bunyad_k), row.__bunyad_v);
+        }
+        for (const model of models) {
+            const id = model[meta.localKey];
+            if (id == null)
+                continue;
+            const value = byParent.get(String(id));
+            if (value !== undefined) {
+                model[spec.alias] = value;
+            }
+        }
+        return;
+    }
+    if (meta.kind === "belongsTo") {
+        const fks = uniqueKeys(models.map((model) => model[meta.foreignKey]));
+        if (fks.length === 0)
+            return;
+        const dialect = meta.related.getConnection().dialect;
+        const owner = wrapSqlName(dialect, meta.ownerKey);
+        let q = meta.related.whereIn(meta.ownerKey, fks).selectRaw(`${owner} as __bunyad_k`);
+        if (spec.fn === "exists") {
+            q = q.selectRaw("1 as __bunyad_v");
+        }
+        else if (spec.fn === "count") {
+            q = q.selectRaw("COUNT(*) as __bunyad_v");
+        }
+        else {
+            const col = wrapSqlName(dialect, spec.column);
+            q = q.selectRaw(`${spec.fn.toUpperCase()}(${col}) as __bunyad_v`);
+        }
+        const rows = await q.groupBy(meta.ownerKey).toBase().getRows();
+        const byOwner = new Map();
+        for (const row of rows) {
+            byOwner.set(String(row.__bunyad_k), row.__bunyad_v);
+        }
+        for (const model of models) {
+            const fk = model[meta.foreignKey];
+            if (fk == null)
+                continue;
+            const value = byOwner.get(String(fk));
+            if (value !== undefined) {
+                model[spec.alias] = value;
+            }
+        }
+        return;
+    }
+    if (meta.kind === "hasManyThrough" || meta.kind === "hasOneThrough")
+        return;
+    const parentIds = uniqueKeys(models.map((model) => model[Parent.primaryKey]));
+    if (parentIds.length === 0)
+        return;
+    const dialect = Parent.getConnection().dialect;
+    const qRelated = wrapSqlName(dialect, meta.related.table);
+    const qPivot = wrapSqlName(dialect, meta.pivotTable);
+    const qRelatedPk = wrapSqlName(dialect, meta.related.primaryKey);
+    const qForeignPivot = wrapSqlName(dialect, meta.foreignPivotKey);
+    const qRelatedPivot = wrapSqlName(dialect, meta.relatedPivotKey);
+    const soft = softDeleteAliasSql(meta.related, qRelated);
+    const byParent = new Map();
+    await forEachIdChunk(parentIds, async (chunk) => {
+        const placeholders = chunk.map(() => "?").join(", ");
+        let selectV;
+        if (spec.fn === "exists") {
+            selectV = "1";
+        }
+        else if (spec.fn === "count") {
+            selectV = "COUNT(*)";
+        }
+        else {
+            selectV = `${spec.fn.toUpperCase()}(${wrapSqlName(dialect, spec.column)})`;
+        }
+        const rows = await Parent.getConnection().all(`SELECT ${qPivot}.${qForeignPivot} AS __bunyad_k, ${selectV} AS __bunyad_v
+       FROM ${qRelated}
+       INNER JOIN ${qPivot}
+         ON ${qPivot}.${qRelatedPivot} = ${qRelated}.${qRelatedPk}
+       WHERE ${qPivot}.${qForeignPivot} IN (${placeholders})${soft}
+       GROUP BY ${qPivot}.${qForeignPivot}`, chunk);
+        for (const row of rows) {
+            byParent.set(String(row.__bunyad_k), row.__bunyad_v);
+        }
+    });
+    for (const model of models) {
+        const id = model[Parent.primaryKey];
+        if (id == null)
+            continue;
+        const value = byParent.get(String(id));
+        if (value !== undefined) {
+            model[spec.alias] = value;
+        }
+    }
+}