metal-orm 1.0.39 → 1.0.41

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

@@ -1,213 +1,192 @@
-import { CompilerContext, Dialect } from '../abstract.js';
-import { SelectQueryNode, InsertQueryNode, UpdateQueryNode, DeleteQueryNode, TableSourceNode, DerivedTableNode } from '../../ast/query.js';
+import { CompilerContext } from '../abstract.js';
+import {
+  SelectQueryNode,
+  DeleteQueryNode,
+  TableSourceNode,
+  DerivedTableNode,
+  OrderByNode
+} from '../../ast/query.js';
 import { JsonPathNode } from '../../ast/expression.js';
 import { MssqlFunctionStrategy } from './functions.js';
-import { FunctionTableFormatter } from '../base/function-table-formatter.js';
-
-/**
- * Microsoft SQL Server dialect implementation
- */
-export class SqlServerDialect extends Dialect {
-  protected readonly dialect = 'mssql';
-  /**
-   * Creates a new SqlServerDialect instance
-   */
-  public constructor() {
-    super(new MssqlFunctionStrategy());
-  }
-
-  /**
-   * Quotes an identifier using SQL Server bracket syntax
-   * @param id - Identifier to quote
-   * @returns Quoted identifier
-   */
-  quoteIdentifier(id: string): string {
-    return `[${id}]`;
-  }
-
-  /**
-   * Compiles JSON path expression using SQL Server syntax
-   * @param node - JSON path node
-   * @returns SQL Server JSON path expression
-   */
-  protected compileJsonPath(node: JsonPathNode): string {
-    const col = `${this.quoteIdentifier(node.column.table)}.${this.quoteIdentifier(node.column.name)}`;
-    // SQL Server uses JSON_VALUE(col, '$.path')
-    return `JSON_VALUE(${col}, '${node.path}')`;
-  }
-
-  /**
-   * Formats parameter placeholders using SQL Server named parameter syntax
-   * @param index - Parameter index
-   * @returns Named parameter placeholder
-   */
-  protected formatPlaceholder(index: number): string {
-    return `@p${index}`;
-  }
-
-  /**
-   * Compiles SELECT query AST to SQL Server SQL
-   * @param ast - Query AST
-   * @param ctx - Compiler context
-   * @returns SQL Server SQL string
-   */
-  protected compileSelectAst(ast: SelectQueryNode, ctx: CompilerContext): string {
-    const hasSetOps = !!(ast.setOps && ast.setOps.length);
-    const ctes = this.compileCtes(ast, ctx);
-
-    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}`;
-    const tail = pagination || orderBy;
-    return `${ctes}${combined}${tail}`;
-  }
-
-  protected compileInsertAst(ast: InsertQueryNode, ctx: CompilerContext): string {
-    const table = this.quoteIdentifier(ast.into.name);
-    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(', ');
-    return `INSERT INTO ${table} (${columnList}) VALUES ${values};`;
-  }
-
-  protected compileUpdateAst(ast: UpdateQueryNode, ctx: CompilerContext): string {
-    const table = this.quoteIdentifier(ast.table.name);
-    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);
-    return `UPDATE ${table} SET ${assignments}${whereClause};`;
-  }
-
+import { OrderByCompiler } from '../base/orderby-compiler.js';
+import { JoinCompiler } from '../base/join-compiler.js';
+import { SqlDialectBase } from '../base/sql-dialect.js';
+
+/**
+ * Microsoft SQL Server dialect implementation
+ */
+export class SqlServerDialect extends SqlDialectBase {
+  protected readonly dialect = 'mssql';
+  /**
+   * Creates a new SqlServerDialect instance
+   */
+  public constructor() {
+    super(new MssqlFunctionStrategy());
+  }
+
+  /**
+   * Quotes an identifier using SQL Server bracket syntax
+   * @param id - Identifier to quote
+   * @returns Quoted identifier
+   */
+  quoteIdentifier(id: string): string {
+    return `[${id}]`;
+  }
+
+  /**
+   * Compiles JSON path expression using SQL Server syntax
+   * @param node - JSON path node
+   * @returns SQL Server JSON path expression
+   */
+  protected compileJsonPath(node: JsonPathNode): string {
+    const col = `${this.quoteIdentifier(node.column.table)}.${this.quoteIdentifier(node.column.name)}`;
+    // SQL Server uses JSON_VALUE(col, '$.path')
+    return `JSON_VALUE(${col}, '${node.path}')`;
+  }
+
+  /**
+   * Formats parameter placeholders using SQL Server named parameter syntax
+   * @param index - Parameter index
+   * @returns Named parameter placeholder
+   */
+  protected formatPlaceholder(index: number): string {
+    return `@p${index}`;
+  }
+
+  /**
+   * Compiles SELECT query AST to SQL Server SQL
+   * @param ast - Query AST
+   * @param ctx - Compiler context
+   * @returns SQL Server SQL string
+   */
+  protected compileSelectAst(ast: SelectQueryNode, ctx: CompilerContext): string {
+    const hasSetOps = !!(ast.setOps && ast.setOps.length);
+    const ctes = this.compileCtes(ast, ctx);
+
+    const baseAst: SelectQueryNode = hasSetOps
+      ? { ...ast, setOps: undefined, orderBy: undefined, limit: undefined, offset: undefined }
+      : ast;
+
+    const baseSelect = this.compileSelectCoreForMssql(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, ctx);
+    const pagination = this.compilePagination(ast, orderBy);
+    const combined = `${this.wrapSetOperand(baseSelect)} ${compound}`;
+    const tail = pagination || orderBy;
+    return `${ctes}${combined}${tail}`;
+  }
+
   protected compileDeleteAst(ast: DeleteQueryNode, ctx: CompilerContext): string {
+    if (ast.using) {
+      throw new Error('DELETE ... USING is not supported in the MSSQL dialect; use join() instead.');
+    }
+
     if (ast.from.type !== 'Table') {
       throw new Error('DELETE only supports base tables in the MSSQL dialect.');
     }
-    const table = this.quoteIdentifier(ast.from.name);
+
+    const alias = ast.from.alias ?? ast.from.name;
+    const target = this.compileTableReference(ast.from);
+    const joins = JoinCompiler.compileJoins(
+      ast.joins,
+      ctx,
+      this.compileFrom.bind(this),
+      this.compileExpression.bind(this)
+    );
     const whereClause = this.compileWhere(ast.where, ctx);
-    return `DELETE FROM ${table}${whereClause};`;
+    const returning = this.compileReturning(ast.returning, ctx);
+    return `DELETE ${this.quoteIdentifier(alias)} FROM ${target}${joins}${whereClause}${returning}`;
   }
 
-  private compileSelectCore(ast: SelectQueryNode, ctx: CompilerContext): string {
-    const columns = ast.columns.map(c => {
-      let expr = '';
-      if (c.type === 'Function') {
-        expr = this.compileOperand(c, ctx);
-      } else if (c.type === 'Column') {
-        expr = `${this.quoteIdentifier(c.table)}.${this.quoteIdentifier(c.name)}`;
-      } else if (c.type === 'ScalarSubquery') {
-        expr = this.compileOperand(c, ctx);
-      } else if (c.type === 'WindowFunction') {
-        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(', ');
+  private compileSelectCoreForMssql(ast: SelectQueryNode, ctx: CompilerContext): string {
+    const columns = ast.columns.map(c => {
+      let expr = '';
+      if (c.type === 'Function') {
+        expr = this.compileOperand(c, ctx);
+      } else if (c.type === 'Column') {
+        expr = `${this.quoteIdentifier(c.table)}.${this.quoteIdentifier(c.name)}`;
+      } else if (c.type === 'ScalarSubquery') {
+        expr = this.compileOperand(c, ctx);
+      } else if (c.type === 'WindowFunction') {
+        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(', ');
 
     const distinct = ast.distinct ? 'DISTINCT ' : '';
-    const from = this.compileTableSource(ast.from, ctx);
+    const from = this.compileTableSource(ast.from);
 
     const joins = ast.joins.map(j => {
-      const table = this.compileTableSource(j.table, ctx);
+      const table = this.compileTableSource(j.table);
       const cond = this.compileExpression(j.condition, ctx);
       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 having = ast.having
-      ? ` HAVING ${this.compileExpression(ast.having, ctx)}`
-      : '';
-
-    const orderBy = this.compileOrderBy(ast);
-    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}`;
-  }
-
-  private compileOrderBy(ast: SelectQueryNode): string {
-    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(', ');
-  }
-
+    const whereClause = this.compileWhere(ast.where, ctx);
+
+    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, 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}`;
+  }
+
+  private compileOrderBy(ast: SelectQueryNode, ctx: CompilerContext): string {
+    return OrderByCompiler.compileOrderBy(
+      ast,
+      term => this.compileOrderingTerm(term, ctx),
+      this.renderOrderByNulls.bind(this),
+      this.renderOrderByCollation.bind(this)
+    );
+  }
+
   private compilePagination(ast: SelectQueryNode, orderBy: string): string {
     const hasLimit = ast.limit !== undefined;
     const hasOffset = ast.offset !== undefined;
     if (!hasLimit && !hasOffset) return '';
-
-    const off = ast.offset ?? 0;
-    const orderClause = orderBy || ' ORDER BY (SELECT NULL)';
-    let pagination = `${orderClause} OFFSET ${off} ROWS`;
+
+    const off = ast.offset ?? 0;
+    const orderClause = orderBy || ' ORDER BY (SELECT NULL)';
+    let pagination = `${orderClause} OFFSET ${off} ROWS`;
     if (hasLimit) {
       pagination += ` FETCH NEXT ${ast.limit} ROWS ONLY`;
     }
     return pagination;
   }
 
-  private compileTableSource(table: TableSourceNode, ctx: CompilerContext): string {
-    if (table.type === 'FunctionTable') {
-      return FunctionTableFormatter.format(table, ctx, this as any);
-    }
-    if (table.type === 'DerivedTable') {
-      return this.compileDerivedTable(table, ctx);
-    }
-    const base = table.schema
-      ? `${this.quoteIdentifier(table.schema)}.${this.quoteIdentifier(table.name)}`
-      : this.quoteIdentifier(table.name);
-    return table.alias ? `${base} AS ${this.quoteIdentifier(table.alias)}` : base;
+  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.
+    const defs = ast.ctes.map(cte => {
+      const name = this.quoteIdentifier(cte.name);
+      const cols = cte.columns ? `(${cte.columns.map(c => this.quoteIdentifier(c)).join(', ')})` : '';
+      const query = this.compileSelectAst(this.normalizeSelectAst(cte.query), ctx).trim().replace(/;$/, '');
+      return `${name}${cols} AS (${query})`;
+    }).join(', ');
+    return `WITH ${defs} `;
   }
 
-  private compileDerivedTable(table: DerivedTableNode, ctx: CompilerContext): string {
-    const sub = 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}`;
-  }
-
-  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.
-    const defs = ast.ctes.map(cte => {
-      const name = this.quoteIdentifier(cte.name);
-      const cols = cte.columns ? `(${cte.columns.map(c => this.quoteIdentifier(c)).join(', ')})` : '';
-      const query = this.compileSelectAst(this.normalizeSelectAst(cte.query), ctx).trim().replace(/;$/, '');
-      return `${name}${cols} AS (${query})`;
-    }).join(', ');
-    return `WITH ${defs} `;
-  }
-
-  private wrapSetOperand(sql: string): string {
-    const trimmed = sql.trim().replace(/;$/, '');
-    return `(${trimmed})`;
-  }
-}
+}

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

