ts-prorm-orm 1.2.3 → 2.1.0

package/dist/dialects/clickhouse/index.js

@@ -40,6 +40,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ClickHouseDialect = void 0;
 exports.createClickHouseDialect = createClickHouseDialect;
+const partial_index_1 = require("../partial-index");
 // Lazily-loaded `@clickhouse/client` module. The native/runtime driver is only
 // required the first time a connection is opened, so merely importing this ORM
 // never pulls in the ClickHouse driver.
@@ -59,6 +60,7 @@ function loadClickHouse() {
 }
 const query_stream_helper_1 = require("../query-stream-helper");
 const prorm_1 = require("../../prorm");
+const order_expression_helper_1 = require("../order-expression-helper");
 /**
  * ClickHouse dialect class that implements the Dialect interface.
  *
@@ -950,6 +952,12 @@ class ClickHouseDialect {
         if (options?.ifNotExists)
             sql += ' IF NOT EXISTS';
         sql += ` ${this.escapeId(indexName)} ${expr} TYPE ${type} GRANULARITY ${granularity}`;
+        // ClickHouse indexes are data-skipping indexes on the whole part set; there
+        // is no predicate to restrict them. `where` was accepted and dropped on the
+        // floor here, so the caller silently got an unfiltered index.
+        if (options?.where) {
+            throw (0, partial_index_1.unsupportedPartialIndex)(this.name);
+        }
         await this.query(sql);
     }
     async removeIndex(tableName, indexName) {
@@ -959,6 +967,7 @@ class ClickHouseDialect {
         await this.addIndex(tableName, indexDef.name, indexDef.fields, {
             type: indexDef.type,
             using: indexDef.using,
+            where: indexDef.where,
         });
     }
     async dropIndex(tableName, indexName, options) {
@@ -1359,6 +1368,12 @@ class ClickHouseDialect {
             return '';
         const parts = [];
         const processItem = (item) => {
+            // Order helpers: asc('name') / desc('name') / random()
+            const orderExpr = (0, order_expression_helper_1.renderOrderExpressionItem)(this, item);
+            if (orderExpr !== null) {
+                parts.push(orderExpr);
+                return;
+            }
             if (typeof item === 'string') {
                 const [field, dir] = item.split(' ');
                 parts.push(dir ? `${this.escapeId(field)} ${dir.toUpperCase()}` : this.escapeId(field));

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

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

package/dist/dialects/cockroachdb/index.js

@@ -36,7 +36,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.CockroachDBTransaction = exports.CockroachDBDialect = void 0;
 exports.createCockroachDBDialect = createCockroachDBDialect;
 const operators_1 = require("../../operators");
+const lock_clause_helper_1 = require("../lock-clause-helper");
+const partial_index_1 = require("../partial-index");
 const prorm_1 = require("../../prorm");
+const order_expression_helper_1 = require("../order-expression-helper");
 // Lazily-loaded `pg` driver. Required only when a connection is opened, so
 // importing this ORM never loads the pg driver.
 let pgModule = null;
@@ -2327,9 +2330,14 @@ class CockroachDBDialect {
         if (options?.include && options.include.length > 0) {
             sql += ` INCLUDE (${options.include.map((f) => this.escapeId(f)).join(', ')})`;
         }
+        // Partial index predicate. The ordinary WHERE builder emits `$1`-style
+        // placeholders and this DDL is executed without a value 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);
     }
@@ -2385,9 +2393,12 @@ class CockroachDBDialect {
         if (indexDef.include && indexDef.include.length > 0) {
             sql += ` INCLUDE (${indexDef.include.map((f) => this.escapeId(f)).join(', ')})`;
         }
-        if (indexDef.where && Object.keys(indexDef.where).length > 0) {
-            const whereClause = this.buildWhereClause(indexDef.where);
-            sql += ` WHERE ${whereClause.sql}`;
+        // Partial index predicate - inlined literals, not placeholders. See addIndex.
+        if (indexDef.where) {
+            const predicate = (0, partial_index_1.buildPartialIndexPredicate)(indexDef.where, this.name, this);
+            if (predicate) {
+                sql += ` WHERE ${predicate}`;
+            }
         }
         await this.query(sql);
     }
@@ -3252,12 +3263,18 @@ class CockroachDBDialect {
      * 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]}` : '';
@@ -3977,35 +3994,10 @@ class CockroachDBDialect {
         }
         // Build LIMIT/OFFSET clause
         sql += this.buildLimitOffset(options.limit, options.offset);
-        // Handle row-level locking (CockroachDB specific)
-        if (options.lock) {
-            let lockType;
-            // lock: true is equivalent to 'UPDATE'
-            if (options.lock === true) {
-                lockType = 'UPDATE';
-            }
-            else if (typeof options.lock === 'string') {
-                lockType = options.lock;
-            }
-            else if (typeof options.lock === 'object' && options.lock.of) {
-                // lock: { of: Model } - defaults to FOR UPDATE for table-specific locking
-                lockType = 'UPDATE';
-            }
-            if (lockType === 'UPDATE') {
-                sql += ' FOR UPDATE';
-            }
-            else if (lockType === 'SHARE') {
-                sql += ' FOR SHARE';
-            }
-            else if (lockType === 'KEY SHARE') {
-                sql += ' FOR KEY SHARE';
-            }
-            // Handle lock on specific table (CockroachDB supports OF clause)
-            if (typeof options.lock === 'object' && options.lock.of) {
-                const model = options.lock.of;
-                sql += ` OF ${this.escapeId(model.tableName || '')}`;
-            }
-        }
+        // Handle row-level locking. CockroachDB implements the PostgreSQL locking
+        // grammar; the shared helper compiles every documented `lock` shape so the
+        // object forms can't silently produce an unlocked SELECT.
+        sql += (0, lock_clause_helper_1.appendLockClause)(options.lock, lock_clause_helper_1.COCKROACHDB_LOCK_SPEC, (id) => this.escapeId(id));
         // Build UNION clause if provided
         if (options.union && options.union.length > 0) {
             const unionType = options.unionType || 'UNION';
@@ -4156,33 +4148,10 @@ class CockroachDBDialect {
      * Get CockroachDB specific lock options
      */
     getLockOptions(lock) {
-        const params = [];
-        let sql = '';
-        const lockType = typeof lock === 'string' ? lock : lock?.level;
-        switch (lockType) {
-            case 'UPDATE':
-                sql = 'FOR UPDATE';
-                break;
-            case 'SHARE':
-                sql = 'FOR SHARE';
-                break;
-            case 'KEY SHARE':
-                sql = 'FOR KEY SHARE';
-                break;
-            default:
-                return { sql: '', params };
-        }
-        if (typeof lock === 'object' && lock?.of) {
-            const model = lock.of;
-            sql += ` OF ${this.escapeId(model.tableName || '')}`;
-        }
-        if (typeof lock === 'object' && lock?.nowait) {
-            sql += ' NOWAIT';
-        }
-        else if (typeof lock === 'object' && lock?.skipLocked) {
-            sql += ' SKIP LOCKED';
-        }
-        return { sql, params };
+        return {
+            sql: (0, lock_clause_helper_1.buildLockClause)(lock, lock_clause_helper_1.COCKROACHDB_LOCK_SPEC, (id) => this.escapeId(id)),
+            params: [],
+        };
     }
     // ---------------------------------------------------------------------------
     // User / Privilege management — CockroachDB dialect

