uql-orm 0.55.0 → 0.56.0

package/dist/migrate/introspection/baseSqlIntrospector.js

@@ -43,90 +43,79 @@ export class BaseSqlIntrospector {
      */
     buildAST(tableSchemas) {
         const ast = new SchemaAST();
-        const tableNodes = new Map();
-        this.buildTables(ast, tableNodes, tableSchemas);
-        this.buildRelationships(ast, tableNodes, tableSchemas);
-        this.buildIndexes(ast, tableNodes, tableSchemas);
+        // Every table first, so a foreign key reaches a table introspected after the one it leaves from.
+        const tables = tableSchemas.map((schema) => ({ schema, table: this.buildTable(schema) }));
+        const tableNodes = new Map(tables.map(({ schema, table }) => [schema.name, table]));
+        for (const { table } of tables) {
+            ast.addTable(table);
+        }
+        for (const { schema, table } of tables) {
+            this.buildRelationships(ast, tableNodes, schema, table);
+            this.buildIndexes(ast, schema, table);
+        }
         return ast;
     }
-    buildTables(ast, tableNodes, tableSchemas) {
-        for (const schema of tableSchemas) {
-            const table = createTableNode(schema.name, this.schema);
-            const { columns } = table;
-            for (const col of schema.columns) {
-                // Spread, not field by field: a `ColumnSchema` is a `ColumnNode` minus the graph links, so
-                // everything but the type crosses unchanged and a field either shape gains cannot be dropped
-                // here. Listed by hand this had already lost `enum` and `generatedAs`.
-                const { type, length: _length, precision: _precision, scale: _scale, ...rest } = col;
-                const column = {
-                    ...rest,
-                    type: canonicalColumnType(type, col),
-                    table,
-                    referencedBy: [],
-                };
-                columns.set(col.name, column);
-            }
-            // From the ordered list the query returned, not from the per-column flags: `(a, b)` is a
-            // different key from `(b, a)`, and a flag says only that a column is *in* the key. Falls back
-            // to the flags for an introspector that reports no key of its own.
-            const keyColumns = schema.primaryKey ?? schema.columns.filter((col) => col.isPrimaryKey).map((col) => col.name);
-            table.primaryKey.push(...keyColumns.flatMap((name) => columns.get(name) ?? []));
-            table.primaryKeyName = schema.primaryKeyName;
-            tableNodes.set(schema.name, table);
-            ast.addTable(table);
+    buildTable(schema) {
+        const table = createTableNode(schema.name, this.schema);
+        const { columns } = table;
+        for (const col of schema.columns) {
+            // Spread, not field by field: a `ColumnSchema` is a `ColumnNode` minus the graph links, so
+            // everything but the type crosses unchanged and a field either shape gains cannot be dropped
+            // here. Listed by hand this had already lost `enum` and `generatedAs`.
+            const { type, length: _length, precision: _precision, scale: _scale, ...rest } = col;
+            const column = {
+                ...rest,
+                type: canonicalColumnType(type, col),
+                table,
+                referencedBy: [],
+            };
+            columns.set(col.name, column);
         }
+        // From the ordered list the query returned, not from the per-column flags: `(a, b)` is a
+        // different key from `(b, a)`, and a flag says only that a column is *in* the key. Falls back
+        // to the flags for an introspector that reports no key of its own.
+        const keyColumns = schema.primaryKey ?? schema.columns.filter((col) => col.isPrimaryKey).map((col) => col.name);
+        table.primaryKey.push(...keyColumns.flatMap((name) => columns.get(name) ?? []));
+        table.primaryKeyName = schema.primaryKeyName;
+        return table;
     }
-    buildRelationships(ast, tableNodes, tableSchemas) {
-        for (const schema of tableSchemas) {
-            if (!schema.foreignKeys)
+    buildRelationships(ast, tableNodes, schema, fromTable) {
+        for (const fk of schema.foreignKeys ?? []) {
+            const toTable = tableNodes.get(fk.references.table);
+            if (!toTable)
                 continue;
-            const fromTable = tableNodes.get(schema.name);
-            if (!fromTable)
-                continue;
-            for (const fk of schema.foreignKeys) {
-                const toTable = tableNodes.get(fk.references.table);
-                if (!toTable)
-                    continue;
-                const fromColumns = fk.columns.flatMap((name) => fromTable.columns.get(name) ?? []);
-                const toColumns = fk.references.columns.flatMap((name) => toTable.columns.get(name) ?? []);
-                if (fromColumns.length > 0 && toColumns.length > 0) {
-                    const rel = {
-                        name: fk.name ?? derivedForeignKeyName(schema.name, fk.columns),
-                        type: fromColumns[0].isUnique ? 'OneToOne' : 'ManyToOne',
-                        from: { table: fromTable, columns: fromColumns },
-                        to: { table: toTable, columns: toColumns },
-                        onDelete: fk.onDelete || 'NO ACTION',
-                        onUpdate: fk.onUpdate || 'NO ACTION',
-                    };
-                    ast.addRelationship(rel);
-                }
+            const fromColumns = fk.columns.flatMap((name) => fromTable.columns.get(name) ?? []);
+            const toColumns = fk.references.columns.flatMap((name) => toTable.columns.get(name) ?? []);
+            if (fromColumns.length > 0 && toColumns.length > 0) {
+                const rel = {
+                    name: fk.name ?? derivedForeignKeyName(schema.name, fk.columns),
+                    type: fromColumns[0].isUnique ? 'OneToOne' : 'ManyToOne',
+                    from: { table: fromTable, columns: fromColumns },
+                    to: { table: toTable, columns: toColumns },
+                    onDelete: fk.onDelete || 'NO ACTION',
+                    onUpdate: fk.onUpdate || 'NO ACTION',
+                };
+                ast.addRelationship(rel);
             }
         }
     }
-    buildIndexes(ast, tableNodes, tableSchemas) {
-        for (const schema of tableSchemas) {
-            if (!schema.indexes)
-                continue;
-            const table = tableNodes.get(schema.name);
-            if (!table)
-                continue;
-            for (const idx of schema.indexes) {
-                // An expression has no column to resolve. Dropping the entries that name a column this table
-                // does not have, and the index if that leaves none, is what the entity side does too.
-                const entries = idx.entries.filter((entry) => entry.expression || table.columns.has(entry.column));
-                if (entries.length > 0) {
-                    const index = {
-                        name: idx.name,
-                        table,
-                        entries,
-                        unique: idx.unique,
-                        type: idx.type,
-                        where: idx.where,
-                        include: idx.include,
-                        source: 'database',
-                    };
-                    ast.addIndex(index);
-                }
+    buildIndexes(ast, schema, table) {
+        for (const idx of schema.indexes ?? []) {
+            // An expression has no column to resolve. Dropping the entries that name a column this table
+            // does not have, and the index if that leaves none, is what the entity side does too.
+            const entries = idx.entries.filter((entry) => entry.expression || table.columns.has(entry.column));
+            if (entries.length > 0) {
+                const index = {
+                    name: idx.name,
+                    table,
+                    entries,
+                    unique: idx.unique,
+                    type: idx.type,
+                    where: idx.where,
+                    include: idx.include,
+                    source: 'database',
+                };
+                ast.addIndex(index);
             }
         }
     }

package/dist/migrate/introspection/mssqlIntrospector.js

@@ -27,7 +27,8 @@ export class MsSqlSchemaIntrospector extends AbstractSqlSchemaIntrospector {
     `;
     }
     parseTableExistsResult(results) {
-        return (this.toNumber(results[0]?.count) ?? 0) > 0;
+        // No row, or no count in it, reads as `NaN`, which is not above zero.
+        return Number(results[0]?.count) > 0;
     }
     /**
      * From `sys` rather than `INFORMATION_SCHEMA`, which has no identity flag and no per-column view of

package/dist/migrate/introspection/mysqlIntrospector.js

@@ -24,11 +24,8 @@ export class MysqlSchemaIntrospector extends AbstractSqlSchemaIntrospector {
     `;
     }
     parseTableExistsResult(results) {
-        const row = results[0];
-        if (row?.count !== undefined) {
-            return (this.toNumber(row.count) ?? 0) > 0;
-        }
-        return false;
+        // No row, or no count in it, reads as `NaN`, which is not above zero.
+        return Number(results[0]?.count) > 0;
     }
     getColumnsQuery(_tableName) {
         return /*sql*/ `
@@ -97,7 +94,7 @@ export class MysqlSchemaIntrospector extends AbstractSqlSchemaIntrospector {
     async mapColumnsResult(_read, _tableName, results) {
         return results.map((row) => ({
             name: row.column_name,
-            type: (row.column_type || '').toUpperCase(),
+            type: row.column_type.toUpperCase(),
             nullable: row.is_nullable === 'YES',
             defaultValue: this.parseDefaultValue(row.column_default),
             isPrimaryKey: row.column_key === 'PRI',
@@ -122,8 +119,8 @@ export class MysqlSchemaIntrospector extends AbstractSqlSchemaIntrospector {
     async mapForeignKeysResult(_read, _tableName, results) {
         return results.map((row) => ({
             name: row.constraint_name,
-            columns: (row.columns || '').split(','),
-            references: { table: row.referenced_table, columns: (row.referenced_columns || '').split(',') },
+            columns: row.columns.split(','),
+            references: { table: row.referenced_table, columns: row.referenced_columns.split(',') },
             onDelete: this.normalizeReferentialAction(row.delete_rule),
             onUpdate: this.normalizeReferentialAction(row.update_rule),
         }));

package/dist/migrate/introspection/sqliteIntrospector.js

@@ -22,11 +22,8 @@ export class SqliteSchemaIntrospector extends AbstractSqlSchemaIntrospector {
     `;
     }
     parseTableExistsResult(results) {
-        const row = results[0];
-        if (row?.count !== undefined) {
-            return (this.toNumber(row.count) ?? 0) > 0;
-        }
-        return false;
+        // No row, or no count in it, reads as `NaN`, which is not above zero.
+        return Number(results[0]?.count) > 0;
     }
     /**
      * `table_xinfo`, not `table_info`: the latter omits generated columns entirely, so a table carrying

package/dist/migrate/migrator.d.ts

@@ -19,8 +19,11 @@ export declare class Migrator {
     private readonly _defaultForeignKeyAction?;
     private _mongoSchemaLoadPromise?;
     constructor(pool: QuerierPool, options?: MigratorOptions);
-    /** Loads MongoDB schema generator on first use; SQL generators are set in the constructor (or via {@link setSchemaGenerator}). */
-    private ensureSchemaGenerator;
+    /**
+     * Loads MongoDB's schema generator on first use, so the optional `mongodb` peer loads only then. SQL
+     * generators are set in the constructor (or via {@link setSchemaGenerator}).
+     */
+    ensureSchemaGenerator(): Promise<void>;
     /**
      * Set the schema generator for DDL operations
      */

package/dist/migrate/migrator.js

@@ -10,7 +10,6 @@ import { buildSqlQuerierMigrationModule, EMPTY_MANUAL_MIGRATION_DOWN_INNER, EMPT
 import { runMongoCommand } from './generator/mongoCommand.js';
 import { introspectorFor } from './introspection/registry.js';
 import { createSchemaGenerator } from './schemaGenerator.js';
-import { createSchemaGeneratorAsync } from './schemaGeneratorAsync.js';
 import { DatabaseMigrationStorage } from './storage/databaseStorage.js';
 /**
  * Main class for managing database migrations
@@ -37,7 +36,7 @@ export class Migrator {
     _mongoSchemaLoadPromise;
     constructor(pool, options = {}) {
         this.pool = pool;
-        this.dialectName = pool.dialect.dialectName ?? 'postgres';
+        this.dialectName = pool.dialect.dialectName;
         this._defaultForeignKeyAction = options.defaultForeignKeyAction;
         this.storage =
             options.storage ??
@@ -51,18 +50,17 @@ export class Migrator {
         this.schemaGenerator =
             options.schemaGenerator ?? (this.dialectName === 'mongodb' ? undefined : this.createGenerator());
     }
-    /** Loads MongoDB schema generator on first use; SQL generators are set in the constructor (or via {@link setSchemaGenerator}). */
+    /**
+     * Loads MongoDB's schema generator on first use, so the optional `mongodb` peer loads only then. SQL
+     * generators are set in the constructor (or via {@link setSchemaGenerator}).
+     */
     async ensureSchemaGenerator() {
         if (this.schemaGenerator || this.dialectName !== 'mongodb') {
             return;
         }
-        if (!this._mongoSchemaLoadPromise) {
-            this._mongoSchemaLoadPromise = createSchemaGeneratorAsync(this.pool.dialect, this._defaultForeignKeyAction).then((gen) => {
-                if (gen) {
-                    this.schemaGenerator = gen;
-                }
-            });
-        }
+        this._mongoSchemaLoadPromise ??= import('./generator/mongoSchemaGenerator.js').then(({ MongoSchemaGenerator }) => {
+            this.schemaGenerator = new MongoSchemaGenerator(this.pool.dialect.namingStrategy, this._defaultForeignKeyAction);
+        });
         await this._mongoSchemaLoadPromise;
     }
     /**
@@ -302,12 +300,9 @@ export class Migrator {
     }
     async findEntityForTable(tableName) {
         await this.ensureSchemaGenerator();
-        if (!this.schemaGenerator) {
-            return undefined;
-        }
         for (const entity of this.entities) {
             const meta = getMeta(entity);
-            const name = this.schemaGenerator.resolveTableName(meta);
+            const name = this.generator.resolveTableName(meta);
             if (name === tableName) {
                 return entity;
             }

package/dist/migrate/schemaGenerator.js

@@ -474,8 +474,6 @@ export class SqlSchemaGenerator {
         if (current == null || desired == null)
             return current == null && desired == null;
         const normalize = (value) => {
-            if (value === null)
-                return 'null';
             // Render first: the desired side may be a symbolic expression, the current side is always the
             // engine's own text, and `{"kind":"now"}` matches no spelling of `CURRENT_TIMESTAMP`.
             const val = SqlExpression.isExpression(value) ? formatDefaultValue(value, this.dialect) : value;
@@ -518,10 +516,8 @@ export class SqlSchemaGenerator {
             constraints.push(`CONSTRAINT ${this.escapeId(name)} CHECK (${check.expression})`);
         });
         for (const rel of table.outgoingRelations) {
-            if (rel.from.columns.length > 0) {
-                const refTable = this.dialect.escapeQualifiedId(rel.to.table.name, rel.to.table.schema);
-                constraints.push(this.foreignKeyConstraint(table.name, foreignKeyOf(rel), refTable));
-            }
+            const refTable = this.dialect.escapeQualifiedId(rel.to.table.name, rel.to.table.schema);
+            constraints.push(this.foreignKeyConstraint(table.name, foreignKeyOf(rel), refTable));
         }
         const ifNotExists = options.ifNotExists && this.features.ifNotExists ? 'IF NOT EXISTS ' : '';
         let createSql = `CREATE TABLE ${ifNotExists}${this.dialect.escapeQualifiedId(table.name, table.schema)} (\n`;

package/dist/mongo/mongoDialect.d.ts

@@ -187,7 +187,7 @@ export declare class MongoDialect extends AbstractDialect {
     /** `[column, key]` for the fields whose stored name differs from their property name, memoized per entity. */
     private renamedColumns;
     private referenceKeys;
-    normalizeIds<E extends Document>(meta: EntityMeta<E>, docs: Document[] | undefined): E[] | undefined;
+    normalizeIds<E extends Document>(meta: EntityMeta<E>, docs: Document[]): E[];
     /** `doc` is the wire shape - `_id`, stored names, `ObjectId`s - and what comes back is the code's. */
     normalizeId<E extends Document>(meta: EntityMeta<E>, doc: Document | undefined): E | undefined;
     /**

package/dist/mongo/mongoDialect.js

@@ -2,7 +2,7 @@ import { ObjectId } from 'mongodb';
 import { AbstractDialect } from '../dialect/abstractDialect.js';
 import { COUNT_ALIAS, REL_NESTED_KEY, REL_TEMP_PREFIX, sortCountField } from '../dialect/aliases.js';
 import { resolveQueryJoins, resolveSortableJoin } from '../dialect/queryJoins.js';
-import { assertSoleId, getMeta, soleIdOf } from '../entity/index.js';
+import { assertSoleId, fieldOf, getMeta, relationOf, soleIdOf } from '../entity/index.js';
 import { QueryRaw } from '../type/queryRaw.js';
 import { asSelectMap, assertAggregateColumns, assertNonNegativeInteger, columnFamily, entityName, fillOnFields, filterFieldKeys, findVectorIndex, findVectorSort, getKeys, getRelationRequestSummary, hasKeys, isJsonUpdateOp, isOperatorMap, isOperatorObject, isVectorSearch, normalizeScalarFieldSelection, parentJoins, parseGroupMap, parseRelationSize, parseSortByCount, someKey, targetKeyColumns, } from '../util/index.js';
 /** Default {@link DialectFeatures} for MongoDB; shared by {@link MongoDialect} and its schema generator. */
@@ -722,7 +722,7 @@ export class MongoDialect extends AbstractDialect {
     #renamedColumns = new WeakMap();
     #referenceKeys = new WeakMap();
     normalizeIds(meta, docs) {
-        return docs?.map((doc) => this.normalizeId(meta, doc));
+        return docs.map((doc) => this.normalizeId(meta, doc));
     }
     /** `doc` is the wire shape - `_id`, stored names, `ObjectId`s - and what comes back is the code's. */
     normalizeId(meta, doc) {
@@ -755,10 +755,7 @@ export class MongoDialect extends AbstractDialect {
         }
         const relKeys = getKeys(meta.relations).filter((key) => res[key]);
         for (const relKey of relKeys) {
-            const relOpts = meta.relations[relKey];
-            if (!relOpts)
-                continue;
-            const relMeta = getMeta(relOpts.entity());
+            const relMeta = getMeta(relationOf(meta, relKey).entity());
             res[relKey] = Array.isArray(res[relKey])
                 ? this.normalizeIds(relMeta, res[relKey])
                 : this.normalizeId(relMeta, res[relKey]);
@@ -894,7 +891,7 @@ export class MongoDialect extends AbstractDialect {
             const named = inserting && it[idKey] != null;
             if (inserting && !named) {
                 // Nothing named the key, so the database is being asked to mint one.
-                this.assertMintableKey(meta, meta.fields[idKey]);
+                this.assertMintableKey(meta, fieldOf(meta, idKey));
             }
             const doc = named ? { [MongoDialect.ID_KEY]: this.toWireId(it[idKey]) } : {};
             for (const key of filterFieldKeys(meta, it, callbackKey)) {

package/dist/mongo/mongodbQuerier.js

@@ -63,7 +63,7 @@ export class MongodbQuerier extends AbstractQuerier {
                 else {
                     const cursor = this.buildFindCursor(entity, q, opts);
                     documents = await this.execute(() => cursor.toArray());
-                    documents = this.dialect.normalizeIds(meta, documents) || [];
+                    documents = this.dialect.normalizeIds(meta, documents);
                 }
             }
             return documents;
@@ -92,7 +92,7 @@ export class MongodbQuerier extends AbstractQuerier {
         const pipelines = queries.map((it) => this.dialect.aggregationPipeline(entity, it));
         // Counted, not estimated: the leading branch's own length grows with every `$lookup` a populate
         // adds, so a fixed parent budget would let a richer query overflow at the server instead.
-        const stages = (pipelines[0]?.length ?? 0) + pipelines.length - 1;
+        const stages = pipelines[0].length + pipelines.length - 1;
         return stages > MAX_PIPELINE_STAGES
             ? this.readEachInTurn(entity, queries)
             : this.readInOnePipeline(entity, q, pipelines);
@@ -139,7 +139,7 @@ export class MongodbQuerier extends AbstractQuerier {
         const cursor = this.buildFindCursor(entity, q, opts);
         try {
             for await (const doc of cursor) {
-                const [normalized] = this.dialect.normalizeIds(meta, [doc]) || [doc];
+                const [normalized] = this.dialect.normalizeIds(meta, [doc]);
                 yield normalized;
             }
         }
@@ -177,7 +177,7 @@ export class MongodbQuerier extends AbstractQuerier {
     /** Execute an aggregation pipeline and normalize `_id` → `id`. */
     async runPipeline(entity, meta, pipeline) {
         const documents = await this.execute((session) => this.collection(entity).aggregate(pipeline, { session }).toArray());
-        return this.dialect.normalizeIds(meta, documents) || [];
+        return this.dialect.normalizeIds(meta, documents);
     }
     /**
      * Build an aggregation pipeline for vector similarity search.
@@ -257,7 +257,7 @@ export class MongodbQuerier extends AbstractQuerier {
         const founds = await this.execute((session) => this.collection(entity).aggregate(pipeline, { session }).toArray());
         // `normalizeIds` has already spread a compound `_id` back into its columns, so the settled rows
         // are named the same way every other driver names them.
-        return (this.dialect.normalizeIds(meta, founds) || []).map((found) => idOf(meta, found));
+        return this.dialect.normalizeIds(meta, founds).map((found) => idOf(meta, found));
     }
     async internalInsertMany(entity, rows) {
         return this.timed('internalInsertMany', undefined, async () => {
@@ -356,7 +356,7 @@ export class MongodbQuerier extends AbstractQuerier {
                 };
             });
             const res = await this.execute((session) => this.collection(entity).bulkWrite(operations, { session }));
-            const changes = (res.upsertedCount ?? 0) + (res.modifiedCount ?? 0);
+            const changes = res.upsertedCount + res.modifiedCount;
             // `upsertedIds` names only the documents inserted, keyed by operation index, so each lands on
             // its own row; an updated document's `_id` is read back by the conflict fields instead.
             const reported = payload.map((_, index) => {

package/dist/querier/abstractQuerier.js

@@ -1,5 +1,5 @@
-import { assertSoleId, getMeta, idOf, namesKey, soleIdOf } from '../entity/index.js';
-import { asSelectMap, childrenOf, clone, dataKeyed, fillOnFields, filterPersistableRelationKeys, forEachRequestedRelation, getKeys, getRelationRequestSummary, idOnlyQuery, isScalarId, joinedColumns, keyColumns, LoggerWrapper, isBoundedPerParent, parentJoins, queryChildrenOfAll, parseRelationAtKey, parseRelationQueryValue, rowKey, runHooks, someKey, targetKeyColumns, whereIds, withoutSoftDeleteFilter, } from '../util/index.js';
+import { assertSoleId, getMeta, idOf, namesKey, relationOf, soleIdOf } from '../entity/index.js';
+import { asSelectMap, childrenOf, clone, dataKeyed, entityName, fillOnFields, filterPersistableRelationKeys, forEachRequestedRelation, getKeys, getRelationRequestSummary, idOnlyQuery, isScalarId, joinedColumns, keyColumns, LoggerWrapper, isBoundedPerParent, parentJoins, queryChildrenOfAll, queryLoggerFor, parseRelationAtKey, parseRelationQueryValue, rowKey, runHooks, someKey, targetKeyColumns, whereIds, withoutSoftDeleteFilter, } from '../util/index.js';
 import { enrichError } from './queryError.js';
 import { fillRelationCounts, withIdForCounts } from './relationCount.js';
 /**
@@ -78,13 +78,10 @@ export class AbstractQuerier {
     logger;
     constructor(extra) {
         this.extra = extra;
-        this.logger = new LoggerWrapper(extra?.logger, {
-            logValues: extra?.logValues,
-            slowQuery: extra?.slowQuery,
-        });
+        this.logger = queryLoggerFor(extra);
     }
     validateProjectionQuery(entity, q) {
-        this.validateProjectionQueryRecursive(entity, q, getMeta(entity).name ?? entity.name);
+        this.validateProjectionQueryRecursive(entity, q, entityName(getMeta(entity)));
     }
     validateProjectionQueryRecursive(entity, q, path) {
         const meta = getMeta(entity);
@@ -96,9 +93,7 @@ export class AbstractQuerier {
             }
         }
         forEachRequestedRelation(meta, q.$populate, (relKey, relValue) => {
-            const relOpts = meta.relations[relKey];
-            if (!relOpts)
-                return;
+            const relOpts = relationOf(meta, relKey);
             const relEntity = relOpts.entity();
             const parsed = parseRelationQueryValue(relValue);
             if (parsed.nested) {
@@ -136,8 +131,14 @@ export class AbstractQuerier {
         const [entity, q, opts] = this.resolveEntityQuery(entityOrQuery, maybeQueryOrOpts, maybeOpts);
         this.validateProjectionQuery(entity, q);
         const founds = await this.internalFindMany(entity, withIdForCounts(entity, q), opts);
-        await fillRelationCounts(this, entity, founds, q.$count);
-        await this.emitHook(entity, 'afterLoad', founds);
+        // Guarded here rather than only inside: awaiting a call that returns at once still costs every read
+        // a promise and a turn of the microtask queue, and most reads count nothing and hook nothing.
+        if (q.$count) {
+            await fillRelationCounts(this, entity, founds, q.$count);
+        }
+        if (this.hasHook(entity, 'afterLoad')) {
+            await this.emitHook(entity, 'afterLoad', founds);
+        }
         return founds;
     }
     findManyStream(entityOrQuery, maybeQueryOrOpts, maybeOpts) {
@@ -348,9 +349,7 @@ export class AbstractQuerier {
         const meta = getMeta(entity);
         const relKeys = getRelationRequestSummary(meta, populate).toManyKeys;
         for (const relKey of relKeys) {
-            const relOpts = meta.relations[relKey];
-            if (!relOpts)
-                continue;
+            const relOpts = relationOf(meta, relKey);
             const relEntity = relOpts.entity();
             const relationQuery = clone(parseRelationAtKey(relKey, populate).query);
             if (relOpts.through) {
@@ -498,9 +497,7 @@ export class AbstractQuerier {
         const relKeys = filterPersistableRelationKeys(meta, meta.relations, 'delete');
         // Cascade forwards `opts` (including `hardDelete`); each child soft-deletes only if it can.
         for (const relKey of relKeys) {
-            const relOpts = meta.relations[relKey];
-            if (!relOpts)
-                continue;
+            const relOpts = relationOf(meta, relKey);
             const relEntity = relOpts.entity();
             const target = relOpts.through ? relOpts.through() : relEntity;
             const where = childrenOf(parentJoins(relOpts, meta.ids.length), ids);
@@ -514,9 +511,7 @@ export class AbstractQuerier {
      */
     async saveRelation(entity, ids, relValue, relKey, isUpdate) {
         const meta = getMeta(entity);
-        const relOpts = meta.relations[relKey];
-        if (!relOpts)
-            return;
+        const relOpts = relationOf(meta, relKey);
         // Here rather than only in the callers below: writing the parent's key into a child is one column
         // per key, so a composite takes a statement per parent. `soleParentColumn` and the sole
         // `targetKeyColumns` under it read the *first* pair, which is a real column of a wrong pairing
@@ -684,7 +679,7 @@ export class AbstractQuerier {
      * another one would wait for a task queued behind itself. Callers below keep their `serialize` calls
      * sequential rather than nested.
      */
-    async serialize(task) {
+    serialize(task) {
         const res = this.taskQueue.then(task);
         this.taskQueue = res.catch(() => { });
         return res;

package/dist/querier/abstractSqlQuerier.d.ts

@@ -100,14 +100,16 @@ export declare abstract class AbstractSqlQuerier extends AbstractQuerier impleme
      */
     protected internalStream<T>(query: string, values?: unknown[]): AsyncIterable<T>;
     /**
-     * Turn what a driver returned back into the types the entity declares, for the row and everything
-     * populated under it. Which columns, and as what, is `hydratableFields`; the per-cell decode is
-     * `decodeColumn`. Both live with the dialect, because a `sparsevec` is only sparse on Postgres.
-     *
-     * `visited` guards a populated graph that points back at itself, and makes a node two paths reach
-     * decode once. Only a relation can lead the walk back somewhere it has been, so an entity that
-     * declares none skips the guard rather than allocating a set per row to hold a single object -
-     * which cost more than the decoding it guards, on a flat read.
+     * Turn what a driver returned back into the types the entity declares, for every row and everything
+     * populated under them. Which columns, and as what, is `hydratableFields`, resolved once for all the
+     * rows; the per-cell decode is `decodeColumn`. Both live with the dialect, because a `sparsevec` is
+     * only sparse on Postgres.
+     */
+    private hydrateAll;
+    /**
+     * One row of {@link hydrateAll}. `visited` guards a populated graph that points back at itself, and
+     * makes a node two paths reach decode once. Only a populated relation can lead the walk back, so the
+     * guard is created at the first one a row carries: rows that populated nothing never allocate one.
      */
     private hydrateFields;
     /**