metal-orm 1.0.39 → 1.0.40

package/dist/index.cjs

@@ -70,7 +70,9 @@ __export(index_exports, {
   UpdateQueryBuilder: () => UpdateQueryBuilder,
   abs: () => abs,
   acos: () => acos,
+  add: () => add,
   addDomainEvent: () => addDomainEvent,
+  aliasRef: () => aliasRef,
   and: () => and,
   ascii: () => ascii,
   asin: () => asin,
@@ -121,6 +123,7 @@ __export(index_exports, {
   degrees: () => degrees,
   denseRank: () => denseRank,
   diffSchema: () => diffSchema,
+  div: () => div,
   endOfMonth: () => endOfMonth,
   eq: () => eq,
   esel: () => esel,
@@ -178,6 +181,7 @@ __export(index_exports, {
   min: () => min,
   mod: () => mod,
   month: () => month,
+  mul: () => mul,
   neq: () => neq,
   notBetween: () => notBetween,
   notExists: () => notExists,
@@ -213,6 +217,7 @@ __export(index_exports, {
   sin: () => sin,
   space: () => space,
   sqrt: () => sqrt,
+  sub: () => sub,
   substr: () => substr,
   sum: () => sum,
   synchronizeSchema: () => synchronizeSchema,
@@ -450,6 +455,7 @@ var belongsToMany = (target, pivotTable, options) => ({
 
 // src/core/ast/expression-nodes.ts
 var operandTypes = /* @__PURE__ */ new Set([
+  "AliasRef",
   "Column",
   "Literal",
   "Function",
@@ -496,6 +502,10 @@ var outerRef = (col2) => ({
   ...columnOperand(col2),
   scope: "outer"
 });
+var aliasRef = (name) => ({
+  type: "AliasRef",
+  name
+});
 var correlateBy = (table, column) => outerRef({ name: column, table });
 var createBinaryExpression = (operator, left2, right2, escape) => {
   const node = {
@@ -554,6 +564,16 @@ var createBetweenExpression = (operator, left2, lower2, upper2) => ({
 });
 var between = (left2, lower2, upper2) => createBetweenExpression("BETWEEN", left2, lower2, upper2);
 var notBetween = (left2, lower2, upper2) => createBetweenExpression("NOT BETWEEN", left2, lower2, upper2);
+var createArithmeticExpression = (operator, left2, right2) => ({
+  type: "ArithmeticExpression",
+  left: toOperand(left2),
+  operator,
+  right: toOperand(right2)
+});
+var add = (left2, right2) => createArithmeticExpression("+", left2, right2);
+var sub = (left2, right2) => createArithmeticExpression("-", left2, right2);
+var mul = (left2, right2) => createArithmeticExpression("*", left2, right2);
+var div = (left2, right2) => createArithmeticExpression("/", left2, right2);
 var jsonPath = (col2, path) => ({
   type: "JsonPath",
   column: columnOperand(col2),
@@ -632,7 +652,7 @@ var windowFunction = (name, args = [], partitionBy, orderBy) => {
   const partitionNodes = partitionBy?.map((col2) => columnOperand(col2)) ?? void 0;
   const orderNodes = orderBy?.map((o) => ({
     type: "OrderBy",
-    column: columnOperand(o.column),
+    term: columnOperand(o.column),
     direction: o.direction
   }));
   return buildWindowFunction(name, nodeArgs, partitionNodes, orderNodes);
@@ -707,7 +727,7 @@ var min = buildAggregate("MIN");
 var max = buildAggregate("MAX");
 var toOrderByNode = (order) => ({
   type: "OrderBy",
-  column: columnOperand(order.column),
+  term: columnOperand(order.column),
   direction: order.direction ?? ORDER_DIRECTIONS.ASC
 });
 var groupConcat = (col2, options) => ({
@@ -757,6 +777,9 @@ var visitExpression = (node, visitor) => {
     case "BetweenExpression":
       if (visitor.visitBetweenExpression) return visitor.visitBetweenExpression(node);
       break;
+    case "ArithmeticExpression":
+      if (visitor.visitArithmeticExpression) return visitor.visitArithmeticExpression(node);
+      break;
     default:
       break;
   }
@@ -788,6 +811,9 @@ var visitOperand = (node, visitor) => {
     case "WindowFunction":
       if (visitor.visitWindowFunction) return visitor.visitWindowFunction(node);
       break;
+    case "AliasRef":
+      if (visitor.visitAliasRef) return visitor.visitAliasRef(node);
+      break;
     default:
       break;
   }
@@ -904,7 +930,14 @@ var StandardFunctionStrategy = class _StandardFunctionStrategy {
     if (!orderBy || orderBy.length === 0) {
       return "";
     }
-    const parts = orderBy.map((order) => `${ctx.compileOperand(order.column)} ${order.direction}`);
+    const parts = orderBy.map((order) => {
+      const term = isOperandNode(order.term) ? ctx.compileOperand(order.term) : (() => {
+        throw new Error("ORDER BY expressions inside functions must be operands");
+      })();
+      const collation = order.collation ? ` COLLATE ${order.collation}` : "";
+      const nulls = order.nulls ? ` NULLS ${order.nulls}` : "";
+      return `${term} ${order.direction}${collation}${nulls}`;
+    });
     return `ORDER BY ${parts.join(", ")}`;
   }
   formatGroupConcatSeparator(ctx) {
@@ -1169,6 +1202,16 @@ var Dialect = class _Dialect {
     }
     return compiler(node, ctx);
   }
+  /**
+   * Compiles an ordering term (operand, expression, or alias reference).
+   */
+  compileOrderingTerm(term, ctx) {
+    if (isOperandNode(term)) {
+      return this.compileOperand(term, ctx);
+    }
+    const expr = this.compileExpression(term, ctx);
+    return `(${expr})`;
+  }
   registerDefaultExpressionCompilers() {
     this.registerExpressionCompiler("BinaryExpression", (binary, ctx) => {
       const left2 = this.compileOperand(binary.left, ctx);
@@ -1207,9 +1250,15 @@ var Dialect = class _Dialect {
       const upper2 = this.compileOperand(betweenExpr.upper, ctx);
       return `${left2} ${betweenExpr.operator} ${lower2} AND ${upper2}`;
     });
+    this.registerExpressionCompiler("ArithmeticExpression", (arith, ctx) => {
+      const left2 = this.compileOperand(arith.left, ctx);
+      const right2 = this.compileOperand(arith.right, ctx);
+      return `${left2} ${arith.operator} ${right2}`;
+    });
   }
   registerDefaultOperandCompilers() {
     this.registerOperandCompiler("Literal", (literal, ctx) => ctx.addParameter(literal.value));
+    this.registerOperandCompiler("AliasRef", (alias, _ctx) => this.quoteIdentifier(alias.name));
     this.registerOperandCompiler("Column", (column, _ctx) => {
       return `${this.quoteIdentifier(column.table)}.${this.quoteIdentifier(column.name)}`;
     });
@@ -1247,9 +1296,12 @@ var Dialect = class _Dialect {
         parts.push(partitionClause);
       }
       if (node.orderBy && node.orderBy.length > 0) {
-        const orderClause = "ORDER BY " + node.orderBy.map(
-          (o) => `${this.quoteIdentifier(o.column.table)}.${this.quoteIdentifier(o.column.name)} ${o.direction}`
-        ).join(", ");
+        const orderClause = "ORDER BY " + node.orderBy.map((o) => {
+          const term = this.compileOrderingTerm(o.term, ctx);
+          const collation = o.collation ? ` COLLATE ${o.collation}` : "";
+          const nulls = o.nulls ? ` NULLS ${o.nulls}` : "";
+          return `${term} ${o.direction}${collation}${nulls}`;
+        }).join(", ");
         parts.push(orderClause);
       }
       result += parts.join(" ");
@@ -1468,12 +1520,12 @@ var GroupByCompiler = class {
   /**
    * Compiles GROUP BY clause from a SELECT query AST.
    * @param ast - The SELECT query AST containing grouping columns.
-   * @param quoteIdentifier - Function to quote identifiers according to dialect rules.
+   * @param renderTerm - Function to render a grouping term.
    * @returns SQL GROUP BY clause (e.g., " GROUP BY table.col1, table.col2") or empty string if no grouping.
    */
-  static compileGroupBy(ast, quoteIdentifier) {
+  static compileGroupBy(ast, renderTerm) {
     if (!ast.groupBy || ast.groupBy.length === 0) return "";
-    const cols = ast.groupBy.map((c) => `${quoteIdentifier(c.table)}.${quoteIdentifier(c.name)}`).join(", ");
+    const cols = ast.groupBy.map(renderTerm).join(", ");
     return ` GROUP BY ${cols}`;
   }
 };
@@ -1483,12 +1535,19 @@ var OrderByCompiler = class {
   /**
    * Compiles ORDER BY clause from a SELECT query AST.
    * @param ast - The SELECT query AST containing sort specifications.
-   * @param quoteIdentifier - Function to quote identifiers according to dialect rules.
+   * @param renderTerm - Function to render an ordering term.
+   * @param renderNulls - Optional function to render NULLS FIRST/LAST.
+   * @param renderCollation - Optional function to render COLLATE clause.
    * @returns SQL ORDER BY clause (e.g., " ORDER BY table.col1 ASC, table.col2 DESC") or empty string if no ordering.
    */
-  static compileOrderBy(ast, quoteIdentifier) {
+  static compileOrderBy(ast, renderTerm, renderNulls, renderCollation) {
     if (!ast.orderBy || ast.orderBy.length === 0) return "";
-    const parts = ast.orderBy.map((o) => `${quoteIdentifier(o.column.table)}.${quoteIdentifier(o.column.name)} ${o.direction}`).join(", ");
+    const parts = ast.orderBy.map((o) => {
+      const term = renderTerm(o.term);
+      const collation = renderCollation ? renderCollation(o) : o.collation ? ` COLLATE ${o.collation}` : "";
+      const nulls = renderNulls ? renderNulls(o) : o.nulls ? ` NULLS ${o.nulls}` : "";
+      return `${term} ${o.direction}${collation}${nulls}`;
+    }).join(", ");
     return ` ORDER BY ${parts}`;
   }
 };
@@ -1519,7 +1578,12 @@ var SqlDialectBase = class extends Dialect {
   }
   compileSelectWithSetOps(ast, baseSelect, ctes, ctx) {
     const compound = ast.setOps.map((op) => `${op.operator} ${this.wrapSetOperand(this.compileSelectAst(op.query, ctx))}`).join(" ");
-    const orderBy = OrderByCompiler.compileOrderBy(ast, this.quoteIdentifier.bind(this));
+    const orderBy = OrderByCompiler.compileOrderBy(
+      ast,
+      (term) => this.compileOrderingTerm(term, ctx),
+      this.renderOrderByNulls.bind(this),
+      this.renderOrderByCollation.bind(this)
+    );
     const pagination = this.paginationStrategy.compilePagination(ast.limit, ast.offset);
     const combined = `${this.wrapSetOperand(baseSelect)} ${compound}`;
     return `${ctes}${combined}${orderBy}${pagination}`;
@@ -1545,9 +1609,14 @@ var SqlDialectBase = class extends Dialect {
     const from = this.compileFrom(ast.from, ctx);
     const joins = JoinCompiler.compileJoins(ast, ctx, this.compileFrom.bind(this), this.compileExpression.bind(this));
     const whereClause = this.compileWhere(ast.where, ctx);
-    const groupBy = GroupByCompiler.compileGroupBy(ast, this.quoteIdentifier.bind(this));
+    const groupBy = GroupByCompiler.compileGroupBy(ast, (term) => this.compileOrderingTerm(term, ctx));
     const having = this.compileHaving(ast, ctx);
-    const orderBy = OrderByCompiler.compileOrderBy(ast, this.quoteIdentifier.bind(this));
+    const orderBy = OrderByCompiler.compileOrderBy(
+      ast,
+      (term) => this.compileOrderingTerm(term, ctx),
+      this.renderOrderByNulls.bind(this),
+      this.renderOrderByCollation.bind(this)
+    );
     const pagination = this.paginationStrategy.compilePagination(ast.limit, ast.offset);
     return `SELECT ${this.compileDistinct(ast)}${columns} FROM ${from}${joins}${whereClause}${groupBy}${having}${orderBy}${pagination}`;
   }
@@ -1636,6 +1705,12 @@ var SqlDialectBase = class extends Dialect {
     const trimmed = this.stripTrailingSemicolon(sql);
     return `(${trimmed})`;
   }
+  renderOrderByNulls(order) {
+    return order.nulls ? ` NULLS ${order.nulls}` : "";
+  }
+  renderOrderByCollation(order) {
+    return order.collation ? ` COLLATE ${order.collation}` : "";
+  }
 };
 
 // src/core/dialect/postgres/functions.ts
@@ -2152,7 +2227,7 @@ var SqlServerDialect = class extends Dialect {
       return `${ctes}${baseSelect}`;
     }
     const compound = ast.setOps.map((op) => `${op.operator} ${this.wrapSetOperand(this.compileSelectAst(op.query, ctx))}`).join(" ");
-    const orderBy = this.compileOrderBy(ast);
+    const orderBy = this.compileOrderBy(ast, ctx);
     const pagination = this.compilePagination(ast, orderBy);
     const combined = `${this.wrapSetOperand(baseSelect)} ${compound}`;
     const tail = pagination || orderBy;
@@ -2209,18 +2284,22 @@ var SqlServerDialect = class extends Dialect {
       return `${j.kind} JOIN ${table} ON ${cond}`;
     }).join(" ");
     const whereClause = this.compileWhere(ast.where, ctx);
-    const groupBy = ast.groupBy && ast.groupBy.length > 0 ? " GROUP BY " + ast.groupBy.map((c) => `${this.quoteIdentifier(c.table)}.${this.quoteIdentifier(c.name)}`).join(", ") : "";
+    const groupBy = ast.groupBy && ast.groupBy.length > 0 ? " GROUP BY " + ast.groupBy.map((term) => this.compileOrderingTerm(term, ctx)).join(", ") : "";
     const having = ast.having ? ` HAVING ${this.compileExpression(ast.having, ctx)}` : "";
-    const orderBy = this.compileOrderBy(ast);
+    const orderBy = this.compileOrderBy(ast, ctx);
     const pagination = this.compilePagination(ast, orderBy);
     if (pagination) {
       return `SELECT ${distinct}${columns} FROM ${from}${joins ? " " + joins : ""}${whereClause}${groupBy}${having}${pagination}`;
     }
     return `SELECT ${distinct}${columns} FROM ${from}${joins ? " " + joins : ""}${whereClause}${groupBy}${having}${orderBy}`;
   }
-  compileOrderBy(ast) {
-    if (!ast.orderBy || ast.orderBy.length === 0) return "";
-    return " ORDER BY " + ast.orderBy.map((o) => `${this.quoteIdentifier(o.column.table)}.${this.quoteIdentifier(o.column.name)} ${o.direction}`).join(", ");
+  compileOrderBy(ast, ctx) {
+    return OrderByCompiler.compileOrderBy(
+      ast,
+      (term) => this.compileOrderingTerm(term, ctx),
+      this.renderOrderByNulls.bind(this),
+      this.renderOrderByCollation.bind(this)
+    );
   }
   compilePagination(ast, orderBy) {
     const hasLimit = ast.limit !== void 0;
@@ -2234,6 +2313,12 @@ var SqlServerDialect = class extends Dialect {
     }
     return pagination;
   }
+  renderOrderByNulls(order) {
+    return order.nulls ? ` NULLS ${order.nulls}` : "";
+  }
+  renderOrderByCollation(order) {
+    return order.collation ? ` COLLATE ${order.collation}` : "";
+  }
   compileTableSource(table, ctx) {
     if (table.type === "FunctionTable") {
       return FunctionTableFormatter.format(table, ctx, this);
@@ -2245,9 +2330,9 @@ var SqlServerDialect = class extends Dialect {
     return table.alias ? `${base} AS ${this.quoteIdentifier(table.alias)}` : base;
   }
   compileDerivedTable(table, ctx) {
-    const sub = this.compileSelectAst(this.normalizeSelectAst(table.query), ctx).trim().replace(/;$/, "");
+    const sub2 = this.compileSelectAst(this.normalizeSelectAst(table.query), ctx).trim().replace(/;$/, "");
     const cols = table.columnAliases?.length ? ` (${table.columnAliases.map((c) => this.quoteIdentifier(c)).join(", ")})` : "";
-    return `(${sub}) AS ${this.quoteIdentifier(table.alias)}${cols}`;
+    return `(${sub2}) AS ${this.quoteIdentifier(table.alias)}${cols}`;
   }
   compileCtes(ast, ctx) {
     if (!ast.ctes || ast.ctes.length === 0) return "";
@@ -2412,7 +2497,7 @@ var SelectQueryState = class _SelectQueryState {
   }
   /**
    * Adds GROUP BY columns to the query
-   * @param columns - Columns to group by
+   * @param columns - Terms to group by
    * @returns New SelectQueryState with GROUP BY clause
    */
   withGroupBy(columns) {
@@ -2695,31 +2780,38 @@ var HydrationManager = class _HydrationManager {
     }
     const mapped = [];
     for (const ob of orderBy) {
-      if (ob.column.table !== plan.rootTable) {
-        return null;
-      }
-      const alias = projectionAliases.get(`${ob.column.table}.${ob.column.name}`) ?? ob.column.name;
-      if (!availableColumns.has(alias)) {
-        return null;
-      }
-      mapped.push({
-        type: "OrderBy",
-        column: { type: "Column", table: baseAlias, name: alias },
-        direction: ob.direction
-      });
+      const mappedTerm = this.mapOrderingTerm(ob.term, plan, projectionAliases, baseAlias, availableColumns);
+      if (!mappedTerm) return null;
+      mapped.push({ ...ob, term: mappedTerm });
     }
     return mapped;
   }
+  mapOrderingTerm(term, plan, projectionAliases, baseAlias, availableColumns) {
+    if (term.type === "Column") {
+      const col2 = term;
+      if (col2.table !== plan.rootTable) return null;
+      const alias = projectionAliases.get(`${col2.table}.${col2.name}`) ?? col2.name;
+      if (!availableColumns.has(alias)) return null;
+      return { type: "Column", table: baseAlias, name: alias };
+    }
+    if (term.type === "AliasRef") {
+      const aliasName = term.name;
+      if (!availableColumns.has(aliasName)) return null;
+      return { type: "Column", table: baseAlias, name: aliasName };
+    }
+    return null;
+  }
   buildPagingColumns(primaryKey, orderBy, tableAlias) {
     const columns = [{ type: "Column", table: tableAlias, name: primaryKey, alias: primaryKey }];
     if (!orderBy) return columns;
     for (const ob of orderBy) {
-      if (!columns.some((col2) => col2.name === ob.column.name)) {
+      const term = ob.term;
+      if (!columns.some((col2) => col2.name === term.name)) {
         columns.push({
           type: "Column",
           table: tableAlias,
-          name: ob.column.name,
-          alias: ob.column.name
+          name: term.name,
+          alias: term.name
         });
       }
     }
@@ -3025,10 +3117,8 @@ var QueryAstService = class {
    * @returns Updated query state with GROUP BY clause
    */
   withGroupBy(col2) {
-    const from = this.state.ast.from;
-    const tableRef = from.type === "Table" && from.alias ? { ...this.table, alias: from.alias } : this.table;
-    const node = buildColumnNode(tableRef, col2);
-    return this.state.withGroupBy([node]);
+    const term = this.normalizeOrderingTerm(col2);
+    return this.state.withGroupBy([term]);
   }
   /**
    * Adds a HAVING clause to the query
@@ -3045,11 +3135,9 @@ var QueryAstService = class {
    * @param direction - Order direction (ASC/DESC)
    * @returns Updated query state with ORDER BY clause
    */
-  withOrderBy(col2, direction) {
-    const from = this.state.ast.from;
-    const tableRef = from.type === "Table" && from.alias ? { ...this.table, alias: from.alias } : this.table;
-    const node = buildColumnNode(tableRef, col2);
-    return this.state.withOrderBy([{ type: "OrderBy", column: node, direction }]);
+  withOrderBy(term, direction, nulls, collation) {
+    const normalized = this.normalizeOrderingTerm(term);
+    return this.state.withOrderBy([{ type: "OrderBy", term: normalized, direction, nulls, collation }]);
   }
   /**
    * Adds a DISTINCT clause to the query
@@ -3084,6 +3172,24 @@ var QueryAstService = class {
   combineExpressions(existing, next) {
     return existing ? and(existing, next) : next;
   }
+  normalizeOrderingTerm(term) {
+    const from = this.state.ast.from;
+    const tableRef = from.type === "Table" && from.alias ? { ...this.table, alias: from.alias } : this.table;
+    const termType = term?.type;
+    if (termType === "Column") {
+      return term;
+    }
+    if (termType === "AliasRef") {
+      return term;
+    }
+    if (isOperandNode(term)) {
+      return term;
+    }
+    if (termType === "BinaryExpression" || termType === "LogicalExpression" || termType === "NullExpression" || termType === "InExpression" || termType === "ExistsExpression" || termType === "BetweenExpression" || termType === "ArithmeticExpression") {
+      return term;
+    }
+    return buildColumnNode(tableRef, term);
+  }
 };
 
 // src/query-builder/relation-projection-helper.ts
@@ -4733,8 +4839,8 @@ var SelectQueryBuilder = class _SelectQueryBuilder {
      * @returns New query builder instance with the subquery selection
   
      */
-  selectSubquery(alias, sub) {
-    const query = this.resolveQueryNode(sub);
+  selectSubquery(alias, sub2) {
+    const query = this.resolveQueryNode(sub2);
     return this.clone(this.columnSelector.selectSubquery(this.context, alias, query));
   }
   /**
@@ -4916,16 +5022,12 @@ var SelectQueryBuilder = class _SelectQueryBuilder {
     return this.clone(nextContext);
   }
   /**
-  
-     * Adds a GROUP BY clause to the query
-  
-     * @param col - Column definition or column node to group by
-  
-     * @returns New query builder instance with the GROUP BY clause
-  
-     */
-  groupBy(col2) {
-    const nextContext = this.applyAst(this.context, (service) => service.withGroupBy(col2));
+   * Adds a GROUP BY clause to the query
+   * @param term - Column definition or ordering term to group by
+   * @returns New query builder instance with the GROUP BY clause
+   */
+  groupBy(term) {
+    const nextContext = this.applyAst(this.context, (service) => service.withGroupBy(term));
     return this.clone(nextContext);
   }
   /**
@@ -4942,18 +5044,18 @@ var SelectQueryBuilder = class _SelectQueryBuilder {
     return this.clone(nextContext);
   }
   /**
-  
-     * Adds an ORDER BY clause to the query
-  
-     * @param col - Column definition or column node to order by
-  
-     * @param direction - Order direction (defaults to ASC)
-  
-     * @returns New query builder instance with the ORDER BY clause
-  
-     */
-  orderBy(col2, direction = ORDER_DIRECTIONS.ASC) {
-    const nextContext = this.applyAst(this.context, (service) => service.withOrderBy(col2, direction));
+   * Adds an ORDER BY clause to the query
+   * @param term - Column definition or ordering term to order by
+   * @param directionOrOptions - Order direction or options (defaults to ASC)
+   * @returns New query builder instance with the ORDER BY clause
+   */
+  orderBy(term, directionOrOptions = ORDER_DIRECTIONS.ASC) {
+    const options = typeof directionOrOptions === "string" ? { direction: directionOrOptions } : directionOrOptions;
+    const dir = options.direction ?? ORDER_DIRECTIONS.ASC;
+    const nextContext = this.applyAst(
+      this.context,
+      (service) => service.withOrderBy(term, dir, options.nulls, options.collation)
+    );
     return this.clone(nextContext);
   }
   /**
@@ -6781,7 +6883,7 @@ var TypeScriptGenerator = class {
       lines.push(`.where(${this.printExpression(ast.where)})`);
     }
     if (ast.groupBy && ast.groupBy.length) {
-      const cols = ast.groupBy.map((c) => `${this.namingStrategy.tableToSymbol(c.table)}.${c.name}`).join(", ");
+      const cols = ast.groupBy.map((term) => this.printOrderingTerm(term)).join(", ");
       lines.push(`.groupBy(${cols})`);
     }
     if (ast.having) {
@@ -6789,7 +6891,16 @@ var TypeScriptGenerator = class {
     }
     if (ast.orderBy && ast.orderBy.length) {
       ast.orderBy.forEach((o) => {
-        lines.push(`.orderBy(${this.namingStrategy.tableToSymbol(o.column.table)}.${o.column.name}, '${o.direction}')`);
+        const term = this.printOrderingTerm(o.term);
+        const opts = [`direction: '${o.direction}'`];
+        if (o.nulls) opts.push(`nulls: '${o.nulls}'`);
+        if (o.collation) opts.push(`collation: '${o.collation}'`);
+        const hasOpts = opts.length > 1;
+        if (hasOpts) {
+          lines.push(`.orderBy(${term}, { ${opts.join(", ")} })`);
+        } else {
+          lines.push(`.orderBy(${term}, '${o.direction}')`);
+        }
       });
     }
     if (ast.limit) lines.push(`.limit(${ast.limit})`);
@@ -6812,6 +6923,29 @@ var TypeScriptGenerator = class {
   printOperand(node) {
     return visitOperand(node, this);
   }
+  /**
+   * Prints an ordering term (operand/expression/alias) to TypeScript code.
+   */
+  printOrderingTerm(term) {
+    if (!term || !term.type) {
+      throw new Error("Unsupported ordering term");
+    }
+    switch (term.type) {
+      case "Column":
+        return `${this.namingStrategy.tableToSymbol(term.table)}.${term.name}`;
+      case "AliasRef":
+        return this.visitAliasRef(term);
+      case "Literal":
+      case "Function":
+      case "JsonPath":
+      case "ScalarSubquery":
+      case "CaseExpression":
+      case "WindowFunction":
+        return this.printOperand(term);
+      default:
+        return this.printExpression(term);
+    }
+  }
   visitBinaryExpression(binary) {
     return this.printBinaryExpression(binary);
   }
@@ -6830,6 +6964,9 @@ var TypeScriptGenerator = class {
   visitBetweenExpression(betweenExpr) {
     return this.printBetweenExpression(betweenExpr);
   }
+  visitArithmeticExpression(arithExpr) {
+    return this.printArithmeticExpression(arithExpr);
+  }
   visitColumn(node) {
     return this.printColumnOperand(node);
   }
@@ -6851,6 +6988,9 @@ var TypeScriptGenerator = class {
   visitWindowFunction(node) {
     return this.printWindowFunctionOperand(node);
   }
+  visitAliasRef(node) {
+    return `aliasRef('${node.name}')`;
+  }
   /**
    * Prints a binary expression to TypeScript code
    * @param binary - Binary expression node
@@ -6881,6 +7021,11 @@ var TypeScriptGenerator = class {
     ${parts.join(",\n    ")}
   )`;
   }
+  printArithmeticExpression(expr) {
+    const left2 = this.printOperand(expr.left);
+    const right2 = this.printOperand(expr.right);
+    return `${left2} ${expr.operator} ${right2}`;
+  }
   /**
    * Prints an IN expression to TypeScript code
    * @param inExpr - IN expression node
@@ -6994,7 +7139,12 @@ var TypeScriptGenerator = class {
       parts.push(partitionClause);
     }
     if (node.orderBy && node.orderBy.length > 0) {
-      const orderClause = "ORDER BY " + node.orderBy.map((o) => `${this.namingStrategy.tableToSymbol(o.column.table)}.${o.column.name} ${o.direction}`).join(", ");
+      const orderClause = "ORDER BY " + node.orderBy.map((o) => {
+        const term = this.printOrderingTerm(o.term);
+        const collation = o.collation ? ` COLLATE ${o.collation}` : "";
+        const nulls = o.nulls ? ` NULLS ${o.nulls}` : "";
+        return `${term} ${o.direction}${collation}${nulls}`;
+      }).join(", ");
       parts.push(orderClause);
     }
     result += parts.join(" ");
@@ -8172,7 +8322,9 @@ function createTediousExecutor(connection, module2, options) {
   UpdateQueryBuilder,
   abs,
   acos,
+  add,
   addDomainEvent,
+  aliasRef,
   and,
   ascii,
   asin,
@@ -8223,6 +8375,7 @@ function createTediousExecutor(connection, module2, options) {
   degrees,
   denseRank,
   diffSchema,
+  div,
   endOfMonth,
   eq,
   esel,
@@ -8280,6 +8433,7 @@ function createTediousExecutor(connection, module2, options) {
   min,
   mod,
   month,
+  mul,
   neq,
   notBetween,
   notExists,
@@ -8315,6 +8469,7 @@ function createTediousExecutor(connection, module2, options) {
   sin,
   space,
   sqrt,
+  sub,
   substr,
   sum,
   synchronizeSchema,