package/dist/dialects/db2/index.js

@@ -14,6 +14,7 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DB2Dialect = void 0;
+const partial_index_1 = require("../partial-index");
 // Lazily-loaded `ibm_db` driver. This native (ODBC-based) addon is only loaded
 // the first time a connection is opened, so importing this ORM never dlopens
 // the ibm_db native binding.
@@ -32,7 +33,9 @@ function loadIbmDb() {
     return ibmDbModule;
 }
 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");
 /**
  * Db2-specific transaction class.
  * Db2 transactions (via ibm_db) are tied to a specific connection - the
@@ -1031,6 +1034,13 @@ class DB2Dialect {
         if (options?.include && options.include.length > 0) {
             sql += ` INCLUDE (${options.include.map((f) => this.escapeId(f)).join(', ')})`;
         }
+        // Db2 has no partial/filtered index predicate (only `EXCLUDE NULL KEYS` on
+        // a unique index, which is not a general WHERE). `where` used to be
+        // accepted by createIndex and then silently dropped here, so the caller got
+        // a full index without being told; say so instead.
+        if (options?.where) {
+            throw (0, partial_index_1.unsupportedPartialIndex)(this.name);
+        }
         return sql;
     }
     async addIndex(tableName, indexName, fields, options) {
@@ -1671,12 +1681,18 @@ class DB2Dialect {
         return { sql, values };
     }
     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]}` : '';
@@ -1902,12 +1918,11 @@ class DB2Dialect {
         if (options.limit !== undefined || options.offset !== undefined) {
             sql += this.buildLimitOffset(options.limit, options.offset);
         }
-        if (options.lock) {
-            sql += ' FOR UPDATE';
-            if (options.lock === 'SHARE') {
-                sql += ' WITH RS';
-            }
-        }
+        // Row-level locking: `FOR UPDATE`, with the read-stability isolation clause
+        // for a shared lock. Db2 has no `NOWAIT` and spells lock-avoidance as
+        // `SKIP LOCKED DATA` inside an isolation clause, so both modifiers throw
+        // rather than being silently dropped.
+        sql += (0, lock_clause_helper_1.appendLockClause)(options.lock, lock_clause_helper_1.DB2_LOCK_SPEC);
         return { sql, values };
     }
     /**

package/dist/dialects/dialect.d.ts

@@ -4,6 +4,16 @@
  */
 import { Transaction, TransactionOptions, QueryResult, QueryOptions, DataType, WhereOptions, Order, IncludeOptions, PartitionBound, CreatePartitionOptions, AttachPartitionOptions, DetachPartitionOptions, RefreshOptions, MaterializedViewOptions, DropMaterializedViewOptions, StoredProcedureOptions, DropStoredProcedureOptions, ExecuteStoredProcedureOptions, TriggerOptions, DropTriggerOptions, SequenceOptions, DropSequenceOptions, PolicyOptions, DropPolicyOptions, StreamOptions } from '../types';
 import type { Readable } from 'stream';
