decocms 2.380.12 → 2.381.1

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

@@ -1,84 +0,0 @@
-'use strict'
-
-module.exports = {
-  // database host. defaults to localhost
-  host: 'localhost',
-
-  // database user's name
-  user: process.platform === 'win32' ? process.env.USERNAME : process.env.USER,
-
-  // name of database to connect
-  database: undefined,
-
-  // database user's password
-  password: null,
-
-  // a Postgres connection string to be used instead of setting individual connection items
-  // NOTE:  Setting this value will cause it to override any other value (such as database or user) defined
-  // in the defaults object.
-  connectionString: undefined,
-
-  // database port
-  port: 5432,
-
-  // number of rows to return at a time from a prepared statement's
-  // portal. 0 will return all rows at once
-  rows: 0,
-
-  // binary result mode
-  binary: false,
-
-  // Connection pool options - see https://github.com/brianc/node-pg-pool
-
-  // number of connections to use in connection pool
-  // 0 will disable connection pooling
-  max: 10,
-
-  // max milliseconds a client can go unused before it is removed
-  // from the pool and destroyed
-  idleTimeoutMillis: 30000,
-
-  client_encoding: '',
-
-  ssl: false,
-
-  application_name: undefined,
-
-  fallback_application_name: undefined,
-
-  options: undefined,
-
-  parseInputDatesAsUTC: false,
-
-  // max milliseconds any query using this connection will execute for before timing out in error.
-  // false=unlimited
-  statement_timeout: false,
-
-  // Abort any statement that waits longer than the specified duration in milliseconds while attempting to acquire a lock.
-  // false=unlimited
-  lock_timeout: false,
-
-  // Terminate any session with an open transaction that has been idle for longer than the specified duration in milliseconds
-  // false=unlimited
-  idle_in_transaction_session_timeout: false,
-
-  // max milliseconds to wait for query to complete (client side)
-  query_timeout: false,
-
-  connect_timeout: 0,
-
-  keepalives: 1,
-
-  keepalives_idle: 0,
-}
-
-var pgTypes = require('pg-types')
-// save default parsers
-var parseBigInteger = pgTypes.getTypeParser(20, 'text')
-var parseBigIntegerArray = pgTypes.getTypeParser(1016, 'text')
-
-// parse int8 so you can get your count values as actual numbers
-module.exports.__defineSetter__('parseInt8', function (val) {
-  pgTypes.setTypeParser(20, 'text', val ? pgTypes.getTypeParser(23, 'text') : parseBigInteger)
-  pgTypes.setTypeParser(1016, 'text', val ? pgTypes.getTypeParser(1007, 'text') : parseBigIntegerArray)
-})

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

@@ -1,58 +0,0 @@
-'use strict'
-
-var Client = require('./client')
-var defaults = require('./defaults')
-var Connection = require('./connection')
-var Pool = require('pg-pool')
-const { DatabaseError } = require('pg-protocol')
-const { escapeIdentifier, escapeLiteral } = require('./utils')
-
-const poolFactory = (Client) => {
-  return class BoundPool extends Pool {
-    constructor(options) {
-      super(options, Client)
-    }
-  }
-}
-
-var PG = function (clientConstructor) {
-  this.defaults = defaults
-  this.Client = clientConstructor
-  this.Query = this.Client.Query
-  this.Pool = poolFactory(this.Client)
-  this._pools = []
-  this.Connection = Connection
-  this.types = require('pg-types')
-  this.DatabaseError = DatabaseError
-  this.escapeIdentifier = escapeIdentifier
-  this.escapeLiteral = escapeLiteral
-}
-
-if (typeof process.env.NODE_PG_FORCE_NATIVE !== 'undefined') {
-  module.exports = new PG(require('./native'))
-} else {
-  module.exports = new PG(Client)
-
-  // lazy require native module...the native module may not have installed
-  Object.defineProperty(module.exports, 'native', {
-    configurable: true,
-    enumerable: false,
-    get() {
-      var native = null
-      try {
-        native = new PG(require('./native'))
-      } catch (err) {
-        if (err.code !== 'MODULE_NOT_FOUND') {
-          throw err
-        }
-      }
-
-      // overwrite module.exports.native so that getter is never called again
-      Object.defineProperty(module.exports, 'native', {
-        value: native,
-      })
-
-      return native
-    },
-  })
-}

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

