ts-prorm-orm 1.2.3 → 2.0.0

package/dist/prorm.js

@@ -78,372 +78,21 @@ const query_interface_1 = require("./query-interface");
 // Import UUIDV4 from data-types
 const data_types_1 = require("./models/data-types");
 const sql_constants_1 = require("./sql-constants");
-/**
- * Hook manager for Prorm instance
- */
-class HooksManager {
-    constructor() {
-        this.beforeDefineHooks = [];
-        this.afterDefineHooks = [];
-        this.beforeSyncHooks = [];
-        this.afterSyncHooks = [];
-        this.beforeConnectHooks = [];
-        this.afterConnectHooks = [];
-        this.beforeDisconnectHooks = [];
-        this.afterDisconnectHooks = [];
-        this.beforeDestroyHooks = [];
-        this.afterDestroyHooks = [];
-        this.beforeUpsertHooks = [];
-        this.afterUpsertHooks = [];
-        this.beforeReloadHooks = [];
-    }
-    /**
-     * Register a beforeDefine hook
-     */
-    beforeDefine(callback) {
-        this.beforeDefineHooks.push(callback);
-    }
-    /**
-     * Register an afterDefine hook
-     */
-    afterDefine(callback) {
-        this.afterDefineHooks.push(callback);
-    }
-    /**
-     * Register a beforeSync hook
-     */
-    beforeSync(callback) {
-        this.beforeSyncHooks.push(callback);
-    }
-    /**
-     * Register an afterSync hook
-     */
-    afterSync(callback) {
-        this.afterSyncHooks.push(callback);
-    }
-    /**
-     * Register a beforeConnect hook
-     */
-    beforeConnect(callback) {
-        this.beforeConnectHooks.push(callback);
-    }
-    /**
-     * Register an afterConnect hook
-     */
-    afterConnect(callback) {
-        this.afterConnectHooks.push(callback);
-    }
-    /**
-     * Register a beforeDisconnect hook
-     */
-    beforeDisconnect(callback) {
-        this.beforeDisconnectHooks.push(callback);
-    }
-    /**
-     * Register an afterDisconnect hook
-     */
-    afterDisconnect(callback) {
-        this.afterDisconnectHooks.push(callback);
-    }
-    /**
-     * Register a beforeDestroy hook
-     */
-    beforeDestroy(callback) {
-        this.beforeDestroyHooks.push(callback);
-    }
-    /**
-     * Register an afterDestroy hook
-     */
-    afterDestroy(callback) {
-        this.afterDestroyHooks.push(callback);
-    }
-    /**
-     * Register a beforeUpsert hook
-     */
-    beforeUpsert(callback) {
-        this.beforeUpsertHooks.push(callback);
-    }
-    /**
-     * Register an afterUpsert hook
-     */
-    afterUpsert(callback) {
-        this.afterUpsertHooks.push(callback);
-    }
-    /**
-     * Register a beforeReload hook
-     */
-    beforeReload(callback) {
-        this.beforeReloadHooks.push(callback);
-    }
-    /**
-     * Execute all beforeDefine hooks
-     */
-    async runBeforeDefine(modelName, attributes, options) {
-        for (const hook of this.beforeDefineHooks) {
-            await hook({ modelName, attributes, options });
-        }
-    }
-    /**
-     * Execute all afterDefine hooks
-     */
-    async runAfterDefine(model) {
-        for (const hook of this.afterDefineHooks) {
-            await hook({ model });
-        }
-    }
-    /**
-     * Execute all beforeSync hooks
-     */
-    async runBeforeSync(options) {
-        for (const hook of this.beforeSyncHooks) {
-            await hook({ options });
-        }
-    }
-    /**
-     * Execute all afterSync hooks
-     */
-    async runAfterSync(options) {
-        for (const hook of this.afterSyncHooks) {
-            await hook({ options });
-        }
-    }
-    /**
-     * Execute all beforeConnect hooks
-     */
-    async runBeforeConnect() {
-        for (const hook of this.beforeConnectHooks) {
-            await hook();
-        }
-    }
-    /**
-     * Execute all afterConnect hooks
-     * @param connection - The connection object to pass to hooks
-     */
-    async runAfterConnect(connection) {
-        for (const hook of this.afterConnectHooks) {
-            await hook(connection);
-        }
-    }
-    /**
-     * Execute all beforeDisconnect hooks
-     * @param connection - The connection object to pass to hooks
-     */
-    async runBeforeDisconnect(connection) {
-        for (const hook of this.beforeDisconnectHooks) {
-            await hook(connection);
-        }
-    }
-    /**
-     * Execute all afterDisconnect hooks
-     * @param connection - The connection object to pass to hooks
-     */
-    async runAfterDisconnect(connection) {
-        for (const hook of this.afterDisconnectHooks) {
-            await hook(connection);
-        }
-    }
-    /**
-     * Execute all beforeDestroy hooks
-     * @param options - The destroy options
-     */
-    async runBeforeDestroy(options) {
-        for (const hook of this.beforeDestroyHooks) {
-            await hook({ options });
-        }
-    }
-    /**
-     * Execute all afterDestroy hooks
-     * @param options - The destroy options
-     */
-    async runAfterDestroy(options) {
-        for (const hook of this.afterDestroyHooks) {
-            await hook({ options });
-        }
-    }
-    /**
-     * Execute all beforeUpsert hooks
-     * @param options - The upsert options
-     */
-    async runBeforeUpsert(options) {
-        for (const hook of this.beforeUpsertHooks) {
-            await hook({ options });
-        }
-    }
-    /**
-     * Execute all afterUpsert hooks
-     * @param options - The upsert options
-     */
-    async runAfterUpsert(options) {
-        for (const hook of this.afterUpsertHooks) {
-            await hook({ options });
-        }
-    }
-    /**
-     * Execute all beforeReload hooks
-     * @param options - The reload options
-     */
-    async runBeforeReload(options) {
-        for (const hook of this.beforeReloadHooks) {
-            await hook({ options });
-        }
-    }
-    /**
-     * Add a hook by name
-     * @param hookName - The name of the hook (e.g., 'beforeDefine', 'afterSync')
-     * @param callback - The hook callback function
-     */
-    addHook(hookName, callback) {
-        const methodName = hookName;
-        if (typeof this[methodName] === 'function') {
-            this[methodName](callback);
-        }
-    }
-    /**
-     * Clear all hooks
-     */
-    clearHooks() {
-        this.beforeDefineHooks = [];
-        this.afterDefineHooks = [];
-        this.beforeSyncHooks = [];
-        this.afterSyncHooks = [];
-        this.beforeConnectHooks = [];
-        this.afterConnectHooks = [];
-        this.beforeDisconnectHooks = [];
-        this.afterDisconnectHooks = [];
-        this.beforeDestroyHooks = [];
-        this.afterDestroyHooks = [];
-        this.beforeUpsertHooks = [];
-        this.afterUpsertHooks = [];
-        this.beforeReloadHooks = [];
-    }
-}
-exports.HooksManager = HooksManager;
-/**
- * Model-level hooks manager
- */
-class ModelHooks {
-    constructor() {
-        this.beforeSyncHooks = [];
-        this.afterSyncHooks = [];
-    }
-    /**
-     * Register a beforeSync hook on the model
-     */
-    beforeSync(callback) {
-        this.beforeSyncHooks.push(callback);
-    }
-    /**
-     * Register an afterSync hook on the model
-     */
-    afterSync(callback) {
-        this.afterSyncHooks.push(callback);
-    }
-    /**
-     * Run beforeSync hooks
-     */
-    async runBeforeSync(options) {
-        for (const hook of this.beforeSyncHooks) {
-            await hook({ options });
-        }
-    }
-    /**
-     * Run afterSync hooks
-     */
-    async runAfterSync(options) {
-        for (const hook of this.afterSyncHooks) {
-            await hook({ options });
-        }
-    }
-}
-/**
- * Represents a raw SQL literal value
- * Used for inserting raw SQL expressions into queries
- *
- * @example
- * // Use in default values
- * createdAt: { type: DATE, defaultValue: prorm.literal('NOW()') }
- *
- * @example
- * // Use in updates
- * User.update({ count: prorm.literal('count + 1') }, {...})
- *
- * @example
- * // Use in select with calculations
- * User.findAll({ attributes: [[prorm.literal('1 + 1'), 'two']] })
- */
-class Literal {
-    constructor(sql) {
-        this.val = sql;
-    }
-    /**
-     * Get the raw SQL string
-     */
-    toString() {
-        return this.val;
-    }
-}
-exports.Literal = Literal;
-/**
- * Class representing a column reference for use with Prorm functions
- * Used to create properly quoted column identifiers
- *
- * @example
- * // Single column: col('name') -> "name"
- * // Table and column: col('User', 'name') -> "User"."name"
- * // Dot notation: col('table.column') -> "table"."column"
- */
-class Col {
-    /**
-     * Create a column reference
-     * @param tableOrColumn - Table name (if second param provided) or column name
-     * @param column - Column name (if first param is table name)
-     */
-    constructor(tableOrColumn, column) {
-        if (column !== undefined) {
-            // col('User', 'name') -> "User"."name"
-            this.col = `"${tableOrColumn}"."${column}"`;
-        }
-        else if (tableOrColumn.includes('.')) {
-            // col('table.column') -> "table"."column"
-            const [table, col] = tableOrColumn.split('.');
-            this.col = `"${table}"."${col}"`;
-        }
-        else {
-            // col('name') -> "name"
-            this.col = `"${tableOrColumn}"`;
-        }
-    }
-    /**
-     * Get the SQL representation of the column
-     */
-    toSql() {
-        return this.col;
-    }
-    /**
-     * Get the column as a string
-     */
-    toString() {
-        return this.col;
-    }
-}
-exports.Col = Col;
+// Instance-API types, hook registries and SQL expression wrappers now live in
+// ./core. They are imported for local use and re-exported, so the public API
+// exposed from this module is unchanged.
+const hooks_manager_1 = require("./core/hooks-manager");
+Object.defineProperty(exports, "HooksManager", { enumerable: true, get: function () { return hooks_manager_1.HooksManager; } });
+const expressions_1 = require("./core/expressions");
+Object.defineProperty(exports, "Literal", { enumerable: true, get: function () { return expressions_1.Literal; } });
+Object.defineProperty(exports, "Col", { enumerable: true, get: function () { return expressions_1.Col; } });
 /**
  * Query types for raw SQL queries
  */
