ts-prorm-orm 1.2.2 → 2.0.0

package/dist/models/eager-load.js

@@ -12,12 +12,24 @@
  * bugs you hit depended on which API you had used to define the model.
  *
  * Both paths now call `loadIncludes()` below.
+ *
+ * Two things about this loader are worth knowing before reading it:
+ *
+ * 1. An include is resolved with ONE query per association level, never a JOIN:
+ *    all parents are satisfied by a single `WHERE fk IN (...)`. That is
+ *    deliberate - it keeps the statement count constant in the number of rows -
+ *    but it is also why a per-include `limit` cannot simply be forwarded to that
+ *    query; see the per-parent window notes on `loadIncludes()`.
+ * 2. `{ all: true }` entries are expanded to one concrete include per
+ *    association before any of that happens; see `expandAllIncludes()`.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.resolvePrimaryKeyAttr = resolvePrimaryKeyAttr;
 exports.resolveIncludeAssociation = resolveIncludeAssociation;
+exports.expandAllIncludes = expandAllIncludes;
 exports.includeFiltersParents = includeFiltersParents;
 exports.resolveRequiredIncludeFilter = resolveRequiredIncludeFilter;
+exports.loadCounts = loadCounts;
 exports.loadIncludes = loadIncludes;
 const errors_1 = require("../errors");
 /** Resolve a model's primary key attribute name, defaulting to `id`. */
@@ -127,6 +139,140 @@ function resolveIncludeAssociation(ctx, parentModel, parentModelName, includeOpt
     }
     return matches[0];
 }