+/**
+ * The contract every SQL engine implements.
+ *
+ * A dialect owns everything engine-specific: identifier quoting, value escaping,
+ * how DDL is written, which clauses are legal, and how pagination and locking
+ * are spelled. Model code builds the same `FindOptions` regardless, and
+ * the dialect is the single place that turns it into SQL for one engine —
+ * which is why `LIMIT ... OFFSET` on PostgreSQL becomes `OFFSET ... FETCH
+ * NEXT` on MSSQL without the caller changing.
+ */
 export interface Dialect {
     /**
      * The name of the dialect
@@ -582,6 +592,10 @@ export interface Dialect {
     executeStoredProcedure(options: ExecuteStoredProcedureOptions): Promise<QueryResult>;
     hasStoredProcedure(procedureName: string, schema?: string): Promise<boolean>;
 }
+/**
+ * One column in a `CREATE TABLE` or `ALTER TABLE`: its type, nullability,
+ * default, and key or reference membership.
+ */
 export interface ColumnDefinition {
     type: DataType;
     allowNull?: boolean;
@@ -616,6 +630,10 @@ export interface ColumnDefinition {
      */
     invisible?: boolean;
 }
+/**
+ * Table-level options for `CREATE TABLE` — the engine, charset, comment,
+ * partitioning and any indexes or constraints declared inline.
+ */
 export interface TableOptions {
     ifNotExists?: boolean;
     engine?: string;
@@ -627,8 +645,18 @@ export interface TableOptions {
     rowFormat?: string;
     indexes?: TableIndex[];
     constraints?: TableConstraint[];
-    /** Unique keys to create with the table */
-    uniqueKeys?: Record<string, string[]>;
+    /**
+     * Unique keys to create with the table.
+     *
+     * Both shapes are accepted because both have always been passed: the legacy
+     * `{ name: fields[] }` map, and the `UniqueKeyOptions`-style array that
+     * `ModelOptions.uniqueKeys` is declared as. The dialects already branch on
+     * `Array.isArray`; the type now says so.
+     */
+    uniqueKeys?: Record<string, string[]> | Array<{
+        name?: string;
+        fields: string[];
+    }>;
     /** PostgreSQL tablespace */
     tablespace?: string;
     /** PostgreSQL: inherit from parent table */
@@ -657,18 +685,26 @@ export interface TableOptions {
         validToColumn?: string;
     };
 }
+/**
+ * An index declared alongside the table rather than in a separate statement.
+ */
 export interface TableIndex {
     name?: string;
     unique?: boolean;
     type?: string;
     using?: string;
     fields: string[];
-    where?: WhereOptions;
+    /** See {@link IndexOptions.where}. */
+    where?: WhereOptions | string;
     /** Expression for expression-based indexes (e.g., LOWER(column)) */
     expression?: string;
     /** Include columns for covering index (PostgreSQL 11+, MySQL 8.0.17+) */
     include?: string[];
 }
+/**
+ * A constraint declared alongside the table: primary key, unique, check,
+ * foreign key or exclusion.
+ */
 export interface TableConstraint {
     name?: string;
     type: 'PRIMARY KEY' | 'UNIQUE' | 'FOREIGN KEY' | 'CHECK';
@@ -681,10 +717,18 @@ export interface TableConstraint {
     };
     check?: string;
 }
+/**
+ * Options for `DROP TABLE`, including `ifExists` and whether to cascade to
+ * dependent objects.
+ */
 export interface DropTableOptions {
     ifExists?: boolean;
     cascade?: boolean;
 }
+/**
+ * What the engine reports back about an existing table — the shape returned
+ * by `describeTable`, used by schema diffing.
+ */
 export interface TableDescription {
     [columnName: string]: {
         type: string;
@@ -694,13 +738,30 @@ export interface TableDescription {
         autoIncrement: boolean;
     };
 }
+/**
+ * Options for `CREATE INDEX`: uniqueness, method, included columns, and the
+ * `where` predicate that makes it partial. Not every engine supports partial
+ * indexes; the dialect rejects the option rather than silently dropping it.
+ */
 export interface IndexOptions {
     /** Explicit index name (used by the `(tableName, fields, options)` addIndex shorthand) */
     name?: string;
     unique?: boolean;
     type?: string;
     using?: string;
-    where?: WhereOptions;
+    /**
+     * Partial (filtered) index predicate.
+     *
+     * Compiled into the `CREATE INDEX ... WHERE ...` clause with every value
+     * inlined as an escaped literal, because DDL is executed without a parameter
+     * list - see `src/dialects/partial-index.ts`. A string is taken as a
+     * predicate the caller already wrote and passed through unchanged.
+     *
+     * Only databases with real partial indexes accept this (PostgreSQL family,
+     * SQLite/Turso, SQL Server filtered indexes); the rest throw an
+     * `UnsupportedSchemaObjectError` rather than emit SQL the server rejects.
+     */
+    where?: WhereOptions | string;
     /** Expression for expression-based indexes (e.g., LOWER(column)) */
     expression?: string;
     /** Include columns for covering index (PostgreSQL 11+, MySQL 8.0.17+) */
@@ -721,20 +782,31 @@ export interface IndexOptions {
      */
     invisible?: boolean;
 }
+/**
+ * An existing index as reported by the engine.
+ */
 export interface IndexDefinition {
     name: string;
     unique?: boolean;
     type?: string;
     using?: string;
     fields: string[];
-    where?: WhereOptions;
+    /** See {@link IndexOptions.where}. */
+    where?: WhereOptions | string;
     /** See {@link IndexOptions.invisible}. */
     invisible?: boolean;
 }
+/**
+ * Options for `DROP INDEX`, including `ifExists` and concurrency where the
+ * engine offers it.
+ */
 export interface DropIndexOptions {
     ifExists?: boolean;
     cascade?: boolean;
 }
+/**
+ * An existing constraint as reported by the engine.
+ */
 export interface ConstraintDefinition {
     name: string;
     type: 'PRIMARY KEY' | 'UNIQUE' | 'FOREIGN KEY' | 'CHECK';
@@ -748,6 +820,9 @@ export interface ConstraintDefinition {
     check?: string;
     deferrable?: 'INITIALLY DEFERRED' | 'INITIALLY IMMEDIATE';
 }
+/**
+ * Options for dropping a named constraint.
+ */
 export interface DropConstraintOptions {
     ifExists?: boolean;
     cascade?: boolean;
@@ -772,6 +847,10 @@ export interface DropViewOptions {
     /** If true, also drops dependent views (PostgreSQL) */
     cascade?: boolean;
 }
+/**
+ * Options for dropping a schema, including whether to cascade to the objects
+ * inside it.
+ */
 export interface DropSchemaOptions {
     ifExists?: boolean;
     cascade?: boolean;
@@ -865,6 +944,10 @@ export interface DropDomainOptions {
     /** Schema the domain lives in */
     schema?: string;
 }
+/**
+ * Options for `CREATE VIEW` — the defining query, whether it is materialised,
+ * and whether to replace an existing view.
+ */
 export interface ViewOptions {
     /** Replace the view if it already exists (CREATE OR REPLACE) */
     replace?: boolean;
@@ -873,12 +956,19 @@ export interface ViewOptions {
     /** View comment */
     comment?: string;
 }
+/**
+ * A foreign server: the wrapper that reaches it and the connection options it
+ * needs. See the foreign-data-wrappers guide.
+ */
 export interface FdwForeignServerOptions {
     fdw: string;
     options?: Record<string, string>;
     version?: string;
     ifNotExists?: boolean;
 }
+/**
+ * Changes to an existing foreign server's version or options.
+ */
 export interface FdwAlterForeignServerOptions {
     options?: Record<string, string>;
     addOptions?: Record<string, string>;
@@ -886,16 +976,26 @@ export interface FdwAlterForeignServerOptions {
     dropOptions?: string[];
     version?: string;
 }
+/**
+ * Maps a local role to credentials on a foreign server.
+ */
 export interface FdwUserMappingOptions {
     serverName: string;
     user: string;
     options?: Record<string, string>;
     ifNotExists?: boolean;
 }
+/**
+ * One column of a foreign table, including the remote name when it differs.
+ */
 export interface FdwForeignTableColumnDef {
     type: string;
     options?: string;
 }
+/**
+ * A foreign table: which server it lives on, its columns, and the remote
+ * object it maps to.
+ */
 export interface FdwForeignTableOptions {
     serverName: string;
     schema?: string;
@@ -903,21 +1003,36 @@ export interface FdwForeignTableOptions {
     options?: Record<string, string>;
     ifNotExists?: boolean;
 }
+/**
+ * Options for importing a remote schema wholesale, with optional limits on
+ * which tables come across.
+ */
 export interface FdwImportForeignSchemaOptions {
     localSchema?: string;
     limitTo?: string[];
     except?: string[];
     options?: Record<string, string>;
 }
+/**
+ * Options for dropping a view, including the materialised variant.
+ */
 export interface DropViewOptions {
     ifExists?: boolean;
     cascade?: boolean;
 }
+/**
+ * Shared options for the statement builders: the transaction to run inside
+ * and any per-statement logging override.
+ */
 export interface BuildOptions {
     replacements?: Record<string, any>;
     model?: any;
     include?: IncludeOptions[];
 }
+/**
+ * Options for building an `INSERT`, including returning clauses and conflict
+ * handling where the engine supports them.
+ */
 export interface InsertOptions {
     /** Schema to use for the table */
     schema?: string;
@@ -927,6 +1042,10 @@ export interface InsertOptions {
     /** Fields to update on conflict (MySQL: ON DUPLICATE KEY UPDATE, PostgreSQL/SQLite: ON CONFLICT DO UPDATE, MariaDB: ON DUPLICATE KEY UPDATE) */
     updateOnDuplicate?: string[];
 }
+/**
+ * Options for an insert-or-update, including which columns decide whether a
+ * row already exists and which are written on conflict.
+ */
 export interface UpsertQueryOptions {
     /** Fields to use for conflict resolution (ON CONFLICT for PostgreSQL/SQLite, ON DUPLICATE KEY for MySQL/MariaDB) */
     conflictFields?: string[];
@@ -939,15 +1058,28 @@ export interface UpsertQueryOptions {
     /** Model raw attributes for type casting */
     model?: any;
 }
+/**
+ * Options for building an `UPDATE`: the `where` that selects rows, and any
+ * limit or ordering the engine permits on it.
+ */
 export interface UpdateOptions {
     limit?: number;
     returning?: boolean | string[];
 }
+/**
+ * Options for building a `DELETE`, including the `where` and any limit the
+ * engine permits.
+ */
 export interface DeleteOptions {
     limit?: number;
     returning?: boolean | string[];
     truncate?: boolean;
 }
+/**
+ * Everything a `SELECT` can carry once associations have been resolved:
+ * columns, joins, filtering, grouping, ordering, pagination and locking. This
+ * is the dialect-facing form of `FindOptions`.
+ */
 export interface SelectOptions {
     tableName: string;
     /** Schema to use for the table */
@@ -1027,6 +1159,10 @@ export interface CTEOption {
     /** Optional explicit column list: `name (col1, col2, ...) AS (...)`. */
     columns?: string[];
 }
+/**
+ * Construction options for a dialect instance — the connection settings and
+ * behaviour flags it needs to build and run statements.
+ */
 export interface DialectOptions {
     host?: string;
     port?: number;

package/dist/dialects/duckdb/index.js

@@ -36,6 +36,7 @@ function loadDuckDb() {
 const query_stream_helper_1 = require("../query-stream-helper");
 const prorm_1 = require("../../prorm");
 const operators_1 = require("../../operators");
+const order_expression_helper_1 = require("../order-expression-helper");
 function promisifyAll(target, sql, params) {
     return new Promise((resolve, reject) => {
         const cb = (err, rows) => {
@@ -1437,12 +1438,18 @@ class DuckDBDialect {
         return { sql: result.sql, values };
     }
     buildOrderClause(order) {
-        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]}` : '';