decocms 2.340.3 → 2.340.4

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

@@ -1,40 +1,15 @@
-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')
-
-const activeQueryDeprecationNotice = nodeUtils.deprecate(
-  () => {},
-  'Client.activeQuery is deprecated and will be removed in pg@9.0'
-)
-
-const queryQueueDeprecationNotice = nodeUtils.deprecate(
-  () => {},
-  'Client.queryQueue is deprecated and will be removed in pg@9.0.'
-)
+'use strict'
 
-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.'
-)
+var EventEmitter = require('events').EventEmitter
+var utils = require('./utils')
+var sasl = require('./crypto/sasl')
+var TypeOverrides = require('./type-overrides')
 
-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.'
-)
+var ConnectionParameters = require('./connection-parameters')
+var Query = require('./query')
+var defaults = require('./defaults')
+var Connection = require('./connection')
+const crypto = require('./crypto/utils')
 
 class Client extends EventEmitter {
   constructor(config) {
@@ -57,11 +32,8 @@ class Client extends EventEmitter {
 
     this.replication = this.connectionParameters.replication
 
-    const c = config || {}
+    var c = config || {}
 
-    if (c.Promise) {
-      byoPromiseDeprecationNotice()
-    }
     this._Promise = c.Promise || global.Promise
     this._types = new TypeOverrides(c.types)
     this._ending = false
@@ -70,9 +42,7 @@ 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({
@@ -82,7 +52,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
@@ -99,20 +69,6 @@ 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(() => {
@@ -120,19 +76,18 @@ class Client extends EventEmitter {
       })
     }
 
-    const activeQuery = this._getActiveQuery()
-    if (activeQuery) {
-      enqueueError(activeQuery)
-      this._activeQuery = null
+    if (this.activeQuery) {
+      enqueueError(this.activeQuery)
+      this.activeQuery = null
     }
 
-    this._queryQueue.forEach(enqueueError)
-    this._queryQueue.length = 0
+    this.queryQueue.forEach(enqueueError)
+    this.queryQueue.length = 0
   }
 
   _connect(callback) {
-    const self = this
-    const con = this.connection
+    var self = this
+    var con = this.connection
     this._connectionCallback = callback
 
     if (this._connecting || this._connected) {
@@ -144,15 +99,12 @@ 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) {
@@ -216,7 +168,7 @@ class Client extends EventEmitter {
         if (error) {
           reject(error)
         } else {
-          resolve(this)
+          resolve()
         }
       })
     })
@@ -247,12 +199,14 @@ class Client extends EventEmitter {
     con.on('notification', this._handleNotification.bind(this))
   }
 
-  _getPassword(cb) {
+  // 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) {
     const con = this.connection
     if (typeof this.password === 'function') {
       this._Promise
         .resolve()
-        .then(() => this.password(this.connectionParameters))
+        .then(() => this.password())
         .then((pass) => {
           if (pass !== undefined) {
             if (typeof pass !== 'string') {
@@ -275,7 +229,6 @@ class Client extends EventEmitter {
         const pgPass = require('pgpass')
         pgPass(this.connectionParameters, (pass) => {
           if (undefined !== pass) {
-            pgPassDeprecationNotice()
             this.connectionParameters.password = this.password = pass
           }
           cb()
@@ -287,13 +240,13 @@ class Client extends EventEmitter {
   }
 
   _handleAuthCleartextPassword(msg) {
-    this._getPassword(() => {
+    this._checkPgPass(() => {
       this.connection.password(this.password)
     })
   }
 
   _handleAuthMD5Password(msg) {
-    this._getPassword(async () => {
+    this._checkPgPass(async () => {
       try {
         const hashedPassword = await crypto.postgresMd5PasswordHash(this.user, this.password, msg.salt)
         this.connection.password(hashedPassword)
@@ -304,9 +257,9 @@ class Client extends EventEmitter {
   }
 
   _handleAuthSASL(msg) {
-    this._getPassword(() => {
+    this._checkPgPass(() => {
       try {
-        this.saslSession = sasl.startSession(msg.mechanisms, this.enableChannelBinding && this.connection.stream)
+        this.saslSession = sasl.startSession(msg.mechanisms)
         this.connection.sendSASLInitialResponseMessage(this.saslSession.mechanism, this.saslSession.response)
       } catch (err) {
         this.connection.emit('error', err)
@@ -316,12 +269,7 @@ class Client extends EventEmitter {
 
   async _handleAuthSASLContinue(msg) {
     try {
-      await sasl.continueSession(
-        this.saslSession,
-        this.password,
-        msg.data,
-        this.enableChannelBinding && this.connection.stream
-      )
+      await sasl.continueSession(this.saslSession, this.password, msg.data)
       this.connection.sendSCRAMClientFinalMessage(this.saslSession.response)
     } catch (err) {
       this.connection.emit('error', err)
@@ -357,8 +305,8 @@ class Client extends EventEmitter {
       }
       this.emit('connect')
     }
-    const activeQuery = this._getActiveQuery()
-    this._activeQuery = null
+    const { activeQuery } = this
+    this.activeQuery = null
     this.readyForQuery = true
     if (activeQuery) {
       activeQuery.handleReadyForQuery(this.connection)
@@ -366,7 +314,7 @@ class Client extends EventEmitter {
     this._pulseQueryQueue()
   }
 
-  // if we receive an error event or error message
+  // if we receieve an error event or error message
   // during the connection process we handle it here
   _handleErrorWhileConnecting(err) {
     if (this._connectionError) {
@@ -398,105 +346,57 @@ class Client extends EventEmitter {
     if (this._connecting) {
       return this._handleErrorWhileConnecting(msg)
     }
-    const activeQuery = this._getActiveQuery()
+    const activeQuery = this.activeQuery
 
     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
-    activeQuery.handleRowDescription(msg)
+    this.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
-    activeQuery.handleDataRow(msg)
+    this.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
-    activeQuery.handlePortalSuspended(this.connection)
+    this.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
-    activeQuery.handleEmptyQuery(this.connection)
+    this.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
-    activeQuery.handleCommandComplete(msg, this.connection)
+    this.activeQuery.handleCommandComplete(msg, this.connection)
   }
 
-  _handleParseComplete() {
-    const activeQuery = this._getActiveQuery()
-    if (activeQuery == null) {
-      const error = new Error('Received unexpected parseComplete message from backend.')
-      this._handleErrorEvent(error)
-      return
-    }
+  _handleParseComplete(msg) {
     // 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 (activeQuery.name) {
-      this.connection.parsedStatements[activeQuery.name] = activeQuery.text
+    if (this.activeQuery.name) {
+      this.connection.parsedStatements[this.activeQuery.name] = this.activeQuery.text
     }
   }
 
   _handleCopyInResponse(msg) {
-    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)
+    this.activeQuery.handleCopyInResponse(this.connection)
   }
 
   _handleCopyData(msg) {
-    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)
+    this.activeQuery.handleCopyData(msg, this.connection)
   }
 
   _handleNotification(msg) {
@@ -508,14 +408,14 @@ class Client extends EventEmitter {
   }
 
   getStartupConf() {
-    const params = this.connectionParameters
+    var params = this.connectionParameters
 
-    const data = {
+    var data = {
       user: params.user,
       database: params.database,
     }
 
-    const appName = params.application_name || params.fallback_application_name
+    var appName = params.application_name || params.fallback_application_name
     if (appName) {
       data.application_name = appName
     }
@@ -540,7 +440,7 @@ class Client extends EventEmitter {
 
   cancel(client, query) {
     if (client.activeQuery === query) {
-      const con = this.connection
+      var con = this.connection
 
       if (this.host && this.host.indexOf('/') === 0) {
         con.connect(this.host + '/.s.PGSQL.' + this.port)
@@ -552,8 +452,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)
     }
   }
 
@@ -578,22 +478,21 @@ class Client extends EventEmitter {
 
   _pulseQueryQueue() {
     if (this.readyForQuery === true) {
-      this._activeQuery = this._queryQueue.shift()
-      const activeQuery = this._getActiveQuery()
-      if (activeQuery) {
+      this.activeQuery = this.queryQueue.shift()
+      if (this.activeQuery) {
         this.readyForQuery = false
         this.hasExecuted = true
 
-        const queryError = activeQuery.submit(this.connection)
+        const queryError = this.activeQuery.submit(this.connection)
         if (queryError) {
           process.nextTick(() => {
-            activeQuery.handleError(queryError, this.connection)
+            this.activeQuery.handleError(queryError, this.connection)
             this.readyForQuery = true
             this._pulseQueryQueue()
           })
         }
       } else if (this.hasExecuted) {
-        this._activeQuery = null
+        this.activeQuery = null
         this.emit('drain')
       }
     }
@@ -601,44 +500,40 @@ class Client extends EventEmitter {
 
   query(config, values, callback) {
     // can take in strings, config object or query object
-    let query
-    let result
-    let readTimeout
-    let readTimeoutTimer
-    let queryCallback
+    var query
+    var result
+    var readTimeout
+    var readTimeoutTimer
+    var 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 (!query.callback) {
-        if (typeof values === 'function') {
-          query.callback = values
-        } else if (callback) {
-          query.callback = callback
-        }
+      if (typeof values === 'function') {
+        query.callback = query.callback || values
       }
     } else {
-      readTimeout = config.query_timeout || this.connectionParameters.query_timeout
+      readTimeout = 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(() => {
-        const error = new Error('Query read timeout')
+        var error = new Error('Query read timeout')
 
         process.nextTick(() => {
           query.handleError(error, this.connection)
@@ -651,9 +546,9 @@ class Client extends EventEmitter {
         query.callback = () => {}
 
         // Remove from queue
-        const index = this._queryQueue.indexOf(query)
+        var index = this.queryQueue.indexOf(query)
         if (index > -1) {
-          this._queryQueue.splice(index, 1)
+          this.queryQueue.splice(index, 1)
         }
 
         this._pulseQueryQueue()
@@ -687,10 +582,7 @@ class Client extends EventEmitter {
       return result
     }
 
-    if (this._queryQueue.length > 0) {
-      queryQueueLengthDeprecationNotice()
-    }
-    this._queryQueue.push(query)
+    this.queryQueue.push(query)
     this._pulseQueryQueue()
     return result
   }
@@ -715,7 +607,7 @@ class Client extends EventEmitter {
       }
     }
 
-    if (this._getActiveQuery() || !this._queryable) {
+    if (this.activeQuery || !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()
@@ -731,10 +623,6 @@ 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,16 +1,12 @@
 'use strict'
 
-const dns = require('dns')
+var dns = require('dns')
 
-const defaults = require('./defaults')
+var defaults = require('./defaults')
 
-const parse = require('pg-connection-string').parse // parses a connection string
-
-const val = function (key, config, envVar) {
-  if (config[key]) {
-    return config[key]
-  }
+var parse = require('pg-connection-string').parse // parses a connection string
 
+var val = function (key, config, envVar) {
   if (envVar === undefined) {
     envVar = process.env['PG' + key.toUpperCase()]
   } else if (envVar === false) {
@@ -19,10 +15,10 @@ const val = function (key, config, envVar) {
     envVar = process.env[envVar]
   }
 
-  return envVar || defaults[key]
+  return config[key] || envVar || defaults[key]
 }
 
-const readSSLConfigFromEnvironment = function () {
+var readSSLConfigFromEnvironment = function () {
   switch (process.env.PGSSLMODE) {
     case 'disable':
       return false
@@ -38,12 +34,12 @@ const readSSLConfigFromEnvironment = function () {
 }
 
 // Convert arg to a string, surround in single quotes, and escape single quotes and backslashes
-const quoteParamValue = function (value) {
+var quoteParamValue = function (value) {
   return "'" + ('' + value).replace(/\\/g, '\\\\').replace(/'/g, "\\'") + "'"
 }
 
-const add = function (params, config, paramName) {
-  const value = config[paramName]
+var add = function (params, config, paramName) {
+  var value = config[paramName]
   if (value !== undefined && value !== null) {
     params.push(paramName + '=' + quoteParamValue(value))
   }
@@ -129,7 +125,7 @@ class ConnectionParameters {
   }
 
   getLibpqConnectionString(cb) {
-    const params = []
+    var params = []
     add(params, this, 'user')
     add(params, this, 'password')
     add(params, this, 'port')
@@ -138,7 +134,7 @@ class ConnectionParameters {
     add(params, this, 'connect_timeout')
     add(params, this, 'options')
 
-    const ssl = typeof this.ssl === 'object' ? this.ssl : this.ssl ? { sslmode: this.ssl } : {}
+    var 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,6 +1,7 @@
 'use strict'
 
-const EventEmitter = require('events').EventEmitter
+var net = require('net')
+var EventEmitter = require('events').EventEmitter
 
 const { parse, serialize } = require('pg-protocol')
 const { getStream, getSecureStream } = require('./stream')
@@ -22,11 +23,12 @@ 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
-    const self = this
+    var self = this
     this.on('newListener', function (eventName) {
       if (eventName === 'message') {
         self._emitMessage = true
@@ -35,7 +37,7 @@ class Connection extends EventEmitter {
   }
 
   connect(port, host) {
-    const self = this
+    var self = this
 
     this._connecting = true
     this.stream.setNoDelay(true)
@@ -66,7 +68,7 @@ class Connection extends EventEmitter {
     }
 
     this.stream.once('data', function (buffer) {
-      const responseCode = buffer.toString('utf8')
+      var responseCode = buffer.toString('utf8')
       switch (responseCode) {
         case 'S': // Server supports SSL connections, continue with a secure connection
           break
@@ -90,7 +92,7 @@ class Connection extends EventEmitter {
         }
       }
 
-      const net = require('net')
+      var net = require('net')
       if (net.isIP && net.isIP(host) === 0) {
         options.servername = host
       }
@@ -108,7 +110,7 @@ class Connection extends EventEmitter {
 
   attachListeners(stream) {
     parse(stream, (msg) => {
-      const eventName = msg.name === 'error' ? 'errorMessage' : msg.name
+      var eventName = msg.name === 'error' ? 'errorMessage' : msg.name
       if (this._emitMessage) {
         this.emit('message', msg)
       }