ts-prorm-orm 1.2.2 → 2.0.0

package/dist/dialects/lock-clause-helper.js

@@ -0,0 +1,316 @@
+"use strict";
+/**
+ * Shared compiler for `FindOptions.lock` (row-level locking).
+ *
+ * Every dialect used to re-implement the `lock` option inline inside its own
+ * `buildSelectQuery()`, and every one of those copies understood a slightly
+ * different subset of the documented `LockOptions` shapes. The object forms
+ * (`{ level }`, `{ level, nowait }`, `{ level, skipLocked }`, `{ skipLocked }`)
+ * fell through most of them and compiled to *nothing* - the caller asked for a
+ * lock, got a plain `SELECT`, and only found out under concurrency. This module
+ * centralises the parsing (`normalizeLockOptions`) and the SQL assembly
+ * (`buildLockClause`) so a shape can only be dropped by deliberately leaving it
+ * out of a dialect's {@link LockClauseSpec} - and a spec that cannot express
+ * what was asked for throws instead of silently emitting a weaker lock.
+ *
+ * Dialects with no row-level locking at all (SQLite and friends) simply never
+ * call in here: ignoring `lock` is a deliberate, documented decision for them
+ * (SQLite serialises writers anyway), not an oversight.
+ *
+ * SQL Server is the odd one out - it expresses row locking as a table hint
+ * (`FROM t WITH (UPDLOCK, ROWLOCK)`) rather than a trailing clause - so it
+ * shares the parsing/validation via {@link buildSqlServerLockHint} while
+ * rendering its own syntax.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HANA_LOCK_SPEC = exports.DB2_LOCK_SPEC = exports.ORACLE_LOCK_SPEC = exports.MARIADB_LOCK_SPEC = exports.MYSQL_LOCK_SPEC = exports.COCKROACHDB_LOCK_SPEC = exports.POSTGRES_LOCK_SPEC = void 0;
+exports.normalizeLockOptions = normalizeLockOptions;
+exports.buildLockClause = buildLockClause;
+exports.appendLockClause = appendLockClause;
+exports.buildSqlServerLockHint = buildSqlServerLockHint;
+exports.getLockSpecForDialect = getLockSpecForDialect;
+const KNOWN_LEVELS = ['UPDATE', 'SHARE', 'KEY SHARE', 'NO KEY UPDATE'];
+function levelList(spec) {
+    return Object.keys(spec.levels).join(', ');
+}
+function parseLevel(value) {
+    if (typeof value !== 'string') {
+        throw new Error(`Invalid lock level ${JSON.stringify(value)}. Expected one of: ${KNOWN_LEVELS.join(', ')}.`);
+    }
+    const normalized = value.trim().toUpperCase().replace(/\s+/g, ' ');
+    if (KNOWN_LEVELS.includes(normalized)) {
+        return normalized;
+    }
+    throw new Error(`Unknown lock level ${JSON.stringify(value)}. Expected one of: ${KNOWN_LEVELS.join(', ')}.`);
+}
+/**
+ * Collapse any documented `lock` shape into a {@link NormalizedLock}.
+ *
+ * Returns `undefined` for a falsy lock (`undefined`, `false`, `null`), which
+ * every caller treats as "no locking clause".
+ *
+ * Accepted shapes:
+ * - `true` -> `FOR UPDATE`
+ * - `'UPDATE' | 'SHARE' | 'KEY SHARE' | 'NO KEY UPDATE'` (case-insensitive)
+ * - `{ of: Model }` -> `FOR UPDATE` scoped to that table
+ * - `{ level?, nowait?, skipLocked?, of? }` -> level defaults to `UPDATE`
+ *
+ * `mode` is accepted as an alias for `level` and `noWait` for `nowait`, since
+ * the MariaDB dialect has always documented those spellings.
+ *
+ * Throws on a level it doesn't recognise rather than quietly emitting no lock.
+ */
+function normalizeLockOptions(lock) {
+    if (!lock) {
+        return undefined;
+    }
+    if (lock === true) {
+        return { level: 'UPDATE', nowait: false, skipLocked: false };
+    }
+    if (typeof lock === 'string') {
+        return { level: parseLevel(lock), nowait: false, skipLocked: false };
+    }
+    if (typeof lock !== 'object') {
+        throw new Error(`Invalid "lock" option: expected true, a lock level string, or an options object, got ${typeof lock}.`);
+    }
+    const raw = lock;
+    const rawLevel = raw.level ?? raw.mode;
+    const level = rawLevel === undefined || rawLevel === null ? 'UPDATE' : parseLevel(rawLevel);
+    const nowait = raw.nowait === true || raw.noWait === true;
+    const skipLocked = raw.skipLocked === true;
+    if (nowait && skipLocked) {
+        throw new Error('Invalid "lock" option: NOWAIT and SKIP LOCKED are mutually exclusive - set only one of lock.nowait / lock.skipLocked.');
+    }
+    return { level, nowait, skipLocked, of: raw.of };
+}
+/**
+ * Build the trailing locking clause for a dialect, e.g. `FOR UPDATE OF "users" NOWAIT`.
+ *
+ * Returns `''` when there is no lock to apply. Throws when the requested lock
+ * cannot be expressed by this dialect - a lock the caller believes they hold
+ * but don't is far worse than a loud failure at query-build time.
+ *
+ * @param lock - the raw `options.lock` value
+ * @param spec - the dialect's locking capabilities
+ * @param escapeId - the dialect's identifier quoter, used for `lock.of`
+ */
+function buildLockClause(lock, spec, escapeId = (id) => id) {
+    const normalized = normalizeLockOptions(lock);
+    if (!normalized) {
+        return '';
+    }
+    const levelSql = spec.levels[normalized.level];
+    if (levelSql === undefined) {
+        throw new Error(`${spec.name} does not support ${normalized.level} row locking. Supported lock levels: ${levelList(spec)}.`);
+    }
+    let clause = typeof levelSql === 'function' ? levelSql(normalized) : levelSql;
+    if (normalized.of && spec.renderOf) {
+        const ofLevels = spec.ofLevels ?? Object.keys(spec.levels);
+        if (ofLevels.includes(normalized.level)) {
+            const ofSql = spec.renderOf(normalized.of, escapeId);
+            if (ofSql) {
+                clause += ` ${ofSql}`;
+            }
+        }
+    }
+    if (normalized.nowait) {
+        if (!spec.nowaitLevels?.includes(normalized.level)) {
+            throw new Error(`${spec.name} does not support NOWAIT with a ${normalized.level} lock. ` +
+                `Remove lock.nowait, or use a lock level that supports it${spec.nowaitLevels?.length ? ` (${spec.nowaitLevels.join(', ')})` : ''}.`);
+        }
+        clause += ' NOWAIT';
+    }
+    else if (normalized.skipLocked) {
+        if (!spec.skipLockedLevels?.includes(normalized.level)) {
+            throw new Error(`${spec.name} does not support SKIP LOCKED with a ${normalized.level} lock. ` +
+                `Remove lock.skipLocked, or use a lock level that supports it${spec.skipLockedLevels?.length ? ` (${spec.skipLockedLevels.join(', ')})` : ''}.`);
+        }
+        clause += ' SKIP LOCKED';
+    }
+    return clause;
+}
+/**
+ * Same as {@link buildLockClause} but returns the clause with a leading space
+ * (or `''`), which is how every `buildSelectQuery()` wants to append it.
+ */
+function appendLockClause(lock, spec, escapeId) {
+    const clause = buildLockClause(lock, spec, escapeId);
+    return clause ? ` ${clause}` : '';
+}
+/* -------------------------------------------------------------------------- */
+/* Per-dialect specs                                                          */
+/* -------------------------------------------------------------------------- */
+/**
+ * PostgreSQL: `FOR UPDATE | NO KEY UPDATE | SHARE | KEY SHARE [OF table] [NOWAIT | SKIP LOCKED]`.
+ * The full matrix - every level accepts both modifiers and the `OF` clause.
+ */
+exports.POSTGRES_LOCK_SPEC = {
+    name: 'PostgreSQL',
+    levels: {
+        UPDATE: 'FOR UPDATE',
+        'NO KEY UPDATE': 'FOR NO KEY UPDATE',
+        SHARE: 'FOR SHARE',
+        'KEY SHARE': 'FOR KEY SHARE',
+    },
+    nowaitLevels: KNOWN_LEVELS,
+    skipLockedLevels: KNOWN_LEVELS,
+    // Historically `OF` was emitted even for a model with no tableName (as `OF ""`);
+    // keep that byte-for-byte rather than silently dropping the requested scope.
+    renderOf: (model, escapeId) => `OF ${escapeId(model.tableName || '')}`,
+};
+/** CockroachDB implements the PostgreSQL locking grammar. */
+exports.COCKROACHDB_LOCK_SPEC = {
+    ...exports.POSTGRES_LOCK_SPEC,
+    name: 'CockroachDB',
+};
+/**
+ * MySQL 8.0+: `FOR UPDATE [OF tbl] [NOWAIT | SKIP LOCKED]` and
+ * `FOR SHARE [OF tbl] [NOWAIT | SKIP LOCKED]`.
+ *
+ * A bare shared lock still compiles to the pre-8.0 `LOCK IN SHARE MODE`
+ * spelling (which every supported MySQL understands, and which existing
+ * `lock: 'SHARE'` callers already get); it only switches to the 8.0 `FOR SHARE`
+ * form when a modifier is requested, because `LOCK IN SHARE MODE` accepts
+ * neither `NOWAIT` nor `SKIP LOCKED`.
+ */
+exports.MYSQL_LOCK_SPEC = {
+    name: 'MySQL',
+    levels: {
+        UPDATE: 'FOR UPDATE',
+        SHARE: (lock) => (lock.nowait || lock.skipLocked ? 'FOR SHARE' : 'LOCK IN SHARE MODE'),
+    },
+    nowaitLevels: ['UPDATE', 'SHARE'],
+    skipLockedLevels: ['UPDATE', 'SHARE'],
+    renderOf: (model, escapeId) => (model.tableName ? `OF ${escapeId(model.tableName)}` : ''),
+    ofLevels: ['UPDATE'],
+};
+/**
+ * MariaDB: `FOR UPDATE` / `LOCK IN SHARE MODE` on every version, with
+ * `FOR SHARE` and the `SKIP LOCKED` / `NOWAIT` modifiers from 10.6.
+ *
+ * MariaDB has no `FOR UPDATE OF <table>`, so `lock.of` only signals that a lock
+ * was wanted (matching this dialect's long-standing behaviour).
+ */
+exports.MARIADB_LOCK_SPEC = {
+    name: 'MariaDB',
+    levels: {
+        UPDATE: 'FOR UPDATE',
+        SHARE: (lock) => (lock.nowait || lock.skipLocked ? 'FOR SHARE' : 'LOCK IN SHARE MODE'),
+    },
+    nowaitLevels: ['UPDATE', 'SHARE'],
+    skipLockedLevels: ['UPDATE', 'SHARE'],
+};
+/**
+ * Oracle: `FOR UPDATE [OF column] [NOWAIT | SKIP LOCKED]`.
+ *
+ * Oracle has no shared row lock (`SHARE`/`KEY SHARE` have no equivalent), and
+ * its `OF` names *columns*, not a table - a `lock.of` model can't be turned into
+ * one, so `of` is treated as a plain `FOR UPDATE` request exactly as it always
+ * has been.
+ */
+exports.ORACLE_LOCK_SPEC = {
+    name: 'Oracle',
+    levels: {
+        UPDATE: 'FOR UPDATE',
+    },
+    nowaitLevels: ['UPDATE'],
+    skipLockedLevels: ['UPDATE'],
+};
+/**
+ * Db2: `FOR UPDATE`, plus the `WITH RS` isolation clause for a read-stability
+ * (shared) lock. Db2 spells lock-avoidance as `SKIP LOCKED DATA` inside an
+ * isolation clause and has no `NOWAIT` at all, so both modifiers throw rather
+ * than being approximated.
+ */
+exports.DB2_LOCK_SPEC = {
+    name: 'Db2',
+    levels: {
+        UPDATE: 'FOR UPDATE',
+        SHARE: 'FOR UPDATE WITH RS',
+    },
+};
+/** SAP HANA: `FOR UPDATE [NOWAIT]`. No shared row lock and no `SKIP LOCKED`. */
+exports.HANA_LOCK_SPEC = {
+    name: 'SAP HANA',
+    levels: {
+        UPDATE: 'FOR UPDATE',
+    },
+    nowaitLevels: ['UPDATE'],
+};
+/* -------------------------------------------------------------------------- */
+/* SQL Server - table hints rather than a trailing clause                     */
+/* -------------------------------------------------------------------------- */
+const SQLSERVER_LEVEL_HINTS = {
+    UPDATE: 'UPDLOCK',
+    SHARE: 'HOLDLOCK',
+};
+/**
+ * Build the SQL Server locking table hint, e.g. `WITH (UPDLOCK, ROWLOCK)`.
+ *
+ * T-SQL has no `FOR UPDATE`; row locking is requested with hints on the table
+ * reference: `UPDLOCK`/`HOLDLOCK` for the lock itself, `ROWLOCK` to pin the
+ * granularity to rows, `READPAST` for `SKIP LOCKED` and `NOWAIT` for `NOWAIT`.
+ *
+ * Returns `''` when there is no lock to apply.
+ *
+ * @param lock - the raw `options.lock` value
+ * @param tableName - the table the hint will be attached to, so a `lock.of`
+ *   naming some *other* table can be rejected instead of silently locking the
+ *   wrong one (a hint only applies to the table reference it sits on).
+ */
+function buildSqlServerLockHint(lock, tableName) {
+    const normalized = normalizeLockOptions(lock);
+    if (!normalized) {
+        return '';
+    }
+    const levelHint = SQLSERVER_LEVEL_HINTS[normalized.level];
+    if (!levelHint) {
+        throw new Error(`SQL Server does not support ${normalized.level} row locking. Supported lock levels: UPDATE, SHARE.`);
+    }
+    if (normalized.of) {
+        const ofTable = normalized.of.tableName || normalized.of.name;
+        if (ofTable && tableName && ofTable !== tableName) {
+            throw new Error(`SQL Server cannot scope a lock to ${JSON.stringify(ofTable)} from a query on ${JSON.stringify(tableName)}: locking is expressed as a table hint, which only applies to the table it is attached to.`);
+        }
+    }
+    const hints = [levelHint, 'ROWLOCK'];
+    if (normalized.nowait) {
+        hints.push('NOWAIT');
+    }
+    else if (normalized.skipLocked) {
+        hints.push('READPAST');
+    }
+    return `WITH (${hints.join(', ')})`;
+}
+/* -------------------------------------------------------------------------- */
+/* Dialect-name lookup                                                        */
+/* -------------------------------------------------------------------------- */
+const SPECS_BY_DIALECT = {
+    postgres: exports.POSTGRES_LOCK_SPEC,
+    postgresql: exports.POSTGRES_LOCK_SPEC,
+    pg: exports.POSTGRES_LOCK_SPEC,
+    greenplum: exports.POSTGRES_LOCK_SPEC,
+    timescaledb: exports.POSTGRES_LOCK_SPEC,
+    yugabytedb: exports.POSTGRES_LOCK_SPEC,
+    vertica: exports.POSTGRES_LOCK_SPEC,
+    cockroachdb: exports.COCKROACHDB_LOCK_SPEC,
+    mysql: exports.MYSQL_LOCK_SPEC,
+    tidb: exports.MYSQL_LOCK_SPEC,
+    singlestore: exports.MYSQL_LOCK_SPEC,
+    mariadb: exports.MARIADB_LOCK_SPEC,
+    oracle: exports.ORACLE_LOCK_SPEC,
+    db2: exports.DB2_LOCK_SPEC,
+    hana: exports.HANA_LOCK_SPEC,
+};
+/**
+ * Look up the locking spec for a dialect name. Returns `undefined` for a
+ * dialect with no row-level locking (SQLite and friends) and for SQL Server,
+ * whose locking is a table hint rather than a trailing clause - callers should
+ * treat `undefined` as "emit no trailing lock clause".
+ */
+function getLockSpecForDialect(dialect) {
+    if (typeof dialect !== 'string') {
+        return undefined;
+    }
+    return SPECS_BY_DIALECT[dialect.toLowerCase()];
+}

