metal-orm 1.0.13 → 1.0.15

package/src/core/dialect/base/sql-dialect.ts

@@ -1,204 +1,181 @@
-import { CompilerContext, Dialect } from '../abstract.js';
-import { SelectQueryNode, InsertQueryNode, UpdateQueryNode, DeleteQueryNode } from '../../ast/query.js';
-import { ColumnNode } from '../../ast/expression.js';
-
-/**
- * Shared SQL compiler for dialects with standard LIMIT/OFFSET pagination.
- * Concrete dialects override only the minimal hooks (identifier quoting,
- * JSON path, placeholders, RETURNING support) instead of re-implementing
- * the entire compile pipeline.
- */
-export abstract class SqlDialectBase extends Dialect {
-  /**
-   * Quotes an identifier (dialect-specific).
-   */
-  abstract quoteIdentifier(id: string): string;
-
-  /**
-   * Compiles SELECT query AST to SQL using common rules.
-   */
-  protected compileSelectAst(ast: SelectQueryNode, ctx: CompilerContext): string {
-    const hasSetOps = !!(ast.setOps && ast.setOps.length);
-    const ctes = this.compileCtes(ast, ctx);
-
-    // When set operations exist, omit ORDER BY/OFFSET/LIMIT from the operands and apply at the end.
-    const baseAst: SelectQueryNode = hasSetOps
-      ? { ...ast, setOps: undefined, orderBy: undefined, limit: undefined, offset: undefined }
-      : ast;
-
-    const baseSelect = this.compileSelectCore(baseAst, ctx);
-
-    if (!hasSetOps) {
-      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 pagination = this.compilePagination(ast, orderBy);
-
-    const combined = `${this.wrapSetOperand(baseSelect)} ${compound}`;
-    return `${ctes}${combined}${orderBy}${pagination}`;
-  }
-
-  protected compileInsertAst(ast: InsertQueryNode, ctx: CompilerContext): string {
-    const table = this.compileTableName(ast.into);
-    const columnList = ast.columns
-      .map(column => `${this.quoteIdentifier(column.table)}.${this.quoteIdentifier(column.name)}`)
-      .join(', ');
-    const values = ast.values.map(row => `(${row.map(value => this.compileOperand(value, ctx)).join(', ')})`).join(', ');
-    const returning = this.compileReturning(ast.returning, ctx);
-    return `INSERT INTO ${table} (${columnList}) VALUES ${values}${returning}`;
-  }
-
-  /**
-   * Compiles a single SELECT (no set operations, no CTE prefix).
-   */
-  private compileSelectCore(ast: SelectQueryNode, ctx: CompilerContext): string {
-    const columns = this.compileSelectColumns(ast, ctx);
-    const from = this.compileFrom(ast.from);
-    const joins = this.compileJoins(ast, ctx);
-    const whereClause = this.compileWhere(ast.where, ctx);
-    const groupBy = this.compileGroupBy(ast);
-    const having = this.compileHaving(ast, ctx);
-    const orderBy = this.compileOrderBy(ast);
-    const pagination = this.compilePagination(ast, orderBy);
-
-    return `SELECT ${this.compileDistinct(ast)}${columns} FROM ${from}${joins}${whereClause}${groupBy}${having}${orderBy}${pagination}`;
-  }
-
-  protected compileUpdateAst(ast: UpdateQueryNode, ctx: CompilerContext): string {
-    const table = this.compileTableName(ast.table);
-    const assignments = ast.set.map(assignment => {
-      const col = assignment.column;
-      const target = `${this.quoteIdentifier(col.table)}.${this.quoteIdentifier(col.name)}`;
-      const value = this.compileOperand(assignment.value, ctx);
-      return `${target} = ${value}`;
-    }).join(', ');
-    const whereClause = this.compileWhere(ast.where, ctx);
-    const returning = this.compileReturning(ast.returning, ctx);
-    return `UPDATE ${table} SET ${assignments}${whereClause}${returning}`;
-  }
-
-  protected compileDeleteAst(ast: DeleteQueryNode, ctx: CompilerContext): string {
-    const table = this.compileTableName(ast.from);
-    const whereClause = this.compileWhere(ast.where, ctx);
-    const returning = this.compileReturning(ast.returning, ctx);
-    return `DELETE FROM ${table}${whereClause}${returning}`;
-  }
-
-  /**
-   * Default RETURNING compilation: no support.
-   */
-  protected compileReturning(returning: ColumnNode[] | undefined, _ctx: CompilerContext): string {
-    if (!returning || returning.length === 0) return '';
-    throw new Error('RETURNING is not supported by this dialect.');
-  }
-
-  protected formatReturningColumns(returning: ColumnNode[]): string {
-    return returning
-      .map(column => {
-        const tablePart = column.table ? `${this.quoteIdentifier(column.table)}.` : '';
-        const aliasPart = column.alias ? ` AS ${this.quoteIdentifier(column.alias)}` : '';
-        return `${tablePart}${this.quoteIdentifier(column.name)}${aliasPart}`;
-      })
-      .join(', ');
-  }
-
-  /**
-   * DISTINCT clause. Override for DISTINCT ON support.
-   */
-  protected compileDistinct(ast: SelectQueryNode): string {
-    return ast.distinct ? 'DISTINCT ' : '';
-  }
-
-  protected compileSelectColumns(ast: SelectQueryNode, ctx: CompilerContext): string {
-    return ast.columns.map(c => {
-      const expr = this.compileOperand(c, ctx);
-      if (c.alias) {
-        if (c.alias.includes('(')) return c.alias;
-        return `${expr} AS ${this.quoteIdentifier(c.alias)}`;
-      }
-      return expr;
-    }).join(', ');
-  }
-
-  protected compileFrom(ast: SelectQueryNode['from']): string {
-    const base = this.compileTableName(ast);
-    return ast.alias ? `${base} AS ${this.quoteIdentifier(ast.alias)}` : base;
-  }
-
-  protected compileTableName(table: { name: string; schema?: string }): string {
-    if (table.schema) {
-      return `${this.quoteIdentifier(table.schema)}.${this.quoteIdentifier(table.name)}`;
-    }
-    return this.quoteIdentifier(table.name);
-  }
-
-  protected compileJoins(ast: SelectQueryNode, ctx: CompilerContext): string {
-    if (!ast.joins || ast.joins.length === 0) return '';
-    const parts = ast.joins.map(j => {
-      const table = this.compileFrom(j.table);
-      const cond = this.compileExpression(j.condition, ctx);
-      return `${j.kind} JOIN ${table} ON ${cond}`;
-    });
-    return ` ${parts.join(' ')}`;
-  }
-
-  protected compileGroupBy(ast: SelectQueryNode): string {
-    if (!ast.groupBy || ast.groupBy.length === 0) return '';
-    const cols = ast.groupBy
-      .map(c => `${this.quoteIdentifier(c.table)}.${this.quoteIdentifier(c.name)}`)
-      .join(', ');
-    return ` GROUP BY ${cols}`;
-  }
-
-  protected compileHaving(ast: SelectQueryNode, ctx: CompilerContext): string {
-    if (!ast.having) return '';
-    return ` HAVING ${this.compileExpression(ast.having, ctx)}`;
-  }
-
-  protected compileOrderBy(ast: SelectQueryNode): string {
-    if (!ast.orderBy || ast.orderBy.length === 0) return '';
-    const parts = ast.orderBy
-      .map(o => `${this.quoteIdentifier(o.column.table)}.${this.quoteIdentifier(o.column.name)} ${o.direction}`)
-      .join(', ');
-    return ` ORDER BY ${parts}`;
-  }
-
-  /**
-   * Default LIMIT/OFFSET pagination clause.
-   */
-  protected compilePagination(ast: SelectQueryNode, _orderByClause: string): string {
-    const parts: string[] = [];
-    if (ast.limit !== undefined) parts.push(`LIMIT ${ast.limit}`);
-    if (ast.offset !== undefined) parts.push(`OFFSET ${ast.offset}`);
-    return parts.length ? ` ${parts.join(' ')}` : '';
-  }
-
-  protected compileCtes(ast: SelectQueryNode, ctx: CompilerContext): string {
-    if (!ast.ctes || ast.ctes.length === 0) return '';
-    const hasRecursive = ast.ctes.some(cte => cte.recursive);
-    const prefix = hasRecursive ? 'WITH RECURSIVE ' : 'WITH ';
-    const cteDefs = ast.ctes.map(cte => {
-      const name = this.quoteIdentifier(cte.name);
-      const cols = cte.columns && cte.columns.length
-        ? `(${cte.columns.map(c => this.quoteIdentifier(c)).join(', ')})`
-        : '';
-      const query = this.stripTrailingSemicolon(this.compileSelectAst(this.normalizeSelectAst(cte.query), ctx));
-      return `${name}${cols} AS (${query})`;
-    }).join(', ');
-    return `${prefix}${cteDefs} `;
-  }
-
-  protected stripTrailingSemicolon(sql: string): string {
-    return sql.trim().replace(/;$/, '');
-  }
-
-  protected wrapSetOperand(sql: string): string {
-    const trimmed = this.stripTrailingSemicolon(sql);
-    return `(${trimmed})`;
-  }
-}
+import { CompilerContext, Dialect } from '../abstract.js';
+import { SelectQueryNode, InsertQueryNode, UpdateQueryNode, DeleteQueryNode } from '../../ast/query.js';
+import { ColumnNode } from '../../ast/expression.js';
+import { FunctionTableFormatter, FunctionTableNode } from './function-table-formatter.js';
+import { PaginationStrategy, StandardLimitOffsetPagination } from './pagination-strategy.js';
+import { CteCompiler } from './cte-compiler.js';
+import { ReturningStrategy, NoReturningStrategy } from './returning-strategy.js';
+import { JoinCompiler } from './join-compiler.js';
+import { GroupByCompiler } from './groupby-compiler.js';
+import { OrderByCompiler } from './orderby-compiler.js';
+
+
+export abstract class SqlDialectBase extends Dialect {
+  abstract quoteIdentifier(id: string): string;
+
+  protected paginationStrategy: PaginationStrategy = new StandardLimitOffsetPagination();
+  protected returningStrategy: ReturningStrategy = new NoReturningStrategy();
+
+  protected compileSelectAst(ast: SelectQueryNode, ctx: CompilerContext): string {
+    const hasSetOps = !!(ast.setOps && ast.setOps.length);
+    const ctes = CteCompiler.compileCtes(
+      ast,
+      ctx,
+      this.quoteIdentifier.bind(this),
+      this.compileSelectAst.bind(this),
+      this.normalizeSelectAst?.bind(this) ?? ((a) => a),
+      this.stripTrailingSemicolon.bind(this)
+    );
+    const baseAst: SelectQueryNode = hasSetOps
+      ? { ...ast, setOps: undefined, orderBy: undefined, limit: undefined, offset: undefined }
+      : ast;
+    const baseSelect = this.compileSelectCore(baseAst, ctx);
+    if (!hasSetOps) {
+      return `${ctes}${baseSelect}`;
+    }
+    return this.compileSelectWithSetOps(ast, baseSelect, ctes, ctx);
+  }
+
+  private compileSelectWithSetOps(
+    ast: SelectQueryNode,
+    baseSelect: string,
+    ctes: string,
+    ctx: CompilerContext
+  ): string {
+    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 pagination = this.paginationStrategy.compilePagination(ast.limit, ast.offset);
+    const combined = `${this.wrapSetOperand(baseSelect)} ${compound}`;
+    return `${ctes}${combined}${orderBy}${pagination}`;
+  }
+
+  protected compileInsertAst(ast: InsertQueryNode, ctx: CompilerContext): string {
+    const table = this.compileTableName(ast.into);
+    const columnList = this.compileInsertColumnList(ast.columns);
+    const values = this.compileInsertValues(ast.values, ctx);
+    const returning = this.compileReturning(ast.returning, ctx);
+    return `INSERT INTO ${table} (${columnList}) VALUES ${values}${returning}`;
+  }
+
+  protected compileReturning(returning: ColumnNode[] | undefined, ctx: CompilerContext): string {
+    return this.returningStrategy.compileReturning(returning, ctx);
+  }
+
+  private compileInsertColumnList(columns: ColumnNode[]): string {
+    return columns
+      .map(column => `${this.quoteIdentifier(column.table)}.${this.quoteIdentifier(column.name)}`)
+      .join(', ');
+  }
+
+  private compileInsertValues(values: any[][], ctx: CompilerContext): string {
+    return values
+      .map(row => `(${row.map(value => this.compileOperand(value, ctx)).join(', ')})`)
+      .join(', ');
+  }
+
+  private compileSelectCore(ast: SelectQueryNode, ctx: CompilerContext): string {
+    const columns = this.compileSelectColumns(ast, ctx);
+    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 having = this.compileHaving(ast, ctx);
+    const orderBy = OrderByCompiler.compileOrderBy(ast, this.quoteIdentifier.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}`;
+  }
+
+  protected compileUpdateAst(ast: UpdateQueryNode, ctx: CompilerContext): string {
+    const table = this.compileTableName(ast.table);
+    const assignments = this.compileUpdateAssignments(ast.set, ctx);
+    const whereClause = this.compileWhere(ast.where, ctx);
+    const returning = this.compileReturning(ast.returning, ctx);
+    return `UPDATE ${table} SET ${assignments}${whereClause}${returning}`;
+  }
+
+  private compileUpdateAssignments(
+    assignments: { column: ColumnNode; value: any }[],
+    ctx: CompilerContext
+  ): string {
+    return assignments
+      .map(assignment => {
+        const col = assignment.column;
+        const target = `${this.quoteIdentifier(col.table)}.${this.quoteIdentifier(col.name)}`;
+        const value = this.compileOperand(assignment.value, ctx);
+        return `${target} = ${value}`;
+      })
+      .join(', ');
+  }
+
+  protected compileDeleteAst(ast: DeleteQueryNode, ctx: CompilerContext): string {
+    const table = this.compileTableName(ast.from);
+    const whereClause = this.compileWhere(ast.where, ctx);
+    const returning = this.compileReturning(ast.returning, ctx);
+    return `DELETE FROM ${table}${whereClause}${returning}`;
+  }
+
+  protected formatReturningColumns(returning: ColumnNode[]): string {
+    return this.returningStrategy.formatReturningColumns(returning, this.quoteIdentifier.bind(this));
+  }
+
+  protected compileDistinct(ast: SelectQueryNode): string {
+    return ast.distinct ? 'DISTINCT ' : '';
+  }
+
+  protected compileSelectColumns(ast: SelectQueryNode, ctx: CompilerContext): string {
+    return ast.columns.map(c => {
+      const expr = this.compileOperand(c, ctx);
+      if (c.alias) {
+        if (c.alias.includes('(')) return c.alias;
+        return `${expr} AS ${this.quoteIdentifier(c.alias)}`;
+      }
+      return expr;
+    }).join(', ');
+  }
+
+  protected compileFrom(ast: SelectQueryNode['from'], ctx?: CompilerContext): string {
+    const tableSource = ast as any;
+    if (tableSource.type === 'FunctionTable') {
+      return this.compileFunctionTable(tableSource, ctx);
+    }
+    return this.compileTableSource(tableSource);
+  }
+
+  protected compileFunctionTable(fn: FunctionTableNode, ctx?: CompilerContext): string {
+    return FunctionTableFormatter.format(fn, ctx, this);
+  }
+
+  protected compileTableSource(table: TableSourceNode): string {
+    const base = this.compileTableName(table);
+    return table.alias ? `${base} AS ${this.quoteIdentifier(table.alias)}` : base;
+  }
+
+  protected compileTableName(table: { name: string; schema?: string }): string {
+    if (table.schema) {
+      return `${this.quoteIdentifier(table.schema)}.${this.quoteIdentifier(table.name)}`;
+    }
+    return this.quoteIdentifier(table.name);
+  }
+
+  protected compileHaving(ast: SelectQueryNode, ctx: CompilerContext): string {
+    if (!ast.having) return '';
+    return ` HAVING ${this.compileExpression(ast.having, ctx)}`;
+  }
+
+  protected stripTrailingSemicolon(sql: string): string {
+    return sql.trim().replace(/;$/, '');
+  }
+
+  protected wrapSetOperand(sql: string): string {
+    const trimmed = this.stripTrailingSemicolon(sql);
+    return `(${trimmed})`;
+  }
+}
+
+interface TableSourceNode {
+  name: string;
+  schema?: string;
+  alias?: string;
+}

package/src/core/dialect/dialect-factory.ts

@@ -0,0 +1,91 @@
+// Dialect factory for the SQL DSL.
+// Centralizes how we go from a symbolic name ("sqlite") to a concrete Dialect instance.
+
+import { Dialect } from './abstract.js';
+import { PostgresDialect } from './postgres/index.js';
+import { MySqlDialect } from './mysql/index.js';
+import { SqliteDialect } from './sqlite/index.js';
+import { SqlServerDialect } from './mssql/index.js';
+
+export type DialectKey =
+  | 'postgres'
+  | 'mysql'
+  | 'sqlite'
+  | 'mssql'
+  | (string & {}); // allow user-defined keys without constraining too much
+
+type DialectFactoryFn = () => Dialect;
+
+export class DialectFactory {
+  private static registry = new Map<DialectKey, DialectFactoryFn>();
+  private static defaultsInitialized = false;
+
+  private static ensureDefaults(): void {
+    if (this.defaultsInitialized) return;
+    this.defaultsInitialized = true;
+
+    // Register built-in dialects only if no override exists yet.
+    if (!this.registry.has('postgres')) {
+      this.registry.set('postgres', () => new PostgresDialect());
+    }
+    if (!this.registry.has('mysql')) {
+      this.registry.set('mysql', () => new MySqlDialect());
+    }
+    if (!this.registry.has('sqlite')) {
+      this.registry.set('sqlite', () => new SqliteDialect());
+    }
+    if (!this.registry.has('mssql')) {
+      this.registry.set('mssql', () => new SqlServerDialect());
+    }
+  }
+
+  /**
+   * Register (or override) a dialect factory for a key.
+   *
+   * Examples:
+   *   DialectFactory.register('sqlite', () => new SqliteDialect());
+   *   DialectFactory.register('my-tenant-dialect', () => new CustomDialect());
+   */
+  public static register(key: DialectKey, factory: DialectFactoryFn): void {
+    this.registry.set(key, factory);
+  }
+
+  /**
+   * Resolve a key into a Dialect instance.
+   * Throws if the key is not registered.
+   */
+  public static create(key: DialectKey): Dialect {
+    this.ensureDefaults();
+    const factory = this.registry.get(key);
+    if (!factory) {
+      throw new Error(
+        `Dialect "${String(
+          key
+        )}" is not registered. Use DialectFactory.register(...) to register it.`
+      );
+    }
+    return factory();
+  }
+
+  /**
+   * Clear all registrations (mainly for tests).
+   * Built-ins will be re-registered lazily on the next create().
+   */
+  public static clear(): void {
+    this.registry.clear();
+    this.defaultsInitialized = false;
+  }
+}
+
+/**
+ * Helper to normalize either a Dialect instance OR a key into a Dialect instance.
+ * This is what query builders will use.
+ */
+export const resolveDialectInput = (
+  dialect: Dialect | DialectKey
+): Dialect => {
+  if (typeof dialect === 'string') {
+    return DialectFactory.create(dialect);
+  }
+  return dialect;
+};