+/** A stable identity for a model, for cycle detection during `all` expansion. */
+function modelKey(m) {
+    return m?.name || m?.tableName || String(m);
+}
+/** Every association declared *from* `parentModel`, in declaration order. */
+function associationsFrom(ctx, parentModel, parentModelName) {
+    const out = [];
+    for (const assoc of ctx.associations) {
+        if (assoc.source === parentModel || assoc.source?.name === parentModelName) {
+            out.push(assoc);
+        }
+    }
+    return out;
+}
+/**
+ * Depth cap for automatic `{ all: true, nested: true }` expansion.
+ *
+ * Same value the class-based path uses (`expandNestedIncludes()` in
+ * models/model.ts), so `{ all: true, nested: true }` expands to the same shape
+ * whichever API defined the model.
+ */
+const MAX_ALL_EXPANSION_DEPTH = 10;
+/**
+ * Expand `{ all: true }` / `{ all: 'alias' }` include entries into one concrete
+ * include per association.
+ *
+ * `loadIncludes()` used to open each iteration with `if (!includeOpt.model)
+ * continue`, so an entry carrying no `model` - which is exactly what
+ * `{ all: true }` is - was skipped without a word: `include: [{ all: true }]`
+ * emitted the parent SELECT and attached nothing. The class-based path expanded
+ * it (models/model.ts) and the `prorm.define()` path did not, so which of the
+ * two APIs you had used decided whether the option existed.
+ *
+ * Bounding the recursion. `nested: true` walks the association graph, and that
+ * graph routinely contains cycles (`User.hasMany(Post)` + `Post.belongsTo(User)`)
+ * and self-references (`Category.hasMany(Category)`). Depth alone does not bound
+ * those usefully here: unlike the class-based expander - which builds one SQL
+ * statement - every expanded include is another round trip, so a cycle across a
+ * model with three associations would reach 3^10 queries before the depth cap
+ * bit. So expansion is bounded twice: by `MAX_ALL_EXPANSION_DEPTH`, and by the
+ * chain of models already expanded on the current branch - a model is never
+ * auto-expanded twice on one path, which terminates cycles and self-references
+ * at their first repeat.
+ *
+ * The chain stops *re-expansion*, not the association itself: `User` with
+ * `{ all: true, nested: true }` still loads `posts` and each post's `user` (that
+ * is one of Post's associations, and `all` means all), but stops there rather
+ * than walking back into User's associations again. So a two-model cycle costs
+ * three queries, not ten levels of ping-pong.
+ *
+ * Two deliberate differences from the class-based expander:
+ * - the depth cap only ever stops *automatic* expansion; a hand-written include
+ *   is passed through at any depth rather than silently dropped.
+ * - an unknown `{ all: 'alias' }` is an error rather than a console warning.
+ *
+ * `required` carried onto an expanded include filters parents like any other
+ * required include. That needs expansion to happen before the parent-filtering
+ * pass rather than inside `loadIncludes()` at the end of the query - the
+ * filtering pass calls `resolveRequiredIncludeFilter`, which returns null for an
+ * entry with no `model`, so while `{ all: true }` was still un-expanded at that
+ * point `{ all: true, required: true }` loaded the associations and narrowed
+ * nothing. Callers therefore expand once, up front; expansion is idempotent, so
+ * `loadIncludes()` re-running it on an already-expanded list is a no-op.
+ */
+function expandAllIncludes(ctx, parentModel, parentModelName, includeList, depth = 0, chain = []) {
+    if (!includeList?.length)
+        return [];
+    const expanded = [];
+    for (const rawIncludeOpt of includeList) {
+        const includeOpt = normalizeInclude(rawIncludeOpt);
+        if (!includeOpt)
+            continue;
+        const all = includeOpt.all;
+        if (all === undefined || all === null || all === false) {
+            // An ordinary include. Its own nested list is expanded relative to the
+            // included model, so `{ model: Post, include: [{ all: true }] }` works.
+            const nestedList = includeOpt.include;
+            if (nestedList?.length && includeOpt.model) {
+                expanded.push({
+                    ...includeOpt,
+                    include: expandAllIncludes(ctx, includeOpt.model, includeOpt.model.name, nestedList, depth, chain),
+                });
+            }
+            else {
+                expanded.push(includeOpt);
+            }
+            continue;
+        }
+        const candidates = associationsFrom(ctx, parentModel, parentModelName);
+        let selected;
+        if (all === true) {
+            selected = candidates;
+        }
+        else if (typeof all === 'string') {
+            selected = candidates.filter((a) => (a.as ?? a.options?.as) === all);
+            if (selected.length === 0) {
+                // The class-based expander only warns here. This loader reports bad
+                // includes rather than resolving them to nothing - the same rule that
+                // makes a mistyped `as` an AssociationError instead of an empty array.
+                const available = candidates.map((a) => a.as ?? a.options?.as).filter(Boolean);
+                throw new errors_1.AssociationError(`include { all: '${all}' }: ${parentModelName} has no association aliased '${all}'` +
+                    (available.length ? `. Available: ${available.join(', ')}` : ''), { association: all });
+            }
+        }
+        else {
+            throw new errors_1.AssociationError(`include \`all\` must be true or an association alias, got ${typeof all}`, { association: String(all) });
+        }
+        // Anything else the caller put on the `{ all: true }` entry - `where`,
+        // `attributes`, `order`, `limit`, `required`, ... - applies to every
+        // association it expands to. `include` is the one exception: a single
+        // hand-written nested list cannot be meaningful for every association at
+        // once, and `nested: true` is the option that expands nested levels.
+        const { all: _all, nested: _nested, include: _include, model: _model, as: _as, ...carried } = includeOpt;
+        const nested = includeOpt.nested === true;
+        const parentKey = modelKey(parentModel);
+        const branch = chain.includes(parentKey) ? chain : [...chain, parentKey];
+        for (const assoc of selected) {
+            const entry = {
+                ...carried,
+                model: assoc.target,
+                as: assoc.as ?? assoc.options?.as,
+            };
+            if (nested &&
+                depth + 1 < MAX_ALL_EXPANSION_DEPTH &&
+                !branch.includes(modelKey(assoc.target))) {
+                const nestedEntries = expandAllIncludes(ctx, assoc.target, assoc.target?.name, [{ all: true, nested: true }], depth + 1, branch);
+                if (nestedEntries.length)
+                    entry.include = nestedEntries;
+            }
+            expanded.push(entry);
+        }
+    }
+    return expanded;
+}
 /** Resolve a `through` given as a string against the model registry. */
 function resolveThroughModel(ctx, assoc) {
     if (assoc.throughModel && typeof assoc.throughModel.findAll === 'function') {
@@ -226,6 +372,110 @@ async function resolveRequiredIncludeFilter(ctx, parentModel, parentModelName, r
         .filter((v) => v !== undefined && v !== null)));
     return { parentAttr: sourcePkAttr, values: parentIds };
 }
