Simplify transaction classes

src/client.js

@@ -51,71 +51,48 @@ assign(Client.prototype, {
     return new Formatter(this)
   },
 
-  QueryBuilder,
-
   queryBuilder() {
-    return new this.QueryBuilder(this)
+    return new QueryBuilder(this)
   },
 
-  QueryCompiler,
-
   queryCompiler(builder) {
-    return new this.QueryCompiler(this, builder)
+    return new QueryCompiler(this, builder)
   },
 
-  SchemaBuilder,
-
   schemaBuilder() {
-    return new this.SchemaBuilder(this)
+    return new SchemaBuilder(this)
   },
 
-  SchemaCompiler,
-
   schemaCompiler(builder) {
-    return new this.SchemaCompiler(this, builder)
+    return new SchemaCompiler(this, builder)
   },
 
-  TableBuilder,
-
   tableBuilder(type, tableName, fn) {
-    return new this.TableBuilder(this, type, tableName, fn)
+    return new TableBuilder(this, type, tableName, fn)
   },
 
-  TableCompiler,
-
   tableCompiler(tableBuilder) {
-    return new this.TableCompiler(this, tableBuilder)
+    return new TableCompiler(this, tableBuilder)
   },
 
-  ColumnBuilder,
-
   columnBuilder(tableBuilder, type, args) {
-    return new this.ColumnBuilder(this, tableBuilder, type, args)
+    return new ColumnBuilder(this, tableBuilder, type, args)
   },
 
-  ColumnCompiler,
-
   columnCompiler(tableBuilder, columnBuilder) {
-    return new this.ColumnCompiler(this, tableBuilder, columnBuilder)
+    return new ColumnCompiler(this, tableBuilder, columnBuilder)
   },
 
-  Runner,
-
   runner(connection) {
-    return new this.Runner(this, connection)
+    return new Runner(this, connection)
   },
 
-  Transaction,
-
   transaction(container, config, outerTx) {
-    return new this.Transaction(this, container, config, outerTx)
+    return new Transaction(this, container, config, outerTx)
   },
 
-  Raw,
-
   raw() {
-    const raw = new this.Raw(this)
-    return raw.set.apply(raw, arguments)
+    return new Raw(this).set(...arguments)
   },
 
   _formatQuery(sql, bindings, timeZone) {

src/dialects/maria/index.js

@@ -20,7 +20,9 @@ assign(Client_MariaSQL.prototype, {
 
   driverName: 'mariasql',
 
-  Transaction,
+  transaction() {
+    return new Transaction(this, ...arguments)
+  },
 
   _driver() {
     return require('mariasql')

src/dialects/maria/transaction.js

@@ -1,18 +1,10 @@
-
-import inherits from 'inherits';
 import Debug from 'debug';
-import { assign } from 'lodash'
 import Transaction from '../../transaction';
 import * as helpers from '../../helpers';
 
 const debug = Debug('knex:tx');
 
-function Transaction_Maria() {
-  Transaction.apply(this, arguments)
-}
-inherits(Transaction_Maria, Transaction)
-
-assign(Transaction_Maria.prototype, {
+export default class Transaction_Maria extends Transaction {
 
   query(conn, sql, status, value) {
     const t = this
@@ -39,6 +31,4 @@ assign(Transaction_Maria.prototype, {
     return q;
   }
 
-})
-
-export default Transaction_Maria
+}

src/dialects/mssql/index.js

@@ -41,7 +41,9 @@ assign(Client_MSSQL.prototype, {
     return require('mssql');
   },
 
-  Transaction,
+  transaction() {
+    return new Transaction(this, ...arguments)
+  },
 
   QueryCompiler,
 

src/dialects/mssql/transaction.js

@@ -1,54 +1,45 @@
-
-import inherits from 'inherits';
 import Promise from 'bluebird';
 import Transaction from '../../transaction';
 const debug = require('debug')('knex:tx')
 
-import { assign } from 'lodash'
-
-function Transaction_MSSQL() {
-  Transaction.apply(this, arguments)
-}
-inherits(Transaction_MSSQL, Transaction)
-
-assign(Transaction_MSSQL.prototype, {
+export default class Transaction_MSSQL extends Transaction {
 
   begin(conn) {
     debug('%s: begin', this.txid)
     return conn.tx_.begin()
       .then(this._resolver, this._rejecter)
-  },
+  }
 
   savepoint(conn) {
     debug('%s: savepoint at', this.txid)
     return Promise.resolve()
       .then(() => this.query(conn, `SAVE TRANSACTION ${this.txid}`))
-  },
+  }
 
   commit(conn, value) {
     this._completed = true
     debug('%s: commit', this.txid)
     return conn.tx_.commit()
       .then(() => this._resolver(value), this._rejecter)
-  },
+  }
 
   release(conn, value) {
     return this._resolver(value)
-  },
+  }
 
   rollback(conn, error) {
     this._completed = true
     debug('%s: rolling back', this.txid)
     return conn.tx_.rollback()
       .then(() => this._rejecter(error))
-  },
+  }
 
   rollbackTo(conn, error) {
     debug('%s: rolling backTo', this.txid)
     return Promise.resolve()
       .then(() => this.query(conn, `ROLLBACK TRANSACTION ${this.txid}`, 2, error))
       .then(() => this._rejecter(error))
-  },
+  }
 
   // Acquire a connection and create a disposer - either using the one passed
   // via config or getting one off the client. The disposer will be called once
@@ -84,6 +75,4 @@ assign(Transaction_MSSQL.prototype, {
     })
   }
 
-})
-
-export default Transaction_MSSQL
+}

src/dialects/mysql/index.js

@@ -42,7 +42,9 @@ assign(Client_MySQL.prototype, {
 
   ColumnCompiler,
 
-  Transaction,
+  transaction() {
+    return new Transaction(this, ...arguments)
+  },
 
   _escapeBinding: makeEscape(),
 

src/dialects/mysql2/index.js

@@ -53,7 +53,9 @@ assign(Client_MySQL2.prototype, {
   // The "dialect", for reference elsewhere.
   driverName: 'mysql2',
 
-  Transaction,
+  transaction() {
+    return new Transaction(this, ...arguments)
+  },
 
   _driver() {
     return require('mysql2')

src/dialects/oracle/index.js

@@ -37,7 +37,9 @@ assign(Client_Oracle.prototype, {
     return require('oracle')
   },
 
-  Transaction,
+  transaction() {
+    return new Transaction(this, ...arguments)
+  },
 
   formatter() {
     return new Oracle_Formatter(this)

src/dialects/oracle/transaction.js

@@ -1,41 +1,33 @@
 
-import inherits from 'inherits';
 import Promise from 'bluebird';
 import Transaction from '../../transaction';
 const debugTx = require('debug')('knex:tx')
 
-import { assign } from 'lodash'
-
-function Oracle_Transaction(client, container, config, outerTx) {
-  Transaction.call(this, client, container, config, outerTx)
-}
-inherits(Oracle_Transaction, Transaction)
-
-assign(Oracle_Transaction.prototype, {
+export default class Oracle_Transaction extends Transaction {
 
   // disable autocommit to allow correct behavior (default is true)
   begin() {
     return Promise.resolve()
-  },
+  }
 
   commit(conn, value) {
     this._completed = true
     return conn.commitAsync()
       .return(value)
       .then(this._resolver, this._rejecter)
-  },
+  }
 
   release(conn, value) {
     return this._resolver(value)
-  },
+  }
 
   rollback(conn, err) {
     this._completed = true
     debugTx('%s: rolling back', this.txid)
     return conn.rollbackAsync()
       .throw(err)
       .catch(this._rejecter)
-  },
+  }
 
   acquireConnection(config) {
     const t = this
@@ -56,6 +48,4 @@ assign(Oracle_Transaction.prototype, {
     })
   }
 
-})
-
-export default Oracle_Transaction
+}

src/dialects/oracledb/transaction.js

@@ -1,30 +1,26 @@
-const inherits = require('inherits');
 const Promise = require('bluebird');
 const Transaction = require('../../transaction');
 const debugTx = require('debug')('knex:tx');
-import {assign} from
-'lodash'
 
-function Oracle_Transaction(client, container, config, outerTx) {
-  Transaction.call(this, client, container, config, outerTx);
-}
-inherits(Oracle_Transaction, Transaction);
+export default class Oracle_Transaction extends Transaction {
 
-assign(Oracle_Transaction.prototype, {
   // disable autocommit to allow correct behavior (default is true)
-  begin: function() {
+  begin() {
     return Promise.resolve();
-  },
-  commit: function(conn, value) {
+  }
+
+  commit(conn, value) {
     this._completed = true;
     return conn.commitAsync()
       .return(value)
       .then(this._resolver, this._rejecter);
-  },
-  release: function(conn, value) {
+  }
+
+  release(conn, value) {
     return this._resolver(value);
-  },
-  rollback: function(conn, err) {
+  }
+
+  rollback(conn, err) {
     const self = this;
     this._completed = true;
     debugTx('%s: rolling back', this.txid);
@@ -33,8 +29,9 @@ assign(Oracle_Transaction.prototype, {
     }).then(function() {
       self._rejecter(err);
     });
-  },
-  acquireConnection: function(config) {
+  }
+
+  acquireConnection(config) {
     const t = this;
     return Promise.try(function() {
       return t.client.acquireConnection().completed.then(function(cnx) {
@@ -57,6 +54,5 @@ assign(Oracle_Transaction.prototype, {
         });
     });
   }
-});
 
-module.exports = Oracle_Transaction;
+}

src/dialects/websql/index.js

@@ -20,7 +20,9 @@ inherits(Client_WebSQL, Client_SQLite3);
 
 assign(Client_WebSQL.prototype, {
 
-  Transaction,
+  transaction() {
+    return new Transaction(this, ...arguments)
+  },
 
   dialect: 'websql',
 

src/index.js

@@ -11,11 +11,11 @@ import { assign } from 'lodash'
 
 // The client names we'll allow in the `{name: lib}` pairing.
 const aliases = {
-  'mariadb'   : 'maria',
-  'mariasql'  : 'maria',
-  'pg'        : 'postgres',
-  'postgresql': 'postgres',
-  'sqlite'    : 'sqlite3'
+  'mariadb' : 'maria',
+  'mariasql' : 'maria',
+  'pg' : 'postgres',
+  'postgresql' : 'postgres',
+  'sqlite' : 'sqlite3'
 };
 
 export default function Knex(config) {