metal-orm 1.1.3 → 1.1.4

package/src/core/dialect/mysql/index.ts

@@ -1,6 +1,12 @@
-import { JsonPathNode } from '../../ast/expression.js';
-import { SqlDialectBase } from '../base/sql-dialect.js';
-import { MysqlFunctionStrategy } from './functions.js';
+import { CompilerContext, CompiledProcedureCall } from '../abstract.js';
+import { JsonPathNode } from '../../ast/expression.js';
+import { InsertQueryNode } from '../../ast/query.js';
+import { SqlDialectBase } from '../base/sql-dialect.js';
+import { MysqlFunctionStrategy } from './functions.js';
+import { ProcedureCallNode } from '../../ast/procedure.js';
+
+const sanitizeVariableSuffix = (value: string): string =>
+  value.replace(/[^a-zA-Z0-9_]/g, '_');
 
 /**
  * MySQL dialect implementation
@@ -28,9 +34,95 @@ export class MySqlDialect extends SqlDialectBase {
    * @param node - JSON path node
    * @returns MySQL JSON path expression
    */
-  protected compileJsonPath(node: JsonPathNode): string {
-    const col = `${this.quoteIdentifier(node.column.table)}.${this.quoteIdentifier(node.column.name)}`;
-    // MySQL 5.7+ uses col->'$.path'
-    return `${col}->'${node.path}'`;
+  protected compileJsonPath(node: JsonPathNode): string {
+    const col = `${this.quoteIdentifier(node.column.table)}.${this.quoteIdentifier(node.column.name)}`;
+    // MySQL 5.7+ uses col->'$.path'
+    return `${col}->'${node.path}'`;
+  }
+
+  protected compileUpsertClause(ast: InsertQueryNode, ctx: CompilerContext): string {
+    if (!ast.onConflict) return '';
+
+    const clause = ast.onConflict;
+    if (clause.action.type === 'DoNothing') {
+      const noOpColumn = clause.target.columns[0] ?? ast.columns[0];
+      if (!noOpColumn) {
+        throw new Error('MySQL ON DUPLICATE KEY UPDATE requires at least one target column.');
+      }
+      const col = this.quoteIdentifier(noOpColumn.name);
+      return ` ON DUPLICATE KEY UPDATE ${col} = ${col}`;
+    }
+
+    if (clause.action.where) {
+      throw new Error('MySQL ON DUPLICATE KEY UPDATE does not support a WHERE clause.');
+    }
+    if (!clause.action.set.length) {
+      throw new Error('MySQL ON DUPLICATE KEY UPDATE requires at least one assignment.');
+    }
+
+    const assignments = clause.action.set
+      .map(assignment => {
+        const target = this.quoteIdentifier(assignment.column.name);
+        const value = this.compileOperand(assignment.value, ctx);
+        return `${target} = ${value}`;
+      })
+      .join(', ');
+    return ` ON DUPLICATE KEY UPDATE ${assignments}`;
+  }
+
+  compileProcedureCall(ast: ProcedureCallNode): CompiledProcedureCall {
+    const ctx = this.createCompilerContext();
+    const qualifiedName = ast.ref.schema
+      ? `${this.quoteIdentifier(ast.ref.schema)}.${this.quoteIdentifier(ast.ref.name)}`
+      : this.quoteIdentifier(ast.ref.name);
+
+    const prelude: string[] = [];
+    const callArgs: string[] = [];
+    const outVars: Array<{ variable: string; name: string }> = [];
+
+    ast.params.forEach((param, index) => {
+      const suffix = sanitizeVariableSuffix(param.name || `p${index + 1}`);
+      const variable = `@__metal_${suffix}_${index + 1}`;
+
+      if (param.direction === 'in') {
+        if (!param.value) {
+          throw new Error(`Procedure parameter "${param.name}" requires a value for direction "in".`);
+        }
+        callArgs.push(this.compileOperand(param.value, ctx));
+        return;
+      }
+
+      if (param.direction === 'inout') {
+        if (!param.value) {
+          throw new Error(`Procedure parameter "${param.name}" requires a value for direction "inout".`);
+        }
+        prelude.push(`SET ${variable} = ${this.compileOperand(param.value, ctx)};`);
+      }
+
+      callArgs.push(variable);
+      outVars.push({ variable, name: param.name });
+    });
+
+    const statements: string[] = [];
+    if (prelude.length) {
+      statements.push(...prelude);
+    }
+    statements.push(`CALL ${qualifiedName}(${callArgs.join(', ')});`);
+
+    if (outVars.length) {
+      const selectOut = outVars
+        .map(({ variable, name }) => `${variable} AS ${this.quoteIdentifier(name)}`)
+        .join(', ');
+      statements.push(`SELECT ${selectOut};`);
+    }
+
+    return {
+      sql: statements.join(' '),
+      params: [...ctx.params],
+      outParams: {
+        source: outVars.length ? 'lastResultSet' : 'none',
+        names: outVars.map(item => item.name)
+      }
+    };
   }
 }

