knex 0.21.20 → 0.21.21

package/lib/dialects/mssql/transaction.js

@@ -1,97 +1,97 @@
-const Transaction = require('../../transaction');
-const debug = require('debug')('knex:tx');
-
-module.exports = class Transaction_MSSQL extends Transaction {
-  begin(conn) {
-    debug('%s: begin', this.txid);
-    return conn.tx_.begin().then(this._resolver, this._rejecter);
-  }
-
-  async savepoint(conn) {
-    debug('%s: savepoint at', this.txid);
-    return 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(
-      () => {
-        let err = error;
-        if (error === undefined) {
-          if (this.doNotRejectOnRollback) {
-            this._resolver();
-            return;
-          }
-          err = new Error(`Transaction rejected with non-error: ${error}`);
-        }
-        this._rejecter(err);
-      },
-      (err) => {
-        if (error) {
-          try {
-            err.originalError = error;
-          } catch (_err) {
-            // This is to handle https://github.com/knex/knex/issues/4128
-          }
-        }
-        return this._rejecter(err);
-      }
-    );
-  }
-
-  async rollbackTo(conn, error) {
-    debug('%s: rolling backTo', this.txid);
-    await this.query(conn, `ROLLBACK TRANSACTION ${this.txid}`, 2, error);
-
-    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
-  // the original promise is marked completed.
-  async acquireConnection(config, cb) {
-    const configConnection = config && config.connection;
-    const conn =
-      (this.outerTx && this.outerTx.conn) ||
-      configConnection ||
-      (await this.client.acquireConnection());
-
-    try {
-      conn.__knexTxId = this.txid;
-      if (!this.outerTx) {
-        this.conn = conn;
-        conn.tx_ = conn.transaction();
-      }
-
-      return await cb(conn);
-    } finally {
-      if (!this.outerTx) {
-        if (conn.tx_) {
-          if (!this._completed) {
-            debug('%s: unreleased transaction', this.txid);
-            conn.tx_.rollback();
-          }
-          conn.tx_ = null;
-        }
-        this.conn = null;
-        if (!configConnection) {
-          debug('%s: releasing connection', this.txid);
-          this.client.releaseConnection(conn);
-        } else {
-          debug('%s: not releasing external connection', this.txid);
-        }
-      }
-    }
-  }
-};
+const Transaction = require('../../transaction');
+const debug = require('debug')('knex:tx');
+
+module.exports = class Transaction_MSSQL extends Transaction {
+  begin(conn) {
+    debug('%s: begin', this.txid);
+    return conn.tx_.begin().then(this._resolver, this._rejecter);
+  }
+
+  async savepoint(conn) {
+    debug('%s: savepoint at', this.txid);
+    return 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(
+      () => {
+        let err = error;
+        if (error === undefined) {
+          if (this.doNotRejectOnRollback) {
+            this._resolver();
+            return;
+          }
+          err = new Error(`Transaction rejected with non-error: ${error}`);
+        }
+        this._rejecter(err);
+      },
+      (err) => {
+        if (error) {
+          try {
+            err.originalError = error;
+          } catch (_err) {
+            // This is to handle https://github.com/knex/knex/issues/4128
+          }
+        }
+        return this._rejecter(err);
+      }
+    );
+  }
+
+  async rollbackTo(conn, error) {
+    debug('%s: rolling backTo', this.txid);
+    await this.query(conn, `ROLLBACK TRANSACTION ${this.txid}`, 2, error);
+
+    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
+  // the original promise is marked completed.
+  async acquireConnection(config, cb) {
+    const configConnection = config && config.connection;
+    const conn =
+      (this.outerTx && this.outerTx.conn) ||
+      configConnection ||
+      (await this.client.acquireConnection());
+
+    try {
+      conn.__knexTxId = this.txid;
+      if (!this.outerTx) {
+        this.conn = conn;
+        conn.tx_ = conn.transaction();
+      }
+
+      return await cb(conn);
+    } finally {
+      if (!this.outerTx) {
+        if (conn.tx_) {
+          if (!this._completed) {
+            debug('%s: unreleased transaction', this.txid);
+            conn.tx_.rollback();
+          }
+          conn.tx_ = null;
+        }
+        this.conn = null;
+        if (!configConnection) {
+          debug('%s: releasing connection', this.txid);
+          this.client.releaseConnection(conn);
+        } else {
+          debug('%s: not releasing external connection', this.txid);
+        }
+      }
+    }
+  }
+};

package/lib/dialects/mysql/index.js

@@ -1,191 +1,191 @@
-// MySQL Client
-// -------
-const defer = require('lodash/defer');
-const map = require('lodash/map');
-const { promisify, inherits } = require('util');
-const Client = require('../../client');
-
-const Transaction = require('./transaction');
-const QueryCompiler = require('./query/compiler');
-const SchemaCompiler = require('./schema/compiler');
-const TableCompiler = require('./schema/tablecompiler');
-const ColumnCompiler = require('./schema/columncompiler');
-
-const { makeEscape } = require('../../query/string');
-
-// Always initialize with the "QueryBuilder" and "QueryCompiler"
-// objects, which extend the base 'lib/query/builder' and
-// 'lib/query/compiler', respectively.
-function Client_MySQL(config) {
-  Client.call(this, config);
-}
-
-inherits(Client_MySQL, Client);
-
-Object.assign(Client_MySQL.prototype, {
-  dialect: 'mysql',
-
-  driverName: 'mysql',
-
-  _driver() {
-    return require('mysql');
-  },
-
-  queryCompiler() {
-    return new QueryCompiler(this, ...arguments);
-  },
-
-  schemaCompiler() {
-    return new SchemaCompiler(this, ...arguments);
-  },
-
-  tableCompiler() {
-    return new TableCompiler(this, ...arguments);
-  },
-
-  columnCompiler() {
-    return new ColumnCompiler(this, ...arguments);
-  },
-
-  transaction() {
-    return new Transaction(this, ...arguments);
-  },
-
-  _escapeBinding: makeEscape(),
-
-  wrapIdentifierImpl(value) {
-    return value !== '*' ? `\`${value.replace(/`/g, '``')}\`` : '*';
-  },
-
-  // Get a raw connection, called by the `pool` whenever a new
-  // connection needs to be added to the pool.
-  acquireRawConnection() {
-    return new Promise((resolver, rejecter) => {
-      const connection = this.driver.createConnection(this.connectionSettings);
-      connection.on('error', (err) => {
-        connection.__knex__disposed = err;
-      });
-      connection.connect((err) => {
-        if (err) {
-          // if connection is rejected, remove listener that was registered above...
-          connection.removeAllListeners();
-          return rejecter(err);
-        }
-        resolver(connection);
-      });
-    });
-  },
-
-  // Used to explicitly close a connection, called internally by the pool
-  // when a connection times out or the pool is shutdown.
-  async destroyRawConnection(connection) {
-    try {
-      const end = promisify((cb) => connection.end(cb));
-      return await end();
-    } catch (err) {
-      connection.__knex__disposed = err;
-    } finally {
-      // see discussion https://github.com/knex/knex/pull/3483
-      defer(() => connection.removeAllListeners());
-    }
-  },
-
-  validateConnection(connection) {
-    if (
-      connection.state === 'connected' ||
-      connection.state === 'authenticated'
-    ) {
-      return true;
-    }
-    return false;
-  },
-
-  // Grab a connection, run the query via the MySQL streaming interface,
-  // and pass that through to the stream we've sent back to the client.
-  _stream(connection, obj, stream, options) {
-    options = options || {};
-    const queryOptions = Object.assign({ sql: obj.sql }, obj.options);
-    return new Promise((resolver, rejecter) => {
-      stream.on('error', rejecter);
-      stream.on('end', resolver);
-      const queryStream = connection
-        .query(queryOptions, obj.bindings)
-        .stream(options);
-
-      queryStream.on('error', (err) => {
-        rejecter(err);
-        stream.emit('error', err);
-      });
-
-      queryStream.pipe(stream);
-    });
-  },
-
-  // Runs the query on the specified connection, providing the bindings
-  // and any other necessary prep work.
-  _query(connection, obj) {
-    if (!obj || typeof obj === 'string') obj = { sql: obj };
-    return new Promise(function (resolver, rejecter) {
-      if (!obj.sql) {
-        resolver();
-        return;
-      }
-      const queryOptions = Object.assign({ sql: obj.sql }, obj.options);
-      connection.query(queryOptions, obj.bindings, function (
-        err,
-        rows,
-        fields
-      ) {
-        if (err) return rejecter(err);
-        obj.response = [rows, fields];
-        resolver(obj);
-      });
-    });
-  },
-
-  // Process the response as returned from the query.
-  processResponse(obj, runner) {
-    if (obj == null) return;
-    const { response } = obj;
-    const { method } = obj;
-    const rows = response[0];
-    const fields = response[1];
-    if (obj.output) return obj.output.call(runner, rows, fields);
-    switch (method) {
-      case 'select':
-      case 'pluck':
-      case 'first': {
-        if (method === 'pluck') {
-          return map(rows, obj.pluck);
-        }
-        return method === 'first' ? rows[0] : rows;
-      }
-      case 'insert':
-        return [rows.insertId];
-      case 'del':
-      case 'update':
-      case 'counter':
-        return rows.affectedRows;
-      default:
-        return response;
-    }
-  },
-
-  canCancelQuery: true,
-
-  async cancelQuery(connectionToKill) {
-    const conn = await this.acquireConnection();
-    try {
-      return await this.query(conn, {
-        method: 'raw',
-        sql: 'KILL QUERY ?',
-        bindings: [connectionToKill.threadId],
-        options: {},
-      });
-    } finally {
-      await this.releaseConnection(conn);
-    }
-  },
-});
-
-module.exports = Client_MySQL;
+// MySQL Client
+// -------
+const defer = require('lodash/defer');
+const map = require('lodash/map');
+const { promisify, inherits } = require('util');
+const Client = require('../../client');
+
+const Transaction = require('./transaction');
+const QueryCompiler = require('./query/compiler');
+const SchemaCompiler = require('./schema/compiler');
+const TableCompiler = require('./schema/tablecompiler');
+const ColumnCompiler = require('./schema/columncompiler');
+
+const { makeEscape } = require('../../query/string');
+
+// Always initialize with the "QueryBuilder" and "QueryCompiler"
+// objects, which extend the base 'lib/query/builder' and
+// 'lib/query/compiler', respectively.
+function Client_MySQL(config) {
+  Client.call(this, config);
+}
+
+inherits(Client_MySQL, Client);
+
+Object.assign(Client_MySQL.prototype, {
+  dialect: 'mysql',
+
+  driverName: 'mysql',
+
+  _driver() {
+    return require('mysql');
+  },
+
+  queryCompiler() {
+    return new QueryCompiler(this, ...arguments);
+  },
+
+  schemaCompiler() {
+    return new SchemaCompiler(this, ...arguments);
+  },
+
+  tableCompiler() {
+    return new TableCompiler(this, ...arguments);
+  },
+
+  columnCompiler() {
+    return new ColumnCompiler(this, ...arguments);
+  },
+
+  transaction() {
+    return new Transaction(this, ...arguments);
+  },
+
+  _escapeBinding: makeEscape(),
+
+  wrapIdentifierImpl(value) {
+    return value !== '*' ? `\`${value.replace(/`/g, '``')}\`` : '*';
+  },
+
+  // Get a raw connection, called by the `pool` whenever a new
+  // connection needs to be added to the pool.
+  acquireRawConnection() {
+    return new Promise((resolver, rejecter) => {
+      const connection = this.driver.createConnection(this.connectionSettings);
+      connection.on('error', (err) => {
+        connection.__knex__disposed = err;
+      });
+      connection.connect((err) => {
+        if (err) {
+          // if connection is rejected, remove listener that was registered above...
+          connection.removeAllListeners();
+          return rejecter(err);
+        }
+        resolver(connection);
+      });
+    });
+  },
+
+  // Used to explicitly close a connection, called internally by the pool
+  // when a connection times out or the pool is shutdown.
+  async destroyRawConnection(connection) {
+    try {
+      const end = promisify((cb) => connection.end(cb));
+      return await end();
+    } catch (err) {
+      connection.__knex__disposed = err;
+    } finally {
+      // see discussion https://github.com/knex/knex/pull/3483
+      defer(() => connection.removeAllListeners());
+    }
+  },
+
+  validateConnection(connection) {
+    if (
+      connection.state === 'connected' ||
+      connection.state === 'authenticated'
+    ) {
+      return true;
+    }
+    return false;
+  },
+
+  // Grab a connection, run the query via the MySQL streaming interface,
+  // and pass that through to the stream we've sent back to the client.
+  _stream(connection, obj, stream, options) {
+    options = options || {};
+    const queryOptions = Object.assign({ sql: obj.sql }, obj.options);
+    return new Promise((resolver, rejecter) => {
+      stream.on('error', rejecter);
+      stream.on('end', resolver);
+      const queryStream = connection
+        .query(queryOptions, obj.bindings)
+        .stream(options);
+
+      queryStream.on('error', (err) => {
+        rejecter(err);
+        stream.emit('error', err);
+      });
+
+      queryStream.pipe(stream);
+    });
+  },
+
+  // Runs the query on the specified connection, providing the bindings
+  // and any other necessary prep work.
+  _query(connection, obj) {
+    if (!obj || typeof obj === 'string') obj = { sql: obj };
+    return new Promise(function (resolver, rejecter) {
+      if (!obj.sql) {
+        resolver();
+        return;
+      }
+      const queryOptions = Object.assign({ sql: obj.sql }, obj.options);
+      connection.query(queryOptions, obj.bindings, function (
+        err,
+        rows,
+        fields
+      ) {
+        if (err) return rejecter(err);
+        obj.response = [rows, fields];
+        resolver(obj);
+      });
+    });
+  },
+
+  // Process the response as returned from the query.
+  processResponse(obj, runner) {
+    if (obj == null) return;
+    const { response } = obj;
+    const { method } = obj;
+    const rows = response[0];
+    const fields = response[1];
+    if (obj.output) return obj.output.call(runner, rows, fields);
+    switch (method) {
+      case 'select':
+      case 'pluck':
+      case 'first': {
+        if (method === 'pluck') {
+          return map(rows, obj.pluck);
+        }
+        return method === 'first' ? rows[0] : rows;
+      }
+      case 'insert':
+        return [rows.insertId];
+      case 'del':
+      case 'update':
+      case 'counter':
+        return rows.affectedRows;
+      default:
+        return response;
+    }
+  },
+
+  canCancelQuery: true,
+
+  async cancelQuery(connectionToKill) {
+    const conn = await this.acquireConnection();
+    try {
+      return await this.query(conn, {
+        method: 'raw',
+        sql: 'KILL QUERY ?',
+        bindings: [connectionToKill.threadId],
+        options: {},
+      });
+    } finally {
+      await this.releaseConnection(conn);
+    }
+  },
+});
+
+module.exports = Client_MySQL;