package/src/core/dialect/mssql/functions.ts

@@ -0,0 +1,101 @@
+import { StandardFunctionStrategy } from '../../functions/standard-strategy.js';
+import { FunctionRenderContext } from '../../functions/types.js';
+import { LiteralNode } from '../../ast/expression.js';
+
+export class MssqlFunctionStrategy extends StandardFunctionStrategy {
+    constructor() {
+        super();
+        this.registerOverrides();
+    }
+
+    private registerOverrides() {
+        // Override Standard/Abstract definitions with MSSQL specifics
+
+        // Date/Time functions
+        this.add('NOW', () => `GETDATE()`);
+        this.add('CURRENT_DATE', () => `CAST(GETDATE() AS DATE)`);
+        this.add('CURRENT_TIME', () => `CAST(GETDATE() AS TIME)`);
+        this.add('UTC_NOW', () => `GETUTCDATE()`);
+
+        this.add('EXTRACT', ({ compiledArgs }) => {
+            if (compiledArgs.length !== 2) throw new Error('EXTRACT expects 2 arguments (part, date)');
+            const [part, date] = compiledArgs;
+            const partClean = part.replace(/['"]/g, '').toLowerCase();
+            return `DATEPART(${partClean}, ${date})`;
+        });
+
+        this.add('YEAR', ({ compiledArgs }) => {
+            if (compiledArgs.length !== 1) throw new Error('YEAR expects 1 argument');
+            return `YEAR(${compiledArgs[0]})`;
+        });
+
+        this.add('MONTH', ({ compiledArgs }) => {
+            if (compiledArgs.length !== 1) throw new Error('MONTH expects 1 argument');
+            return `MONTH(${compiledArgs[0]})`;
+        });
+
+        this.add('DAY', ({ compiledArgs }) => {
+            if (compiledArgs.length !== 1) throw new Error('DAY expects 1 argument');
+            return `DAY(${compiledArgs[0]})`;
+        });
+
+        this.add('DATE_ADD', ({ node, compiledArgs }) => {
+            if (compiledArgs.length !== 3) throw new Error('DATE_ADD expects 3 arguments (date, interval, unit)');
+            const [date, interval] = compiledArgs;
+            const unitArg = node.args[2] as LiteralNode;
+            const unitClean = String(unitArg.value).replace(/['"]/g, '').toLowerCase();
+            return `DATEADD(${unitClean}, ${interval}, ${date})`;
+        });
+
+        this.add('DATE_SUB', ({ node, compiledArgs }) => {
+            if (compiledArgs.length !== 3) throw new Error('DATE_SUB expects 3 arguments (date, interval, unit)');
+            const [date, interval] = compiledArgs;
+            const unitArg = node.args[2] as LiteralNode;
+            const unitClean = String(unitArg.value).replace(/['"]/g, '').toLowerCase();
+            return `DATEADD(${unitClean}, -${interval}, ${date})`;
+        });
+
+        this.add('DATE_DIFF', ({ compiledArgs }) => {
+            if (compiledArgs.length !== 2) throw new Error('DATE_DIFF expects 2 arguments');
+            const [date1, date2] = compiledArgs;
+            return `DATEDIFF(day, ${date2}, ${date1})`;
+        });
+
+        this.add('DATE_FORMAT', ({ compiledArgs }) => {
+            if (compiledArgs.length !== 2) throw new Error('DATE_FORMAT expects 2 arguments');
+            const [date, format] = compiledArgs;
+            return `FORMAT(${date}, ${format})`;
+        });
+
+        this.add('UNIX_TIMESTAMP', () => `DATEDIFF(SECOND, '1970-01-01', GETUTCDATE())`);
+
+        this.add('FROM_UNIXTIME', ({ compiledArgs }) => {
+            if (compiledArgs.length !== 1) throw new Error('FROM_UNIXTIME expects 1 argument');
+            return `DATEADD(SECOND, ${compiledArgs[0]}, '1970-01-01')`;
+        });
+
+        this.add('END_OF_MONTH', ({ compiledArgs }) => {
+            if (compiledArgs.length !== 1) throw new Error('END_OF_MONTH expects 1 argument');
+            return `EOMONTH(${compiledArgs[0]})`;
+        });
+
+        this.add('DAY_OF_WEEK', ({ compiledArgs }) => {
+            if (compiledArgs.length !== 1) throw new Error('DAY_OF_WEEK expects 1 argument');
+            return `DATEPART(dw, ${compiledArgs[0]})`;
+        });
+
+        this.add('WEEK_OF_YEAR', ({ compiledArgs }) => {
+            if (compiledArgs.length !== 1) throw new Error('WEEK_OF_YEAR expects 1 argument');
+            return `DATEPART(wk, ${compiledArgs[0]})`;
+        });
+
+        this.add('DATE_TRUNC', ({ node, compiledArgs }) => {
+            if (compiledArgs.length !== 2) throw new Error('DATE_TRUNC expects 2 arguments (part, date)');
+            const [, date] = compiledArgs;
+            const partArg = node.args[0] as LiteralNode;
+            const partClean = String(partArg.value).replace(/['"]/g, '').toLowerCase();
+            // SQL Server 2022+ has DATETRUNC
+            return `DATETRUNC(${partClean}, ${date})`;
+        });
+    }
+}