-var QueryTypes;
-(function (QueryTypes) {
-    QueryTypes["SELECT"] = "SELECT";
-    QueryTypes["INSERT"] = "INSERT";
-    QueryTypes["UPDATE"] = "UPDATE";
-    QueryTypes["DELETE"] = "DELETE";
-    QueryTypes["BULKDELETE"] = "BULKDELETE";
-    QueryTypes["BULKINSERT"] = "BULKINSERT";
-    QueryTypes["UPSERT"] = "UPSERT";
-    QueryTypes["VERSION"] = "VERSION";
-    QueryTypes["SHOWTABLES"] = "SHOWTABLES";
-    QueryTypes["DESCRIBE"] = "DESCRIBE";
-    QueryTypes["RAW"] = "RAW";
-})(QueryTypes || (exports.QueryTypes = QueryTypes = {}));
+// QueryTypes is defined once in ./types/query-types. Imported for local use
+// and re-exported, since the package root has always exported it from here.
+const query_types_1 = require("./types/query-types");
+Object.defineProperty(exports, "QueryTypes", { enumerable: true, get: function () { return query_types_1.QueryTypes; } });
 /**
  * Resolve the primary-key attribute name for a model, based on its `rawAttributes`
  * (looking for the field marked `primaryKey: true`). Falls back to `'id'` when the
@@ -493,6 +142,48 @@ function extractAssociationConditions(where) {
     }
     return { rest, conditions };
 }
+/**
+ * Model options inherited from an `@AbstractModel` base.
+ *
+ * A concrete model with its own `@Table` uses that; one without falls back to
+ * the nearest annotated ancestor, so timestamps/paranoid/scopes declared once
+ * on a base apply to every subclass.
+ */
+function inheritedModelMetadata(modelClass) {
+    let current = Object.getPrototypeOf(modelClass);
+    while (current && current.name) {
+        const meta = (0, decorators_1.getModelMetadata)(current.name);
+        if (meta)
+            return meta;
+        current = Object.getPrototypeOf(current);
+    }
+    return undefined;
+}
+/**
+ * The column names a model's table actually has.
+ *
+ * `rawAttributes` holds only what the caller declared. `createTableFromModel`
+ * additionally synthesizes an `id` primary key when none was declared, plus the
+ * timestamp columns - so a model defined as `{ name }` yields a table with
+ * `id, name, createdAt, updatedAt`. Validating an attribute name against
+ * `rawAttributes` alone therefore rejects columns that genuinely exist.
+ */
+function modelColumnNames(model) {
+    const names = new Set(Object.keys(model?.rawAttributes || {}));
+    const options = (model?.options || {});
+    // Implicit primary key: added only when the model declared none.
+    const hasDeclaredPk = Object.values(model?.rawAttributes || {}).some((a) => a?.primaryKey);
+    if (!hasDeclaredPk && !names.has('id'))
+        names.add('id');
+    if (options?.timestamps !== false) {
+        names.add(options?.createdAt || 'createdAt');
+        names.add(options?.updatedAt || 'updatedAt');
+    }
+    if (options?.paranoid) {
+        names.add(options?.deletedAt || 'deletedAt');
+    }
+    return names;
+}
 /**
  * Derive a model's table name from its name and options.
  *
@@ -554,6 +245,127 @@ function resolveForeignKeyColumnType(refModel, refField) {
     // Otherwise mirror the referenced column's own type (UUID, STRING(n), BIGINT, ...).
     return (type ?? 'INTEGER');
 }
+/**
+ * Resolve the physical column name a model attribute maps to.
+ *
+ * `field` renames a column explicitly and `underscored` snake_cases the rest,
+ * but a constraint has to name the column the CREATE TABLE statement actually
+ * emitted. This DDL path keys its column map by attribute name, so when the
+ * renamed name is not among the emitted columns the attribute name is used
+ * instead: naming a column that does not exist would turn a silently-missing
+ * constraint into a hard CREATE TABLE failure, which is not an improvement.
+ */
+function resolvePhysicalColumnName(attrName, attributes, options, emittedColumns) {
+    const attr = attributes[attrName];
+    const renamed = attr?.field ?? (options?.underscored ? (0, utils_2.snakeCase)(attrName) : undefined);
+    if (!renamed || renamed === attrName)
+        return attrName;
+    if (emittedColumns[renamed])
+        return renamed;
+    return emittedColumns[attrName] ? attrName : renamed;
+}
+/**
+ * Collect every composite-unique declaration on a model into one canonical list.
+ *
+ * Three documented, typed ways to declare a composite unique constraint all
+ * used to be read by nobody, so they emitted no SQL at all: the developer read
+ * back a `CREATE TABLE` with no UNIQUE in it only if they went looking, the
+ * database never enforced anything, and the duplicate rows turned up later.
+ *
+ *  - attribute-level `uniqueKey: 'name'` - every attribute sharing that value
+ *    joins one constraint of that name, in declaration order (as documented on
+ *    `AttributeOptions.uniqueKey`);
+ *  - model-level `uniqueKeys: UniqueKeyOptions[]`, whose optional `unique: true`
+ *    selects a unique index over a table constraint;
+ *  - the legacy `uniqueKeysLegacy: Record<name, fields[]>` map, still declared
+ *    on `ModelOptions` and still supported here so that models written against
+ *    it keep working.
+ *
+ * Declaring the same constraint through more than one form is deliberately not
+ * an error - it is the natural thing to do when migrating from one form to
+ * another - so entries are collapsed both by name and by column set, and the
+ * first declaration of each wins.
+ *
+ * @throws {Error} when a declaration names a column the table does not have -
+ * the whole point of this function is that a unique key which cannot be
+ * enforced must not pass silently.
+ */
+function collectUniqueKeys(tableName, attributes, options, emittedColumns) {
+    const opts = options;
+    const collected = [];
+    const seenNames = new Set();
+    const seenColumnSets = new Set();
+    const columnOf = (attrName) => resolvePhysicalColumnName(attrName, attributes, options, emittedColumns);
+    const add = (name, columns, asIndex, source) => {
+        if (columns.length === 0)
+            return;
+        for (const column of columns) {
+            if (!emittedColumns[column]) {
+                throw new Error(`Unique key "${name}" on table "${tableName}" (${source}) references ` +
+                    `column "${column}", which the table does not have. ` +
+                    `Known columns: ${Object.keys(emittedColumns).join(', ')}.`);
+            }
+        }
+        // Column order is part of a composite key's identity for index purposes but
+        // not for uniqueness, so the de-duplication signature is order-independent:
+        // (a, b) and (b, a) enforce exactly the same rule and one of them is enough.
+        const signature = [...columns].sort().join(' ');
+        if (seenNames.has(name) || seenColumnSets.has(signature))
+            return;
+        seenNames.add(name);
+        seenColumnSets.add(signature);
+        collected.push({ name, fields: columns, asIndex });
+    };
+    // 1. Attribute-level grouping. Insertion order of `attributes` is the
+    //    declaration order the user wrote, which is the order the columns take.
+    const groups = new Map();
+    for (const [attrName, attr] of Object.entries(attributes)) {
+        const key = attr?.uniqueKey;
+        if (typeof key !== 'string' || key.length === 0)
+            continue;
+        const group = groups.get(key);
+        if (group)
+            group.push(columnOf(attrName));
+        else
+            groups.set(key, [columnOf(attrName)]);
+    }
+    for (const [name, columns] of groups) {
+        add(name, columns, false, 'attribute-level uniqueKey');
+    }
+    // 2. Model-level `uniqueKeys: UniqueKeyOptions[]`. Tolerate the legacy record
+    //    shape here too - `ModelOptions.uniqueKeys` is typed as an array, but the
+    //    dialects have always accepted `Record<name, fields[]>` under the same
+    //    option name, and an untyped caller passing one should not be dropped.
+    const uniqueKeys = opts?.uniqueKeys;
+    if (Array.isArray(uniqueKeys)) {
+        for (const uk of uniqueKeys) {
+            if (!uk || !Array.isArray(uk.fields))
+                continue;
+            const columns = uk.fields.map(columnOf);
+            const name = uk.name || `${tableName}_${columns.join('_')}_key`;
+            add(name, columns, uk.unique === true, 'model-level uniqueKeys');
+        }
+    }
+    else if (uniqueKeys && typeof uniqueKeys === 'object') {
+        for (const [name, fields] of Object.entries(uniqueKeys)) {
+            if (!Array.isArray(fields))
+                continue;
+            const columns = fields.map(columnOf);
+            add(name || `${tableName}_${columns.join('_')}_key`, columns, false, 'model-level uniqueKeys');
+        }
+    }
+    // 3. Legacy `uniqueKeysLegacy` map.
+    const legacy = opts?.uniqueKeysLegacy;
+    if (legacy && typeof legacy === 'object') {
+        for (const [name, fields] of Object.entries(legacy)) {
+            if (!Array.isArray(fields))
+                continue;
+            const columns = fields.map(columnOf);
+            add(name || `${tableName}_${columns.join('_')}_key`, columns, false, 'uniqueKeysLegacy');
+        }
+    }
+    return collected;
+}
 // Tracks (via Node's AsyncLocalStorage, which correctly follows a logical
 // call chain across `await`s regardless of how concurrent operations
 // interleave) whether the currently-executing code is running inside an