@@ -1,307 +0,0 @@
-'use strict'
-
-// eslint-disable-next-line
-var Native
-try {
-  // Wrap this `require()` in a try-catch to avoid upstream bundlers from complaining that this might not be available since it is an optional import
-  Native = require('pg-native')
-} catch (e) {
-  throw e
-}
-var TypeOverrides = require('../type-overrides')
-var EventEmitter = require('events').EventEmitter
-var util = require('util')
-var ConnectionParameters = require('../connection-parameters')
-
-var NativeQuery = require('./query')
-
-var Client = (module.exports = function (config) {
-  EventEmitter.call(this)
-  config = config || {}
-
-  this._Promise = config.Promise || global.Promise
-  this._types = new TypeOverrides(config.types)
-
-  this.native = new Native({
-    types: this._types,
-  })
-
-  this._queryQueue = []
-  this._ending = false
-  this._connecting = false
-  this._connected = false
-  this._queryable = true
-
-  // keep these on the object for legacy reasons
-  // for the time being. TODO: deprecate all this jazz
-  var cp = (this.connectionParameters = new ConnectionParameters(config))
-  if (config.nativeConnectionString) cp.nativeConnectionString = config.nativeConnectionString
-  this.user = cp.user
-
-  // "hiding" the password so it doesn't show up in stack traces
-  // or if the client is console.logged
-  Object.defineProperty(this, 'password', {
-    configurable: true,
-    enumerable: false,
-    writable: true,
-    value: cp.password,
-  })
-  this.database = cp.database
-  this.host = cp.host
-  this.port = cp.port
-
-  // a hash to hold named queries
-  this.namedQueries = {}
-})
-
-Client.Query = NativeQuery
-
-util.inherits(Client, EventEmitter)
-
-Client.prototype._errorAllQueries = function (err) {
-  const enqueueError = (query) => {
-    process.nextTick(() => {
-      query.native = this.native
-      query.handleError(err)
-    })
-  }
-
-  if (this._hasActiveQuery()) {
-    enqueueError(this._activeQuery)
-    this._activeQuery = null
-  }
-
-  this._queryQueue.forEach(enqueueError)
-  this._queryQueue.length = 0
-}
-
-// connect to the backend
-// pass an optional callback to be called once connected
-// or with an error if there was a connection error
-Client.prototype._connect = function (cb) {
-  var self = this
-
-  if (this._connecting) {
-    process.nextTick(() => cb(new Error('Client has already been connected. You cannot reuse a client.')))
-    return
-  }
-
-  this._connecting = true
-
-  this.connectionParameters.getLibpqConnectionString(function (err, conString) {
-    if (self.connectionParameters.nativeConnectionString) conString = self.connectionParameters.nativeConnectionString
-    if (err) return cb(err)
-    self.native.connect(conString, function (err) {
-      if (err) {
-        self.native.end()
-        return cb(err)
-      }
-
-      // set internal states to connected
-      self._connected = true
-
-      // handle connection errors from the native layer
-      self.native.on('error', function (err) {
-        self._queryable = false
-        self._errorAllQueries(err)
-        self.emit('error', err)
-      })
-
-      self.native.on('notification', function (msg) {
-        self.emit('notification', {
-          channel: msg.relname,
-          payload: msg.extra,
-        })
-      })
-
-      // signal we are connected now
-      self.emit('connect')
-      self._pulseQueryQueue(true)
-
-      cb()
-    })
-  })
-}
-
-Client.prototype.connect = function (callback) {
-  if (callback) {
-    this._connect(callback)
-    return
-  }
-
-  return new this._Promise((resolve, reject) => {
-    this._connect((error) => {
-      if (error) {
-        reject(error)
-      } else {
-        resolve()
-      }
-    })
-  })
-}
-
-// send a query to the server
-// this method is highly overloaded to take
-// 1) string query, optional array of parameters, optional function callback
-// 2) object query with {
-//    string query
-//    optional array values,
-//    optional function callback instead of as a separate parameter
-//    optional string name to name & cache the query plan
-//    optional string rowMode = 'array' for an array of results
-//  }
-Client.prototype.query = function (config, values, callback) {
-  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
-    // accept query(new Query(...), (err, res) => { }) style
-    if (typeof values === 'function') {
-      config.callback = values
-    }
-  } else {
-    readTimeout = this.connectionParameters.query_timeout
-    query = new NativeQuery(config, values, callback)
-    if (!query.callback) {
-      let resolveOut, rejectOut
-      result = new this._Promise((resolve, reject) => {
-        resolveOut = resolve
-        rejectOut = reject
-      }).catch(err => {
-        Error.captureStackTrace(err);
-        throw err;
-      })
-      query.callback = (err, res) => (err ? rejectOut(err) : resolveOut(res))
-    }
-  }
-
-  if (readTimeout) {
-    queryCallback = query.callback
-
-    readTimeoutTimer = setTimeout(() => {
-      var error = new Error('Query read timeout')
-
-      process.nextTick(() => {
-        query.handleError(error, this.connection)
-      })
-
-      queryCallback(error)
-
-      // we already returned an error,
-      // just do nothing if query completes
-      query.callback = () => {}
-
-      // Remove from queue
-      var index = this._queryQueue.indexOf(query)
-      if (index > -1) {
-        this._queryQueue.splice(index, 1)
-      }
-
-      this._pulseQueryQueue()
-    }, readTimeout)
-
-    query.callback = (err, res) => {
-      clearTimeout(readTimeoutTimer)
-      queryCallback(err, res)
-    }
-  }
-
-  if (!this._queryable) {
-    query.native = this.native
-    process.nextTick(() => {
-      query.handleError(new Error('Client has encountered a connection error and is not queryable'))
-    })
-    return result
-  }
-
-  if (this._ending) {
-    query.native = this.native
-    process.nextTick(() => {
-      query.handleError(new Error('Client was closed and is not queryable'))
-    })
-    return result
-  }
-
-  this._queryQueue.push(query)
-  this._pulseQueryQueue()
-  return result
-}
-
-// disconnect from the backend server
-Client.prototype.end = function (cb) {
-  var self = this
-
-  this._ending = true
-
-  if (!this._connected) {
-    this.once('connect', this.end.bind(this, cb))
-  }
-  var result
-  if (!cb) {
-    result = new this._Promise(function (resolve, reject) {
-      cb = (err) => (err ? reject(err) : resolve())
-    })
-  }
-  this.native.end(function () {
-    self._errorAllQueries(new Error('Connection terminated'))
-
-    process.nextTick(() => {
-      self.emit('end')
-      if (cb) cb()
-    })
-  })
-  return result
-}
-
-Client.prototype._hasActiveQuery = function () {
-  return this._activeQuery && this._activeQuery.state !== 'error' && this._activeQuery.state !== 'end'
-}
-
-Client.prototype._pulseQueryQueue = function (initialConnection) {
-  if (!this._connected) {
-    return
-  }
-  if (this._hasActiveQuery()) {
-    return
-  }
-  var query = this._queryQueue.shift()
-  if (!query) {
-    if (!initialConnection) {
-      this.emit('drain')
-    }
-    return
-  }
-  this._activeQuery = query
-  query.submit(this)
-  var self = this
-  query.once('_done', function () {
-    self._pulseQueryQueue()
-  })
-}
-
-// attempt to cancel an in-progress query
-Client.prototype.cancel = function (query) {
-  if (this._activeQuery === query) {
-    this.native.cancel(function () {})
-  } else if (this._queryQueue.indexOf(query) !== -1) {
-    this._queryQueue.splice(this._queryQueue.indexOf(query), 1)
-  }
-}
-
-Client.prototype.ref = function () {}
-Client.prototype.unref = function () {}
-
-Client.prototype.setTypeParser = function (oid, format, parseFn) {
-  return this._types.setTypeParser(oid, format, parseFn)
-}
-
-Client.prototype.getTypeParser = function (oid, format) {
-  return this._types.getTypeParser(oid, format)
-}