@@ -1,11 +1,12 @@
-import { CompilerContext } from '../abstract.js';
-import { JsonPathNode, ColumnNode } from '../../ast/expression.js';
-import { SqlDialectBase } from '../base/sql-dialect.js';
-import { SqliteFunctionStrategy } from './functions.js';
-
-/**
- * SQLite dialect implementation
- */
+import { CompilerContext } from '../abstract.js';
+import { JsonPathNode, ColumnNode } from '../../ast/expression.js';
+import { 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';
   /**
@@ -14,27 +15,31 @@ export class SqliteDialect extends SqlDialectBase {
   public constructor() {
     super(new SqliteFunctionStrategy());
   }
-
-  /**
-   * 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}')`;
-  }
-
+
+  /**
+   * 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 {
+    return this.quoteIdentifier(column.name);
+  }
+
   protected compileReturning(returning: ColumnNode[] | undefined, ctx: CompilerContext): string {
     if (!returning || returning.length === 0) return '';
     const columns = this.formatReturningColumns(returning);
@@ -49,8 +54,8 @@ export class SqliteDialect extends SqlDialectBase {
       })
       .join(', ');
   }
-
-  supportsReturning(): boolean {
-    return true;
-  }
-}
+
+  supportsReturning(): boolean {
+    return true;
+  }
+}

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

@@ -7,11 +7,20 @@ export type QueryResult = {
 };
 
 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>;
+  beginTransaction(): Promise<void>;
+  commitTransaction(): Promise<void>;
+  rollbackTransaction(): Promise<void>;
+
+  /** Release any underlying resources (connections, pool leases, etc). Must be idempotent. */
+  dispose(): Promise<void>;
 }
 
 // --- helpers ---
