metal-orm 1.0.56 → 1.0.57

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "metal-orm",
-  "version": "1.0.56",
+  "version": "1.0.57",
   "type": "module",
   "types": "./dist/index.d.ts",
   "engines": {

package/src/codegen/naming-strategy.ts

@@ -36,7 +36,9 @@ export class DefaultNamingStrategy implements NamingStrategy {
         ? table
         : table.type === 'DerivedTable'
           ? table.alias
-          : table.name;
+          : table.type === 'FunctionTable'
+            ? table.alias ?? table.name
+            : table.name;
 
     // Handle schema-qualified names (e.g., "auth.user" → "AuthUser")
     if (tableName.includes('.')) {

package/src/codegen/typescript.ts

@@ -18,6 +18,7 @@ import {
   FunctionNode,
   AliasRefNode,
   CastExpressionNode,
+  CollateExpressionNode,
   ExpressionVisitor,
   OperandVisitor,
   visitExpression,
@@ -183,16 +184,17 @@ export class TypeScriptGenerator implements ExpressionVisitor<string>, OperandVi
         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':
-    case 'Cast':
-      return this.printOperand(term);
-    default:
-      return this.printExpression(term);
+      case 'Literal':
+      case 'Function':
+      case 'JsonPath':
+      case 'ScalarSubquery':
+      case 'CaseExpression':
+      case 'WindowFunction':
+      case 'Cast':
+      case 'Collate':
+        return this.printOperand(term);
+      default:
+        return this.printExpression(term);
     }
   }
 
@@ -270,6 +272,10 @@ export class TypeScriptGenerator implements ExpressionVisitor<string>, OperandVi
     return this.printCastOperand(node);
   }
 
+  public visitCollate(node: CollateExpressionNode): string {
+    return this.printCollateOperand(node);
+  }
+
   public visitAliasRef(node: AliasRefNode): string {
     return `aliasRef('${node.name}')`;
   }
@@ -466,6 +472,10 @@ export class TypeScriptGenerator implements ExpressionVisitor<string>, OperandVi
     return `cast(${this.printOperand(node.expression)}, '${typeLiteral}')`;
   }
 
+  private printCollateOperand(node: CollateExpressionNode): string {
+    return `collate(${this.printOperand(node.expression)}, '${node.collation}')`;
+  }
+
   /**
    * Converts method chain lines to inline format
    * @param lines - Method chain lines

package/src/core/ast/aggregate-functions.ts

@@ -84,3 +84,17 @@ export const groupConcat = (
   orderBy: options?.orderBy?.map(toOrderByNode),
   separator: options?.separator !== undefined ? valueToOperand(options.separator) : undefined
 });
+
+/**
+ * Creates a STDDEV function expression
+ * @param col - Column to calculate standard deviation for
+ * @returns Function node with STDDEV
+ */
+export const stddev = buildAggregate('STDDEV');
+
+/**
+ * Creates a VARIANCE function expression
+ * @param col - Column to calculate variance for
+ * @returns Function node with VARIANCE
+ */
+export const variance = buildAggregate('VARIANCE');

package/src/core/ast/builders.ts