package/dist/dialects/mariadb/index.d.ts

@@ -740,10 +740,13 @@ export declare class MariaDBDialect implements Dialect {
      */
     removeIndex(tableName: string, indexName: string): Promise<void>;
     /**
-     * Create a partial index (index with WHERE clause)
-     * MariaDB supports partial indexes since version 10.0.3
+     * Partial (filtered) indexes - not available on MariaDB.
+     *
+     * The claim that MariaDB 10.0.3 added them is wrong: `CREATE INDEX` has never
+     * taken a `WHERE` clause on MariaDB (a live mariadb:11 server answers
+     * ER_PARSE_ERROR), so this throws rather than build that statement.
      */
-    createPartialIndex(tableName: string, indexName: string, fields: string[], where: string, options?: IndexOptions): Promise<void>;
+    createPartialIndex(_tableName: string, _indexName: string, _fields: string[], _where: string, _options?: IndexOptions): Promise<void>;
     /**
      * Create an index on a table with full options support
      */
@@ -753,7 +756,7 @@ export declare class MariaDBDialect implements Dialect {
         type?: string;
         using?: string;
         fields: string[];
-        where?: WhereOptions;
+        where?: WhereOptions | string;
         invisible?: boolean;
     }): Promise<void>;
     /**

package/dist/dialects/mariadb/index.js

@@ -15,6 +15,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.MariaDBRowFormats = exports.MariaDBConnectTypes = exports.MariaDBStorageEngines = exports.MariaDBTransaction = exports.MariaDBDialect = void 0;
 exports.createMariaDBDialect = createMariaDBDialect;
 const operators_1 = require("../../operators");
+const partial_index_1 = require("../partial-index");
 // Lazily-loaded `mariadb` driver. Required only when a connection is opened,
 // so importing this ORM never loads the mariadb driver.
 let mariadbModule = null;
@@ -32,8 +33,10 @@ function loadMariaDb() {
     return mariadbModule;
 }
 const query_stream_helper_1 = require("../query-stream-helper");
+const lock_clause_helper_1 = require("../lock-clause-helper");
 const prorm_1 = require("../../prorm");
 const operators_2 = require("../../operators");
+const order_expression_helper_1 = require("../order-expression-helper");
 /**
  * MariaDB dialect class that implements the Dialect interface
  * Extends MySQL compatibility with MariaDB-specific features
@@ -1835,10 +1838,12 @@ class MariaDBDialect {
         if (options?.include && options.include.length > 0) {
             sql += ` INCLUDE (${options.include.map((f) => this.escapeId(f)).join(', ')})`;
         }
-        // Add WHERE clause for partial index (MariaDB 10.0.3+)
-        if (options?.where && Object.keys(options.where).length > 0) {
-            const whereClause = this.buildWhereClause(options.where);
-            sql += ` WHERE ${whereClause.sql}`;
+        // MariaDB has no partial/filtered indexes at any version - `CREATE INDEX`
+        // takes no WHERE clause. This used to compile the predicate through the
+        // ordinary WHERE builder and append it, producing SQL the server rejects
+        // (with unbound `?` placeholders in it, no less), so fail with a reason.
+        if (options?.where) {
+            throw (0, partial_index_1.unsupportedPartialIndex)(this.name);
         }
         // Index visibility (MariaDB 10.6+). Unlike MySQL, MariaDB uses the
         // `IGNORED` keyword for indexes (not `INVISIBLE` — that keyword is
@@ -1858,15 +1863,16 @@ class MariaDBDialect {
         await this.query(sql);
     }
     /**
-     * Create a partial index (index with WHERE clause)
-     * MariaDB supports partial indexes since version 10.0.3
+     * Partial (filtered) indexes - not available on MariaDB.
+     *
+     * The claim that MariaDB 10.0.3 added them is wrong: `CREATE INDEX` has never
+     * taken a `WHERE` clause on MariaDB (a live mariadb:11 server answers
+     * ER_PARSE_ERROR), so this throws rather than build that statement.
      */
