metal-orm 1.0.118 → 1.1.0

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

@@ -1,9 +1,11 @@
 import { CompilerContext } from '../abstract.js';
 import {
   SelectQueryNode,
+  InsertQueryNode,
+  UpdateQueryNode,
   DeleteQueryNode
 } from '../../ast/query.js';
-import { JsonPathNode } from '../../ast/expression.js';
+import { JsonPathNode, ColumnNode } from '../../ast/expression.js';
 import { MssqlFunctionStrategy } from './functions.js';
 import { OrderByCompiler } from '../base/orderby-compiler.js';
 import { JoinCompiler } from '../base/join-compiler.js';
@@ -99,8 +101,24 @@ export class SqlServerDialect extends SqlDialectBase {
       this.compileExpression.bind(this)
     );
     const whereClause = this.compileWhere(ast.where, ctx);
-    const returning = this.compileReturning(ast.returning, ctx);
-    return `DELETE ${this.quoteIdentifier(alias)} FROM ${target}${joins}${whereClause}${returning}`;
+    const returning = this.compileOutputClause(ast.returning, 'deleted');
+    return `DELETE ${this.quoteIdentifier(alias)}${returning} FROM ${target}${joins}${whereClause}`;
+  }
+
+  protected compileUpdateAst(ast: UpdateQueryNode, ctx: CompilerContext): string {
+    const target = this.compileTableReference(ast.table);
+    const assignments = this.compileUpdateAssignments(ast.set, ast.table, ctx);
+    const output = this.compileReturning(ast.returning, ctx);
+    const fromClause = ast.from ? ` FROM ${this.compileFrom(ast.from, ctx)}` : '';
+    const joins = ast.joins
+      ? ast.joins.map(j => {
+          const table = this.compileFrom(j.table, ctx);
+          const cond = this.compileExpression(j.condition, ctx);
+          return ` ${j.kind} JOIN ${table} ON ${cond}`;
+        }).join('')
+      : '';
+    const whereClause = this.compileWhere(ast.where, ctx);
+    return `UPDATE ${target} SET ${assignments}${output}${fromClause}${joins}${whereClause}`;
   }
 
   private compileSelectCoreForMssql(ast: SelectQueryNode, ctx: CompilerContext): string {
@@ -175,6 +193,53 @@ export class SqlServerDialect extends SqlDialectBase {
     return pagination;
   }
 
+  supportsDmlReturningClause(): boolean {
+    return true;
+  }
+
+  protected compileReturning(returning: ColumnNode[] | undefined, _ctx: CompilerContext): string {
+    void _ctx;
+    return this.compileOutputClause(returning, 'inserted');
+  }
+
+  private compileOutputClause(returning: ColumnNode[] | undefined, prefix: 'inserted' | 'deleted'): string {
+    if (!returning || returning.length === 0) return '';
+    const columns = returning
+      .map(column => {
+        const colName = this.quoteIdentifier(column.name);
+        const alias = column.alias ? ` AS ${this.quoteIdentifier(column.alias)}` : '';
+        return `${prefix}.${colName}${alias}`;
+      })
+      .join(', ');
+    return ` OUTPUT ${columns}`;
+  }
+
+  protected compileInsertAst(ast: InsertQueryNode, ctx: CompilerContext): string {
+    if (!ast.columns.length) {
+      throw new Error('INSERT queries must specify columns.');
+    }
+    const table = this.compileTableName(ast.into);
+    const columnList = ast.columns.map(column => this.quoteIdentifier(column.name)).join(', ');
+    const output = this.compileReturning(ast.returning, ctx);
+    const source = this.compileInsertValues(ast, ctx);
+    return `INSERT INTO ${table} (${columnList})${output} ${source}`;
+  }
+
+  private compileInsertValues(ast: InsertQueryNode, ctx: CompilerContext): string {
+    const source = ast.source;
+    if (source.type === 'InsertValues') {
+      if (!source.rows.length) {
+        throw new Error('INSERT ... VALUES requires at least one row.');
+      }
+      const values = source.rows
+        .map(row => `(${row.map(value => this.compileOperand(value, ctx)).join(', ')})`)
+        .join(', ');
+      return `VALUES ${values}`;
+    }
+    const normalized = this.normalizeSelectAst(source.query);
+    return this.compileSelectAst(normalized, ctx).trim();
+  }
+
   private compileCtes(ast: SelectQueryNode, ctx: CompilerContext): string {
     if (!ast.ctes || ast.ctes.length === 0) return '';
     // MSSQL does not use RECURSIVE keyword, but supports recursion when CTE references itself.

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

@@ -60,7 +60,7 @@ export class PostgresDialect extends SqlDialectBase {
     return ` RETURNING ${columns}`;
   }
 
-  supportsReturning(): boolean {
+  supportsDmlReturningClause(): boolean {
     return true;
   }
 

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

@@ -73,7 +73,7 @@ export class SqliteDialect extends SqlDialectBase {
       .join(', ');
   }
 
-  supportsReturning(): boolean {
+  supportsDmlReturningClause(): boolean {
     return true;
   }
 }

package/src/core/execution/db-executor.ts

@@ -1,103 +1,107 @@
-// src/core/execution/db-executor.ts
-
-// low-level canonical shape
-export type QueryResult = {
-  columns: string[];
-  values: unknown[][];
-};
-
-export interface DbExecutor {
-  /** Capability flags so the runtime can make correct decisions without relying on optional methods. */
-  readonly capabilities: {
-    /** True if begin/commit/rollback are real and should be used to provide atomicity. */
-    transactions: boolean;
-  };
-
-  executeSql(sql: string, params?: unknown[]): Promise<QueryResult[]>;
-
-  beginTransaction(): Promise<void>;
-  commitTransaction(): Promise<void>;
-  rollbackTransaction(): Promise<void>;
-
-  /** Release any underlying resources (connections, pool leases, etc). Must be idempotent. */
-  dispose(): Promise<void>;
-}
-
-// --- helpers ---
-
-/**
- * Convert an array of row objects into a QueryResult.
- */
-export function rowsToQueryResult(
-  rows: Array<Record<string, unknown>>
-): QueryResult {
-  if (rows.length === 0) {
-    return { columns: [], values: [] };
-  }
-
-  const columns = Object.keys(rows[0]);
-  const values = rows.map(row => columns.map(c => row[c]));
-  return { columns, values };
-}
-
-/**
- * Minimal contract that most SQL clients can implement.
- */
-export interface SimpleQueryRunner {
-  query(
-    sql: string,
-    params?: unknown[]
-  ): Promise<Array<Record<string, unknown>>>;
-
-  /** Optional: used to support real transactions. */
-  beginTransaction?(): Promise<void>;
-  commitTransaction?(): Promise<void>;
-  rollbackTransaction?(): Promise<void>;
-
-  /** Optional: release resources (connection close, pool lease release, etc). */
-  dispose?(): Promise<void>;
-}
-
-/**
- * Generic factory: turn any SimpleQueryRunner into a DbExecutor.
- */
-export function createExecutorFromQueryRunner(
-  runner: SimpleQueryRunner
-): DbExecutor {
-  const supportsTransactions =
-    typeof runner.beginTransaction === 'function' &&
-    typeof runner.commitTransaction === 'function' &&
-    typeof runner.rollbackTransaction === 'function';
-
-  return {
-    capabilities: {
-      transactions: supportsTransactions,
-    },
-    async executeSql(sql, params) {
-      const rows = await runner.query(sql, params);
-      const result = rowsToQueryResult(rows);
-      return [result];
-    },
-    async beginTransaction() {
-      if (!supportsTransactions) {
-        throw new Error('Transactions are not supported by this executor');
-      }
-      await runner.beginTransaction!.call(runner);
-    },
-    async commitTransaction() {
-      if (!supportsTransactions) {
-        throw new Error('Transactions are not supported by this executor');
-      }
-      await runner.commitTransaction!.call(runner);
-    },
-    async rollbackTransaction() {
-      if (!supportsTransactions) {
-        throw new Error('Transactions are not supported by this executor');
-      }
-      await runner.rollbackTransaction!.call(runner);
-    },
-    async dispose() {
-      await runner.dispose?.call(runner);
-    },
-  };
-}
+// src/core/execution/db-executor.ts
+
+// low-level canonical shape
+export type QueryResult = {
+  columns: string[];
+  values: unknown[][];
+  meta?: {
+    insertId?: number | string;
+    rowsAffected?: number;
+  };
+};
+
+export interface DbExecutor {
+  /** Capability flags so the runtime can make correct decisions without relying on optional methods. */
+  readonly capabilities: {
+    /** True if begin/commit/rollback are real and should be used to provide atomicity. */
+    transactions: boolean;
+  };
+
+  executeSql(sql: string, params?: unknown[]): Promise<QueryResult[]>;
+
+  beginTransaction(): Promise<void>;
+  commitTransaction(): Promise<void>;
+  rollbackTransaction(): Promise<void>;
+
+  /** Release any underlying resources (connections, pool leases, etc). Must be idempotent. */
+  dispose(): Promise<void>;
+}
+
+// --- helpers ---
+
+/**
+ * Convert an array of row objects into a QueryResult.
+ */
+export function rowsToQueryResult(
+  rows: Array<Record<string, unknown>>
+): QueryResult {
+  if (rows.length === 0) {
+    return { columns: [], values: [] };
+  }
+
+  const columns = Object.keys(rows[0]);
+  const values = rows.map(row => columns.map(c => row[c]));
+  return { columns, values };
+}
+
+/**
+ * Minimal contract that most SQL clients can implement.
+ */
+export interface SimpleQueryRunner {
+  query(
+    sql: string,
+    params?: unknown[]
+  ): Promise<Array<Record<string, unknown>>>;
+
+  /** Optional: used to support real transactions. */
+  beginTransaction?(): Promise<void>;
+  commitTransaction?(): Promise<void>;
+  rollbackTransaction?(): Promise<void>;
+
+  /** Optional: release resources (connection close, pool lease release, etc). */
+  dispose?(): Promise<void>;
+}
+
+/**
+ * Generic factory: turn any SimpleQueryRunner into a DbExecutor.
+ */
+export function createExecutorFromQueryRunner(
+  runner: SimpleQueryRunner
+): DbExecutor {
+  const supportsTransactions =
+    typeof runner.beginTransaction === 'function' &&
+    typeof runner.commitTransaction === 'function' &&
+    typeof runner.rollbackTransaction === 'function';
+
+  return {
+    capabilities: {
+      transactions: supportsTransactions,
+    },
+    async executeSql(sql, params) {
+      const rows = await runner.query(sql, params);
+      const result = rowsToQueryResult(rows);
+      return [result];
+    },
+    async beginTransaction() {
+      if (!supportsTransactions) {
+        throw new Error('Transactions are not supported by this executor');
+      }
+      await runner.beginTransaction!.call(runner);
+    },
+    async commitTransaction() {
+      if (!supportsTransactions) {
+        throw new Error('Transactions are not supported by this executor');
+      }
+      await runner.commitTransaction!.call(runner);
+    },
+    async rollbackTransaction() {
+      if (!supportsTransactions) {
+        throw new Error('Transactions are not supported by this executor');
+      }
+      await runner.rollbackTransaction!.call(runner);
+    },
+    async dispose() {
+      await runner.dispose?.call(runner);
+    },
+  };
+}

package/src/core/execution/executors/mysql-executor.ts

@@ -35,8 +35,15 @@ export function createMysqlExecutor(
       const [rows] = await client.query(sql, params);
 
       if (!Array.isArray(rows)) {
-        // e.g. insert/update returning only headers, treat as no rows
-        return [{ columns: [], values: [] }];
+        const header = rows as Record<string, unknown>;
+        return [{
+          columns: [],
+          values: [],
+          meta: {
+            insertId: header.insertId as number | undefined,
+            rowsAffected: header.affectedRows as number | undefined,
+          }
+        }];
       }
 
       const result = rowsToQueryResult(

package/src/index.ts

@@ -71,3 +71,6 @@ export * from './dto/index.js';
 
 // Tree behavior (Nested Set / MPTT)
 export * from './tree/index.js';
+
+// Cache module
+export * from './cache/index.js';