decocms 2.375.0 → 2.375.1

package/dist/server/node_modules/pg/lib/client.js

@@ -1,15 +1,40 @@
-'use strict'
+const EventEmitter = require('events').EventEmitter
+const utils = require('./utils')
+const nodeUtils = require('util')
+const sasl = require('./crypto/sasl')
+const TypeOverrides = require('./type-overrides')
+
+const ConnectionParameters = require('./connection-parameters')
+const Query = require('./query')
+const defaults = require('./defaults')
+const Connection = require('./connection')
+const crypto = require('./crypto/utils')
 
-var EventEmitter = require('events').EventEmitter
-var utils = require('./utils')
-var sasl = require('./crypto/sasl')
-var TypeOverrides = require('./type-overrides')
+const activeQueryDeprecationNotice = nodeUtils.deprecate(
+  () => {},
+  'Client.activeQuery is deprecated and will be removed in pg@9.0'
+)
 
-var ConnectionParameters = require('./connection-parameters')
-var Query = require('./query')
-var defaults = require('./defaults')
-var Connection = require('./connection')
-const crypto = require('./crypto/utils')
+const queryQueueDeprecationNotice = nodeUtils.deprecate(
+  () => {},
+  'Client.queryQueue is deprecated and will be removed in pg@9.0.'
+)
+
+const pgPassDeprecationNotice = nodeUtils.deprecate(
+  () => {},
+  'pgpass support is deprecated and will be removed in pg@9.0. ' +
+    'You can provide an async function as the password property to the Client/Pool constructor that returns a password instead. Within this function you can call the pgpass module in your own code.'
+)
+
+const byoPromiseDeprecationNotice = nodeUtils.deprecate(
+  () => {},
+  'Passing a custom Promise implementation to the Client/Pool constructor is deprecated and will be removed in pg@9.0.'
+)
+
+const queryQueueLengthDeprecationNotice = nodeUtils.deprecate(
+  () => {},
+  'Calling client.query() when the client is already executing a query is deprecated and will be removed in pg@9.0. Use async/await or an external async flow control mechanism instead.'
+)
 
 class Client extends EventEmitter {
   constructor(config) {
@@ -32,8 +57,11 @@ class Client extends EventEmitter {
 
     this.replication = this.connectionParameters.replication
 
-    var c = config || {}
+    const c = config || {}
 
+    if (c.Promise) {
+      byoPromiseDeprecationNotice()
+    }
     this._Promise = c.Promise || global.Promise
     this._types = new TypeOverrides(c.types)
     this._ending = false
@@ -42,7 +70,9 @@ class Client extends EventEmitter {
     this._connected = false
     this._connectionError = false
     this._queryable = true
+    this._activeQuery = null
 
+    this.enableChannelBinding = Boolean(c.enableChannelBinding) // set true to use SCRAM-SHA-256-PLUS when offered
     this.connection =
       c.connection ||
       new Connection({
@@ -52,7 +82,7 @@ class Client extends EventEmitter {
         keepAliveInitialDelayMillis: c.keepAliveInitialDelayMillis || 0,
         encoding: this.connectionParameters.client_encoding || 'utf8',
       })
-    this.queryQueue = []
+    this._queryQueue = []
     this.binary = c.binary || defaults.binary
     this.processID = null
     this.secretKey = null
@@ -69,6 +99,20 @@ class Client extends EventEmitter {
     this._connectionTimeoutMillis = c.connectionTimeoutMillis || 0
   }
 
+  get activeQuery() {
+    activeQueryDeprecationNotice()
+    return this._activeQuery
+  }
+
+  set activeQuery(val) {
+    activeQueryDeprecationNotice()
+    this._activeQuery = val
+  }
+
+  _getActiveQuery() {
+    return this._activeQuery
+  }
+
   _errorAllQueries(err) {
     const enqueueError = (query) => {
       process.nextTick(() => {
@@ -76,18 +120,19 @@ class Client extends EventEmitter {
       })
     }
 
-    if (this.activeQuery) {
-      enqueueError(this.activeQuery)
-      this.activeQuery = null
+    const activeQuery = this._getActiveQuery()
+    if (activeQuery) {
+      enqueueError(activeQuery)
+      this._activeQuery = null
     }
 
-    this.queryQueue.forEach(enqueueError)
-    this.queryQueue.length = 0
+    this._queryQueue.forEach(enqueueError)
+    this._queryQueue.length = 0
   }
 
   _connect(callback) {
-    var self = this
-    var con = this.connection
+    const self = this
+    const con = this.connection
     this._connectionCallback = callback
 
     if (this._connecting || this._connected) {
@@ -99,12 +144,15 @@ class Client extends EventEmitter {
     }
     this._connecting = true
 
-    this.connectionTimeoutHandle
     if (this._connectionTimeoutMillis > 0) {
       this.connectionTimeoutHandle = setTimeout(() => {
         con._ending = true
         con.stream.destroy(new Error('timeout expired'))
       }, this._connectionTimeoutMillis)
+
+      if (this.connectionTimeoutHandle.unref) {
+        this.connectionTimeoutHandle.unref()
+      }
     }
 
     if (this.host && this.host.indexOf('/') === 0) {
@@ -168,7 +216,7 @@ class Client extends EventEmitter {
         if (error) {
           reject(error)
         } else {
-          resolve()
+          resolve(this)
         }
       })
     })
@@ -199,14 +247,12 @@ class Client extends EventEmitter {
     con.on('notification', this._handleNotification.bind(this))
   }
 
-  // TODO(bmc): deprecate pgpass "built in" integration since this.password can be a function
-  // it can be supplied by the user if required - this is a breaking change!
-  _checkPgPass(cb) {
+  _getPassword(cb) {
     const con = this.connection
     if (typeof this.password === 'function') {
       this._Promise
         .resolve()
-        .then(() => this.password())
+        .then(() => this.password(this.connectionParameters))
         .then((pass) => {
           if (pass !== undefined) {
             if (typeof pass !== 'string') {
@@ -229,6 +275,7 @@ class Client extends EventEmitter {
         const pgPass = require('pgpass')
         pgPass(this.connectionParameters, (pass) => {
           if (undefined !== pass) {
+            pgPassDeprecationNotice()
             this.connectionParameters.password = this.password = pass
           }
           cb()
@@ -240,13 +287,13 @@ class Client extends EventEmitter {
   }
 
   _handleAuthCleartextPassword(msg) {
-    this._checkPgPass(() => {
+    this._getPassword(() => {
       this.connection.password(this.password)
     })
   }
 
   _handleAuthMD5Password(msg) {
-    this._checkPgPass(async () => {
+    this._getPassword(async () => {
       try {
         const hashedPassword = await crypto.postgresMd5PasswordHash(this.user, this.password, msg.salt)
         this.connection.password(hashedPassword)
@@ -257,9 +304,9 @@ class Client extends EventEmitter {
   }
 
   _handleAuthSASL(msg) {
-    this._checkPgPass(() => {
+    this._getPassword(() => {
       try {
-        this.saslSession = sasl.startSession(msg.mechanisms)
+        this.saslSession = sasl.startSession(msg.mechanisms, this.enableChannelBinding && this.connection.stream)
         this.connection.sendSASLInitialResponseMessage(this.saslSession.mechanism, this.saslSession.response)
       } catch (err) {
         this.connection.emit('error', err)
@@ -269,7 +316,12 @@ class Client extends EventEmitter {
 
   async _handleAuthSASLContinue(msg) {
     try {
-      await sasl.continueSession(this.saslSession, this.password, msg.data)
+      await sasl.continueSession(
+        this.saslSession,
+        this.password,
+        msg.data,
+        this.enableChannelBinding && this.connection.stream
+      )
       this.connection.sendSCRAMClientFinalMessage(this.saslSession.response)
     } catch (err) {
       this.connection.emit('error', err)
@@ -305,8 +357,8 @@ class Client extends EventEmitter {
       }
       this.emit('connect')
     }
-    const { activeQuery } = this
-    this.activeQuery = null
+    const activeQuery = this._getActiveQuery()
+    this._activeQuery = null
     this.readyForQuery = true
     if (activeQuery) {
       activeQuery.handleReadyForQuery(this.connection)
@@ -314,7 +366,7 @@ class Client extends EventEmitter {
     this._pulseQueryQueue()
   }
 
-  // if we receieve an error event or error message
+  // if we receive an error event or error message
   // during the connection process we handle it here
   _handleErrorWhileConnecting(err) {
     if (this._connectionError) {
@@ -346,57 +398,105 @@ class Client extends EventEmitter {
     if (this._connecting) {
       return this._handleErrorWhileConnecting(msg)
     }
-    const activeQuery = this.activeQuery
+    const activeQuery = this._getActiveQuery()
 
     if (!activeQuery) {
       this._handleErrorEvent(msg)
       return
     }
 
-    this.activeQuery = null
+    this._activeQuery = null
     activeQuery.handleError(msg, this.connection)
   }
 
   _handleRowDescription(msg) {
+    const activeQuery = this._getActiveQuery()
+    if (activeQuery == null) {
+      const error = new Error('Received unexpected rowDescription message from backend.')
+      this._handleErrorEvent(error)
+      return
+    }
     // delegate rowDescription to active query
-    this.activeQuery.handleRowDescription(msg)
+    activeQuery.handleRowDescription(msg)
   }
 
   _handleDataRow(msg) {
+    const activeQuery = this._getActiveQuery()
+    if (activeQuery == null) {
+      const error = new Error('Received unexpected dataRow message from backend.')
+      this._handleErrorEvent(error)
+      return
+    }
     // delegate dataRow to active query
-    this.activeQuery.handleDataRow(msg)
+    activeQuery.handleDataRow(msg)
   }
 
   _handlePortalSuspended(msg) {
+    const activeQuery = this._getActiveQuery()
+    if (activeQuery == null) {
+      const error = new Error('Received unexpected portalSuspended message from backend.')
+      this._handleErrorEvent(error)
+      return
+    }
     // delegate portalSuspended to active query
-    this.activeQuery.handlePortalSuspended(this.connection)
+    activeQuery.handlePortalSuspended(this.connection)
   }
 
   _handleEmptyQuery(msg) {
+    const activeQuery = this._getActiveQuery()
+    if (activeQuery == null) {
+      const error = new Error('Received unexpected emptyQuery message from backend.')
+      this._handleErrorEvent(error)
+      return
+    }
     // delegate emptyQuery to active query
-    this.activeQuery.handleEmptyQuery(this.connection)
+    activeQuery.handleEmptyQuery(this.connection)
   }
 
   _handleCommandComplete(msg) {
+    const activeQuery = this._getActiveQuery()
+    if (activeQuery == null) {
+      const error = new Error('Received unexpected commandComplete message from backend.')
+      this._handleErrorEvent(error)
+      return
+    }
     // delegate commandComplete to active query
-    this.activeQuery.handleCommandComplete(msg, this.connection)
+    activeQuery.handleCommandComplete(msg, this.connection)
   }
 
-  _handleParseComplete(msg) {
+  _handleParseComplete() {
+    const activeQuery = this._getActiveQuery()
+    if (activeQuery == null) {
+      const error = new Error('Received unexpected parseComplete message from backend.')
+      this._handleErrorEvent(error)
+      return
+    }
     // if a prepared statement has a name and properly parses
     // we track that its already been executed so we don't parse
     // it again on the same client
-    if (this.activeQuery.name) {
-      this.connection.parsedStatements[this.activeQuery.name] = this.activeQuery.text
+    if (activeQuery.name) {
+      this.connection.parsedStatements[activeQuery.name] = activeQuery.text
     }
   }
 
   _handleCopyInResponse(msg) {
-    this.activeQuery.handleCopyInResponse(this.connection)
+    const activeQuery = this._getActiveQuery()
+    if (activeQuery == null) {
+      const error = new Error('Received unexpected copyInResponse message from backend.')
+      this._handleErrorEvent(error)
+      return
+    }
+    activeQuery.handleCopyInResponse(this.connection)
   }
 
   _handleCopyData(msg) {
-    this.activeQuery.handleCopyData(msg, this.connection)
+    const activeQuery = this._getActiveQuery()
+    if (activeQuery == null) {
+      const error = new Error('Received unexpected copyData message from backend.')
+      this._handleErrorEvent(error)
+      return
+    }
+    activeQuery.handleCopyData(msg, this.connection)
   }
 
   _handleNotification(msg) {
@@ -408,14 +508,14 @@ class Client extends EventEmitter {
   }
 
   getStartupConf() {
-    var params = this.connectionParameters
+    const params = this.connectionParameters
 
-    var data = {
+    const data = {
       user: params.user,
       database: params.database,
     }
 
-    var appName = params.application_name || params.fallback_application_name
+    const appName = params.application_name || params.fallback_application_name
     if (appName) {
       data.application_name = appName
     }
@@ -440,7 +540,7 @@ class Client extends EventEmitter {
 
   cancel(client, query) {
     if (client.activeQuery === query) {
-      var con = this.connection
+      const con = this.connection
 
       if (this.host && this.host.indexOf('/') === 0) {
         con.connect(this.host + '/.s.PGSQL.' + this.port)
@@ -452,8 +552,8 @@ class Client extends EventEmitter {
       con.on('connect', function () {
         con.cancel(client.processID, client.secretKey)
       })
-    } else if (client.queryQueue.indexOf(query) !== -1) {
-      client.queryQueue.splice(client.queryQueue.indexOf(query), 1)
+    } else if (client._queryQueue.indexOf(query) !== -1) {
+      client._queryQueue.splice(client._queryQueue.indexOf(query), 1)
     }
   }
 
@@ -478,21 +578,22 @@ class Client extends EventEmitter {
 
   _pulseQueryQueue() {
     if (this.readyForQuery === true) {
-      this.activeQuery = this.queryQueue.shift()
-      if (this.activeQuery) {
+      this._activeQuery = this._queryQueue.shift()
+      const activeQuery = this._getActiveQuery()
+      if (activeQuery) {
         this.readyForQuery = false
         this.hasExecuted = true
 
-        const queryError = this.activeQuery.submit(this.connection)
+        const queryError = activeQuery.submit(this.connection)
         if (queryError) {
           process.nextTick(() => {
-            this.activeQuery.handleError(queryError, this.connection)
+            activeQuery.handleError(queryError, this.connection)
             this.readyForQuery = true
             this._pulseQueryQueue()
           })
         }
       } else if (this.hasExecuted) {
-        this.activeQuery = null
+        this._activeQuery = null
         this.emit('drain')
       }
     }
@@ -500,40 +601,44 @@ class Client extends EventEmitter {
 
   query(config, values, callback) {
     // can take in strings, config object or query object
-    var query
-    var result
-    var readTimeout
-    var readTimeoutTimer
-    var queryCallback
+    let query
+    let result
+    let readTimeout
+    let readTimeoutTimer
+    let queryCallback
 
     if (config === null || config === undefined) {
       throw new TypeError('Client was passed a null or undefined query')
     } else if (typeof config.submit === 'function') {
       readTimeout = config.query_timeout || this.connectionParameters.query_timeout
       result = query = config
-      if (typeof values === 'function') {
-        query.callback = query.callback || values
+      if (!query.callback) {
+        if (typeof values === 'function') {
+          query.callback = values
+        } else if (callback) {
+          query.callback = callback
+        }
       }
     } else {
-      readTimeout = this.connectionParameters.query_timeout
+      readTimeout = config.query_timeout || this.connectionParameters.query_timeout
       query = new Query(config, values, callback)
       if (!query.callback) {
         result = new this._Promise((resolve, reject) => {
           query.callback = (err, res) => (err ? reject(err) : resolve(res))
-        }).catch(err => {
+        }).catch((err) => {
           // replace the stack trace that leads to `TCP.onStreamRead` with one that leads back to the
           // application that created the query
-          Error.captureStackTrace(err);
-          throw err;
+          Error.captureStackTrace(err)
+          throw err
         })
       }
     }
 
     if (readTimeout) {
-      queryCallback = query.callback
+      queryCallback = query.callback || (() => {})
 
       readTimeoutTimer = setTimeout(() => {
-        var error = new Error('Query read timeout')
+        const error = new Error('Query read timeout')
 
         process.nextTick(() => {
           query.handleError(error, this.connection)
@@ -546,9 +651,9 @@ class Client extends EventEmitter {
         query.callback = () => {}
 
         // Remove from queue
-        var index = this.queryQueue.indexOf(query)
+        const index = this._queryQueue.indexOf(query)
         if (index > -1) {
-          this.queryQueue.splice(index, 1)
+          this._queryQueue.splice(index, 1)
         }
 
         this._pulseQueryQueue()
@@ -582,7 +687,10 @@ class Client extends EventEmitter {
       return result
     }
 
-    this.queryQueue.push(query)
+    if (this._queryQueue.length > 0) {
+      queryQueueLengthDeprecationNotice()
+    }
+    this._queryQueue.push(query)
     this._pulseQueryQueue()
     return result
   }
@@ -607,7 +715,7 @@ class Client extends EventEmitter {
       }
     }
 
-    if (this.activeQuery || !this._queryable) {
+    if (this._getActiveQuery() || !this._queryable) {
       // if we have an active query we need to force a disconnect
       // on the socket - otherwise a hung query could block end forever
       this.connection.stream.destroy()
@@ -623,6 +731,10 @@ class Client extends EventEmitter {
       })
     }
   }
+  get queryQueue() {
+    queryQueueDeprecationNotice()
+    return this._queryQueue
+  }
 }
 
 // expose a Query constructor

package/dist/server/node_modules/pg/lib/connection-parameters.js

@@ -1,12 +1,16 @@
 'use strict'
 
-var dns = require('dns')
+const dns = require('dns')
 
-var defaults = require('./defaults')
+const defaults = require('./defaults')
 
-var parse = require('pg-connection-string').parse // parses a connection string
+const parse = require('pg-connection-string').parse // parses a connection string
+
+const val = function (key, config, envVar) {
+  if (config[key]) {
+    return config[key]
+  }
 
-var val = function (key, config, envVar) {
   if (envVar === undefined) {
     envVar = process.env['PG' + key.toUpperCase()]
   } else if (envVar === false) {
@@ -15,10 +19,10 @@ var val = function (key, config, envVar) {
     envVar = process.env[envVar]
   }
 
-  return config[key] || envVar || defaults[key]
+  return envVar || defaults[key]
 }
 
-var readSSLConfigFromEnvironment = function () {
+const readSSLConfigFromEnvironment = function () {
   switch (process.env.PGSSLMODE) {
     case 'disable':
       return false
@@ -34,12 +38,12 @@ var readSSLConfigFromEnvironment = function () {
 }
 
 // Convert arg to a string, surround in single quotes, and escape single quotes and backslashes
-var quoteParamValue = function (value) {
+const quoteParamValue = function (value) {
   return "'" + ('' + value).replace(/\\/g, '\\\\').replace(/'/g, "\\'") + "'"
 }
 
-var add = function (params, config, paramName) {
-  var value = config[paramName]
+const add = function (params, config, paramName) {
+  const value = config[paramName]
   if (value !== undefined && value !== null) {
     params.push(paramName + '=' + quoteParamValue(value))
   }
@@ -125,7 +129,7 @@ class ConnectionParameters {
   }
 
   getLibpqConnectionString(cb) {
-    var params = []
+    const params = []
     add(params, this, 'user')
     add(params, this, 'password')
     add(params, this, 'port')
@@ -134,7 +138,7 @@ class ConnectionParameters {
     add(params, this, 'connect_timeout')
     add(params, this, 'options')
 
-    var ssl = typeof this.ssl === 'object' ? this.ssl : this.ssl ? { sslmode: this.ssl } : {}
+    const ssl = typeof this.ssl === 'object' ? this.ssl : this.ssl ? { sslmode: this.ssl } : {}
     add(params, ssl, 'sslmode')
     add(params, ssl, 'sslca')
     add(params, ssl, 'sslkey')

package/dist/server/node_modules/pg/lib/connection.js

@@ -1,7 +1,6 @@
 'use strict'
 
-var net = require('net')
-var EventEmitter = require('events').EventEmitter
+const EventEmitter = require('events').EventEmitter
 
 const { parse, serialize } = require('pg-protocol')
 const { getStream, getSecureStream } = require('./stream')
@@ -23,12 +22,11 @@ class Connection extends EventEmitter {
 
     this._keepAlive = config.keepAlive
     this._keepAliveInitialDelayMillis = config.keepAliveInitialDelayMillis
-    this.lastBuffer = false
     this.parsedStatements = {}
     this.ssl = config.ssl || false
     this._ending = false
     this._emitMessage = false
-    var self = this
+    const self = this
     this.on('newListener', function (eventName) {
       if (eventName === 'message') {
         self._emitMessage = true
@@ -37,7 +35,7 @@ class Connection extends EventEmitter {
   }
 
   connect(port, host) {
-    var self = this
+    const self = this
 
     this._connecting = true
     this.stream.setNoDelay(true)
@@ -68,7 +66,7 @@ class Connection extends EventEmitter {
     }
 
     this.stream.once('data', function (buffer) {
-      var responseCode = buffer.toString('utf8')
+      const responseCode = buffer.toString('utf8')
       switch (responseCode) {
         case 'S': // Server supports SSL connections, continue with a secure connection
           break
@@ -92,7 +90,7 @@ class Connection extends EventEmitter {
         }
       }
 
-      var net = require('net')
+      const net = require('net')
       if (net.isIP && net.isIP(host) === 0) {
         options.servername = host
       }
@@ -110,7 +108,7 @@ class Connection extends EventEmitter {
 
   attachListeners(stream) {
     parse(stream, (msg) => {
-      var eventName = msg.name === 'error' ? 'errorMessage' : msg.name
+      const eventName = msg.name === 'error' ? 'errorMessage' : msg.name
       if (this._emitMessage) {
         this.emit('message', msg)
       }