-    async createPartialIndex(tableName, indexName, fields, where, options) {
-        const fieldsSql = fields.map((f) => this.escapeId(f)).join(', ');
-        let sql = `CREATE INDEX ${this.escapeId(indexName)} ON ${this.quoteTable(tableName)} (${fieldsSql}) WHERE ${where}`;
-        if (options?.unique)
-            sql = sql.replace('CREATE INDEX', 'CREATE UNIQUE INDEX');
-        await this.query(sql);
+    async createPartialIndex(_tableName, _indexName, _fields, _where, _options) {
+        // This used to emit `CREATE INDEX ... WHERE ...`, which MariaDB has never
+        // accepted; the statement failed at the server with a syntax error.
+        throw (0, partial_index_1.unsupportedPartialIndex)(this.name);
     }
     /**
      * Create an index on a table with full options support
@@ -1891,10 +1897,9 @@ class MariaDBDialect {
         if (indexDef.using) {
             sql += ` USING ${indexDef.using}`;
         }
-        // Add WHERE clause for partial index (MariaDB 10.0.3+)
-        if (indexDef.where && Object.keys(indexDef.where).length > 0) {
-            const whereClause = this.buildWhereClause(indexDef.where);
-            sql += ` WHERE ${whereClause.sql}`;
+        // No partial/filtered indexes on MariaDB - see addIndex.
+        if (indexDef.where) {
+            throw (0, partial_index_1.unsupportedPartialIndex)(this.name);
         }
         // Index visibility (MariaDB 10.6+). Unlike MySQL, MariaDB uses
         // `IGNORED` (not `INVISIBLE`) for indexes. Not ignored by default.
@@ -2368,12 +2373,18 @@ class MariaDBDialect {
      * Build an ORDER BY clause
      */
     buildOrderClause(order, options) {
-        const orderArray = order;
-        if (!orderArray || !Array.isArray(orderArray) || orderArray.length === 0) {
+        const orderArray = (0, order_expression_helper_1.normalizeOrderItems)(order);
+        if (orderArray.length === 0) {
             return '';
         }
         const orderParts = [];
         for (const item of orderArray) {
+            // Order helpers: asc('name') / desc('name') / random()
+            const orderExpr = (0, order_expression_helper_1.renderOrderExpressionItem)(this, item);
+            if (orderExpr !== null) {
+                orderParts.push(orderExpr);
+                continue;
+            }
             if (Array.isArray(item)) {
                 const field = typeof item[0] === 'string' ? this.escapeId(item[0]) : item[0];
                 const direction = item[1] ? ` ${item[1]}` : '';
@@ -3025,48 +3036,13 @@ class MariaDBDialect {
         }
         // Build LIMIT/OFFSET clause
         sql += this.buildLimitOffset(options.limit, options.offset);
-        // Handle row-level locking
-        if (options.lock) {
-            // lock: true is equivalent to 'UPDATE'
-            let lockType;
-            let skipLocked = false;
-            let noWait = false;
-            if (options.lock === true) {
-                lockType = 'UPDATE';
-            }
-            else if (typeof options.lock === 'string') {
-                lockType = options.lock;
-            }
-            else if (typeof options.lock === 'object' && options.lock !== null) {
-                // lock: { of: Model, mode: 'UPDATE' | 'SHARE', skipLocked?, noWait? }
-                lockType = options.lock.mode || (options.lock.of ? 'UPDATE' : undefined);
-                skipLocked = !!options.lock.skipLocked;
-                noWait = !!options.lock.noWait;
-            }
-            if (lockType === 'UPDATE') {
-                sql += ' FOR UPDATE';
-            }
-            else if (lockType === 'SHARE') {
-                // MariaDB 10.6+ prefers `FOR SHARE` over the legacy `LOCK IN SHARE MODE`
-                // syntax, but only `LOCK IN SHARE MODE` supports no modifiers, so use
-                // `FOR SHARE` whenever a SKIP LOCKED/NOWAIT modifier is requested.
-                if (skipLocked || noWait) {
-                    sql += ' FOR SHARE';
-                }
-                else {
-                    sql += ' LOCK IN SHARE MODE';
-                }
-            }
-            // MariaDB 10.6+ locking modifiers
-            if (lockType === 'UPDATE' || lockType === 'SHARE') {
-                if (skipLocked) {
-                    sql += ' SKIP LOCKED';
-                }
-                else if (noWait) {
-                    sql += ' NOWAIT';
-                }
-            }
-        }
+        // Handle row-level locking (MariaDB 10.6+). The shared helper parses
+        // every documented `lock` shape - including `{ level, nowait }`, which this dialect only understood
+        // under its own `{ mode, noWait }` spelling and otherwise compiled to no
+        // lock at all. Both spellings are still accepted. A shared lock uses the
+        // legacy `LOCK IN SHARE MODE` unless a modifier is requested, since only
+        // `FOR SHARE` accepts SKIP LOCKED / NOWAIT.
+        sql += (0, lock_clause_helper_1.appendLockClause)(options.lock, lock_clause_helper_1.MARIADB_LOCK_SPEC);
         // Build UNION/EXCEPT/INTERSECT clause if provided
         // MariaDB 10.3+ supports EXCEPT/EXCEPT ALL/INTERSECT/INTERSECT ALL in
         // addition to UNION/UNION ALL.

package/dist/dialects/mssql/index.js

@@ -8,9 +8,12 @@ exports.MSSQLDialect = void 0;
 exports.createMSSQLDialect = createMSSQLDialect;
 const mssql_1 = require("mssql");
 const operators_1 = require("../../operators");
+const partial_index_1 = require("../partial-index");
 const types_1 = require("../../types");
 const query_stream_helper_1 = require("../query-stream-helper");
+const lock_clause_helper_1 = require("../lock-clause-helper");
 const prorm_1 = require("../../prorm");
+const order_expression_helper_1 = require("../order-expression-helper");
 /**
  * Default retry options for connection
  */
@@ -975,10 +978,15 @@ class MSSQLDialect {
         if (options?.using)
             sql += ` USING ${options.using}`;
         // Filtered index predicate (a real, commonly-used MSSQL feature) - was
-        // previously accepted by createIndex() but silently dropped here.
+        // previously accepted by createIndex() but silently dropped here. The
+        // ordinary WHERE builder emits `@p1`-style placeholders and this DDL is
+        // executed without a parameter list, so the predicate is compiled with its
+        // values inlined as escaped literals.
         if (options?.where) {
-            const whereClause = this.buildWhereClause(options.where);
-            sql += ` WHERE ${whereClause.sql}`;
+            const predicate = (0, partial_index_1.buildPartialIndexPredicate)(options.where, this.name, this);
+            if (predicate) {
+                sql += ` WHERE ${predicate}`;
+            }
         }
         await this.query(sql);
     }
@@ -1333,6 +1341,12 @@ class MSSQLDialect {
             return '';
         const orderParts = [];
         const processOrder = (orderItem) => {
+            // Order helpers: asc('name') / desc('name') / random()
+            const orderExpr = (0, order_expression_helper_1.renderOrderExpressionItem)(this, orderItem);
+            if (orderExpr !== null) {
+                orderParts.push(orderExpr);
+                return;
+            }
             if (typeof orderItem === 'string') {
                 const parts = orderItem.split(' ');
                 if (parts.length === 1) {
@@ -1342,6 +1356,16 @@ class MSSQLDialect {
                     orderParts.push(`${this.escapeId(parts[0])} ${parts[1].toUpperCase()}`);
                 }
             }
+            else if (Array.isArray(orderItem)) {
+                // Tuple form — `['name', 'DESC']` / `['name']`, the elements of the
+                // primary documented `[['name', 'DESC'], ['id', 'ASC']]` shape. An
+                // array is also an object, so without this branch each tuple fell
+                // through to the map branch below and its *indices* were emitted as
+                // column names (`ORDER BY [0] NAME, [1] DESC`).
+                const [field, direction] = orderItem;
+                const column = typeof field === 'string' ? this.escapeId(field) : String(field);
+                orderParts.push(direction ? `${column} ${String(direction).toUpperCase()}` : column);
+            }
             else if (typeof orderItem === 'object' && orderItem !== null) {
                 for (const [key, value] of Object.entries(orderItem)) {
                     if (key === '$raw') {
@@ -1569,6 +1593,13 @@ class MSSQLDialect {
         else if (options.temporalAll) {
             sql += ' FOR SYSTEM_TIME ALL';
         }
+        // Row-level locking. T-SQL has no `FOR UPDATE`; a lock is requested with a
+        // table hint on the table reference, which has to sit immediately after it
+        // (and after any FOR SYSTEM_TIME clause). See lock-clause-helper.ts.
+        const lockHint = (0, lock_clause_helper_1.buildSqlServerLockHint)(options.lock, options.tableName);
+        if (lockHint) {
+            sql += ` ${lockHint}`;
+        }
         if (options.include && options.include.length > 0) {
             for (const include of options.include) {
                 // CROSS APPLY / OUTER APPLY — a lateral join, needed for anything an

package/dist/dialects/mysql/index.d.ts

@@ -711,7 +711,7 @@ export declare class MySQLDialect implements Dialect {
         type?: string;
         using?: string;
         fields: string[];
-        where?: WhereOptions;
+        where?: WhereOptions | string;
         expression?: string;
         include?: string[];
         invisible?: boolean;

package/dist/dialects/mysql/index.js

@@ -12,6 +12,8 @@ const promise_1 = __importDefault(require("mysql2/promise"));
 const prorm_1 = require("../../prorm");
 const operators_1 = require("../../operators");
 const operators_2 = require("../../operators");
+const lock_clause_helper_1 = require("../lock-clause-helper");
+const order_expression_helper_1 = require("../order-expression-helper");
 /**
  * Default retry options for connection
  */
@@ -2881,12 +2883,18 @@ class MySQLDialect {
      * Build an ORDER BY clause
      */
     buildOrderClause(order, options) {
-        const orderArray = order;
-        if (!orderArray || !Array.isArray(orderArray) || orderArray.length === 0) {
+        const orderArray = (0, order_expression_helper_1.normalizeOrderItems)(order);
+        if (orderArray.length === 0) {
             return '';
         }
         const orderParts = [];
         for (const item of orderArray) {
+            // Order helpers: asc('name') / desc('name') / random()
+            const orderExpr = (0, order_expression_helper_1.renderOrderExpressionItem)(this, item);
+            if (orderExpr !== null) {
+                orderParts.push(orderExpr);
+                continue;
+            }
             if (Array.isArray(item)) {
                 const field = typeof item[0] === 'string' ? this.escapeId(item[0]) : item[0];
                 const direction = item[1] ? ` ${item[1]}` : '';
@@ -3483,49 +3491,13 @@ class MySQLDialect {
         // Build LIMIT/OFFSET clause
         sql += this.buildLimitOffset(options.limit, options.offset);
         // Handle row-level locking
-        if (options.lock) {
-            // lock: true is equivalent to 'UPDATE'
-            let lockType;
-            let nowait = false;
-            let skipLocked = false;
-            if (options.lock === true) {
-                lockType = 'UPDATE';
-            }
-            else if (typeof options.lock === 'string') {
-                lockType = options.lock;
-            }
-            else if (typeof options.lock === 'object') {
-                // Handle { level: 'UPDATE', nowait: true } or { level: 'UPDATE', skipLocked: true }
-                lockType = options.lock.level || (options.lock.of ? 'UPDATE' : undefined);
-                nowait = options.lock.nowait === true;
-                skipLocked = options.lock.skipLocked === true;
-            }
-            if (lockType === 'UPDATE') {
-                sql += ' FOR UPDATE';
-                // MySQL 8.0+ supports table-scoped locking via `FOR UPDATE OF <table>`
-                if (typeof options.lock === 'object' && options.lock.of) {
-                    const model = options.lock.of;
-                    if (model.tableName) {
-                        sql += ` OF ${this.escapeId(model.tableName)}`;
-                    }
-                }
-                // MySQL 8.0+ supports NOWAIT and SKIP LOCKED
-                if (nowait) {
-                    sql += ' NOWAIT';
-                }
-                else if (skipLocked) {
-                    sql += ' SKIP LOCKED';
-                }
-            }
-            else if (lockType === 'SHARE') {
-                sql += ' LOCK IN SHARE MODE';
-                // MySQL 8.0+ supports NOWAIT for SHARE mode
-                if (nowait) {
-                    sql += ' NOWAIT';
-                }
-                // MySQL doesn't support SKIP LOCKED for LOCK IN SHARE MODE
-            }
-        }
+        // `FOR UPDATE [OF tbl] [NOWAIT | SKIP LOCKED]` / `LOCK IN SHARE MODE`, with
+        // every documented `lock` shape parsed by the shared helper. A shared lock
+        // switches to the MySQL 8.0 `FOR SHARE` spelling when a NOWAIT/SKIP LOCKED
+        // modifier is requested, since `LOCK IN SHARE MODE` accepts neither (it
+        // used to emit an invalid `LOCK IN SHARE MODE NOWAIT`, and drop SKIP LOCKED
+        // on the floor). See src/dialects/lock-clause-helper.ts.
+        sql += (0, lock_clause_helper_1.appendLockClause)(options.lock, lock_clause_helper_1.MYSQL_LOCK_SPEC, (id) => this.escapeId(id));
         // Build UNION clause if provided
         if (options.union && options.union.length > 0) {
             const unionType = options.unionType || 'UNION';