knex 0.20.9 → 0.20.10

package/CHANGELOG.md

@@ -1,5 +1,22 @@
 # Master (Unreleased)
 
+# 0.20.10 - 13 February, 2020
+
+### Bug fixes:
+
+- Oracle: commit was a no-op causing race conditions #3668
+- CLI: Knex calls process.chdir() before opening Knexfile #3661
+- Fixed unresolved promise in cancelQuery() #3666
+
+### Typings:
+
+- `fn.now` takes optionally a precision argument. #3662
+- PG: Include SSL in connection definition #3659 
+
+### Test / internal changes:
+
+- replace Bluebird.timeout #3634
+
 # 0.20.9 - 08 February, 2020
 
 ### Bug fixes:

package/bin/cli.js

@@ -28,26 +28,18 @@ const fsPromised = {
   writeFile: promisify(fs.writeFile),
 };
 
-function initKnex(env, opts) {
-  if (opts.esm) {
-    // enable esm interop via 'esm' module
-    require = require('esm')(module);
-  }
-
-  env.configuration = env.configPath
-    ? require(env.configPath)
-    : mkConfigObj(opts);
+function openKnexfile(configPath) {
+  const config = require(configPath);
 
   // FYI: By default, the extension for the migration files is inferred
   //      from the knexfile's extension. So, the following lines are in
   //      place for backwards compatibility purposes.
-  if (!env.configuration.ext) {
-    const p = env.configPath || opts.knexpath;
+  config.ext = config.ext || path.extname(configPath).replace('.', '');
 
-    // TODO: Should this property be documented somewhere?
-    env.configuration.ext = path.extname(p).replace('.', '');
-  }
+  return config;
+}
 
+function initKnex(env, opts) {
   checkLocalModule(env);
   if (process.cwd() !== env.cwd) {
     process.chdir(env.cwd);
@@ -57,6 +49,15 @@ function initKnex(env, opts) {
     );
   }
 
+  if (opts.esm) {
+    // enable esm interop via 'esm' module
+    require = require('esm')(module);
+  }
+
+  env.configuration = env.configPath
+    ? openKnexfile(env.configPath)
+    : mkConfigObj(opts);
+
   const resolvedConfig = resolveEnvironmentConfig(opts, env.configuration);
   const knex = require(env.modulePath);
   return knex(resolvedConfig);

package/lib/client.js

@@ -25,6 +25,7 @@ const { makeEscape } = require('./query/string');
 const { uniqueId, cloneDeep, defaults } = require('lodash');
 
 const Logger = require('./logger');
+const { KnexTimeoutError } = require('./util/timeout');
 
 const debug = require('debug')('knex:client');
 const _debugQuery = require('debug')('knex:query');
@@ -344,11 +345,15 @@ Object.assign(Client.prototype, {
           debug('acquired connection from pool: %s', connection.__knexUid);
           return connection;
         })
-        .catch(TimeoutError, () => {
-          throw new Bluebird.TimeoutError(
-            'Knex: Timeout acquiring a connection. The pool is probably full. ' +
-              'Are you missing a .transacting(trx) call?'
-          );
+        .catch((error) => {
+          let convertedError = error;
+          if (error instanceof TimeoutError) {
+            convertedError = new KnexTimeoutError(
+              'Knex: Timeout acquiring a connection. The pool is probably full. ' +
+                'Are you missing a .transacting(trx) call?'
+            );
+          }
+          throw convertedError;
         });
     } catch (e) {
       return Bluebird.reject(e);

package/lib/dialects/mysql/index.js

@@ -170,28 +170,18 @@ Object.assign(Client_MySQL.prototype, {
 
   canCancelQuery: true,
 
-  cancelQuery(connectionToKill) {
-    const acquiringConn = this.acquireConnection();
-
-    // Error out if we can't acquire connection in time.
-    // Purposely not putting timeout on `KILL QUERY` execution because erroring
-    // early there would release the `connectionToKill` back to the pool with
-    // a `KILL QUERY` command yet to finish.
-    return acquiringConn
-      .timeout(100)
-      .then((conn) =>
-        this.query(conn, {
-          method: 'raw',
-          sql: 'KILL QUERY ?',
-          bindings: [connectionToKill.threadId],
-          options: {},
-        })
-      )
-      .finally(() => {
-        // NOT returning this promise because we want to release the connection
-        // in a non-blocking fashion
-        acquiringConn.then((conn) => this.releaseConnection(conn));
+  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);
+    }
   },
 });
 

package/lib/dialects/oracledb/index.js

@@ -108,9 +108,6 @@ Client_Oracledb.prototype.acquireRawConnection = function() {
       }
       connection.commitAsync = function() {
         return new Bluebird((commitResolve, commitReject) => {
-          if (connection.isTransaction) {
-            return commitResolve();
-          }
           this.commit(function(err) {
             if (err) {
               return commitReject(err);
@@ -293,7 +290,9 @@ Client_Oracledb.prototype._query = function(connection, obj) {
     }
 
     if (!obj.returning && outBinds.length === 0) {
-      await connection.commitAsync();
+      if (!connection.isTransaction) {
+        await connection.commitAsync();
+      }
       return obj;
     }
     const rowIds = [];
@@ -335,17 +334,15 @@ Client_Oracledb.prototype._query = function(connection, obj) {
         });
       }
     }
-    return connection.commitAsync().then(function() {
-      if (obj.returningSql) {
-        return connection
-          .executeAsync(obj.returningSql(), rowIds, { resultSet: true })
-          .then(function(response) {
-            obj.response = response.rows;
-            return obj;
-          });
-      }
+    if (connection.isTransaction) {
       return obj;
-    });
+    }
+    await connection.commitAsync();
+    if (obj.returningSql) {
+      const response = await connection.executeAsync(obj.returningSql(), rowIds, { resultSet: true })
+      obj.response = response.rows;
+    }
+    return obj;
   });
 };
 

package/lib/dialects/oracledb/transaction.js

@@ -2,6 +2,7 @@ const { isUndefined } = require('lodash');
 
 const Bluebird = require('bluebird');
 const Transaction = require('../../transaction');
+const { timeout, KnexTimeoutError } = require('../../util/timeout');
 const debugTx = require('debug')('knex:tx');
 
 module.exports = class Oracle_Transaction extends Transaction {
@@ -10,12 +11,14 @@ module.exports = class Oracle_Transaction extends Transaction {
     return Bluebird.resolve();
   }
 
-  commit(conn, value) {
+  async commit(conn, value) {
     this._completed = true;
-    return conn
-      .commitAsync()
-      .then(() => value)
-      .then(this._resolver, this._rejecter);
+    try {
+      await conn.commitAsync();
+      this._resolver(value);
+    } catch (err) {
+      this._rejecter(err);
+    }
   }
 
   release(conn, value) {
@@ -23,24 +26,24 @@ module.exports = class Oracle_Transaction extends Transaction {
   }
 
   rollback(conn, err) {
-    const self = this;
     this._completed = true;
     debugTx('%s: rolling back', this.txid);
-    return conn
-      .rollbackAsync()
-      .timeout(5000)
-      .catch(Bluebird.TimeoutError, function(e) {
-        self._rejecter(e);
+    return timeout(conn.rollbackAsync(), 5000)
+      .catch((e) => {
+        if (!(e instanceof KnexTimeoutError)) {
+          return Promise.reject(e);
+        }
+        this._rejecter(e);
       })
-      .then(function() {
+      .then(() => {
         if (isUndefined(err)) {
-          if (self.doNotRejectOnRollback) {
-            self._resolver();
+          if (this.doNotRejectOnRollback) {
+            this._resolver();
             return;
           }
           err = new Error(`Transaction rejected with non-error: ${err}`);
         }
-        self._rejecter(err);
+        this._rejecter(err);
       });
   }
 

package/lib/knex.js

@@ -5,6 +5,7 @@ const QueryInterface = require('./query/methods');
 
 const makeKnex = require('./util/make-knex');
 const parseConnection = require('./util/parse-connection');
+const { KnexTimeoutError } = require('./util/timeout');
 const fakeClient = require('./util/fake-client');
 const { SUPPORTED_CLIENTS } = require('./constants');
 const { resolveClientNameWithAliases } = require('./helpers');
@@ -58,6 +59,9 @@ function Knex(config) {
 
 // Expose Client on the main Knex namespace.
 Knex.Client = Client;
+
+Knex.KnexTimeoutError = KnexTimeoutError;
+
 Knex.QueryBuilder = {
   extend: function(methodName, fn) {
     QueryBuilder.extend(methodName, fn);

package/lib/runner.js

@@ -1,4 +1,6 @@
 const Bluebird = require('bluebird');
+const { KnexTimeoutError } = require('./util/timeout');
+const { timeout } = require('./util/timeout');
 
 let PassThrough;
 
@@ -133,7 +135,7 @@ Object.assign(Runner.prototype, {
     let queryPromise = this.client.query(this.connection, obj);
 
     if (obj.timeout) {
-      queryPromise = queryPromise.timeout(obj.timeout);
+      queryPromise = timeout(queryPromise, obj.timeout);
     }
 
     // Await the return value of client.processResponse; in the case of sqlite3's
@@ -164,7 +166,10 @@ Object.assign(Runner.prototype, {
 
         return postProcessedResponse;
       })
-      .catch(Bluebird.TimeoutError, (error) => {
+      .catch((error) => {
+        if (!(error instanceof KnexTimeoutError)) {
+          return Promise.reject(error);
+        }
         const { timeout, sql, bindings } = obj;
 
         let cancelQuery;
@@ -241,7 +246,10 @@ Object.assign(Runner.prototype, {
     }
     return this.client
       .acquireConnection()
-      .catch(Bluebird.TimeoutError, (error) => {
+      .catch((error) => {
+        if (!(error instanceof KnexTimeoutError)) {
+          return Promise.reject(error);
+        }
         if (this.builder) {
           error.sql = this.builder.sql;
           error.bindings = this.builder.bindings;

package/lib/transaction.js

@@ -5,6 +5,7 @@ const { EventEmitter } = require('events');
 const Debug = require('debug');
 
 const makeKnex = require('./util/make-knex');
+const { timeout, KnexTimeoutError } = require('./util/timeout');
 
 const debug = Debug('knex:tx');
 
@@ -150,19 +151,26 @@ class Transaction extends EventEmitter {
   }
 
   rollback(conn, error) {
-    return this.query(conn, 'ROLLBACK', 2, error)
-      .timeout(5000)
-      .catch(Bluebird.TimeoutError, () => {
+    return timeout(this.query(conn, 'ROLLBACK', 2, error), 5000).catch(
+      (err) => {
+        if (!(err instanceof KnexTimeoutError)) {
+          return Promise.reject(err);
+        }
         this._rejecter(error);
-      });
+      }
+    );
   }
 
   rollbackTo(conn, error) {
-    return this.query(conn, `ROLLBACK TO SAVEPOINT ${this.txid}`, 2, error)
-      .timeout(5000)
-      .catch(Bluebird.TimeoutError, () => {
-        this._rejecter(error);
-      });
+    return timeout(
+      this.query(conn, `ROLLBACK TO SAVEPOINT ${this.txid}`, 2, error),
+      5000
+    ).catch((err) => {
+      if (!(err instanceof KnexTimeoutError)) {
+        return Promise.reject(err);
+      }
+      this._rejecter(error);
+    });
   }
 
   query(conn, sql, status, value) {

package/lib/util/timeout.js

@@ -0,0 +1,20 @@
+const Bluebird = require('bluebird');
+const delay = require('./delay');
+
+class KnexTimeoutError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = 'KnexTimeoutError';
+  }
+}
+
+module.exports.KnexTimeoutError = KnexTimeoutError;
+module.exports.timeout = (promise, ms) =>
+  Bluebird.resolve(
+    Promise.race([
+      promise,
+      delay(ms).then(() =>
+        Promise.reject(new KnexTimeoutError('operation timed out'))
+      ),
+    ])
+  );

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "knex",
-  "version": "0.20.9",
+  "version": "0.20.10",
   "description": "A batteries-included SQL query & schema builder for Postgres, MySQL and SQLite3 and the Browser",
   "main": "knex.js",
   "types": "types/index.d.ts",
@@ -76,7 +76,7 @@
     ]
   },
   "devDependencies": {
-    "@types/node": "^10.17.14",
+    "@types/node": "^10.17.15",
     "JSONStream": "^1.3.5",
     "chai": "^4.2.0",
     "chai-subset-in-order": "^2.1.3",
@@ -99,7 +99,7 @@
     "pg": "^7.18.1",
     "pg-query-stream": "^2.1.2",
     "prettier": "1.18.2",
-    "rimraf": "^3.0.1",
+    "rimraf": "^3.0.2",
     "sinon": "^8.1.1",
     "sinon-chai": "^3.4.0",
     "source-map-support": "^0.5.16",
@@ -109,7 +109,7 @@
     "toxiproxy-node-client": "^2.0.6",
     "ts-node": "^8.6.2",
     "typescript": "3.7.4",
-    "webpack-cli": "^3.3.10"
+    "webpack-cli": "^3.3.1"
   },
   "buildDependencies": [
     "rimraf"

package/types/index.d.ts

@@ -13,6 +13,8 @@ import events = require('events');
 import stream = require('stream');
 import ResultTypes = require('./result');
 
+import { ConnectionOptions } from "tls";
+
 // # Generic type-level utilities
 
 // If T is object then make it a partial otherwise fallback to any
@@ -1808,6 +1810,7 @@ declare namespace Knex {
     statement_timeout?: false | number;
     connectionTimeoutMillis?: number;
     keepAliveInitialDelayMillis?: number;
+    ssl?: boolean | ConnectionOptions;
   }
 
   type RedshiftConnectionConfig = PgConnectionConfig;
@@ -1912,7 +1915,7 @@ declare namespace Knex {
   }
 
   interface FunctionHelper {
-    now(): Raw;
+    now(precision?: number): Raw;
   }
 
   interface EnumOptions {
@@ -1990,6 +1993,8 @@ declare namespace Knex {
       ) => QueryBuilder<TRecord, TResult>
     ): void;
   }
+
+  export class KnexTimeoutError extends Error {}
 }
 
 export = Knex;