@@ -74,26 +74,44 @@ export const createTableNode = (table: TableRef): TableNode => ({
 /**
  * Creates a FunctionTable node for expressions like `function_name(args...)` used in FROM
  */
-export const fnTable = (
-  name: string,
-  args: OperandNode[] = [],
-  alias?: string,
-  opts?: { lateral?: boolean; withOrdinality?: boolean; columnAliases?: string[]; schema?: string }
-): FunctionTableNode => ({
-  type: 'FunctionTable',
-  name,
-  args,
-  alias,
-  lateral: opts?.lateral,
-  withOrdinality: opts?.withOrdinality,
-  columnAliases: opts?.columnAliases,
-  schema: opts?.schema
-});
-
-/**
- * Creates a derived table node wrapping a subquery.
- */
-export const derivedTable = (
+export const fnTable = (
+  name: string,
+  args: OperandNode[] = [],
+  alias?: string,
+  opts?: { lateral?: boolean; withOrdinality?: boolean; columnAliases?: string[]; schema?: string }
+): FunctionTableNode => ({
+  type: 'FunctionTable',
+  name,
+  args,
+  alias,
+  lateral: opts?.lateral,
+  withOrdinality: opts?.withOrdinality,
+  columnAliases: opts?.columnAliases,
+  schema: opts?.schema
+});
+
+// Dialect-aware table function (portable intent key, not a real SQL function name).
+export const tvf = (
+  key: string,
+  args: OperandNode[] = [],
+  alias?: string,
+  opts?: { lateral?: boolean; withOrdinality?: boolean; columnAliases?: string[]; schema?: string }
+): FunctionTableNode => ({
+  type: 'FunctionTable',
+  key,
+  name: key,
+  args,
+  alias,
+  lateral: opts?.lateral,
+  withOrdinality: opts?.withOrdinality,
+  columnAliases: opts?.columnAliases,
+  schema: opts?.schema
+});
+
+/**
+ * Creates a derived table node wrapping a subquery.
+ */
+export const derivedTable = (
   query: import('./query.js').SelectQueryNode,
   alias: string,
   columnAliases?: string[]

package/src/core/ast/expression-builders.ts

@@ -1,5 +1,5 @@
 import { SelectQueryNode } from './query.js';
-import { SqlOperator } from '../sql/sql.js';
+import { SqlOperator, BitwiseOperator } from '../sql/sql.js';
 import { ColumnRef } from './types.js';
 import {
   ColumnNode,
@@ -19,7 +19,9 @@ import {
   BetweenExpressionNode,
   isOperandNode,
   AliasRefNode,
-  ArithmeticExpressionNode
+  ArithmeticExpressionNode,
+  BitwiseExpressionNode,
+  CollateExpressionNode
 } from './expression-nodes.js';
 
 export type LiteralValue = LiteralNode['value'];
@@ -378,6 +380,57 @@ export const div = (
   right: OperandNode | ColumnRef | string | number
 ): ArithmeticExpressionNode => createArithmeticExpression('/', left, right);
 
+const createBitwiseExpression = (
+  operator: BitwiseOperator,
+  left: OperandNode | ColumnRef,
+  right: OperandNode | ColumnRef | string | number
+): BitwiseExpressionNode => ({
+  type: 'BitwiseExpression',
+  left: toOperand(left),
+  operator,
+  right: toOperand(right)
+});
+
+/**
+ * Creates a bitwise AND expression (left & right)
+ */
+export const bitAnd = (
+  left: OperandNode | ColumnRef,
+  right: OperandNode | ColumnRef | string | number
+): BitwiseExpressionNode => createBitwiseExpression('&', left, right);
+
+/**
+ * Creates a bitwise OR expression (left | right)
+ */
+export const bitOr = (
+  left: OperandNode | ColumnRef,
+  right: OperandNode | ColumnRef | string | number
+): BitwiseExpressionNode => createBitwiseExpression('|', left, right);
+
+/**
+ * Creates a bitwise XOR expression (left ^ right)
+ */
+export const bitXor = (
+  left: OperandNode | ColumnRef,
+  right: OperandNode | ColumnRef | string | number
+): BitwiseExpressionNode => createBitwiseExpression('^', left, right);
+
+/**
+ * Creates a bitwise shift left expression (left << right)
+ */
+export const shiftLeft = (
+  left: OperandNode | ColumnRef,
+  right: OperandNode | ColumnRef | string | number
+): BitwiseExpressionNode => createBitwiseExpression('<<', left, right);
+
+/**
+ * Creates a bitwise shift right expression (left >> right)
+ */
+export const shiftRight = (
+  left: OperandNode | ColumnRef,
+  right: OperandNode | ColumnRef | string | number
+): BitwiseExpressionNode => createBitwiseExpression('>>', left, right);
+
 /**
  * Creates a JSON path expression
  * @param col - Source column
@@ -441,3 +494,18 @@ export const notExists = (subquery: SelectQueryNode): ExistsExpressionNode => ({
   operator: 'NOT EXISTS',
   subquery
 });
+
+/**
+ * Creates a COLLATE expression (expression COLLATE collationName)
+ * @param expression - Expression to be collated
+ * @param collation - Collation name
+ * @returns COLLATE expression node
+ */
+export const collate = (
+  expression: OperandNode | ColumnRef | string | number | boolean | null,
+  collation: string
+): CollateExpressionNode => ({
+  type: 'Collate',
+  expression: toOperand(expression),
+  collation
+});