@@ -648,6 +460,17 @@ class Prorm extends events_1.EventEmitter {
         this._fdwManager = null;
         this._userManager = null;
         this._models = new Map();
+        /**
+         * The registry this instance was created by, if any.
+         *
+         * `ConnectionManager.addConnection()` sets this on the instance it builds,
+         * which is what makes `FindOptions.using` work: a query can name a sibling
+         * connection and be routed to that connection's copy of the model. Nothing
+         * else assigned it before, so `using` threw "Available: none" on every call.
+         * Typed structurally (rather than as `ConnectionManager`) to keep prorm.ts
+         * free of an import cycle with connection-manager.ts.
+         */
+        this.connectionManager = null;
         this.currentTransaction = null;
         // Serializes root-level (non-nested) transactions for dialects backed by a
         // single shared connection (currently just SQLite/better-sqlite3) - see
@@ -680,7 +503,7 @@ class Prorm extends events_1.EventEmitter {
         // i.e. missing the FOREIGN KEY/REFERENCES clause associations imply.
         this.pendingTableCreates = [];
         this._isConnected = false;
-        this.hooksManager = new HooksManager();
+        this.hooksManager = new hooks_manager_1.HooksManager();
         this.modelHooks = new Map();
         /**
          * The connection pool instance
@@ -721,9 +544,11 @@ class Prorm extends events_1.EventEmitter {
             logSQL: options.logSQL || false,
             slowQueryThreshold: options.slowQueryThreshold || 1000,
             logSlowQueries: options.logSlowQueries !== false,
-            prormLogging: typeof options.logging === 'function'
-                ? options.logging
-                : undefined,
+            // Deliberately NOT wired to `options.logging`. User-facing query logging
+            // is owned by `_logQuery`, which honours per-query overrides; handing the
+            // same callback to this logger too made it fire a second time and ignore
+            // `{ logging: false }` on an individual call. This logger's remaining job
+            // is slow-query detection and the debug/info/warn/error levels.
             colors: options.colors !== false,
         });
         // Set up query logging event handlers
@@ -780,7 +605,7 @@ class Prorm extends events_1.EventEmitter {
      * });
      */
     literal(sql) {
-        return new Literal((0, operators_1.literal)(sql).$literal);
+        return new expressions_1.Literal((0, operators_1.literal)(sql).$literal);
     }
     /**
      * Set up the connection pool with event forwarding
@@ -1194,7 +1019,7 @@ class Prorm extends events_1.EventEmitter {
                 sql: 'SELECT 1',
                 duration,
                 timestamp: new Date(),
-                type: QueryTypes.SELECT,
+                type: query_types_1.QueryTypes.SELECT,
             });
         }
         catch (error) {
@@ -1293,40 +1118,31 @@ class Prorm extends events_1.EventEmitter {
     }
     /**
      * Disable foreign key checks for the current session
+     *
+     * On PostgreSQL this issues `SET session_replication_role = 'replica'`, which
+     * needs superuser or a role granted `SET ON PARAMETER
+     * session_replication_role` (PostgreSQL 15+).
+     *
+     * @throws {UnsupportedForeignKeyChecksError} on dialects with no
+     * session-level switch (SQL Server, Oracle and Db2 are per-table; Redshift,
+     * Snowflake and ClickHouse never enforce foreign keys).
      * @returns Promise that resolves when foreign key checks are disabled
      */
     async disableForeignKeyChecks() {
-        const dialect = this.getDialect();
-        let sql;
-        if (dialect === 'sqlite' || dialect === 'turso') {
-            sql = sql_constants_1.SQLITE.PRAGMA.foreign_keys.off;
-        }
-        else if (dialect === 'postgres') {
-            // PostgreSQL uses deferrable constraints, not FK checks
-            sql = 'SET FOREIGN_KEY_CHECKS = 0'; // Fallback
-        }
-        else {
-            sql = sql_constants_1.MYSQL.FOREIGN_KEY_CHECKS.disable;
-        }
-        await this.query(sql, { raw: true });
+        await this.query(this.getDisableForeignKeyChecksSQL(), { raw: true });
     }
     /**
      * Enable foreign key checks for the current session
+     *
+     * The inverse of {@link disableForeignKeyChecks}, with the same dialect
+     * support and the same PostgreSQL privilege requirement.
+     *
+     * @throws {UnsupportedForeignKeyChecksError} on dialects with no
+     * session-level switch
      * @returns Promise that resolves when foreign key checks are enabled
      */
     async enableForeignKeyChecks() {
-        const dialect = this.getDialect();
-        let sql;
-        if (dialect === 'sqlite' || dialect === 'turso') {
-            sql = sql_constants_1.SQLITE.PRAGMA.foreign_keys.on;
-        }
-        else if (dialect === 'postgres') {
-            sql = 'SET FOREIGN_KEY_CHECKS = 1'; // Fallback
-        }
-        else {
-            sql = sql_constants_1.MYSQL.FOREIGN_KEY_CHECKS.enable;
-        }
-        await this.query(sql, { raw: true });
+        await this.query(this.getEnableForeignKeyChecksSQL(), { raw: true });
     }
     /**
      * Set the transaction isolation level
@@ -1349,31 +1165,30 @@ class Prorm extends events_1.EventEmitter {
     }
     /**
      * Get SQL for disabling foreign key checks for the current dialect
+     *
+     * Routing lives in `sql-constants.getForeignKeyChecksSQL` so that the three
+     * mutually incompatible statements (SQLite's PRAGMA, MySQL's session
+     * variable, PostgreSQL's `session_replication_role`) are chosen from one
+     * table. This used to fall through to MySQL syntax for every dialect it did
+     * not name - PostgreSQL included - so `disableForeignKeyChecks()` threw a
+     * syntax error at the server on most of the supported databases.
+     *
+     * @throws {UnsupportedForeignKeyChecksError} when the dialect has no
+     * session-level equivalent
      * @returns SQL string for disabling foreign key checks
      */
     getDisableForeignKeyChecksSQL() {
-        const dialect = this.getDialect();
-        if (dialect === 'sqlite' || dialect === 'turso') {
-            return sql_constants_1.SQLITE.PRAGMA.foreign_keys.off;
-        }
-        else if (dialect === 'postgres') {
-            return 'SET FOREIGN_KEY_CHECKS = 0';
-        }
-        return sql_constants_1.MYSQL.FOREIGN_KEY_CHECKS.disable;
+        return (0, sql_constants_1.getForeignKeyChecksSQL)(this.getDialect(), 'disable');
     }
     /**
      * Get SQL for enabling foreign key checks for the current dialect
+     *
+     * @throws {UnsupportedForeignKeyChecksError} when the dialect has no
+     * session-level equivalent
      * @returns SQL string for enabling foreign key checks
      */
     getEnableForeignKeyChecksSQL() {
-        const dialect = this.getDialect();
-        if (dialect === 'sqlite' || dialect === 'turso') {
-            return sql_constants_1.SQLITE.PRAGMA.foreign_keys.on;
-        }
-        else if (dialect === 'postgres') {
-            return 'SET FOREIGN_KEY_CHECKS = 1';
-        }
-        return sql_constants_1.MYSQL.FOREIGN_KEY_CHECKS.enable;
+        return (0, sql_constants_1.getForeignKeyChecksSQL)(this.getDialect(), 'enable');
     }
     /**
      * Get SQL for setting transaction isolation level for the current dialect
@@ -1392,6 +1207,19 @@ class Prorm extends events_1.EventEmitter {
     }
     /**
      * Disable unique key checks for the current session (MySQL/MariaDB only)
+     *
+     * The no-op on other dialects is deliberate, and is not the same situation as
+     * the foreign key switch above. `SET UNIQUE_CHECKS` is a MySQL/MariaDB
+     * *optimisation* hint: it defers uniqueness verification on InnoDB secondary
+     * indexes during bulk loads. No other supported database has a session
+     * setting that suspends unique constraint checking - PostgreSQL's
+     * `session_replication_role = 'replica'` suppresses triggers and foreign
+     * keys but still enforces unique indexes - so there is nothing to translate
+     * it to. Skipping the statement leaves the database in exactly the state the
+     * caller already had (uniqueness enforced), which is safe; throwing would
+     * break the common `disableUniqueKeyChecks(); bulkCreate(); enable...()`
+     * bulk-load pattern on every non-MySQL dialect for no benefit.
+     *
      * @returns Promise that resolves when unique key checks are disabled
      */
     async disableUniqueKeyChecks() {
@@ -1402,6 +1230,9 @@ class Prorm extends events_1.EventEmitter {
     }
     /**
      * Enable unique key checks for the current session (MySQL/MariaDB only)
+     *
+     * A no-op elsewhere, for the reason given on {@link disableUniqueKeyChecks}.
+     *
      * @returns Promise that resolves when unique key checks are enabled
      */
     async enableUniqueKeyChecks() {
@@ -1746,6 +1577,70 @@ class Prorm extends events_1.EventEmitter {
                 }
                 return val;
             }
+            if (typeKey === 'JSON' || typeKey === 'JSONB') {
+                // Dialects disagree about the wire format of a JSON column: SQLite
+                // stores it as TEXT and hands back the raw string, while the
+                // PostgreSQL and MySQL drivers parse it and hand back an object. That
+                // made the same model code dialect-specific - `row.attrs.a` worked on
+                // Postgres and threw on SQLite. Parse the string form here so every
+                // dialect yields the same JS value.
+                //
+                // Parse defensively, exactly as `castValuesFromDatabase` in
+                // models/model.ts does: a value that is already an object is left
+                // alone, and a string that isn't valid JSON is returned untouched
+                // rather than throwing or collapsing to undefined (a column that
+                // predates the JSON type, or hand-written data, should still read
+                // back as whatever it actually holds).
+                if (typeof val === 'string') {
+                    try {
+                        return JSON.parse(val);
+                    }
+                    catch {
+                        // Not valid JSON. Rows written before the encoding fix above stored
+                        // strings raw, so this is the path that still reads them back
+                        // correctly; hand-written data and pre-JSON-type columns land here
+                        // too. Returning the raw string beats throwing or yielding
+                        // undefined.
+                        return val;
+                    }
+                }
+                return val;
+            }
+            return val;
+        };
+        // Helper: prepare a JS value for the wire format its column expects.
+        //
+        // Only JSON/JSONB needs this today, and it is the write-side mirror of
+        // the JSON branch in `_coerceValue`. The base dialect's
+        // `escapeReplacement()` does stringify a plain object, but it expands an
+        // *array* into the `(a, b, c)` IN-list form, so `{ tags: ['a', 'b'] }` on
+        // a JSON column produced invalid SQL instead of a JSON literal.
+        // Serializing here settles the format before it reaches the dialect and
+        // keeps write and read symmetric. Strings are passed through so a caller
+        // that already did their own `JSON.stringify` isn't double-encoded.
+        const _serializeValue = (key, val) => {
+            const attr = attributes[key];
+            if (attr === undefined || val === null || val === undefined)
+                return val;
+            const typeObj = (attr.type || attr);
+            const typeKey = typeObj?.key || (typeof typeObj === 'string' ? typeObj : undefined);
+            if (typeKey === 'JSON' || typeKey === 'JSONB') {
+                // A Literal/Col is raw SQL the caller wants inlined, not data - the
+                // insert/update builders detect it by class, so stringifying it here
+                // would turn `literal("'{}'::jsonb")` into a quoted string.
+                if (val instanceof expressions_1.Literal || val instanceof expressions_1.Col)
+                    return val;
+                // Encode EVERY value, strings included. Returning a string unencoded
+                // here is what made the round trip lossy: the value went to the column
+                // raw, and the read side then JSON.parse'd it unconditionally, so any
+                // string that happened to be valid JSON came back as something else -
+                // '123' as the number 123, 'true' as a boolean, '{"a":1}' as an object,
+                // and '12345678901234567890' silently rounded to 12345678901234567000.
+                // It also produced invalid JSON on PostgreSQL, which rejects a bare
+                // `hello` for a json column. Encoding strings makes write and read
+                // symmetric, so a value round-trips as the type it was stored as.
+                return JSON.stringify(val);
+            }
             return val;
         };
         // Helper: wrap a plain data object with full instance methods (get/set/update/save/destroy/toJSON)
@@ -1960,15 +1855,26 @@ class Prorm extends events_1.EventEmitter {
                     if (typeof modelHooksRef.beforeUpdate === 'function') {
                         await modelHooksRef.beforeUpdate(rowInstance, {});
                     }
+                    // beforeSave covers both halves of persistence, so a single hook can
+                    // normalize a record whether it is being created or updated.
+                    if (typeof modelHooksRef.beforeSave === 'function') {
+                        await modelHooksRef.beforeSave(rowInstance, {});
+                    }
                     const pk = dataValues.id;
                     if (pk !== undefined) {
-                        await modelRef.update(vals, { where: { id: pk } });
+                        // This path has already fired the update hooks for this record;
+                        // without the marker the static update() fires them a second time,
+                        // with a different argument shape.
+                        await modelRef.update(vals, { where: { id: pk }, _hooksAlreadyRun: true });
                     }
                     Object.assign(dataValues, vals);
                     Object.assign(rowInstance, vals);
                     if (typeof modelHooksRef.afterUpdate === 'function') {
                         await modelHooksRef.afterUpdate(rowInstance, {});
                     }
+                    if (typeof modelHooksRef.afterSave === 'function') {
+                        await modelHooksRef.afterSave(rowInstance, {});
+                    }
                     return rowInstance;
                 },
                 save: async () => {
@@ -2024,7 +1930,24 @@ class Prorm extends events_1.EventEmitter {
                                     saveVals[k] = v;
                             }
                         }
-                        await modelRef.update(saveVals, { where: { id: pk } });
+                        // Fire the persistence hooks once, here, rather than letting the
+                        // delegated static update() fire a different-shaped pair.
+                        if (typeof modelHooksRef.beforeUpdate === 'function') {
+                            await modelHooksRef.beforeUpdate(rowInstance, {});
+                        }
+                        if (typeof modelHooksRef.beforeSave === 'function') {
+                            await modelHooksRef.beforeSave(rowInstance, {});
+                        }
+                        await modelRef.update(saveVals, {
+                            where: { id: pk },
+                            _hooksAlreadyRun: true,
+                        });
+                        if (typeof modelHooksRef.afterUpdate === 'function') {
+                            await modelHooksRef.afterUpdate(rowInstance, {});
+                        }
+                        if (typeof modelHooksRef.afterSave === 'function') {
+                            await modelHooksRef.afterSave(rowInstance, {});
+                        }
                     }
                     else {
                         // New record - do an INSERT via create
@@ -2161,7 +2084,11 @@ class Prorm extends events_1.EventEmitter {
                 // Validation methods
                 validate: async function (options) {
                     const modelOptions = modelRef.options || {};
-                    const hooksManager = modelRef._hooksManager;
+                    // `validate({ hooks: true })` used to read `_hooksManager`, a property
+                    // nothing ever assigned - so the flag was accepted and the hooks never
+                    // ran. Use the model's declared hooks, the same source every other
+                    // lifecycle hook comes from.
+                    const validateHooks = modelOptions?.hooks || {};
                     // Parse options
                     let fieldsToValidate;
                     let runHooks = false;
@@ -2177,8 +2104,8 @@ class Prorm extends events_1.EventEmitter {
                         return { valid: true, errors: [] };
                     }
                     // Run beforeValidate hook if requested
-                    if (runHooks && hooksManager) {
-                        await hooksManager.runHook('beforeValidate', rowInstance, { model: modelRef });
+                    if (runHooks && typeof validateHooks.beforeValidate === 'function') {
+                        await validateHooks.beforeValidate(rowInstance, { model: modelRef });
                     }
                     const validations = {};
                     // Collect validations from attributes
@@ -2216,8 +2143,10 @@ class Prorm extends events_1.EventEmitter {
                     // Use the validator
                     const result = (0, validator_1.validate)(dataToValidate, validations);
                     // Run afterValidate hook if requested
-                    if (runHooks && hooksManager && result.valid) {
-                        await hooksManager.runHook('afterValidate', rowInstance, { model: modelRef });
+                    if (runHooks &&
+                        result.valid &&
+                        typeof validateHooks.afterValidate === 'function') {
+                        await validateHooks.afterValidate(rowInstance, { model: modelRef });
                     }
                     return {
                         valid: result.valid,
@@ -2369,11 +2298,23 @@ class Prorm extends events_1.EventEmitter {
                         return assoc.target.findOne({ where: { id: fkVal }, ...(opts || {}) });
                     };
                     rowInstance[`set${capitalize(assocAlias)}`] = async (instance) => {
-                        const targetId = instance?.id ?? instance;
+                        // Passing null clears the association, matching `unset`.
+                        const targetId = instance === null ? null : (instance?.id ?? instance);
                         dataValues[fk] = targetId;
                         rowInstance[fk] = targetId;
                         await modelRef.update({ [fk]: targetId }, { where: { id: dataValues.id } });
                     };
+                    /**
+                     * Clear the association: null the foreign key and persist.
+                     *
+                     * `setX(null)` does the same thing, but reads as an assignment; this
+                     * says what it does at the call site.
+                     */
+                    rowInstance[`unset${capitalize(assocAlias)}`] = async () => {
+                        dataValues[fk] = null;
+                        rowInstance[fk] = null;
+                        await modelRef.update({ [fk]: null }, { where: { id: dataValues.id } });
+                    };
                     // create/has/count were missing here while the equivalent mixins in
                     // models/associations.ts defined them, so which helpers existed on an
                     // instance depended on how the model had been defined.
@@ -2878,10 +2819,25 @@ class Prorm extends events_1.EventEmitter {
              * Find all records
              */
             async findAll(findOptions = {}) {
+                // `using: 'name'` runs this query against a sibling connection
+                // registered on the same ConnectionManager, rather than this one.
+                // Resolve it before anything else touches `self.dialect` - the whole
+                // point is that the query never runs here.
+                if (findOptions.using) {
+                    return self._findAllUsingConnection(modelName, findOptions);
+                }
                 if (!self.dialect) {
                     throw new Error('Database not connected');
                 }
                 const dialect = self.dialect;
+                // beforeFind runs before scopes are merged so a hook sees - and can
+                // adjust - the options the caller actually passed.
+                const findHooks = this.options?.hooks || {};
+                if (typeof findHooks.beforeFind === 'function') {
+                    const replaced = await findHooks.beforeFind(findOptions);
+                    if (replaced)
+                        findOptions = replaced;
+                }
                 // Apply scopes (defaultScope + named scopes)
                 findOptions = this._mergeScopes(findOptions);
                 // Get model options for paranoid configuration
@@ -2900,6 +2856,19 @@ class Prorm extends events_1.EventEmitter {
                         [deletedAt]: { $isNull: true },
                     };
                 }
+                // Resolve `{ all: true }` / `{ all: 'alias' }` into one concrete include
+                // per association *before* anything reads the include list. This used to
+                // happen inside `loadIncludes()`, at the very end of the query - which
+                // is after the two passes below have already run over the raw list, so
+                // `{ all: true, required: true }` reached `resolveRequiredIncludeFilter`
+                // as an entry with no `model` and was skipped: the associations loaded
+                // but the parents were never narrowed.
+                if (findOptions.include && findOptions.include.length > 0) {
+                    findOptions = {
+                        ...findOptions,
+                        include: self._expandIncludes(model, modelName, findOptions.include),
+                    };
+                }
                 // Apply INNER-JOIN semantics for filtering includes.
                 //
                 // `include: [{ model: Post, required: true }]` and an include carrying
@@ -2929,24 +2898,11 @@ class Prorm extends events_1.EventEmitter {
                     }
                     findOptions = { ...findOptions, include: includeList };
                 }
-                if (findOptions.include && findOptions.include.length > 0) {
-                    for (const rawInclude of findOptions.include) {
-                        const filter = await (0, eager_load_1.resolveRequiredIncludeFilter)(self.eagerLoadContext(), model, modelName, rawInclude);
-                        if (!filter)
-                            continue;
-                        if (filter.values.length === 0) {
-                            // No parent can satisfy a required include with no matches.
-                            return [];
-                        }
-                        const existing = where?.[filter.parentAttr];
-                        where = {
-                            ...where,
-                            [filter.parentAttr]: existing
-                                ? { $and: [existing, { $in: filter.values }] }
-                                : { $in: filter.values },
-                        };
-                    }
-                }
+                const filteredWhere = await self._applyRequiredIncludeFilters(model, modelName, findOptions.include, where);
+                // null means some required include matches nothing, so nothing matches.
+                if (filteredWhere === null)
+                    return [];
+                where = filteredWhere;
                 // Translate attributes.exclude to explicit list (SQLite doesn't support "* EXCEPT(...)")
                 let resolvedAttributes = findOptions.attributes;
                 if (resolvedAttributes &&
@@ -2976,6 +2932,26 @@ class Prorm extends events_1.EventEmitter {
                     subQuery: findOptions.subquery,
                     benchmark: findOptions.benchmark,
                     cte: findOptions.cte,
+                    // Row-level locking. `lock` was declared on FindOptions, documented,
+                    // and compiled by the dialects (PostgreSQL emits FOR UPDATE / FOR
+                    // SHARE / FOR KEY SHARE, MySQL LOCK IN SHARE MODE), but never made
+                    // it out of here - so `findAll({ lock: 'UPDATE', transaction: t })`
+                    // silently took no lock at all and code written to serialize
+                    // concurrent updates didn't.
+                    //
+                    // Dialects with no row-level locking (SQLite above all) drop the
+                    // clause rather than throwing. That is deliberate: SQLite already
+                    // serializes writers at the database level, so the transaction the
+                    // lock was protecting is serialized there anyway, and rejecting the
+                    // option would make otherwise-portable model code dialect-specific.
+                    lock: findOptions.lock,
+                    // UNION / UNION ALL / EXCEPT / INTERSECT branches appended after the
+                    // main query. Each dialect pushes the branches' bound values onto
+                    // the same `values` array in the order they are emitted, so the
+                    // single replaceReplacements() call below binds them correctly
+                    // alongside the main query's.
+                    unionType: findOptions.unionType,
+                    union: findOptions.union,
                 });
                 // Handle benchmark option
                 const startTime = Date.now();
@@ -2984,44 +2960,15 @@ class Prorm extends events_1.EventEmitter {
                 // Calculate query duration
                 const duration = Date.now() - startTime;
                 // Determine logging function
-                const shouldLog = findOptions.logging !== false && self.loggingOptions !== false;
-                const logFn = typeof findOptions.logging === 'function'
-                    ? findOptions.logging
-                    : typeof self.loggingOptions === 'function'
-                        ? self.loggingOptions
-                        : null;
-                // Log benchmark/timing if enabled
-                const benchmarkEnabled = findOptions.benchmark === true;
-                if (shouldLog || benchmarkEnabled) {
-                    if (logFn) {
-                        logFn(query.sql, duration);
-                    }
-                    else if (findOptions.logging === true ||
-                        self.loggingOptions === true ||
-                        benchmarkEnabled) {
-                        console.log(`Executed (${duration}ms): ${query.sql}`);
-                    }
-                    // Log to internal logger for slow query detection
-                    self.logger.logQuery(query.sql, duration);
-                }
-                // Emit query event for external listeners
-                self.emit('query', {
+                // Query logging, slow-query detection and the query/slowQuery events all
+                // go through one path so every operation behaves the same way.
+                self._logQuery({
                     sql: query.sql,
                     duration,
-                    timestamp: new Date(),
+                    parameters: query.values,
                     model: modelName,
-                });
-                // Emit slow query event if query exceeds threshold
-                const slowQueryThreshold = self.config.slowQueryThreshold || 1000;
-                if (duration > slowQueryThreshold) {
-                    self.emit('slowQuery', {
-                        sql: query.sql,
-                        duration,
-                        threshold: slowQueryThreshold,
-                        timestamp: new Date(),
-                        model: modelName,
-                    });
-                }
+                    type: 'SELECT',
+                }, findOptions.logging);
                 // Wrap each row with instance methods.
                 //
                 // `raw: true` asks for plain rows and was accepted but ignored - every
@@ -3034,6 +2981,12 @@ class Prorm extends events_1.EventEmitter {
                 const wrappedRows = (findOptions.raw === true
                     ? result.rows.map((row) => ({ ...row }))
                     : result.rows.map((row) => _wrapInstance(row, modelRef, modelHooksRef)));
+                // Related-row counts, without loading the rows. One grouped query per
+                // association rather than one per parent.
+                const withCount = findOptions.withCount;
+                if (withCount?.length) {
+                    await (0, eager_load_1.loadCounts)(self.eagerLoadContext(), wrappedRows, model, modelName, withCount);
+                }
                 // Eager-load associations. The implementation is shared with the
                 // class-based Model API (see models/eager-load.ts) - it used to be
                 // duplicated here and in models/model.ts, and the two copies had
@@ -3041,6 +2994,11 @@ class Prorm extends events_1.EventEmitter {
                 if (findOptions.include && findOptions.include.length > 0) {
                     await (0, eager_load_1.loadIncludes)(self.eagerLoadContext(), wrappedRows, model, modelName, findOptions.include);
                 }
+                if (typeof findHooks.afterFind === 'function') {
+                    const replaced = await findHooks.afterFind(wrappedRows, findOptions);
+                    if (replaced)
+                        return replaced;
+                }
                 return wrappedRows;
             },
             /**
@@ -3051,7 +3009,8 @@ class Prorm extends events_1.EventEmitter {
                 // Count with an aggregate rather than by re-running the full query
                 // without a limit and measuring the array. `limit`/`offset` are dropped
                 // (the count describes the whole matching set), everything else that
-                // narrows the set - including filtering includes - is preserved.
+                // narrows the set - filtering includes and `union` branches included -
+                // is preserved, so `count` and `rows` always describe the same set.
                 const { limit: _limit, offset: _offset, ...countable } = this._mergeScopes(findOptions);
                 const count = await self._countRows(model, modelName, countable);
                 return { rows, count };
@@ -3313,6 +3272,11 @@ class Prorm extends events_1.EventEmitter {
                 if (typeof modelHooks.beforeCreate === 'function') {
                     await modelHooks.beforeCreate(hookInstance, createOptions);
                 }
+                // beforeSave fires for both create and update, so a single hook can
+                // normalize a record however it is being persisted.
+                if (typeof modelHooks.beforeSave === 'function') {
+                    await modelHooks.beforeSave(hookInstance, createOptions);
+                }
                 // Build dbValues from hookInstance (after hooks may have modified it), filtering virtual fields and respecting 'fields' option
                 const allowedFields = createOptions.fields;
                 const dbValues = {};
@@ -3325,7 +3289,7 @@ class Prorm extends events_1.EventEmitter {
                         if (typeObj.key === 'VIRTUAL' || typeObj.key === 'VIRTUALSTRING')
                             continue;
                     }
-                    dbValues[key] = value;
+                    dbValues[key] = _serializeValue(key, value);
                 }
                 const { sql, values: insertValues } = dialect.buildInsertQuery(this.tableName, dbValues, {
                     returning: createOptions.returning,
@@ -3420,6 +3384,9 @@ class Prorm extends events_1.EventEmitter {
                 if (typeof modelHooks.afterCreate === 'function') {
                     await modelHooks.afterCreate(createdInstance, createOptions);
                 }
+                if (typeof modelHooks.afterSave === 'function') {
+                    await modelHooks.afterSave(createdInstance, createOptions);
+                }
                 return createdInstance;
             },
             /**
@@ -3432,11 +3399,27 @@ class Prorm extends events_1.EventEmitter {
                     throw new Error('Database not connected');
                 }
                 const bulkModelHooks = this.options?.hooks || {};
+                // `instance.update()` fires the update hooks itself before delegating
+                // here; the marker stops them running twice per call.
+                const hooksAlreadyRun = updateOptions?._hooksAlreadyRun === true;
+                // beforeUpdate fires for the statement as a whole, alongside the bulk
+                // hook; it previously only ran for `instance.update()`, so a model-level
+                // update bypassed it entirely.
+                if (!hooksAlreadyRun && typeof bulkModelHooks.beforeUpdate === 'function') {
+                    await bulkModelHooks.beforeUpdate(values, updateOptions);
+                }
                 if (typeof bulkModelHooks.beforeBulkUpdate === 'function') {
                     await bulkModelHooks.beforeBulkUpdate({ ...updateOptions, attributes: values });
                 }
                 const dialect = self.dialect;
-                const { sql: updateSql, values: updateVals } = dialect.buildUpdateQuery(this.tableName, values, updateOptions.where, { limit: updateOptions.limit, returning: updateOptions.returning });
+                // Serialize JSON/JSONB columns on the way to the dialect (see
+                // `_serializeValue`). `values` itself is left untouched so the
+                // after-hooks below still see what the caller passed.
+                const dbValues = {};
+                for (const [key, value] of Object.entries(values)) {
+                    dbValues[key] = _serializeValue(key, value);
+                }
+                const { sql: updateSql, values: updateVals } = dialect.buildUpdateQuery(this.tableName, dbValues, updateOptions.where, { limit: updateOptions.limit, returning: updateOptions.returning });
                 const sql = dialect.replaceReplacements(updateSql, updateVals);
                 // Handle logging
                 const startTime = Date.now();
@@ -3466,6 +3449,9 @@ class Prorm extends events_1.EventEmitter {
                     model: modelName,
                     type: 'UPDATE',
                 });
+                if (!hooksAlreadyRun && typeof bulkModelHooks.afterUpdate === 'function') {
+                    await bulkModelHooks.afterUpdate(values, updateOptions);
+                }
                 if (typeof bulkModelHooks.afterBulkUpdate === 'function') {
                     await bulkModelHooks.afterBulkUpdate({ ...updateOptions, attributes: values });
                 }
@@ -3482,6 +3468,11 @@ class Prorm extends events_1.EventEmitter {
                 if (!destroyOptions.where) {
                     throw new Error('Missing where option in destroy');
                 }
+                // As with update, this previously only fired for `instance.destroy()`.
+                const destroyHooks = this.options?.hooks || {};
+                if (typeof destroyHooks.beforeDestroy === 'function') {
+                    await destroyHooks.beforeDestroy(destroyOptions);
+                }
                 const dialect = self.dialect;
                 const modelOptions = this.options;
                 const bulkDestroyHooks = modelOptions?.hooks || {};
@@ -3555,6 +3546,9 @@ class Prorm extends events_1.EventEmitter {
                     model: modelName,
                     type: isParanoid && !forceDelete ? 'UPDATE' : 'DELETE',
                 });
+                if (typeof destroyHooks.afterDestroy === 'function') {
+                    await destroyHooks.afterDestroy(destroyOptions);
+                }
                 if (typeof bulkDestroyHooks.afterBulkDestroy === 'function') {
                     await bulkDestroyHooks.afterBulkDestroy(destroyOptions);
                 }
@@ -3615,6 +3609,11 @@ class Prorm extends events_1.EventEmitter {
                     const dialect = self.dialect;
                     for (const record of records) {
                         const dbValues = {};
+                        // The values as the caller supplied them, used to build the
+                        // returned record: `dbValues` holds the wire format (a JSON column
+                        // is serialized on the way to the dialect), which is not what a
+                        // caller should get back from bulkCreate.
+                        const jsValues = {};
                         for (const [key, value] of Object.entries(record)) {
                             const attr = attributes[key];
                             if (attr && attr.type) {
@@ -3622,14 +3621,23 @@ class Prorm extends events_1.EventEmitter {
                                 if (typeObj.key === 'VIRTUAL' || typeObj.key === 'VIRTUALSTRING')
                                     continue;
                             }
-                            dbValues[key] = value;
+                            dbValues[key] = _serializeValue(key, value);
+                            jsValues[key] = value;
                         }
                         const { sql, values: insertValues } = dialect.buildInsertQuery(this.tableName, dbValues, {});
                         const finalSql = dialect.replaceReplacements(sql, insertValues);
+                        const bcStarted = Date.now();
                         const insertResult = await dialect.query(finalSql);
+                        self._logQuery({
+                            sql: finalSql,
+                            duration: Date.now() - bcStarted,
+                            parameters: insertValues,
+                            model: modelName,
+                            type: 'INSERT',
+                        }, bulkCreateOptions?.logging);
                         const lastId = insertResult.lastInsertRowid;
                         results.push({
-                            ...dbValues,
+                            ...jsValues,
                             ...(lastId !== undefined && !record.id ? { id: lastId } : {}),
                             isNewRecord: false,
                         });
@@ -3653,6 +3661,12 @@ class Prorm extends events_1.EventEmitter {
              * and `distinct`, `col` and `group` were silently discarded.
              */
             async count(countOptions = {}) {
+                const countHooks = this.options?.hooks || {};
+                if (typeof countHooks.beforeCount === 'function') {
+                    const replaced = await countHooks.beforeCount(countOptions);
+                    if (replaced)
+                        countOptions = replaced;
+                }
                 // Apply defaultScope / named scopes exactly as findAll does, so
                 // `User.scope('admin').count()` counts the scoped set.
                 return self._countRows(model, modelName, this._mergeScopes(countOptions));
@@ -3926,7 +3940,148 @@ class Prorm extends events_1.EventEmitter {
             async avg(attribute, aggOptions = {}) {
                 return self._aggregate(model, modelName, 'AVG', attribute, this._mergeScopes(aggOptions));
             },
+            /**
+             * Like `findOne`, but throws `EmptyResultError` when nothing matches.
+             *
+             * Saves the `if (!row) throw ...` that otherwise follows every lookup
+             * whose absence is a genuine error rather than a case to handle.
+             */
+            async findOneOrFail(findOptions = {}) {
+                const row = await this.findOne(findOptions);
+                if (!row) {
+                    throw new errors_1.EmptyResultError(`No ${modelName} matched the given conditions`, {
+                        model: modelName,
+                    });
+                }
+                return row;
+            },
+            /** Like `findByPk`, but throws `EmptyResultError` when the row is absent. */
+            async findByPkOrFail(pk, findOptions = {}) {
+                const row = await this.findByPk(pk, findOptions);
+                if (!row) {
+                    throw new errors_1.EmptyResultError(`${modelName} ${String(pk)} not found`, {
+                        model: modelName,
+                        primaryKey: pk,
+                    });
+                }
+                return row;
+            },
+            /** The last row in `order`, or null. Inverts the ordering and takes one. */
+            async findLast(findOptions = {}) {
+                const pkAttr = resolveModelPrimaryKeyAttr(model);
+                const order = findOptions.order ?? [[pkAttr, 'ASC']];
+                const inverted = order.map((entry) => {
+                    if (!Array.isArray(entry))
+                        return [entry, 'DESC'];
+                    const [col, dir] = entry;
+                    return [col, String(dir ?? 'ASC').toUpperCase() === 'DESC' ? 'ASC' : 'DESC'];
+                });
+                const rows = await this.findAll({ ...findOptions, order: inverted, limit: 1 });
+                return rows[0] ?? null;
+            },
+            /**
+             * Whether any row matches, without fetching one.
+             *
+             * `SELECT COUNT(*) ... LIMIT 1` rather than loading a row and testing it
+             * for null.
+             */
+            async exists(where = {}) {
+                return (await self._countRows(model, modelName, this._mergeScopes({ where }))) > 0;
+            },
+            /**
+             * Walk the whole matching set in batches, without holding it in memory.
+             *
+             * Pages by primary key rather than OFFSET, so the cost per batch stays
+             * flat instead of degrading as the offset grows, and rows written during
+             * the walk cannot cause a page to be skipped.
+             *
+             * ```typescript
+             * await User.findInBatches({ where: { active: true } }, async (batch) => {
+             *   await sendDigest(batch);
+             * }, { batchSize: 500 });
+             * ```
+             */
+            async findInBatches(findOptions, handler, options = {}) {
+                const size = options.batchSize ?? 100;
+                const pkAttr = resolveModelPrimaryKeyAttr(model);
+                let cursor = undefined;
+                let seen = 0;
+                for (;;) {
+                    const where = cursor === undefined
+                        ? findOptions.where
+                        : {
+                            ...findOptions.where,
+                            [pkAttr]: { $gt: cursor },
+                        };
+                    const batch = await this.findAll({
+                        ...findOptions,
+                        where,
+                        order: [[pkAttr, 'ASC']],
+                        limit: size,
+                    });
+                    if (batch.length === 0)
+                        break;
+                    await handler(batch);
+                    seen += batch.length;
+                    cursor = batch[batch.length - 1][pkAttr];
+                    if (batch.length < size)
+                        break;
+                }
+                return seen;
+            },
+            /** Call `handler` once per matching row, in batches. See `findInBatches`. */
+            async findEach(findOptions, handler, options = {}) {
+                return this.findInBatches(findOptions, async (batch) => {
+                    for (const row of batch)
+                        await handler(row);
+                }, options);
+            },
+            /**
+             * Add to one or more numeric columns in the database.
+             *
+             * `SET n = n + 1` in a single statement, so concurrent callers each apply
+             * their delta. Reading a value, adding to it in JS and writing it back
+             * loses one of two simultaneous increments.
+             *
+             * ```typescript
+             * await Post.increment('views', { where: { id: 1 } });
+             * await Post.increment(['views', 'score'], { by: 2, where: { id: 1 } });
+             * await Post.increment({ views: 1, score: -1 }, { where: { id: 1 } });
+             * ```
+             *
+             * @returns the number of rows affected
+             */
+            async increment(fields, options = {}) {
+                return self._applyDelta(model, modelName, fields, options, 1);
+            },
+            /** Subtract from one or more numeric columns. See `increment`. */
+            async decrement(fields, options = {}) {
+                return self._applyDelta(model, modelName, fields, options, -1);
+            },
+            /**
+             * Update many rows to *different* values in one statement.
+             *
+             * Looping `update()` costs one round trip per row. This compiles a single
+             * UPDATE with a CASE per column, which every supported dialect accepts:
+             *
+             * ```sql
+             * UPDATE users SET name = CASE id WHEN 1 THEN 'a' WHEN 2 THEN 'b' END
+             * WHERE id IN (1, 2)
+             * ```
+             *
+             * Each row must carry the primary key. Columns absent from a given row
+             * keep their current value.
+             *
+             * @returns the number of rows affected
+             */
+            async bulkUpdate(rows, options = {}) {
+                return self._bulkUpdate(model, modelName, rows, options);
+            },
             async upsert(values, upsertOptions) {
+                const upsertHooks = this.options?.hooks || {};
+                if (typeof upsertHooks.beforeUpsert === 'function') {
+                    await upsertHooks.beforeUpsert(values, upsertOptions);
+                }
                 if (!self.dialect) {
                     throw new Error('Database not connected');
                 }
@@ -3949,7 +4104,9 @@ class Prorm extends events_1.EventEmitter {
                         if (typeObj.key === 'VIRTUAL' || typeObj.key === 'VIRTUALSTRING')
                             continue;
                     }
-                    dbValues[key] = value;
+                    // Serialized on the way to the dialect (JSON/JSONB) - see
+                    // `_serializeValue`.
+                    dbValues[key] = _serializeValue(key, value);
                 }
                 const columns = Object.keys(dbValues);
                 // Default the conflict target: prefer an explicit primary key value, but
@@ -4035,6 +4192,9 @@ class Prorm extends events_1.EventEmitter {
                 if (!instance) {
                     instance = _wrapInstance({ ...dbValues }, model, options.hooks || {});
                 }
+                if (typeof upsertHooks.afterUpsert === 'function') {
+                    await upsertHooks.afterUpsert([instance, created], upsertOptions);
+                }
                 return [instance, created];
             },
             // ============ Model-level Hooks ============
@@ -4050,7 +4210,7 @@ class Prorm extends events_1.EventEmitter {
             beforeSync(callback) {
                 let modelHook = self.modelHooks.get(modelName);
                 if (!modelHook) {
-                    modelHook = new ModelHooks();
+                    modelHook = new hooks_manager_1.ModelHooks();
                     self.modelHooks.set(modelName, modelHook);
                 }
                 modelHook.beforeSync(callback);
@@ -4067,7 +4227,7 @@ class Prorm extends events_1.EventEmitter {
             afterSync(callback) {
                 let modelHook = self.modelHooks.get(modelName);
                 if (!modelHook) {
-                    modelHook = new ModelHooks();
+                    modelHook = new hooks_manager_1.ModelHooks();
                     self.modelHooks.set(modelName, modelHook);
                 }
                 modelHook.afterSync(callback);
@@ -4182,9 +4342,16 @@ class Prorm extends events_1.EventEmitter {
      */
     addModel(modelClass) {
         const modelName = modelClass.name;
-        // Get model metadata from decorators
-        const modelMeta = (0, decorators_1.getModelMetadata)(modelName);
-        const attrMeta = (0, decorators_1.getAttributeMetadata)(modelName);
+        if ((0, decorators_1.isAbstractModel)(modelClass)) {
+            throw new Error(`${modelName} is declared @AbstractModel and has no table of its own. ` +
+                `Register the concrete models that extend it instead.`);
+        }
+        // Get model metadata from decorators. Attributes are collected up the
+        // prototype chain so columns declared on an @AbstractModel base are
+        // inherited; metadata is keyed by constructor name, so without this a
+        // subclass would only see the columns declared directly on it.
+        const modelMeta = (0, decorators_1.getModelMetadata)(modelName) ?? inheritedModelMetadata(modelClass);
+        const attrMeta = (0, decorators_1.getInheritedAttributeMetadata)(modelClass);
         // A plain class with no @Table/@Attribute decorators is still valid — register it
         // with no attributes rather than failing, matching a bare `class Foo extends Model {}`.
         // Convert attribute metadata to Prorm format
@@ -4523,9 +4690,29 @@ class Prorm extends events_1.EventEmitter {
                 : undefined,
             check: c.check,
         }));
+        // Composite unique keys, from all three declaration forms. They are turned
+        // into ordinary table-level UNIQUE constraints - and unique indexes, for
+        // the entries that asked for one - rather than being forwarded as the
+        // dialects' `uniqueKeys` option, because that option is honored
+        // inconsistently: ClickHouse warns and drops it, and roughly half the
+        // dialects have no handling for it at all, while every dialect renders
+        // `constraints`. (The SQLite dialect built its list and then never used it,
+        // which is fixed there too, for callers who reach `createTable` directly.)
+        // Forwarding both would emit the constraint twice on Postgres/MySQL/MariaDB,
+        // which do implement it.
+        const uniqueKeys = collectUniqueKeys(tableName, attributes, options, columns);
         const allTableConstraints = [
             ...(tableConstraints || []),
             ...synthesizedFkConstraints,
+            ...uniqueKeys
+                .filter((uk) => !uk.asIndex)
+                .map((uk) => ({ name: uk.name, type: 'UNIQUE', fields: uk.fields })),
+        ];
+        const allTableIndexes = [
+            ...(tableIndexes || []),
+            ...uniqueKeys
+                .filter((uk) => uk.asIndex)
+                .map((uk) => ({ name: uk.name, unique: true, fields: uk.fields })),
         ];
         await this.dialect.createTable(tableName, columns, {
             ifNotExists: true,
@@ -4535,8 +4722,7 @@ class Prorm extends events_1.EventEmitter {
             comment: options.comment,
             rowFormat: options.rowFormat,
             initialAutoIncrement: options.initialAutoIncrement,
-            uniqueKeys: options.uniqueKeys,
-            indexes: tableIndexes,
+            indexes: allTableIndexes.length ? allTableIndexes : undefined,
             constraints: allTableConstraints,
         });
     }
@@ -4621,30 +4807,30 @@ class Prorm extends events_1.EventEmitter {
         }
         const trimmedSql = sql.trim().toUpperCase();
         if (trimmedSql.startsWith('SELECT')) {
-            return QueryTypes.SELECT;
+            return query_types_1.QueryTypes.SELECT;
         }
         if (trimmedSql.startsWith('INSERT')) {
             // Check for UPSERT patterns: ON CONFLICT, ON DUPLICATE KEY, INSERT OR REPLACE
             if (trimmedSql.includes('ON CONFLICT') ||
                 trimmedSql.includes('ON DUPLICATE KEY') ||
                 trimmedSql.includes('INSERT OR REPLACE')) {
-                return QueryTypes.UPSERT;
+                return query_types_1.QueryTypes.UPSERT;
             }
-            return QueryTypes.INSERT;
+            return query_types_1.QueryTypes.INSERT;
         }
         if (trimmedSql.startsWith('UPDATE')) {
-            return QueryTypes.UPDATE;
+            return query_types_1.QueryTypes.UPDATE;
         }
         if (trimmedSql.startsWith('DELETE')) {
-            return QueryTypes.DELETE;
+            return query_types_1.QueryTypes.DELETE;
         }
         if (trimmedSql.startsWith('UPSERT')) {
-            return QueryTypes.UPSERT;
+            return query_types_1.QueryTypes.UPSERT;
         }
         if (trimmedSql.startsWith('PRAGMA') || trimmedSql.startsWith('EXPLAIN')) {
-            return QueryTypes.RAW;
+            return query_types_1.QueryTypes.RAW;
         }
-        return QueryTypes.RAW;
+        return query_types_1.QueryTypes.RAW;
     }
     /**
      * Execute a raw query
@@ -4755,10 +4941,10 @@ class Prorm extends events_1.EventEmitter {
         }
         // Process results based on query type
         switch (queryType) {
-            case QueryTypes.SELECT:
-            case QueryTypes.SHOWTABLES:
-            case QueryTypes.DESCRIBE:
-            case QueryTypes.VERSION: {
+            case query_types_1.QueryTypes.SELECT:
+            case query_types_1.QueryTypes.SHOWTABLES:
+            case query_types_1.QueryTypes.DESCRIBE:
+            case query_types_1.QueryTypes.VERSION: {
                 // Map raw results to model instances if requested
                 if (options?.mapToModel && options?.model) {
                     const ModelStatic = options.model;
@@ -4768,22 +4954,22 @@ class Prorm extends events_1.EventEmitter {
                 // Return array of results
                 return result.rows;
             }
-            case QueryTypes.INSERT:
+            case query_types_1.QueryTypes.INSERT:
                 // For INSERT, return [results, created]
                 // Check if a row was inserted by examining the last insert rowid
                 const insertId = result.rowid || result.insertId || 0;
                 const created = insertId > 0;
                 return [result.rows, created];
-            case QueryTypes.UPDATE:
-            case QueryTypes.DELETE:
-            case QueryTypes.BULKDELETE:
-            case QueryTypes.UPSERT:
+            case query_types_1.QueryTypes.UPDATE:
+            case query_types_1.QueryTypes.DELETE:
+            case query_types_1.QueryTypes.BULKDELETE:
+            case query_types_1.QueryTypes.UPSERT:
                 // Return affected count
                 return result.rowCount;
-            case QueryTypes.BULKINSERT:
+            case query_types_1.QueryTypes.BULKINSERT:
                 // Return number of inserted rows
                 return result.rowCount;
-            case QueryTypes.RAW:
+            case query_types_1.QueryTypes.RAW:
             default:
                 // For RAW queries, return rows
                 return result.rows;
@@ -4843,10 +5029,10 @@ class Prorm extends events_1.EventEmitter {
         // Determine query type
         const queryType = this.determineQueryType(processedSql, options?.type);
         const isSelect = [
-            QueryTypes.SELECT,
-            QueryTypes.SHOWTABLES,
-            QueryTypes.DESCRIBE,
-            QueryTypes.VERSION,
+            query_types_1.QueryTypes.SELECT,
+            query_types_1.QueryTypes.SHOWTABLES,
+            query_types_1.QueryTypes.DESCRIBE,
+            query_types_1.QueryTypes.VERSION,
         ].includes(queryType);
         // Execute the query
         const result = await this.dialect.query(processedSql, { raw: options?.raw });
@@ -6321,6 +6507,103 @@ $$ LANGUAGE plpgsql;`;
         }
         return Array.from(names);
     }
+    /**
+     * Run a `findAll` against the connection named by `FindOptions.using`.
+     *
+     * `using` lets one query hop to a sibling database registered on the same
+     * `ConnectionManager` (`User.findAll({ using: 'analytics' })`). The target
+     * connection has its own models, so this re-dispatches to *that*
+     * connection's copy of the model by name and drops `using` from the options
+     * so the delegate runs the query normally instead of bouncing forever.
+     *
+     * Both failure modes report what is actually available, since a typo in a
+     * connection name and a model that was never defined on the target
+     * connection are otherwise indistinguishable from "the query returned
+     * nothing".
+     */
+    async _findAllUsingConnection(modelName, findOptions) {
+        const name = findOptions.using;
+        const registry = this.connectionManager;
+        const connection = registry?.getConnection(name);
+        if (!connection) {
+            const available = registry?.getConnectionNames().join(', ') || 'none';
+            throw new Error(`Connection '${name}' not found. Available: ${available}`);
+        }
+        const target = connection.models[modelName];
+        if (!target) {
+            const defined = Object.keys(connection.models).join(', ') || 'none';
+            throw new Error(`Model '${modelName}' is not defined on connection '${name}'. Defined there: ${defined}`);
+        }
+        const { using: _using, ...queryOptions } = findOptions;
+        return target.findAll(queryOptions);
+    }
+    /**
+     * Resolve an `include` list into concrete, per-association entries.
+     *
+     * Every pass that reads an include - the cross-table `$assoc.col$` rewrite,
+     * the parent-filtering (`required`) pass, and the eager loader itself - is
+     * written against an entry that carries a `model`. `{ all: true }` carries
+     * none, so each of those passes has to see the *expanded* list or it silently
+     * does nothing for `all`: that is how `include: [{ all: true, required: true }]`
+     * came to load the associations without narrowing the parents, while the
+     * equivalent explicit include filtered correctly.
+     *
+     * Expansion is idempotent - a list with no `all` entry comes back as the same
+     * entries - so running it here as well as inside `loadIncludes()` is safe.
+     */
+    _expandIncludes(model, modelName, include) {
+        if (!Array.isArray(include) || include.length === 0)
+            return [];
+        return (0, eager_load_1.expandAllIncludes)(this.eagerLoadContext(), model, modelName, include);
+    }
+    /**
+     * Narrow a WHERE clause by the query's filtering (`required`) includes.
+     *
+     * Shared by `findAll`, `_countRows` and `_aggregate` so that a filtering
+     * include restricts the rows, the count and an aggregate to the same set.
+     * Returns `null` when some include can match no parent at all - the whole
+     * query is then empty, and each caller spells "empty" its own way (no rows,
+     * a count of 0, a null aggregate).
+     *
+     * Several includes can constrain the *same* parent column, and since
+     * `{ all: true, required: true }` expands to one include per association that
+     * is now the common case rather than a corner. Their key sets are intersected
+     * here. They must not be emitted as two conditions on one key: a
+     * `{ id: { $and: [{ $in: [...] }, { $in: [...] }] } }` shape is not something
+     * the where-builders recognize, and it collapsed to a single `"id" = ?` -
+     * which is why two `required` includes used to return the wrong rows.
+     */
+    async _applyRequiredIncludeFilters(model, modelName, include, where) {
+        const byParentAttr = new Map();
+        for (const rawInclude of this._expandIncludes(model, modelName, include)) {
+            const filter = await (0, eager_load_1.resolveRequiredIncludeFilter)(this.eagerLoadContext(), model, modelName, rawInclude);
+            if (!filter)
+                continue;
+            // No parent can satisfy a required include with no matches.
+            if (filter.values.length === 0)
+                return null;
+            const previous = byParentAttr.get(filter.parentAttr);
+            if (!previous) {
+                byParentAttr.set(filter.parentAttr, filter.values);
+                continue;
+            }
+            const keep = new Set(filter.values);
+            const intersection = previous.filter((v) => keep.has(v));
+            if (intersection.length === 0)
+                return null;
+            byParentAttr.set(filter.parentAttr, intersection);
+        }
+        let narrowed = where;
+        for (const [parentAttr, values] of byParentAttr) {
+            // A condition the caller wrote on the same column still applies on top.
+            const existing = narrowed?.[parentAttr];
+            narrowed = {
+                ...narrowed,
+                [parentAttr]: existing ? { $and: [existing, { $in: values }] } : { $in: values },
+            };
+        }
+        return narrowed;
+    }
     /**
      * Issue a real `SELECT COUNT(...)` for a model.
      *
@@ -6329,6 +6612,9 @@ $$ LANGUAGE plpgsql;`;
      *  - `col` picks the counted expression (`COUNT("col")`)
      *  - `distinct: true` counts distinct values of `col`, or of the primary key
      *  - `group` returns the number of groups
+     *
+     * A query carrying `union` branches is counted over the combined query rather
+     * than this model's table alone - see the derived-table note below.
      */
     async _countRows(model, modelName, options = {}) {
         if (!this.dialect) {
@@ -6344,22 +6630,10 @@ $$ LANGUAGE plpgsql;`;
             where = { ...where, [deletedAt]: { $isNull: true } };
         }
         // Filtering includes restrict the counted set exactly as they restrict findAll.
-        if (options.include && options.include.length > 0) {
-            for (const rawInclude of options.include) {
-                const filter = await (0, eager_load_1.resolveRequiredIncludeFilter)(this.eagerLoadContext(), model, modelName, rawInclude);
-                if (!filter)
-                    continue;
-                if (filter.values.length === 0)
-                    return 0;
-                const existing = where?.[filter.parentAttr];
-                where = {
-                    ...where,
-                    [filter.parentAttr]: existing
-                        ? { $and: [existing, { $in: filter.values }] }
-                        : { $in: filter.values },
-                };
-            }
-        }
+        const countableWhere = await this._applyRequiredIncludeFilters(model, modelName, options.include, where);
+        if (countableWhere === null)
+            return 0;
+        where = countableWhere;
         const pkAttr = resolveModelPrimaryKeyAttr(model);
         const countCol = opts.col;
         const distinct = opts.distinct === true;
@@ -6380,18 +6654,89 @@ $$ LANGUAGE plpgsql;`;
         const groupFields = opts.group
             ? (Array.isArray(opts.group) ? opts.group : [opts.group]).map((g) => typeof g === 'string' ? g : String(g))
             : undefined;
-        let sql = `SELECT ${countExpr} AS ${dialect.escapeId('count')} FROM ${qualified}`;
+        // `union` branches widen the set the query returns, so counting this
+        // model's table alone leaves `findAndCountAll` contradicting itself: `rows`
+        // spans every branch while `count` describes only the first. When the query
+        // carries branches, count over the combined query instead:
+        //
+        //   SELECT COUNT(*) AS "count" FROM (
+        //     SELECT * FROM "active" WHERE ... UNION ALL SELECT * FROM "archived" WHERE ...
+        //   ) AS "prorm_count"
+        //
+        // The set operator does its work *inside* the derived table, so `UNION` and
+        // `UNION ALL` count differently with no special-casing here: the distinct
+        // form collapses duplicate rows before they reach COUNT, the ALL form does
+        // not, and EXCEPT/INTERSECT likewise count exactly what they produce.
+        //
+        // Left out on purpose: `order` and the outer `limit`/`offset`. Neither can
+        // change a count, and several dialects reject ORDER BY inside a derived
+        // table. Every other narrowing option is kept, each branch's own `where`
+        // and `limit` included. The projection is resolved the way findAll resolves
+        // it, because a distinct UNION dedupes on the selected columns.
+        //
+        // Not every dialect compiles `union` - the ones that don't drop it from
+        // findAll too, so their rows come from this table alone and the plain count
+        // is already correct for them. Rather than keep a list of which do, compile
+        // the query both with and without the branches and compare: identical SQL
+        // means the dialect ignored them.
+        const unionBranches = opts.union ?? [];
+        let unionSource = null;
+        if (unionBranches.length > 0) {
+            let projection = opts.attributes;
+            if (projection && !Array.isArray(projection) && projection.exclude) {
+                const excluded = new Set(projection.exclude);
+                projection = Array.from(modelColumnNames(model)).filter((k) => !excluded.has(k));
+            }
+            const shared = {
+                tableName,
+                schema: model.schema,
+                attributes: projection,
+                where,
+                distinct: opts.distinct,
+                distinctOn: opts.distinctOn,
+                // Associations are resolved with their own queries, never joined in.
+                include: undefined,
+            };
+            const withoutBranches = dialect.buildSelectQuery({ ...shared });
+            const withBranches = dialect.buildSelectQuery({
+                ...shared,
+                unionType: opts.unionType,
+                union: unionBranches,
+            });
+            if (withBranches.sql !== withoutBranches.sql) {
+                unionSource = { sql: withBranches.sql, values: withBranches.values };
+            }
+        }
+        let sql;
         let values = [];
-        if (where && Object.keys(where).length > 0) {
-            const built = dialect.buildWhereClause(where);
-            sql += ` WHERE ${built.sql}`;
-            values = built.values;
+        if (unionSource) {
+            // `where` is already compiled into the derived table; no outer WHERE.
+            sql =
+                `SELECT ${countExpr} AS ${dialect.escapeId('count')} ` +
+                    `FROM (${unionSource.sql}) AS ${dialect.escapeId('prorm_count')}`;
+            values = unionSource.values;
+        }
+        else {
+            sql = `SELECT ${countExpr} AS ${dialect.escapeId('count')} FROM ${qualified}`;
+            if (where && Object.keys(where).length > 0) {
+                const built = dialect.buildWhereClause(where);
+                sql += ` WHERE ${built.sql}`;
+                values = built.values;
+            }
         }
         if (groupFields?.length) {
             sql += ` GROUP BY ${groupFields.map((g) => dialect.escapeId(g)).join(', ')}`;
         }
         const finalSql = dialect.replaceReplacements(sql, values);
+        const started = Date.now();
         const result = await dialect.query(finalSql);
+        this._logQuery({
+            sql: finalSql,
+            duration: Date.now() - started,
+            parameters: values,
+            model: modelName,
+            type: 'SELECT',
+        }, options.logging);
         const rows = result.rows || [];
         // With GROUP BY the aggregate returns one row per group; the count is the
         // number of groups, matching how callers use `count({ group })`.
@@ -6417,10 +6762,10 @@ $$ LANGUAGE plpgsql;`;
             throw new Error('Database not connected');
         }
         const dialect = this.dialect;
-        if (!model.rawAttributes?.[attribute]) {
-            const known = Object.keys(model.rawAttributes || {}).join(', ');
+        const columns = modelColumnNames(model);
+        if (!columns.has(attribute)) {
             throw new Error(`${modelName} has no attribute '${attribute}' to ${aggregate.toLowerCase()}.` +
-                (known ? ` Known attributes: ${known}.` : ''));
+                ` Known attributes: ${Array.from(columns).join(', ')}.`);
         }
         const modelOptions = model.options;
         const deletedAt = modelOptions?.deletedAt || 'deletedAt';
@@ -6431,22 +6776,10 @@ $$ LANGUAGE plpgsql;`;
             where = { ...where, [deletedAt]: { $isNull: true } };
         }
         // Filtering includes restrict the aggregated set, as they do for findAll.
-        if (options.include && options.include.length > 0) {
-            for (const rawInclude of options.include) {
-                const filter = await (0, eager_load_1.resolveRequiredIncludeFilter)(this.eagerLoadContext(), model, modelName, rawInclude);
-                if (!filter)
-                    continue;
-                if (filter.values.length === 0)
-                    return aggregate === 'SUM' ? 0 : null;
-                const existing = where?.[filter.parentAttr];
-                where = {
-                    ...where,
-                    [filter.parentAttr]: existing
-                        ? { $and: [existing, { $in: filter.values }] }
-                        : { $in: filter.values },
-                };
-            }
-        }
+        const aggregateWhere = await this._applyRequiredIncludeFilters(model, modelName, options.include, where);
+        if (aggregateWhere === null)
+            return aggregate === 'SUM' ? 0 : null;
+        where = aggregateWhere;
         const qualified = model.schema
             ? `${dialect.escapeId(model.schema)}.${dialect.escapeId(model.tableName)}`
             : dialect.escapeId(model.tableName);
@@ -6457,12 +6790,191 @@ $$ LANGUAGE plpgsql;`;
             sql += ` WHERE ${built.sql}`;
             values = built.values;
         }
-        const result = await dialect.query(dialect.replaceReplacements(sql, values));
+        const finalAggSql = dialect.replaceReplacements(sql, values);
+        const aggStarted = Date.now();
+        const result = await dialect.query(finalAggSql);
+        this._logQuery({
+            sql: finalAggSql,
+            duration: Date.now() - aggStarted,
+            parameters: values,
+            model: modelName,
+            type: 'SELECT',
+        }, options.logging);
         const val = result.rows?.[0]?.__agg;
         if (val === null || val === undefined)
             return aggregate === 'SUM' ? 0 : null;
         return Number(val);
     }
+    /**
+     * Log one executed query, and emit the events that hang off it.
+     *
+     * Every statement the ORM issues should route through here. Query logging was
+     * previously inlined at four call sites and only some ran it, so `count`,
+     * `bulkCreate`, `increment` and the aggregates emitted nothing - turning
+     * logging on showed an incomplete picture of what the ORM was doing.
+     */
+    _logQuery(context, queryLogging) {
+        (0, logging_1.logQuery)(context, {
+            instanceLogging: this.loggingOptions,
+            queryLogging,
+            benchmark: this.config.benchmark === true,
+            logQueryParameters: this.config.logQueryParameters === true,
+        });
+        // Slow-query detection and the internal logger's own listeners.
+        this.logger.logQuery(context.sql, context.duration);
+        this.emit('query', {
+            sql: context.sql,
+            duration: context.duration,
+            timestamp: new Date(),
+            model: context.model,
+        });
+        const threshold = this.config.slowQueryThreshold || 1000;
+        if (context.duration > threshold) {
+            this.emit('slowQuery', {
+                sql: context.sql,
+                duration: context.duration,
+                threshold,
+                timestamp: new Date(),
+                model: context.model,
+            });
+        }
+    }
+    /**
+     * Apply `+/- delta` to numeric columns in a single UPDATE.
+     *
+     * Backs `Model.increment` / `Model.decrement`. The arithmetic happens in the
+     * database, so two concurrent callers both land - a read-modify-write in
+     * application code silently drops one of them.
+     */
+    async _applyDelta(model, modelName, fields, options = {}, sign) {
+        if (!this.dialect)
+            throw new Error('Database not connected');
+        const dialect = this.dialect;
+        // Normalize the three accepted shapes to column -> delta.
+        const by = options.by ?? 1;
+        let deltas;
+        if (typeof fields === 'string') {
+            deltas = { [fields]: by };
+        }
+        else if (Array.isArray(fields)) {
+            deltas = Object.fromEntries(fields.map((f) => [f, by]));
+        }
+        else {
+            deltas = fields;
+        }
+        const names = Object.keys(deltas);
+        if (names.length === 0)
+            return 0;
+        const columns = modelColumnNames(model);
+        for (const name of names) {
+            if (!columns.has(name)) {
+                throw new Error(`${modelName} has no attribute '${name}' to increment. ` +
+                    `Known attributes: ${Array.from(columns).join(', ')}.`);
+            }
+        }
+        const qualified = model.schema
+            ? `${dialect.escapeId(model.schema)}.${dialect.escapeId(model.tableName)}`
+            : dialect.escapeId(model.tableName);
+        const assignments = names.map((name) => {
+            const col = dialect.escapeId(name);
+            const amount = deltas[name] * sign;
+            // Emit `col = col + n` / `col = col - n` rather than a bound parameter
+            // for the operator, since the sign is structural.
+            return `${col} = ${col} ${amount < 0 ? '-' : '+'} ${Math.abs(amount)}`;
+        });
+        let sql = `UPDATE ${qualified} SET ${assignments.join(', ')}`;
+        let values = [];
+        // Respect paranoid filtering, as update() does.
+        const modelOptions = model.options;
+        const deletedAt = modelOptions?.deletedAt || 'deletedAt';
+        let where = options.where;
+        if (modelOptions?.paranoid === true && model.rawAttributes?.[deletedAt]) {
+            where = { ...where, [deletedAt]: { $isNull: true } };
+        }
+        if (where && Object.keys(where).length > 0) {
+            const built = dialect.buildWhereClause((0, operators_1.normalizeOperatorKeys)(where));
+            sql += ` WHERE ${built.sql}`;
+            values = built.values;
+        }
+        const finalDeltaSql = dialect.replaceReplacements(sql, values);
+        const deltaStarted = Date.now();
+        const result = await dialect.query(finalDeltaSql);
+        this._logQuery({
+            sql: finalDeltaSql,
+            duration: Date.now() - deltaStarted,
+            parameters: values,
+            model: modelName,
+            type: 'UPDATE',
+        }, options.logging);
+        return result.affectedRows ?? result.rowCount ?? 0;
+    }
+    /**
+     * Update many rows to different values in one statement.
+     *
+     * Backs `Model.bulkUpdate`. Compiles one UPDATE with a CASE expression per
+     * column - portable across every supported dialect - instead of N round
+     * trips.
+     */
+    async _bulkUpdate(model, modelName, rows, options = {}) {
+        if (!this.dialect)
+            throw new Error('Database not connected');
+        if (!rows || rows.length === 0)
+            return 0;
+        const dialect = this.dialect;
+        const keyAttr = options.key ?? resolveModelPrimaryKeyAttr(model);
+        const keys = [];
+        for (const row of rows) {
+            if (row[keyAttr] === undefined || row[keyAttr] === null) {
+                throw new Error(`bulkUpdate on ${modelName}: every row must carry '${keyAttr}'. ` +
+                    `Pass { key: '<column>' } if the rows are identified by something else.`);
+            }
+            keys.push(row[keyAttr]);
+        }
+        // Columns to write: every key seen across the rows, minus the identifier.
+        const columns = Array.from(new Set(rows.flatMap((r) => Object.keys(r)))).filter((c) => c !== keyAttr);
+        if (columns.length === 0)
+            return 0;
+        const knownColumns = modelColumnNames(model);
+        for (const col of columns) {
+            if (!knownColumns.has(col)) {
+                throw new Error(`bulkUpdate on ${modelName}: unknown attribute '${col}'. ` +
+                    `Known attributes: ${Array.from(knownColumns).join(', ')}.`);
+            }
+        }
+        const qualified = model.schema
+            ? `${dialect.escapeId(model.schema)}.${dialect.escapeId(model.tableName)}`
+            : dialect.escapeId(model.tableName);
+        const keyCol = dialect.escapeId(keyAttr);
+        const values = [];
+        const assignments = columns.map((col) => {
+            const escaped = dialect.escapeId(col);
+            const branches = [];
+            for (const row of rows) {
+                // A row that omits this column keeps its current value, so it gets no
+                // WHEN branch and falls through to the ELSE.
+                if (!(col in row))
+                    continue;
+                branches.push('WHEN ? THEN ?');
+                values.push(row[keyAttr], row[col]);
+            }
+            return `${escaped} = CASE ${keyCol} ${branches.join(' ')} ELSE ${escaped} END`;
+        });
+        const placeholders = keys.map(() => '?').join(', ');
+        values.push(...keys);
+        const sql = `UPDATE ${qualified} SET ${assignments.join(', ')} ` +
+            `WHERE ${keyCol} IN (${placeholders})`;
+        const finalBulkSql = dialect.replaceReplacements(sql, values);
+        const bulkStarted = Date.now();
+        const result = await dialect.query(finalBulkSql);
+        this._logQuery({
+            sql: finalBulkSql,
+            duration: Date.now() - bulkStarted,
+            parameters: values,
+            model: modelName,
+            type: 'UPDATE',
+        }, options.logging);
+        return result.affectedRows ?? result.rowCount ?? rows.length;
+    }
     /**
      * The view of this instance that the shared eager-loader needs.
      */
@@ -6630,6 +7142,7 @@ $$ LANGUAGE plpgsql;`;
                 }
                 // Table exists - let's alter it to match the model
                 await this.alterTable(tableName, modelAttributes, modelOptions, { drop });
+                await this.reconcileUniqueKeys(tableName, modelAttributes, modelOptions);
             }
             catch (error) {
                 this.logger.error(`Failed to alter table ${tableName}`, { error });
@@ -6637,8 +7150,74 @@ $$ LANGUAGE plpgsql;`;
             }
         }
     }
+    /**
+     * Make sure the model's declared composite unique keys are enforced on an
+     * existing table, as a unique index.
+     *
+     * `alterTable` reconciles columns only, and on SQLite reconciling a column
+     * means rebuilding the table - which drops the table-level UNIQUE constraint
+     * that `createTableFromModel` put in the CREATE TABLE text. Without this step
+     * a single `sync({ alter: true })` would silently un-enforce a unique key the
+     * model still declares, which is the same silent-data-integrity failure the
+     * unique key support was added to fix.
+     *
+     * A unique index enforces exactly the same rule as a unique constraint and,
+     * unlike `ADD CONSTRAINT`, every dialect here can create one. Existing
+     * indexes are listed first so re-syncing is idempotent on dialects whose
+     * `addIndex` has no IF NOT EXISTS.
+     *
+     * This deliberately does not remove unique keys the model no longer declares
+     * (dropping a constraint is not a change to make implicitly), and it will
+     * fail loudly if the table already holds rows that violate a newly declared
+     * key - which is the honest outcome, not something to swallow.
+     */
+    async reconcileUniqueKeys(tableName, attributes, options) {
+        if (!this.dialect)
+            return;
+        const columns = this.buildColumnDefinitions(attributes, options);
+        // `buildColumnDefinitions` omits the implicit `id` that
+        // `createTableFromModel` synthesizes for a model with no declared primary
+        // key, so add it back before validating the declared field names against
+        // the column list - otherwise a unique key over `id` looks bogus here.
+        if (!Object.values(columns).some((c) => c.primaryKey) && !columns['id']) {
+            columns['id'] = {
+                type: 'INTEGER',
+                allowNull: false,
+                primaryKey: true,
+                autoIncrement: true,
+            };
+        }
+        const uniqueKeys = collectUniqueKeys(tableName, attributes, options, columns);
+        if (uniqueKeys.length === 0)
+            return;
+        const existing = new Set();
+        try {
+            for (const index of await this.dialect.showIndexes(tableName)) {
+                const name = index?.name ?? index?.Key_name ?? index?.index_name;
+                if (typeof name === 'string')
+                    existing.add(name);
+            }
+        }
+        catch {
+            // A dialect that cannot list indexes just means we may re-issue a CREATE
+            // that already exists; that is the addIndex implementation's problem, not
+            // a reason to skip enforcing the key.
+        }
+        for (const uk of uniqueKeys) {
+            if (existing.has(uk.name))
+                continue;
+            await this.dialect.addIndex(tableName, uk.name, uk.fields, { unique: true });
+            this.logger.info(`Applied unique key ${uk.name} to table ${tableName}`);
+        }
+    }
     /**
      * Alter a table to match model definition
+     *
+     * Scope note: this reconciles *columns* only - it adds, changes and (with
+     * `drop`) removes them. Table-level constraints are not diffed against the
+     * database. The composite unique keys collected by `collectUniqueKeys` are
+     * the exception, and they are handled just after this runs, by
+     * `reconcileUniqueKeys`, because a column rebuild would otherwise drop them.
      */
     async alterTable(tableName, modelAttributes, modelOptions, options = {}) {
         if (!this.dialect) {
@@ -6916,7 +7495,7 @@ $$ LANGUAGE plpgsql;`;
      * })
      */
     col(tableOrColumn, column) {
-        return new Col(tableOrColumn, column);
+        return new expressions_1.Col(tableOrColumn, column);
     }
     /**
      * Create a literal SQL expression
@@ -6979,7 +7558,7 @@ $$ LANGUAGE plpgsql;`;
      * });
      */
     get UUIDV4() {
-        return new Literal(data_types_1.UUIDV4.generate());
+        return new expressions_1.Literal(data_types_1.UUIDV4.generate());
     }
     /**
      * Create a where condition for complex queries
@@ -7265,10 +7844,10 @@ exports.DataTypes = {
 // Static Prorm operators - these can be used without creating a Prorm instance (e.g., Prorm.literal('NOW()'))
 // Using type assertion to avoid TypeScript errors since these are added after class definition
 Prorm.literal = function (sql) {
-    return new Literal(sql);
+    return new expressions_1.Literal(sql);
 };
 Prorm.col = function (tableOrColumn, column) {
-    return new Col(tableOrColumn, column);
+    return new expressions_1.Col(tableOrColumn, column);
 };
 Prorm.fn = function (fnName, ...args) {
     return {
@@ -7285,7 +7864,7 @@ Prorm.cast = function (value, type) {
 };
 Object.defineProperty(Prorm, 'UUIDV4', {
     get() {
-        return new Literal('lower(hex(randomblob(16)))');
+        return new expressions_1.Literal('lower(hex(randomblob(16)))');
     },
 });
 Prorm.where = function (col, value) {