package/dist/server/node_modules/pg/lib/native/index.js

@@ -1,2 +0,0 @@
-'use strict'
-module.exports = require('./client')

package/dist/server/node_modules/pg/lib/native/query.js

@@ -1,165 +0,0 @@
-'use strict'
-
-var EventEmitter = require('events').EventEmitter
-var util = require('util')
-var utils = require('../utils')
-
-var NativeQuery = (module.exports = function (config, values, callback) {
-  EventEmitter.call(this)
-  config = utils.normalizeQueryConfig(config, values, callback)
-  this.text = config.text
-  this.values = config.values
-  this.name = config.name
-  this.callback = config.callback
-  this.state = 'new'
-  this._arrayMode = config.rowMode === 'array'
-
-  // if the 'row' event is listened for
-  // then emit them as they come in
-  // without setting singleRowMode to true
-  // this has almost no meaning because libpq
-  // reads all rows into memory befor returning any
-  this._emitRowEvents = false
-  this.on(
-    'newListener',
-    function (event) {
-      if (event === 'row') this._emitRowEvents = true
-    }.bind(this)
-  )
-})
-
-util.inherits(NativeQuery, EventEmitter)
-
-var errorFieldMap = {
-  /* eslint-disable quote-props */
-  sqlState: 'code',
-  statementPosition: 'position',
-  messagePrimary: 'message',
-  context: 'where',
-  schemaName: 'schema',
-  tableName: 'table',
-  columnName: 'column',
-  dataTypeName: 'dataType',
-  constraintName: 'constraint',
-  sourceFile: 'file',
-  sourceLine: 'line',
-  sourceFunction: 'routine',
-}
-
-NativeQuery.prototype.handleError = function (err) {
-  // copy pq error fields into the error object
-  var fields = this.native.pq.resultErrorFields()
-  if (fields) {
-    for (var key in fields) {
-      var normalizedFieldName = errorFieldMap[key] || key
-      err[normalizedFieldName] = fields[key]
-    }
-  }
-  if (this.callback) {
-    this.callback(err)
-  } else {
-    this.emit('error', err)
-  }
-  this.state = 'error'
-}
-
-NativeQuery.prototype.then = function (onSuccess, onFailure) {
-  return this._getPromise().then(onSuccess, onFailure)
-}
-
-NativeQuery.prototype.catch = function (callback) {
-  return this._getPromise().catch(callback)
-}
-
-NativeQuery.prototype._getPromise = function () {
-  if (this._promise) return this._promise
-  this._promise = new Promise(
-    function (resolve, reject) {
-      this._once('end', resolve)
-      this._once('error', reject)
-    }.bind(this)
-  )
-  return this._promise
-}
-
-NativeQuery.prototype.submit = function (client) {
-  this.state = 'running'
-  var self = this
-  this.native = client.native
-  client.native.arrayMode = this._arrayMode
-
-  var after = function (err, rows, results) {
-    client.native.arrayMode = false
-    setImmediate(function () {
-      self.emit('_done')
-    })
-
-    // handle possible query error
-    if (err) {
-      return self.handleError(err)
-    }
-
-    // emit row events for each row in the result
-    if (self._emitRowEvents) {
-      if (results.length > 1) {
-        rows.forEach((rowOfRows, i) => {
-          rowOfRows.forEach((row) => {
-            self.emit('row', row, results[i])
-          })
-        })
-      } else {
-        rows.forEach(function (row) {
-          self.emit('row', row, results)
-        })
-      }
-    }
-
-    // handle successful result
-    self.state = 'end'
-    self.emit('end', results)
-    if (self.callback) {
-      self.callback(null, results)
-    }
-  }
-
-  if (process.domain) {
-    after = process.domain.bind(after)
-  }
-
-  // named query
-  if (this.name) {
-    if (this.name.length > 63) {
-      /* eslint-disable no-console */
-      console.error('Warning! Postgres only supports 63 characters for query names.')
-      console.error('You supplied %s (%s)', this.name, this.name.length)
-      console.error('This can cause conflicts and silent errors executing queries')
-      /* eslint-enable no-console */
-    }
-    var values = (this.values || []).map(utils.prepareValue)
-
-    // check if the client has already executed this named query
-    // if so...just execute it again - skip the planning phase
-    if (client.namedQueries[this.name]) {
-      if (this.text && client.namedQueries[this.name] !== this.text) {
-        const err = new Error(`Prepared statements must be unique - '${this.name}' was used for a different statement`)
-        return after(err)
-      }
-      return client.native.execute(this.name, values, after)
-    }
-    // plan the named query the first time, then execute it
-    return client.native.prepare(this.name, this.text, values.length, function (err) {
-      if (err) return after(err)
-      client.namedQueries[self.name] = self.text
-      return self.native.execute(self.name, values, after)
-    })
-  } else if (this.values) {
-    if (!Array.isArray(this.values)) {
-      const err = new Error('Query values must be an array')
-      return after(err)
-    }
-    var vals = this.values.map(utils.prepareValue)
-    client.native.query(this.text, vals, after)
-  } else {
-    client.native.query(this.text, after)
-  }
-}