package/src/core/dialect/postgres/index.ts

@@ -1,58 +1,59 @@
-import { CompilerContext } from '../abstract.js';
+import { CompilerContext, CompiledProcedureCall } from '../abstract.js';
 import { JsonPathNode, ColumnNode, BitwiseExpressionNode } from '../../ast/expression.js';
-import { TableNode } from '../../ast/query.js';
+import { InsertQueryNode, TableNode } from '../../ast/query.js';
 import { SqlDialectBase } from '../base/sql-dialect.js';
 import { PostgresFunctionStrategy } from './functions.js';
 import { PostgresTableFunctionStrategy } from './table-functions.js';
-
-/**
- * PostgreSQL dialect implementation
- */
-export class PostgresDialect extends SqlDialectBase {
-  protected readonly dialect = 'postgres';
-  /**
-   * Creates a new PostgresDialect instance
-   */
-  public constructor() {
-    super(new PostgresFunctionStrategy(), new PostgresTableFunctionStrategy());
-    this.registerExpressionCompiler('BitwiseExpression', (node: BitwiseExpressionNode, ctx) => {
-      const left = this.compileOperand(node.left, ctx);
-      const right = this.compileOperand(node.right, ctx);
-      const op = node.operator === '^' ? '#' : node.operator;
-      return `${left} ${op} ${right}`;
-    });
-    this.registerOperandCompiler('BitwiseExpression', (node: BitwiseExpressionNode, ctx) => {
-      const left = this.compileOperand(node.left, ctx);
-      const right = this.compileOperand(node.right, ctx);
-      const op = node.operator === '^' ? '#' : node.operator;
-      return `(${left} ${op} ${right})`;
-    });
-  }
-
-  /**
-   * Quotes an identifier using PostgreSQL double-quote syntax
-   * @param id - Identifier to quote
-   * @returns Quoted identifier
-   */
-  quoteIdentifier(id: string): string {
-    return `"${id}"`;
-  }
-
-  protected formatPlaceholder(index: number): string {
-    return `$${index}`;
-  }
-
-  /**
-   * Compiles JSON path expression using PostgreSQL syntax
-   * @param node - JSON path node
-   * @returns PostgreSQL JSON path expression
-   */
-  protected compileJsonPath(node: JsonPathNode): string {
-    const col = `${this.quoteIdentifier(node.column.table)}.${this.quoteIdentifier(node.column.name)}`;
-    // Postgres uses col->>'path' for text extraction
-    return `${col}->>'${node.path}'`;
-  }
-
+import { ProcedureCallNode } from '../../ast/procedure.js';
+
+/**
+ * PostgreSQL dialect implementation
+ */
+export class PostgresDialect extends SqlDialectBase {
+  protected readonly dialect = 'postgres';
+  /**
+   * Creates a new PostgresDialect instance
+   */
+  public constructor() {
+    super(new PostgresFunctionStrategy(), new PostgresTableFunctionStrategy());
+    this.registerExpressionCompiler('BitwiseExpression', (node: BitwiseExpressionNode, ctx) => {
+      const left = this.compileOperand(node.left, ctx);
+      const right = this.compileOperand(node.right, ctx);
+      const op = node.operator === '^' ? '#' : node.operator;
+      return `${left} ${op} ${right}`;
+    });
+    this.registerOperandCompiler('BitwiseExpression', (node: BitwiseExpressionNode, ctx) => {
+      const left = this.compileOperand(node.left, ctx);
+      const right = this.compileOperand(node.right, ctx);
+      const op = node.operator === '^' ? '#' : node.operator;
+      return `(${left} ${op} ${right})`;
+    });
+  }
+
+  /**
+   * Quotes an identifier using PostgreSQL double-quote syntax
+   * @param id - Identifier to quote
+   * @returns Quoted identifier
+   */
+  quoteIdentifier(id: string): string {
+    return `"${id}"`;
+  }
+
+  protected formatPlaceholder(index: number): string {
+    return `$${index}`;
+  }
+
+  /**
+   * Compiles JSON path expression using PostgreSQL syntax
+   * @param node - JSON path node
+   * @returns PostgreSQL JSON path expression
+   */
+  protected compileJsonPath(node: JsonPathNode): string {
+    const col = `${this.quoteIdentifier(node.column.table)}.${this.quoteIdentifier(node.column.name)}`;
+    // Postgres uses col->>'path' for text extraction
+    return `${col}->>'${node.path}'`;
+  }
+
   protected compileReturning(returning: ColumnNode[] | undefined, ctx: CompilerContext): string {
     void ctx;
     if (!returning || returning.length === 0) return '';
@@ -60,14 +61,74 @@ export class PostgresDialect extends SqlDialectBase {
     return ` RETURNING ${columns}`;
   }
 
-  supportsDmlReturningClause(): boolean {
-    return true;
-  }
+  protected compileUpsertClause(ast: InsertQueryNode, ctx: CompilerContext): string {
+    if (!ast.onConflict) return '';
+
+    const clause = ast.onConflict;
+    const target = clause.target.constraint
+      ? ` ON CONFLICT ON CONSTRAINT ${this.quoteIdentifier(clause.target.constraint)}`
+      : (() => {
+          this.ensureConflictColumns(
+            clause,
+            'PostgreSQL ON CONFLICT requires conflict columns or a constraint name.'
+          );
+          const cols = clause.target.columns.map(col => this.quoteIdentifier(col.name)).join(', ');
+          return ` ON CONFLICT (${cols})`;
+        })();
+
+    if (clause.action.type === 'DoNothing') {
+      return `${target} DO NOTHING`;
+    }
+
+    if (!clause.action.set.length) {
+      throw new Error('PostgreSQL ON CONFLICT DO UPDATE requires at least one assignment.');
+    }
 
-  /**
-   * PostgreSQL requires unqualified column names in SET clause
-   */
-  protected compileSetTarget(column: ColumnNode, _table: TableNode): string {
-    return this.quoteIdentifier(column.name);
+    const assignments = this.compileUpdateAssignments(clause.action.set, ast.into, ctx);
+    const where = clause.action.where
+      ? ` WHERE ${this.compileExpression(clause.action.where, ctx)}`
+      : '';
+    return `${target} DO UPDATE SET ${assignments}${where}`;
   }
-}
+
+  supportsDmlReturningClause(): boolean {
+    return true;
+  }
+
+  compileProcedureCall(ast: ProcedureCallNode): CompiledProcedureCall {
+    const ctx = this.createCompilerContext();
+    const qualifiedName = ast.ref.schema
+      ? `${this.quoteIdentifier(ast.ref.schema)}.${this.quoteIdentifier(ast.ref.name)}`
+      : this.quoteIdentifier(ast.ref.name);
+
+    const args: string[] = [];
+    for (const param of ast.params) {
+      if (param.direction === 'out') continue;
+      if (!param.value) {
+        throw new Error(`Procedure parameter "${param.name}" requires a value for direction "${param.direction}".`);
+      }
+      args.push(this.compileOperand(param.value, ctx));
+    }
+
+    const outNames = ast.params
+      .filter(param => param.direction === 'out' || param.direction === 'inout')
+      .map(param => param.name);
+
+    const rawSql = `CALL ${qualifiedName}(${args.join(', ')})`;
+    return {
+      sql: `${rawSql};`,
+      params: [...ctx.params],
+      outParams: {
+        source: outNames.length ? 'firstResultSet' : 'none',
+        names: outNames
+      }
+    };
+  }
+
+  /**
+   * PostgreSQL requires unqualified column names in SET clause
+   */
+  protected compileSetTarget(column: ColumnNode, _table: TableNode): string {
+    return this.quoteIdentifier(column.name);
+  }
+}

package/src/core/dialect/sqlite/index.ts

@@ -1,69 +1,70 @@
-import { CompilerContext } from '../abstract.js';
+import { CompilerContext, CompiledProcedureCall } from '../abstract.js';
 import { JsonPathNode, ColumnNode, BitwiseExpressionNode } from '../../ast/expression.js';
-import { TableNode } from '../../ast/query.js';
+import { InsertQueryNode, TableNode } from '../../ast/query.js';
 import { SqlDialectBase } from '../base/sql-dialect.js';
 import { SqliteFunctionStrategy } from './functions.js';
-
-/**
- * SQLite dialect implementation
- */
-export class SqliteDialect extends SqlDialectBase {
-  protected readonly dialect = 'sqlite';
-  /**
-   * Creates a new SqliteDialect instance
-   */
-  public constructor() {
-    super(new SqliteFunctionStrategy());
-    this.registerExpressionCompiler('BitwiseExpression', (node: BitwiseExpressionNode, ctx) => {
-      const left = this.compileOperand(node.left, ctx);
-      const right = this.compileOperand(node.right, ctx);
-      if (node.operator === '^') {
-        return `(${left} | ${right}) & ~(${left} & ${right})`;
-      }
-      return `${left} ${node.operator} ${right}`;
-    });
-    this.registerOperandCompiler('BitwiseExpression', (node: BitwiseExpressionNode, ctx) => {
-      const left = this.compileOperand(node.left, ctx);
-      const right = this.compileOperand(node.right, ctx);
-      if (node.operator === '^') {
-        return `((${left} | ${right}) & ~(${left} & ${right}))`;
-      }
-      return `(${left} ${node.operator} ${right})`;
-    });
-  }
-
-  /**
-   * Quotes an identifier using SQLite double-quote syntax
-   * @param id - Identifier to quote
-   * @returns Quoted identifier
-   */
-  quoteIdentifier(id: string): string {
-    return `"${id}"`;
-  }
-
-  /**
-   * Compiles JSON path expression using SQLite syntax
-   * @param node - JSON path node
-   * @returns SQLite JSON path expression
-   */
-  protected compileJsonPath(node: JsonPathNode): string {
-    const col = `${this.quoteIdentifier(node.column.table)}.${this.quoteIdentifier(node.column.name)}`;
-    // SQLite uses json_extract(col, '$.path')
-    return `json_extract(${col}, '${node.path}')`;
-  }
-
-  protected compileQualifiedColumn(column: ColumnNode, _table: TableNode): string {
-    void _table;
-    return this.quoteIdentifier(column.name);
-  }
-
-  protected compileReturning(returning: ColumnNode[] | undefined, ctx: CompilerContext): string {
-    void ctx;
-    if (!returning || returning.length === 0) return '';
-    const columns = this.formatReturningColumns(returning);
-    return ` RETURNING ${columns}`;
-  }
-
+import { ProcedureCallNode } from '../../ast/procedure.js';
+
+/**
+ * SQLite dialect implementation
+ */
+export class SqliteDialect extends SqlDialectBase {
+  protected readonly dialect = 'sqlite';
+  /**
+   * Creates a new SqliteDialect instance
+   */
+  public constructor() {
+    super(new SqliteFunctionStrategy());
+    this.registerExpressionCompiler('BitwiseExpression', (node: BitwiseExpressionNode, ctx) => {
+      const left = this.compileOperand(node.left, ctx);
+      const right = this.compileOperand(node.right, ctx);
+      if (node.operator === '^') {
+        return `(${left} | ${right}) & ~(${left} & ${right})`;
+      }
+      return `${left} ${node.operator} ${right}`;
+    });
+    this.registerOperandCompiler('BitwiseExpression', (node: BitwiseExpressionNode, ctx) => {
+      const left = this.compileOperand(node.left, ctx);
+      const right = this.compileOperand(node.right, ctx);
+      if (node.operator === '^') {
+        return `((${left} | ${right}) & ~(${left} & ${right}))`;
+      }
+      return `(${left} ${node.operator} ${right})`;
+    });
+  }
+
+  /**
+   * Quotes an identifier using SQLite double-quote syntax
+   * @param id - Identifier to quote
+   * @returns Quoted identifier
+   */
+  quoteIdentifier(id: string): string {
+    return `"${id}"`;
+  }
+
+  /**
+   * Compiles JSON path expression using SQLite syntax
+   * @param node - JSON path node
+   * @returns SQLite JSON path expression
+   */
+  protected compileJsonPath(node: JsonPathNode): string {
+    const col = `${this.quoteIdentifier(node.column.table)}.${this.quoteIdentifier(node.column.name)}`;
+    // SQLite uses json_extract(col, '$.path')
+    return `json_extract(${col}, '${node.path}')`;
+  }
+
+  protected compileQualifiedColumn(column: ColumnNode, _table: TableNode): string {
+    void _table;
+    return this.quoteIdentifier(column.name);
+  }
+
+  protected compileReturning(returning: ColumnNode[] | undefined, ctx: CompilerContext): string {
+    void ctx;
+    if (!returning || returning.length === 0) return '';
+    const columns = this.formatReturningColumns(returning);
+    return ` RETURNING ${columns}`;
+  }
+
   protected formatReturningColumns(returning: ColumnNode[]): string {
     return returning
       .map(column => {
@@ -73,7 +74,39 @@ export class SqliteDialect extends SqlDialectBase {
       .join(', ');
   }
 
+  protected compileUpsertClause(ast: InsertQueryNode, ctx: CompilerContext): string {
+    if (!ast.onConflict) return '';
+
+    const clause = ast.onConflict;
+    if (clause.target.constraint) {
+      throw new Error('SQLite ON CONFLICT does not support named constraints.');
+    }
+    this.ensureConflictColumns(clause, 'SQLite ON CONFLICT requires conflict columns.');
+
+    const cols = clause.target.columns.map(col => this.quoteIdentifier(col.name)).join(', ');
+    const target = ` ON CONFLICT (${cols})`;
+
+    if (clause.action.type === 'DoNothing') {
+      return `${target} DO NOTHING`;
+    }
+
+    if (!clause.action.set.length) {
+      throw new Error('SQLite ON CONFLICT DO UPDATE requires at least one assignment.');
+    }
+
+    const assignments = this.compileUpdateAssignments(clause.action.set, ast.into, ctx);
+    const where = clause.action.where
+      ? ` WHERE ${this.compileExpression(clause.action.where, ctx)}`
+      : '';
+    return `${target} DO UPDATE SET ${assignments}${where}`;
+  }
+
   supportsDmlReturningClause(): boolean {
     return true;
   }
-}
+
+  compileProcedureCall(_ast: ProcedureCallNode): CompiledProcedureCall {
+    void _ast;
+    throw new Error('Stored procedures are not supported by the SQLite dialect.');
+  }
+}