+/**
+ * Attach a count of related rows to each parent, without loading them.
+ *
+ * `findAll({ withCount: ['posts'] })` sets `row.postsCount` on every parent.
+ * The counts are resolved with one grouped query per association, so this stays
+ * a constant number of statements no matter how many parents there are - the
+ * naive alternative is a count query per row.
+ *
+ * Use this when you need "how many" but not the rows themselves; a full
+ * `include` fetches every child just to measure the array.
+ */
+async function loadCounts(ctx, parentRows, parentModel, parentModelName, aliases) {
+    if (!parentRows.length || !aliases?.length)
+        return;
+    const sourcePkAttr = resolvePrimaryKeyAttr(parentModel);
+    const parentIds = parentRows
+        .map((r) => readField(r, sourcePkAttr))
+        .filter((v) => v !== undefined && v !== null);
+    for (const alias of aliases) {
+        const assoc = findAssociationByAlias(ctx, parentModel, parentModelName, alias);
+        const field = `${alias}Count`;
+        if (parentIds.length === 0) {
+            for (const row of parentRows)
+                attachField(row, field, 0);
+            continue;
+        }
+        try {
+            const counts = new Map();
+            if (assoc.type === 'belongsToMany') {
+                const throughModel = resolveThroughModel(ctx, assoc);
+                if (!throughModel || typeof throughModel.findAll !== 'function') {
+                    throw new Error(`Cannot resolve through model for '${alias}'`);
+                }
+                const junction = await throughModel.findAll({
+                    where: { [assoc.foreignKey]: { $in: parentIds } },
+                });
+                for (const jr of junction) {
+                    const k = readField(jr, assoc.foreignKey);
+                    counts.set(k, (counts.get(k) ?? 0) + 1);
+                }
+            }
+            else if (assoc.type === 'belongsTo') {
+                // A belongsTo points at one row, so the count is 0 or 1 per parent.
+                for (const row of parentRows) {
+                    const fk = readField(row, assoc.foreignKey);
+                    attachField(row, field, fk === undefined || fk === null ? 0 : 1);
+                }
+                continue;
+            }
+            else {
+                const children = await assoc.target.findAll({
+                    where: {
+                        ...(assoc.options?.scope || {}),
+                        [assoc.foreignKey]: { $in: parentIds },
+                    },
+                });
+                for (const c of children) {
+                    const k = readField(c, assoc.foreignKey);
+                    counts.set(k, (counts.get(k) ?? 0) + 1);
+                }
+            }
+            for (const row of parentRows) {
+                attachField(row, field, counts.get(readField(row, sourcePkAttr)) ?? 0);
+            }
+        }
+        catch (error) {
+            if (error instanceof errors_1.EagerLoadError || error instanceof errors_1.AssociationError)
+                throw error;
+            throw new errors_1.EagerLoadError(parentModelName, alias, assoc.type, error);
+        }
+    }
+}
+/** Resolve an association by its alias alone, for `withCount`. */
+function findAssociationByAlias(ctx, parentModel, parentModelName, alias) {
+    const candidates = associationsFrom(ctx, parentModel, parentModelName);
+    const match = candidates.find((a) => (a.as ?? a.options?.as) === alias);
+    if (!match) {
+        const available = candidates.map((a) => a.as).filter(Boolean);
+        throw new errors_1.AssociationError(`withCount: ${parentModelName} has no association aliased '${alias}'` +
+            (available.length ? `. Available: ${available.join(', ')}` : ''), { association: alias });
+    }
+    return match;
+}
+/**
+ * A per-parent `limit`/`offset` requested by one include, normalized.
+ *
+ * Anything that is not a non-negative integer is rejected rather than rounded or
+ * ignored: silently dropping a `limit` is the bug this whole path exists to fix,
+ * so a nonsensical one should not be dropped either.
+ */
+function readIncludeWindow(includeOpt, includeAlias) {
+    const window = {};
+    for (const key of ['limit', 'offset']) {
+        const raw = includeOpt[key];
+        if (raw === undefined || raw === null)
+            continue;
+        const value = typeof raw === 'string' ? Number(raw) : raw;
+        if (typeof value !== 'number' || !Number.isInteger(value) || value < 0) {
+            throw new errors_1.AssociationError(`include '${includeAlias}': \`${key}\` must be a non-negative integer, got ${JSON.stringify(raw)}`, { association: includeAlias });
+        }
+        window[key] = value;
+    }
+    return window;
+}
 /**
  * Eager-load `includeList` onto `parentRows`, recursing into nested includes.
  *
@@ -233,11 +483,48 @@ async function resolveRequiredIncludeFilter(ctx, parentModel, parentModelName, r
  * caught and reported as an empty result, which made a typo'd alias, a missing
  * foreign key column, an unresolvable through model and a genuinely childless
  * parent all look identical - and hid most of the bugs this module now fixes.
+ *
+ * ## Per-include `limit` / `offset`
+ *
+ * `include: [{ model: Post, order: [['id', 'DESC']], limit: 5 }]` reads as "the
+ * 5 most recent posts *per user*", and that is what it now means. Getting there
+ * needs care, because one query serves every parent:
+ *
+ *   SELECT ... FROM "posts" WHERE "userId" IN (1, 2, 3) ORDER BY "id" DESC
+ *
+ * Forwarding `LIMIT 5` into that statement would cap the *whole result set* at 5
+ * rows - user 1 would get five posts and users 2 and 3 none - which is worse
+ * than the old behaviour of dropping the option, because the answer looks
+ * plausible while being wrong for every parent but the first. So the limit is
+ * never forwarded into a multi-parent `IN (...)` query. Instead:
+ *
+ * - `order` is still applied *in SQL*, so the database decides which rows come
+ *   first - the window is a window over the ordering the caller asked for, not
+ *   over insertion order.
+ * - the window is then applied per parent, in memory, when the fetched rows are
+ *   grouped onto their parents.
+ * - the one case where the shared query and a per-parent window coincide is a
+ *   single parent row (`findByPk(...)` with an include, the common case): there
+ *   `LIMIT`/`OFFSET` *are* pushed down to SQL, for `hasMany` only - see below.
+ *
+ * What this does NOT do: reduce what crosses the wire for multi-parent queries.
+ * All matching children are fetched and most of them are then discarded.
+ * `limit` here bounds the arrays you get back, it is not a transfer
+ * optimization. Doing better needs per-parent SQL windows (`ROW_NUMBER() OVER
+ * (PARTITION BY ...)` or `LATERAL`), which is a dialect-level feature this
+ * loader - which only ever calls `Model.findAll()` - cannot express today.
+ *
+ * `limit`/`offset` are only meaningful on a to-many include. On `belongsTo` and
+ * `hasOne` the result is a single row rather than a list, so they are reported
+ * and ignored rather than quietly accepted.
  */
 async function loadIncludes(ctx, parentRows, parentModel, parentModelName, includeList) {
     if (!parentRows.length || !includeList?.length)
         return;
-    for (const rawIncludeOpt of includeList) {
+    // Resolve `{ all: true }` / `{ all: 'alias' }` into concrete includes first,
+    // so everything below only ever sees an entry with a `model`.
+    const resolvedIncludes = expandAllIncludes(ctx, parentModel, parentModelName, includeList);
+    for (const rawIncludeOpt of resolvedIncludes) {
         const includeOpt = normalizeInclude(rawIncludeOpt);
         const includeModel = includeOpt?.model;
         if (!includeModel)
@@ -251,6 +538,32 @@ async function loadIncludes(ctx, parentRows, parentModel, parentModelName, inclu
         const foreignKey = assoc.foreignKey;
         const sourcePkAttr = resolvePrimaryKeyAttr(parentModel);
         const targetPkAttr = resolvePrimaryKeyAttr(includeModel);
+        // Per-parent window. See the `limit`/`offset` section on this function for
+        // why this is resolved here rather than forwarded to the child query.
+        const perParent = readIncludeWindow(includeOpt, includeAlias);
+        const hasWindow = perParent.limit !== undefined || perParent.offset !== undefined;
+        const isToMany = associationType === 'hasMany' || associationType === 'belongsToMany';
+        if (hasWindow && !isToMany) {
+            // eslint-disable-next-line no-console
+            console.warn(`include '${includeAlias}' on ${parentModelName} is a ${associationType}, which ` +
+                `resolves to a single row: \`limit\`/\`offset\` have no meaning here and are ignored.`);
+        }
+        // The only shape where the shared query's LIMIT *is* the per-parent limit is
+        // a single parent, and only for hasMany - there one fetched row is one
+        // element of one parent's array. belongsToMany goes through a junction, so
+        // fetched target rows and array elements are not in one-to-one
+        // correspondence (a repeated junction pair yields two elements from one
+        // row); its window always stays in memory, where it counts the right things.
+        const pushWindowDown = hasWindow && associationType === 'hasMany' && parentRows.length === 1;
+        /** Apply the per-parent window to one parent's list of related rows. */
+        const applyWindow = (rows) => {
+            if (!hasWindow || pushWindowDown)
+                return rows;
+            const start = perParent.offset ?? 0;
+            return perParent.limit === undefined
+                ? rows.slice(start)
+                : rows.slice(start, start + perParent.limit);
+        };
         let fetchedRows = [];
         try {
             // An association `scope` is a fixed set of conditions applied every time
@@ -264,6 +577,16 @@ async function loadIncludes(ctx, parentRows, parentModel, parentModelName, inclu
             const passThrough = {
                 ...(includeOpt.attributes ? { attributes: includeOpt.attributes } : {}),
                 ...(includeOpt.order ? { order: includeOpt.order } : {}),
+                // `limit`/`offset` reach SQL only in the single-parent hasMany case,
+                // where the shared query's window and the per-parent window are the same
+                // window. Every other shape applies it per parent below - forwarding it
+                // here would bound the combined result set instead.
+                ...(pushWindowDown
+                    ? {
+                        ...(perParent.limit !== undefined ? { limit: perParent.limit } : {}),
+                        ...(perParent.offset !== undefined ? { offset: perParent.offset } : {}),
+                    }
+                    : {}),
             };
             if (associationType === 'belongsTo') {
                 // The foreign key is a column on the parent, referencing the target's key.
@@ -325,11 +648,28 @@ async function loadIncludes(ctx, parentRows, parentModel, parentModelName, inclu
                 });
                 fetchedRows = targetRows;
                 const targetMap = new Map();
-                for (const tr of targetRows)
-                    targetMap.set(readField(tr, targetPkAttr), tr);
+                // Position of each target row in the order the database returned them.
+                // A parent's array is otherwise built in *junction* row order, which
+                // means an `order` on the include never reached the array the caller
+                // sees - and a per-parent `limit` would then slice an arbitrary window
+                // rather than the one that was ordered. Only reordered when an `order`
+                // was actually asked for, so the junction ordering stays the default.
+                const targetPos = new Map();
+                targetRows.forEach((tr, i) => {
+                    const pk = readField(tr, targetPkAttr);
+                    targetMap.set(pk, tr);
+                    targetPos.set(pk, i);
+                });
                 for (const row of parentRows) {
                     const targetIds = targetIdsBySource.get(readField(row, sourcePkAttr)) || [];
-                    attachField(row, includeAlias, targetIds.map((tid) => targetMap.get(tid)).filter((v) => v !== undefined));
+                    const related = targetIds
+                        .map((tid) => targetMap.get(tid))
+                        .filter((v) => v !== undefined);
+                    if (includeOpt.order) {
+                        related.sort((a, b) => (targetPos.get(readField(a, targetPkAttr)) ?? 0) -
+                            (targetPos.get(readField(b, targetPkAttr)) ?? 0));
+                    }
+                    attachField(row, includeAlias, applyWindow(related));
                 }
             }
             else {
@@ -351,7 +691,10 @@ async function loadIncludes(ctx, parentRows, parentModel, parentModelName, inclu
                 }
                 for (const row of parentRows) {
                     const associated = groupedRows.get(readField(row, sourcePkAttr)) || [];
-                    attachField(row, includeAlias, associationType === 'hasOne' ? associated[0] ?? null : associated);
+                    attachField(row, includeAlias, 
+                    // hasOne is a single row, so the window (already reported as ignored
+                    // above) does not apply to it.
+                    associationType === 'hasOne' ? associated[0] ?? null : applyWindow(associated));
                 }
             }
             // Recurse, treating the rows just fetched as the parents for the next level.

package/dist/models/indexes.d.ts

@@ -23,7 +23,8 @@ export interface IndexOptions {
     using?: string;
     algorithm?: 'btree' | 'hash' | 'gist' | 'spgist' | 'gin' | 'brin' | 'hstore' | 'rum' | 'zombodb' | 'spatial';
     fields?: (string | IndexField)[];
-    where?: WhereOptions;
+    /** Partial-index predicate; see `IndexOptions.where` in `src/dialects/dialect.ts`. */
+    where?: WhereOptions | string;
     /** Include columns for covering index (PostgreSQL 11+, MySQL 8.0.17+) */
     include?: string[];
     /** Expression for expression-based indexes (e.g., LOWER(column)) */
@@ -80,7 +81,7 @@ export declare class Index {
     readonly using?: string;
     readonly algorithm?: 'btree' | 'hash' | 'gist' | 'spgist' | 'gin' | 'brin' | 'hstore' | 'rum' | 'zombodb' | 'spatial';
     readonly fields: IndexField[];
-    readonly where?: WhereOptions;
+    readonly where?: WhereOptions | string;
     readonly include?: string[];
     readonly expression?: string;
     readonly tableName?: string;

package/dist/models/indexes.js

@@ -64,7 +64,13 @@ class Index {
      * Check if this is a partial index
      */
     isPartial() {
-        return !!this.where && Object.keys(this.where).length > 0;
+        if (!this.where)
+            return false;
+        // A predicate can be a hand-written SQL string as well as an object.
+        if (typeof this.where === 'string')
+            return this.where.trim().length > 0;
+        // Symbol operator keys (`{ [Op.or]: [...] }`) do not show up in Object.keys.
+        return (Object.keys(this.where).length > 0 || Object.getOwnPropertySymbols(this.where).length > 0);
     }
     /**
      * Check if this is an expression index

package/dist/models/model.js

@@ -48,6 +48,25 @@ const validators_1 = require("../validators");
 const sql_compiler_1 = require("../query-builders/sql-compiler");
 const history_query_1 = require("../audit/history-query");
 // ==================== Nested Include Helpers ====================
+/**
+ * Normalize the two accepted include shapes: `{ model: Post, as: 'posts' }` and
+ * the bare-model shorthand `Post`.
+ *
+ * Mirrors `normalizeInclude()` in `./eager-load` - a bare model is recognised by
+ * carrying `rawAttributes` while carrying no `model` of its own. Keep the two in
+ * step: the loader skips any entry without a `model`, so an entry that is not
+ * normalized here silently loads nothing (and the SQL builder, which reads
+ * `include.model.tableName` when it emits the JOIN, throws on it outright).
+ *
+ * @param include - A raw include entry, either shape
+ * @returns The entry as `IncludeOptions`, wrapping a bare model if needed
+ */
+function normalizeIncludeEntry(include) {
+    const raw = include;
+    return raw && !raw.model && raw.rawAttributes
+        ? { model: raw }
+        : raw;
+}
 /**
  * Expand nested includes from { all: true } or { nested: true } options
  * This processes the include options to expand all associations recursively
@@ -70,7 +89,9 @@ function expandNestedIncludes(includes, model, depth = 0, maxDepth = 10) {
     }
     const expanded = [];
     for (const include of includes) {
-        const includeOpts = include;
+        // Accept the bare-model shorthand (`include: [Post]`) at every level, not
+        // just `{ model: Post }`.
+        const includeOpts = normalizeIncludeEntry(include);
         // Handle { all: true } or { all: 'associationName' } - include all or specific associations
         if (includeOpts.all !== undefined) {
             const modelAssociations = model.associations || {};
@@ -93,19 +114,16 @@ function expandNestedIncludes(includes, model, depth = 0, maxDepth = 10) {
                     console.warn(`Association '${allValue}' not found on model '${model.name}'`);
                 }
             }
+            // Everything the caller put on the `{ all }` entry is copied onto each
+            // generated entry. `all`/`nested` are consumed by this branch and must not
+            // leak through, and `include` belongs to the entry being expanded, not to
+            // the associations it expands into.
+            const { all: _all, nested: _nested, include: _include, ...carriedOptions } = includeOpts;
             for (const [assocName, association] of associationsToInclude) {
                 const assocInclude = {
+                    ...carriedOptions,
                     model: association.target,
                     as: association.as,
-                    where: includeOpts.where,
-                    attributes: includeOpts.attributes,
-                    required: includeOpts.required,
-                    through: includeOpts.through,
-                    on: includeOpts.on,
-                    order: includeOpts.order,
-                    limit: includeOpts.limit,
-                    offset: includeOpts.offset,
-                    paranoid: includeOpts.paranoid,
                     duplicate,
                 };
                 // If nested is true, recursively expand all nested associations
@@ -116,22 +134,12 @@ function expandNestedIncludes(includes, model, depth = 0, maxDepth = 10) {
             }
             continue;
         }
-        // Handle regular include (no { all } or { nested } special handling)
-        const expandedInclude = {
-            model: includeOpts.model,
-            as: includeOpts.as,
-            where: includeOpts.where,
-            attributes: includeOpts.attributes,
-            required: includeOpts.required,
-            through: includeOpts.through,
-            on: includeOpts.on,
-            order: includeOpts.order,
-            limit: includeOpts.limit,
-            offset: includeOpts.offset,
-            paranoid: includeOpts.paranoid,
-            duplicate: includeOpts.duplicate,
-            targetKey: includeOpts.targetKey,
-        };
+        // Handle regular include (no { all } or { nested } special handling).
+        // Copy the whole entry: this used to rebuild it from a fixed field list,
+        // which dropped every option that list did not name (`schema`, `foreignKey`,
+        // `joinType`, `lateral`, `antiJoin`/`antiJoinType`, `apply`,
+        // `lateralSubquery`, `duplicating`, `includeIgnoreAttributes`, `nested`).
+        const expandedInclude = { ...includeOpts };
         // Recursively expand nested includes
         if (includeOpts.include) {
             expandedInclude.include = expandNestedIncludes(includeOpts.include, includeOpts.model, depth + 1, maxDepth);
@@ -774,10 +782,15 @@ class ModelInstance {
                 if (value === null || value === undefined) {
                     casted[key] = null;
                 }
-                else if (typeof value === 'string') {
-                    casted[key] = value;
-                }
                 else {
+                    // Encode every value, strings included. Passing a string through
+                    // unencoded is what made the round trip lossy: it reached the column
+                    // raw, and castValuesFromDatabase then JSON.parse'd it
+                    // unconditionally, so any string that was itself valid JSON came back
+                    // as something else - '123' as a number, 'true' as a boolean,
+                    // '12345678901234567890' silently rounded. It also wrote invalid JSON
+                    // on PostgreSQL, which rejects a bare `hello` for a json column.
+                    // (Mirrors the same fix in `_serializeValue` in src/prorm.ts.)
                     casted[key] = JSON.stringify(value);
                 }
                 continue;
@@ -1405,7 +1418,9 @@ class ModelInstance {
      */
     async validate(options) {
         const modelOptions = this.model.options;
-        const hooksManager = this.model._hooksManager;
+        // `_hooksManager` was read here but assigned nowhere, so `{ hooks: true }`
+        // silently ran no hooks. Use the model's declared hooks instead.
+        const validateHooks = modelOptions?.hooks || {};
         // Parse options
         let fieldsToValidate;
         let runHooks = false;
@@ -1421,8 +1436,8 @@ class ModelInstance {
             return { valid: true, errors: [] };
         }
         // Run beforeValidate hook if requested
-        if (runHooks && hooksManager) {
-            await hooksManager.runHook('beforeValidate', this, { model: this.model });
+        if (runHooks && typeof validateHooks.beforeValidate === 'function') {
+            await validateHooks.beforeValidate(this, { model: this.model });
         }
         const validations = {};
         // Collect validations from rawAttributes
@@ -1465,8 +1480,8 @@ class ModelInstance {
             exclude: !this.isNewRecord && pkField ? { [pkField]: this.dataValues[pkField] } : undefined,
         });
         // Run afterValidate hook if requested
-        if (runHooks && hooksManager && result.valid) {
-            await hooksManager.runHook('afterValidate', this, { model: this.model });
+        if (runHooks && result.valid && typeof validateHooks.afterValidate === 'function') {
+            await validateHooks.afterValidate(this, { model: this.model });
         }
         // Store validation errors for later retrieval
         this._validationErrors = result.errors;
@@ -2805,18 +2820,26 @@ function createModel(prorm, modelName, attributes, options = {}) {
          * });
          */
         async findAll(findOptions = {}) {
-            // Handle connection switching via 'using' option
+            // Handle connection switching via 'using' option: the query runs against
+            // the named sibling connection's copy of this model, not this one.
             if (findOptions.using) {
-                const connection = prorm.connectionManager?.getConnection(findOptions.using);
+                const registry = prorm.connectionManager;
+                const connection = registry?.getConnection(findOptions.using);
                 if (!connection) {
-                    throw new Error(`Connection '${findOptions.using}' not found. Available: ${prorm.connectionManager?.getConnectionNames()?.join(', ') || 'none'}`);
+                    const available = registry?.getConnectionNames()?.join(', ') || 'none';
+                    throw new Error(`Connection '${findOptions.using}' not found. Available: ${available}`);
                 }
-                // Delegate to the specified connection's model
-                const model = connection.models.get(this.name);
+                // `connection.models` is a plain object keyed by model name (the
+                // getter builds it from the internal map); this used to call `.get()`
+                // on it, which threw a TypeError before the option could ever work.
+                const modelName = this.name;
+                const model = connection.models[modelName];
                 if (!model) {
-                    throw new Error(`Model '${this.name}' not found in connection '${findOptions.using}'`);
+                    const defined = Object.keys(connection.models).join(', ') || 'none';
+                    throw new Error(`Model '${modelName}' is not defined on connection '${findOptions.using}'. ` +
+                        `Defined there: ${defined}`);
                 }
-                const { using, ...queryOptions } = findOptions;
+                const { using: _using, ...queryOptions } = findOptions;
                 return model.findAll(queryOptions);
             }
             const dialect = prorm.getDialectInstance();
@@ -2881,10 +2904,13 @@ function createModel(prorm, modelName, attributes, options = {}) {
                 lock: findOptions.lock,
             };
             const { sql, values } = dialect.buildSelectQuery(selectOptions);
-            // Execute query
+            // Execute query. The bind values come from buildSelectQuery - passing
+            // `selectOptions` here instead meant every query carrying a placeholder
+            // (any `where`, including one on an include) bound nothing and failed with
+            // "Too few parameter values were provided".
             const result = await dialect.query(sql, {
                 raw: findOptions.raw,
-                replacements: values?.length ? selectOptions : undefined,
+                replacements: values?.length ? values : undefined,
             });
             // Create model instances
             const instances = result.rows.map((row) => new ModelInstance(this, prorm, row, { isNewRecord: false }));