ts-prorm-orm 1.2.2 → 2.0.0

package/dist/query-builders/order-limit-builder.js

@@ -9,6 +9,8 @@ exports.createOrderBuilder = createOrderBuilder;
 exports.createOrderLimitBuilder = createOrderLimitBuilder;
 exports.buildOrder = buildOrder;
 exports.buildLimitOffset = buildLimitOffset;
+const operators_1 = require("../operators");
+const order_expression_helper_1 = require("../dialects/order-expression-helper");
 /**
  * OrderBuilder class for building ORDER BY clauses
  */
@@ -45,18 +47,18 @@ class OrderBuilder {
             return item;
         }
         // Handle OrderExpression from order helper functions (asc, desc, random)
-        if (item && typeof item === 'object' && item.__type === 'order') {
-            const direction = item.direction;
-            if (direction === 'RANDOM') {
-                // RANDOM() for SQLite/PostgreSQL, RAND() for MySQL/MariaDB
-                const dialectName = this.options.dialect?.name;
-                if (dialectName === 'mysql' || dialectName === 'mariadb') {
-                    return 'RAND()';
-                }
-                // Default to RANDOM() (SQLite/PostgreSQL)
+        if ((0, operators_1.isOrderExpression)(item)) {
+            const dialectName = this.options.dialect?.name;
+            if (!dialectName && item.direction === 'RANDOM') {
+                // Standalone builder with no dialect configured: there is nothing to
+                // look the random function up by, so keep the historical default
+                // rather than throwing.
                 return 'RANDOM()';
             }
-            return `${this.escapeId(item.field)} ${direction}`;
+            // Otherwise render through the same shared helper the dialects' own
+            // buildOrderClause() uses, so `order: [desc('name')]` / `random()`
+            // produce identical SQL whichever of the two paths a query takes.
+            return (0, order_expression_helper_1.renderOrderExpression)({ name: dialectName, escapeId: (id) => this.escapeId(id) }, item);
         }
         // Handle array: ['field', 'ASC'] or [['field', 'ASC'], ['field2', 'DESC']]
         if (Array.isArray(item)) {

package/dist/query-builders/sql-compiler.d.ts

@@ -468,11 +468,18 @@ export declare class SqlCompiler {
      */
     private compileFrameBound;
     /**
-     * Compile lock options for row-level locking
-     * Supports NOWAIT and SKIP LOCKED for PostgreSQL and MySQL 8.0+
+     * Compile lock options for row-level locking.
+     *
+     * Delegates to the shared dialect lock compiler so this and each dialect's
+     * own `buildSelectQuery()` can never disagree about what a given `lock` shape
+     * means. Supports `true`, a level string, and the
+     * `{ level, nowait, skipLocked, of }` object form; throws when the named
+     * dialect cannot express the requested lock.
+     *
      * @param lock - Lock options
      * @param dialect - The database dialect
-     * @returns The compiled lock SQL clause
+     * @returns The compiled lock SQL clause, or an empty string for no lock and
+     *   for dialects with no trailing locking clause (SQLite, SQL Server, ...)
      */
     compileLockOptions(lock: any, dialect?: string): string;
     /**

package/dist/query-builders/sql-compiler.js

@@ -15,6 +15,7 @@ exports.jsonKeys = jsonKeys;
 exports.jsonLength = jsonLength;
 exports.jsonContains = jsonContains;
 exports.jsonSearch = jsonSearch;
+const lock_clause_helper_1 = require("../dialects/lock-clause-helper");
 const operators_1 = require("../operators");
 /**
  * Default compiler options
@@ -1816,55 +1817,25 @@ class SqlCompiler {
         return bound === 1 ? '1 FOLLOWING' : `${bound} FOLLOWING`;
     }
     /**
-     * Compile lock options for row-level locking
-     * Supports NOWAIT and SKIP LOCKED for PostgreSQL and MySQL 8.0+
+     * Compile lock options for row-level locking.
+     *
+     * Delegates to the shared dialect lock compiler so this and each dialect's
+     * own `buildSelectQuery()` can never disagree about what a given `lock` shape
+     * means. Supports `true`, a level string, and the
+     * `{ level, nowait, skipLocked, of }` object form; throws when the named
+     * dialect cannot express the requested lock.
+     *
      * @param lock - Lock options
      * @param dialect - The database dialect
-     * @returns The compiled lock SQL clause
+     * @returns The compiled lock SQL clause, or an empty string for no lock and
+     *   for dialects with no trailing locking clause (SQLite, SQL Server, ...)
      */
     compileLockOptions(lock, dialect = 'postgres') {
-        if (!lock) {
+        const spec = (0, lock_clause_helper_1.getLockSpecForDialect)(dialect);
+        if (!spec) {
             return '';
         }
-        let lockType;
-        let nowait = false;
-        let skipLocked = false;
-        // Extract lock configuration
-        if (lock === true) {
-            lockType = 'UPDATE';
-        }
-        else if (typeof lock === 'string') {
-            lockType = lock;
-        }
-        else if (typeof lock === 'object') {
-            lockType = lock.level || lock;
-            nowait = lock.nowait === true;
-            skipLocked = lock.skipLocked === true;
-        }
-        // Build base lock clause
-        let lockClause = '';
-        if (lockType === 'UPDATE' || lockType === 'UPDATE') {
-            lockClause = 'FOR UPDATE';
-        }
-        else if (lockType === 'SHARE') {
-            if (dialect === 'mysql') {
-                lockClause = 'LOCK IN SHARE MODE';
-            }
-            else {
-                lockClause = 'FOR SHARE';
-            }
-        }
-        else if (lockType === 'KEY SHARE') {
-            lockClause = 'FOR KEY SHARE';
-        }
-        // Add NOWAIT or SKIP LOCKED (PostgreSQL and MySQL 8.0+)
-        if (nowait && (dialect === 'postgres' || dialect === 'mysql')) {
-            lockClause += ' NOWAIT';
-        }
-        else if (skipLocked && (dialect === 'postgres' || dialect === 'mysql')) {
-            lockClause += ' SKIP LOCKED';
-        }
-        return lockClause;
+        return (0, lock_clause_helper_1.buildLockClause)(lock, spec);
     }
     /**
      * Compile OVER clause with partition, order, and window frame

package/dist/query-interface.d.ts

@@ -57,7 +57,8 @@ export interface ConstraintDefinition {
     };
     onDelete?: string;
     onUpdate?: string;
-    where?: WhereOptions;
+    /** Partial-index predicate; see `IndexOptions.where` in `src/dialects/dialect.ts`. */
+    where?: WhereOptions | string;
 }
 /**
  * Bulk operation options

package/dist/sql-constants.d.ts

@@ -113,6 +113,14 @@ export interface PostgresConstants {
     SEARCH_PATH: SearchPath;
     AUTOCOMMIT: Autocommit;
     CACHE: Cache;
+    /**
+     * Optional: PostgreSQL has no `SET FOREIGN_KEY_CHECKS`. The session-level
+     * equivalent is `session_replication_role`, which is present on true
+     * PostgreSQL and CockroachDB but absent from some PostgreSQL-derived engines
+     * (Redshift does not enforce foreign keys at all), so this is deliberately
+     * optional rather than a required member with a fake value.
+     */
+    FOREIGN_KEY_CHECKS?: ForeignKeyChecks;
 }
 /**
  * SQLite SQL constants
@@ -193,6 +201,10 @@ export declare const COCKROACHDB: CockroachDBConstants;
  * Amazon Redshift SQL constants
  * Redshift is derived from PostgreSQL 8.0.2 and only supports the
  * SERIALIZABLE (default) and READ COMMITTED isolation levels.
+ *
+ * No FOREIGN_KEY_CHECKS: Redshift treats foreign keys as informational only -
+ * it never enforces them and has no `session_replication_role` - so there is
+ * nothing to turn off.
  */
 export declare const REDSHIFT: RedshiftConstants;
 /**
@@ -225,6 +237,38 @@ export declare const SQL: SQLConstants;
  * 'cockroachdb', 'redshift', 'db2', 'snowflake', 'clickhouse')
  */
 export declare function getConstantsForDialect(dialect: string): MySQLConstants | PostgresConstants | SQLiteConstants | DB2Constants | SnowflakeConstants | ClickHouseConstants;
+/** Which end of the switch is wanted. */
+export type ForeignKeyChecksMode = 'disable' | 'enable';
+/**
+ * Raised when a dialect has no session-level foreign key switch.
+ *
+ * Mirrors `UnsupportedSchemaObjectError` in ./schema-objects: name the database
+ * and say what to do instead, rather than returning SQL that fails at the
+ * server. Declared here (not imported) to keep this module dependency-free.
+ */
+export declare class UnsupportedForeignKeyChecksError extends Error {
+    constructor(dialect: string, hint?: string);
+}
+/**
+ * SQL that turns foreign key enforcement off/on for the current session.
+ *
+ * Every family has its own statement and they are not interchangeable:
+ * SQLite/Turso use a PRAGMA, the MySQL family a session variable, and the
+ * PostgreSQL family `session_replication_role`. Handing MySQL's
+ * `SET FOREIGN_KEY_CHECKS` to anything else - which is what the default branch
+ * used to do for every unlisted dialect, PostgreSQL included - produces a
+ * syntax error at the server, and the caller only finds out at runtime.
+ *
+ * The PostgreSQL form needs superuser, or a role granted
+ * `SET ON PARAMETER session_replication_role` (PostgreSQL 15+); on an ordinary
+ * application role the server answers `permission denied to set parameter`.
+ *
+ * @throws {UnsupportedForeignKeyChecksError} when the dialect has no
+ * session-level equivalent (SQL Server, Oracle and Db2 are per-table or
+ * per-constraint; Redshift, Snowflake, ClickHouse and friends do not enforce
+ * foreign keys at all).
+ */
+export declare function getForeignKeyChecksSQL(dialect: string, mode: ForeignKeyChecksMode): string;
 /**
  * Transaction isolation level enum
  */

package/dist/sql-constants.js

@@ -5,8 +5,9 @@
  * like foreign key checks, transaction isolation levels, etc.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.IsolationLevelEnum = exports.SQL = exports.CLICKHOUSE = exports.SNOWFLAKE = exports.DB2 = exports.REDSHIFT = exports.COCKROACHDB = exports.SQLITE = exports.POSTGRES = exports.MARIADB = exports.MYSQL = void 0;
+exports.IsolationLevelEnum = exports.UnsupportedForeignKeyChecksError = exports.SQL = exports.CLICKHOUSE = exports.SNOWFLAKE = exports.DB2 = exports.REDSHIFT = exports.COCKROACHDB = exports.SQLITE = exports.POSTGRES = exports.MARIADB = exports.MYSQL = void 0;
 exports.getConstantsForDialect = getConstantsForDialect;
+exports.getForeignKeyChecksSQL = getForeignKeyChecksSQL;
 /**
  * MySQL/MariaDB SQL constants
  */
@@ -87,6 +88,22 @@ exports.POSTGRES = {
         on: 'SET SESSION statement_cache_mode = ON',
         off: 'SET SESSION statement_cache_mode = OFF',
     },
+    /**
+     * PostgreSQL suppresses foreign key (and trigger) enforcement for the session
+     * by pretending to be a replication target. There is no `SET
+     * FOREIGN_KEY_CHECKS` - that is MySQL syntax and PostgreSQL rejects it with a
+     * syntax error.
+     *
+     * Requires superuser, or (PostgreSQL 15+) a role that has been granted
+     * `SET ON PARAMETER session_replication_role`. On a plain application role
+     * the server raises `permission denied to set parameter`; that error is left
+     * to surface rather than being swallowed, because silently continuing with
+     * foreign keys still enforced is the failure mode this replaced.
+     */
+    FOREIGN_KEY_CHECKS: {
+        disable: "SET session_replication_role = 'replica'",
+        enable: "SET session_replication_role = 'origin'",
+    },
 };
 /**
  * SQLite SQL constants
@@ -150,11 +167,21 @@ exports.COCKROACHDB = {
         on: 'SET SESSION statement_cache_mode = ON',
         off: 'SET SESSION statement_cache_mode = OFF',
     },
+    /** CockroachDB implements `session_replication_role` (v22.2+) with the same
+     * `replica`/`origin` values as PostgreSQL. */
+    FOREIGN_KEY_CHECKS: {
+        disable: "SET session_replication_role = 'replica'",
+        enable: "SET session_replication_role = 'origin'",
+    },
 };
 /**
  * Amazon Redshift SQL constants
  * Redshift is derived from PostgreSQL 8.0.2 and only supports the
  * SERIALIZABLE (default) and READ COMMITTED isolation levels.
+ *
+ * No FOREIGN_KEY_CHECKS: Redshift treats foreign keys as informational only -
+ * it never enforces them and has no `session_replication_role` - so there is
+ * nothing to turn off.
  */
 exports.REDSHIFT = {
     ISOLATION_LEVEL: {
@@ -284,10 +311,120 @@ function getConstantsForDialect(dialect) {
             return exports.SNOWFLAKE;
         case 'clickhouse':
             return exports.CLICKHOUSE;
+        // Derived dialects report their own name but run the parent server's
+        // session SQL. Without these, `getConstantsForDialect('timescaledb')` fell
+        // through to the MySQL constants and handed MySQL syntax to a PostgreSQL
+        // server.
+        case 'timescaledb':
+        case 'greenplum':
+        case 'yugabytedb':
+            return exports.POSTGRES;
+        case 'turso':
+            return exports.SQLITE;
+        case 'tidb':
+            return exports.MYSQL;
         default:
             return exports.MYSQL;
     }
 }
+// ==================== Foreign key checks ====================
+/**
+ * Dialects whose session-level foreign key switch is SQLite's PRAGMA.
+ * Turso/libSQL is SQLite over the wire and shares the pragma verbatim.
+ */
+const SQLITE_FK_DIALECTS = new Set(['sqlite', 'turso']);
+/**
+ * Dialects that implement MySQL's `SET FOREIGN_KEY_CHECKS` session variable.
+ *
+ * TiDB implements the variable for MySQL compatibility. SingleStore and
+ * Databricks extend the MySQL dialect class in this codebase but do not support
+ * enforced foreign keys at all, so they are deliberately absent - an explicit
+ * error naming the database beats a statement the server rejects.
+ */
+const MYSQL_FK_DIALECTS = new Set(['mysql', 'mariadb', 'tidb']);
+/**
+ * Dialects that implement PostgreSQL's `session_replication_role`.
+ *
+ * TimescaleDB and Greenplum are PostgreSQL servers; YugabyteDB and CockroachDB
+ * reimplement the parameter with the same `replica`/`origin` values. Trino,
+ * CrateDB, QuestDB, Exasol, Vertica and Redshift extend the Postgres dialect
+ * class here but are separate engines with no such parameter (Redshift never
+ * enforces foreign keys in the first place), so they are left out.
+ */
+const POSTGRES_FK_DIALECTS = new Set([
+    'postgres',
+    'timescaledb',
+    'greenplum',
+    'yugabytedb',
+    'cockroachdb',
+]);
+/**
+ * Why a given dialect cannot switch foreign key enforcement for a whole
+ * session, and what to do instead. Used to build the thrown error message.
+ */
+const FK_CHECKS_UNSUPPORTED_HINTS = {
+    mssql: 'Use ALTER TABLE <table> NOCHECK CONSTRAINT ALL per table instead.',
+    oracle: 'Use ALTER TABLE <table> DISABLE CONSTRAINT <name> per constraint instead.',
+    db2: 'Use SET INTEGRITY FOR <table> OFF / IMMEDIATE CHECKED per table instead.',
+    redshift: 'Redshift treats foreign keys as informational only and never enforces them.',
+    snowflake: 'Snowflake does not enforce foreign keys, so there is nothing to disable.',
+    clickhouse: 'ClickHouse has no foreign key constraints.',
+    duckdb: 'DuckDB has no session-level switch; drop and recreate the constraint instead.',
+    singlestore: 'SingleStore does not support enforced foreign key constraints.',
+    databricks: 'Databricks foreign keys are informational only and are never enforced.',
+    spanner: 'Spanner has no session-level switch; drop and recreate the constraint instead.',
+};
+/**
+ * Raised when a dialect has no session-level foreign key switch.
+ *
+ * Mirrors `UnsupportedSchemaObjectError` in ./schema-objects: name the database
+ * and say what to do instead, rather than returning SQL that fails at the
+ * server. Declared here (not imported) to keep this module dependency-free.
+ */
+class UnsupportedForeignKeyChecksError extends Error {
+    constructor(dialect, hint) {
+        super(`Session-level foreign key checks are not supported on ${dialect}` +
+            `${hint ? `. ${hint}` : ''}`);
+        this.name = 'UnsupportedForeignKeyChecksError';
+    }
+}
+exports.UnsupportedForeignKeyChecksError = UnsupportedForeignKeyChecksError;
+/**
+ * SQL that turns foreign key enforcement off/on for the current session.
+ *
+ * Every family has its own statement and they are not interchangeable:
+ * SQLite/Turso use a PRAGMA, the MySQL family a session variable, and the
+ * PostgreSQL family `session_replication_role`. Handing MySQL's
+ * `SET FOREIGN_KEY_CHECKS` to anything else - which is what the default branch
+ * used to do for every unlisted dialect, PostgreSQL included - produces a
+ * syntax error at the server, and the caller only finds out at runtime.
+ *
+ * The PostgreSQL form needs superuser, or a role granted
+ * `SET ON PARAMETER session_replication_role` (PostgreSQL 15+); on an ordinary
+ * application role the server answers `permission denied to set parameter`.
+ *
+ * @throws {UnsupportedForeignKeyChecksError} when the dialect has no
+ * session-level equivalent (SQL Server, Oracle and Db2 are per-table or
+ * per-constraint; Redshift, Snowflake, ClickHouse and friends do not enforce
+ * foreign keys at all).
+ */
+function getForeignKeyChecksSQL(dialect, mode) {
+    if (SQLITE_FK_DIALECTS.has(dialect)) {
+        return mode === 'disable' ? exports.SQLITE.PRAGMA.foreign_keys.off : exports.SQLITE.PRAGMA.foreign_keys.on;
+    }
+    if (MYSQL_FK_DIALECTS.has(dialect)) {
+        return exports.MYSQL.FOREIGN_KEY_CHECKS[mode];
+    }
+    if (POSTGRES_FK_DIALECTS.has(dialect)) {
+        // COCKROACHDB carries its own copy of the constant; both resolve to the
+        // same `session_replication_role` statement.
+        const constants = dialect === 'cockroachdb' ? exports.COCKROACHDB : exports.POSTGRES;
+        const checks = constants.FOREIGN_KEY_CHECKS;
+        if (checks)
+            return checks[mode];
+    }
+    throw new UnsupportedForeignKeyChecksError(dialect, FK_CHECKS_UNSUPPORTED_HINTS[dialect]);
+}
 /**
  * Transaction isolation level enum
  */

package/dist/types/index.d.ts

@@ -572,7 +572,23 @@ export interface PrormOptions {
     host?: string;
     port?: number;
     storage?: string;
+    /**
+     * Query logging, following Sequelize's contract:
+     * `false` off, `true` console.log, or a function called as `(sql, timing)`.
+     * A per-query `logging` overrides this for that call.
+     */
     logging?: boolean | ((sql: string, timing?: number) => void);
+    /**
+     * Append the elapsed time to each logged query, and log even when `logging`
+     * was never set. Matches Sequelize's `benchmark`.
+     */
+    benchmark?: boolean;
+    /**
+     * Append the values bound to each statement. Off by default: bound values
+     * routinely contain credentials and personal data, so this must be opted
+     * into deliberately.
+     */
+    logQueryParameters?: boolean;
     loggingLevel?: LoggingLevel | 'debug' | 'info' | 'warn' | 'error';
     logSQL?: boolean;
     logSlowQueries?: boolean;
@@ -765,7 +781,8 @@ export interface IndexOptions {
     unique?: boolean;
     type?: string;
     using?: string;
-    where?: WhereOptions;
+    /** Partial-index predicate; see `IndexOptions.where` in `src/dialects/dialect.ts`. */
+    where?: WhereOptions | string;
     /** PostgreSQL: specify tablespace for the index */
     tablespace?: string;
     /** PostgreSQL: index storage parameters */
@@ -1519,6 +1536,20 @@ export interface UnpivotOptions {
 export interface FindOptions {
     where?: WhereOptions;
     attributes?: AttributesOptions;
+    /**
+     * Association aliases to count without loading their rows. Each sets
+     * `<alias>Count` on every returned row.
+     *
+     * ```typescript
+     * const users = await User.findAll({ withCount: ['posts'] });
+     * users[0].postsCount; // number
+     * ```
+     *
+     * Resolved with one grouped query per association, so the statement count
+     * does not grow with the number of parent rows. Prefer this over a full
+     * `include` when you only need the size.
+     */
+    withCount?: string[];
     /** Schema to use for the main table */
     schema?: string;
     /**
@@ -1829,21 +1860,26 @@ export interface GroupByItem {
 }
 /**
  * Lock types for row-level locking
- * - 'UPDATE': FOR UPDATE (PostgreSQL/MySQL) - prevents other transactions from modifying the rows
- * - 'SHARE': FOR SHARE (PostgreSQL) / LOCK IN SHARE MODE (MySQL) - allows other transactions to read but not modify
- * - 'KEY SHARE': FOR KEY SHARE (PostgreSQL only) - prevents key updates but allows row updates
+ * - 'UPDATE': FOR UPDATE (PostgreSQL/MySQL/MariaDB/Oracle/Db2/HANA, UPDLOCK on SQL Server) - prevents other transactions from modifying the rows
+ * - 'SHARE': FOR SHARE (PostgreSQL) / LOCK IN SHARE MODE (MySQL/MariaDB, or FOR SHARE when a modifier is used) / HOLDLOCK (SQL Server) - allows other transactions to read but not modify
+ * - 'KEY SHARE': FOR KEY SHARE (PostgreSQL/CockroachDB only) - prevents key updates but allows row updates
+ * - 'NO KEY UPDATE': FOR NO KEY UPDATE (PostgreSQL/CockroachDB only) - like UPDATE but does not block KEY SHARE lockers
+ *
+ * A dialect that cannot express the requested level throws when the query is
+ * built, rather than silently falling back to a weaker lock (or to none).
  */
 export declare enum LockLevel {
     Share = "SHARE",
     Update = "UPDATE",
-    KeyShare = "KEY SHARE"
+    KeyShare = "KEY SHARE",
+    NoKeyUpdate = "NO KEY UPDATE"
 }
 /**
  * Lock types for row-level locking
  *
  * Accepts either the raw string literals or the equivalent {@link LockLevel} enum member.
  */
-export type LockType = 'SHARE' | 'UPDATE' | 'KEY SHARE' | LockLevel;
+export type LockType = 'SHARE' | 'UPDATE' | 'KEY SHARE' | 'NO KEY UPDATE' | LockLevel;
 /**
  * Lock options for row-level locking
  * @example
@@ -1861,6 +1897,15 @@ export type LockType = 'SHARE' | 'UPDATE' | 'KEY SHARE' | LockLevel;
  *
  * // SKIP LOCKED - skip locked rows (PostgreSQL/MySQL 8.0+)
  * User.findAll({ lock: { level: 'UPDATE', skipLocked: true } })
+ *
+ * // Modifiers on their own imply FOR UPDATE
+ * User.findAll({ lock: { skipLocked: true } })
+ *
+ * @remarks
+ * `nowait` and `skipLocked` are mutually exclusive - setting both throws.
+ * Dialects with no row-level locking (SQLite and friends) ignore `lock`
+ * entirely; dialects that have locking but cannot express the exact request
+ * (e.g. `SHARE` on Oracle, `SKIP LOCKED` on Db2) throw when the query is built.
  */
 export type LockOptions = LockType | boolean | {
     of: ModelStatic<any>;
@@ -2880,17 +2925,8 @@ export interface RawQueryResult {
  * prorm.query('SELECT * FROM users', { type: QueryTypes.SELECT })
  * prorm.query('INSERT INTO users VALUES(...)', { type: QueryTypes.INSERT })
  */
-export declare enum QueryTypes {
-    SELECT = "SELECT",
-    INSERT = "INSERT",
-    UPDATE = "UPDATE",
-    DELETE = "DELETE",
-    BULKINSERT = "BULKINSERT",
-    BULKUPDATE = "BULKUPDATE",
-    BULKDELETE = "BULKDELETE",
-    RAW = "RAW",
-    CALL = "CALL"
-}
+import { QueryTypes } from './query-types';
+export { QueryTypes };
 export interface QueryOptions {
     plain?: boolean;
     raw?: boolean;

package/dist/types/index.js

@@ -110,15 +110,20 @@ var ValidateOn;
 })(ValidateOn || (exports.ValidateOn = ValidateOn = {}));
 /**
  * Lock types for row-level locking
- * - 'UPDATE': FOR UPDATE (PostgreSQL/MySQL) - prevents other transactions from modifying the rows
- * - 'SHARE': FOR SHARE (PostgreSQL) / LOCK IN SHARE MODE (MySQL) - allows other transactions to read but not modify
- * - 'KEY SHARE': FOR KEY SHARE (PostgreSQL only) - prevents key updates but allows row updates
+ * - 'UPDATE': FOR UPDATE (PostgreSQL/MySQL/MariaDB/Oracle/Db2/HANA, UPDLOCK on SQL Server) - prevents other transactions from modifying the rows
+ * - 'SHARE': FOR SHARE (PostgreSQL) / LOCK IN SHARE MODE (MySQL/MariaDB, or FOR SHARE when a modifier is used) / HOLDLOCK (SQL Server) - allows other transactions to read but not modify
+ * - 'KEY SHARE': FOR KEY SHARE (PostgreSQL/CockroachDB only) - prevents key updates but allows row updates
+ * - 'NO KEY UPDATE': FOR NO KEY UPDATE (PostgreSQL/CockroachDB only) - like UPDATE but does not block KEY SHARE lockers
+ *
+ * A dialect that cannot express the requested level throws when the query is
+ * built, rather than silently falling back to a weaker lock (or to none).
  */
 var LockLevel;
 (function (LockLevel) {
     LockLevel["Share"] = "SHARE";
     LockLevel["Update"] = "UPDATE";
     LockLevel["KeyShare"] = "KEY SHARE";
+    LockLevel["NoKeyUpdate"] = "NO KEY UPDATE";
 })(LockLevel || (exports.LockLevel = LockLevel = {}));
 // ==================== Transaction Options ====================
 /**
@@ -166,15 +171,5 @@ var IsolationLevel;
  * prorm.query('SELECT * FROM users', { type: QueryTypes.SELECT })
  * prorm.query('INSERT INTO users VALUES(...)', { type: QueryTypes.INSERT })
  */
-var QueryTypes;
-(function (QueryTypes) {
-    QueryTypes["SELECT"] = "SELECT";
-    QueryTypes["INSERT"] = "INSERT";
-    QueryTypes["UPDATE"] = "UPDATE";
-    QueryTypes["DELETE"] = "DELETE";
-    QueryTypes["BULKINSERT"] = "BULKINSERT";
-    QueryTypes["BULKUPDATE"] = "BULKUPDATE";
-    QueryTypes["BULKDELETE"] = "BULKDELETE";
-    QueryTypes["RAW"] = "RAW";
-    QueryTypes["CALL"] = "CALL";
-})(QueryTypes || (exports.QueryTypes = QueryTypes = {}));
+const query_types_1 = require("./query-types");
+Object.defineProperty(exports, "QueryTypes", { enumerable: true, get: function () { return query_types_1.QueryTypes; } });

package/dist/types/query-types.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Query type discriminator, used by `prorm.query()` to decide how to shape a
+ * raw result.
+ *
+ * This enum existed twice with *different members*: `src/prorm.ts` declared
+ * UPSERT/VERSION/SHOWTABLES/DESCRIBE, while `src/types/index.ts` declared
+ * BULKUPDATE/CALL. The package root explicitly re-exported the prorm.ts one, so
+ * `QueryTypes.CALL` and `QueryTypes.BULKUPDATE` were unreachable for consumers
+ * even though internal code in types/index.ts referred to them. This is the
+ * union of both, defined once; both modules now re-export it.
+ */
+export declare enum QueryTypes {
+    SELECT = "SELECT",
+    INSERT = "INSERT",
+    UPDATE = "UPDATE",
+    DELETE = "DELETE",
+    UPSERT = "UPSERT",
+    BULKINSERT = "BULKINSERT",
+    BULKUPDATE = "BULKUPDATE",
+    BULKDELETE = "BULKDELETE",
+    VERSION = "VERSION",
+    SHOWTABLES = "SHOWTABLES",
+    DESCRIBE = "DESCRIBE",
+    CALL = "CALL",
+    RAW = "RAW"
+}

package/dist/types/query-types.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QueryTypes = void 0;
+/**
+ * Query type discriminator, used by `prorm.query()` to decide how to shape a
+ * raw result.
+ *
+ * This enum existed twice with *different members*: `src/prorm.ts` declared
+ * UPSERT/VERSION/SHOWTABLES/DESCRIBE, while `src/types/index.ts` declared
+ * BULKUPDATE/CALL. The package root explicitly re-exported the prorm.ts one, so
+ * `QueryTypes.CALL` and `QueryTypes.BULKUPDATE` were unreachable for consumers
+ * even though internal code in types/index.ts referred to them. This is the
+ * union of both, defined once; both modules now re-export it.
+ */
+var QueryTypes;
+(function (QueryTypes) {
+    QueryTypes["SELECT"] = "SELECT";
+    QueryTypes["INSERT"] = "INSERT";
+    QueryTypes["UPDATE"] = "UPDATE";
+    QueryTypes["DELETE"] = "DELETE";
+    QueryTypes["UPSERT"] = "UPSERT";
+    QueryTypes["BULKINSERT"] = "BULKINSERT";
+    QueryTypes["BULKUPDATE"] = "BULKUPDATE";
+    QueryTypes["BULKDELETE"] = "BULKDELETE";
+    QueryTypes["VERSION"] = "VERSION";
+    QueryTypes["SHOWTABLES"] = "SHOWTABLES";
+    QueryTypes["DESCRIBE"] = "DESCRIBE";
+    QueryTypes["CALL"] = "CALL";
+    QueryTypes["RAW"] = "RAW";
+})(QueryTypes || (exports.QueryTypes = QueryTypes = {}));