@@ -39,9 +48,14 @@ export interface SimpleQueryRunner {
     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>;
 }
 
 /**
@@ -50,14 +64,40 @@ export interface SimpleQueryRunner {
 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];
     },
-    beginTransaction: runner.beginTransaction?.bind(runner),
-    commitTransaction: runner.commitTransaction?.bind(runner),
-    rollbackTransaction: runner.rollbackTransaction?.bind(runner),
+    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/mssql-executor.ts

@@ -17,23 +17,40 @@ export interface MssqlClientLike {
 export function createMssqlExecutor(
   client: MssqlClientLike
 ): DbExecutor {
+  const supportsTransactions =
+    typeof client.beginTransaction === 'function' &&
+    typeof client.commit === 'function' &&
+    typeof client.rollback === 'function';
+
   return {
+    capabilities: {
+      transactions: supportsTransactions,
+    },
     async executeSql(sql, params) {
       const { recordset } = await client.query(sql, params);
       const result = rowsToQueryResult(recordset ?? []);
       return [result];
     },
     async beginTransaction() {
-      if (!client.beginTransaction) return;
-      await client.beginTransaction();
+      if (!supportsTransactions) {
+        throw new Error('Transactions are not supported by this executor');
+      }
+      await client.beginTransaction!();
     },
     async commitTransaction() {
-      if (!client.commit) return;
-      await client.commit();
+      if (!supportsTransactions) {
+        throw new Error('Transactions are not supported by this executor');
+      }
+      await client.commit!();
     },
     async rollbackTransaction() {
-      if (!client.rollback) return;
-      await client.rollback();
+      if (!supportsTransactions) {
+        throw new Error('Transactions are not supported by this executor');
+      }
+      await client.rollback!();
+    },
+    async dispose() {
+      // Connection lifecycle is owned by the caller/driver. Pool lease executors should implement dispose.
     },
   };
 }
@@ -53,7 +70,7 @@ export interface TediousRequest {
 }
 
 export interface TediousRequestCtor {
-  new (sql: string, callback: (err?: Error | null) => void): TediousRequest;
+  new(sql: string, callback: (err?: Error | null) => void): TediousRequest;
 }
 
 export interface TediousTypes {
@@ -140,29 +157,29 @@ export function createTediousMssqlClient(
 
     beginTransaction: connection.beginTransaction
       ? () =>
-          new Promise<void>((resolve, reject) => {
-            connection.beginTransaction!(err =>
-              err ? reject(err) : resolve()
-            );
-          })
+        new Promise<void>((resolve, reject) => {
+          connection.beginTransaction!(err =>
+            err ? reject(err) : resolve()
+          );
+        })
       : undefined,
 
     commit: connection.commitTransaction
       ? () =>
-          new Promise<void>((resolve, reject) => {
-            connection.commitTransaction!(err =>
-              err ? reject(err) : resolve()
-            );
-          })
+        new Promise<void>((resolve, reject) => {
+          connection.commitTransaction!(err =>
+            err ? reject(err) : resolve()
+          );
+        })
       : undefined,
 
     rollback: connection.rollbackTransaction
       ? () =>
-          new Promise<void>((resolve, reject) => {
-            connection.rollbackTransaction!(err =>
-              err ? reject(err) : resolve()
-            );
-          })
+        new Promise<void>((resolve, reject) => {
+          connection.rollbackTransaction!(err =>
+            err ? reject(err) : resolve()
+          );
+        })
       : undefined,
   };
 }