decocms 2.373.11 → 2.373.12

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

@@ -1,252 +0,0 @@
-'use strict'
-
-const { EventEmitter } = require('events')
-
-const Result = require('./result')
-const utils = require('./utils')
-
-class Query extends EventEmitter {
-  constructor(config, values, callback) {
-    super()
-
-    config = utils.normalizeQueryConfig(config, values, callback)
-
-    this.text = config.text
-    this.values = config.values
-    this.rows = config.rows
-    this.types = config.types
-    this.name = config.name
-    this.queryMode = config.queryMode
-    this.binary = config.binary
-    // use unique portal name each time
-    this.portal = config.portal || ''
-    this.callback = config.callback
-    this._rowMode = config.rowMode
-    if (process.domain && config.callback) {
-      this.callback = process.domain.bind(config.callback)
-    }
-    this._result = new Result(this._rowMode, this.types)
-
-    // potential for multiple results
-    this._results = this._result
-    this._canceledDueToError = false
-  }
-
-  requiresPreparation() {
-    if (this.queryMode === 'extended') {
-      return true
-    }
-
-    // named queries must always be prepared
-    if (this.name) {
-      return true
-    }
-    // always prepare if there are max number of rows expected per
-    // portal execution
-    if (this.rows) {
-      return true
-    }
-    // don't prepare empty text queries
-    if (!this.text) {
-      return false
-    }
-    // prepare if there are values
-    if (!this.values) {
-      return false
-    }
-    return this.values.length > 0
-  }
-
-  _checkForMultirow() {
-    // if we already have a result with a command property
-    // then we've already executed one query in a multi-statement simple query
-    // turn our results into an array of results
-    if (this._result.command) {
-      if (!Array.isArray(this._results)) {
-        this._results = [this._result]
-      }
-      this._result = new Result(this._rowMode, this._result._types)
-      this._results.push(this._result)
-    }
-  }
-
-  // associates row metadata from the supplied
-  // message with this query object
-  // metadata used when parsing row results
-  handleRowDescription(msg) {
-    this._checkForMultirow()
-    this._result.addFields(msg.fields)
-    this._accumulateRows = this.callback || !this.listeners('row').length
-  }
-
-  handleDataRow(msg) {
-    let row
-
-    if (this._canceledDueToError) {
-      return
-    }
-
-    try {
-      row = this._result.parseRow(msg.fields)
-    } catch (err) {
-      this._canceledDueToError = err
-      return
-    }
-
-    this.emit('row', row, this._result)
-    if (this._accumulateRows) {
-      this._result.addRow(row)
-    }
-  }
-
-  handleCommandComplete(msg, connection) {
-    this._checkForMultirow()
-    this._result.addCommandComplete(msg)
-    // need to sync after each command complete of a prepared statement
-    // if we were using a row count which results in multiple calls to _getRows
-    if (this.rows) {
-      connection.sync()
-    }
-  }
-
-  // if a named prepared statement is created with empty query text
-  // the backend will send an emptyQuery message but *not* a command complete message
-  // since we pipeline sync immediately after execute we don't need to do anything here
-  // unless we have rows specified, in which case we did not pipeline the initial sync call
-  handleEmptyQuery(connection) {
-    if (this.rows) {
-      connection.sync()
-    }
-  }
-
-  handleError(err, connection) {
-    // need to sync after error during a prepared statement
-    if (this._canceledDueToError) {
-      err = this._canceledDueToError
-      this._canceledDueToError = false
-    }
-    // if callback supplied do not emit error event as uncaught error
-    // events will bubble up to node process
-    if (this.callback) {
-      return this.callback(err)
-    }
-    this.emit('error', err)
-  }
-
-  handleReadyForQuery(con) {
-    if (this._canceledDueToError) {
-      return this.handleError(this._canceledDueToError, con)
-    }
-    if (this.callback) {
-      try {
-        this.callback(null, this._results)
-      } catch (err) {
-        process.nextTick(() => {
-          throw err
-        })
-      }
-    }
-    this.emit('end', this._results)
-  }
-
-  submit(connection) {
-    if (typeof this.text !== 'string' && typeof this.name !== 'string') {
-      return new Error('A query must have either text or a name. Supplying neither is unsupported.')
-    }
-    const previous = connection.parsedStatements[this.name]
-    if (this.text && previous && this.text !== previous) {
-      return new Error(`Prepared statements must be unique - '${this.name}' was used for a different statement`)
-    }
-    if (this.values && !Array.isArray(this.values)) {
-      return new Error('Query values must be an array')
-    }
-    if (this.requiresPreparation()) {
-      // If we're using the extended query protocol we fire off several separate commands
-      // to the backend. On some versions of node & some operating system versions
-      // the network stack writes each message separately instead of buffering them together
-      // causing the client & network to send more slowly. Corking & uncorking the stream
-      // allows node to buffer up the messages internally before sending them all off at once.
-      // note: we're checking for existence of cork/uncork because some versions of streams
-      // might not have this (cloudflare?)
-      connection.stream.cork && connection.stream.cork()
-      try {
-        this.prepare(connection)
-      } finally {
-        // while unlikely for this.prepare to throw, if it does & we don't uncork this stream
-        // this client becomes unresponsive, so put in finally block "just in case"
-        connection.stream.uncork && connection.stream.uncork()
-      }
-    } else {
-      connection.query(this.text)
-    }
-    return null
-  }
-
-  hasBeenParsed(connection) {
-    return this.name && connection.parsedStatements[this.name]
-  }
-
-  handlePortalSuspended(connection) {
-    this._getRows(connection, this.rows)
-  }
-
-  _getRows(connection, rows) {
-    connection.execute({
-      portal: this.portal,
-      rows: rows,
-    })
-    // if we're not reading pages of rows send the sync command
-    // to indicate the pipeline is finished
-    if (!rows) {
-      connection.sync()
-    } else {
-      // otherwise flush the call out to read more rows
-      connection.flush()
-    }
-  }
-
-  // http://developer.postgresql.org/pgdocs/postgres/protocol-flow.html#PROTOCOL-FLOW-EXT-QUERY
-  prepare(connection) {
-    // TODO refactor this poor encapsulation
-    if (!this.hasBeenParsed(connection)) {
-      connection.parse({
-        text: this.text,
-        name: this.name,
-        types: this.types,
-      })
-    }
-
-    // because we're mapping user supplied values to
-    // postgres wire protocol compatible values it could
-    // throw an exception, so try/catch this section
-    try {
-      connection.bind({
-        portal: this.portal,
-        statement: this.name,
-        values: this.values,
-        binary: this.binary,
-        valueMapper: utils.prepareValue,
-      })
-    } catch (err) {
-      this.handleError(err, connection)
-      return
-    }
-
-    connection.describe({
-      type: 'P',
-      name: this.portal || '',
-    })
-
-    this._getRows(connection, this.rows)
-  }
-
-  handleCopyInResponse(connection) {
-    connection.sendCopyFail('No source stream defined')
-  }
-
-  handleCopyData(msg, connection) {
-    // noop
-  }
-}
-
-module.exports = Query

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

@@ -1,109 +0,0 @@
-'use strict'
-
-const types = require('pg-types')
-
-const matchRegexp = /^([A-Za-z]+)(?: (\d+))?(?: (\d+))?/
-
-// result object returned from query
-// in the 'end' event and also
-// passed as second argument to provided callback
-class Result {
-  constructor(rowMode, types) {
-    this.command = null
-    this.rowCount = null
-    this.oid = null
-    this.rows = []
-    this.fields = []
-    this._parsers = undefined
-    this._types = types
-    this.RowCtor = null
-    this.rowAsArray = rowMode === 'array'
-    if (this.rowAsArray) {
-      this.parseRow = this._parseRowAsArray
-    }
-    this._prebuiltEmptyResultObject = null
-  }
-
-  // adds a command complete message
-  addCommandComplete(msg) {
-    let match
-    if (msg.text) {
-      // pure javascript
-      match = matchRegexp.exec(msg.text)
-    } else {
-      // native bindings
-      match = matchRegexp.exec(msg.command)
-    }
-    if (match) {
-      this.command = match[1]
-      if (match[3]) {
-        // COMMAND OID ROWS
-        this.oid = parseInt(match[2], 10)
-        this.rowCount = parseInt(match[3], 10)
-      } else if (match[2]) {
-        // COMMAND ROWS
-        this.rowCount = parseInt(match[2], 10)
-      }
-    }
-  }
-
-  _parseRowAsArray(rowData) {
-    const row = new Array(rowData.length)
-    for (let i = 0, len = rowData.length; i < len; i++) {
-      const rawValue = rowData[i]
-      if (rawValue !== null) {
-        row[i] = this._parsers[i](rawValue)
-      } else {
-        row[i] = null
-      }
-    }
-    return row
-  }
-
-  parseRow(rowData) {
-    const row = { ...this._prebuiltEmptyResultObject }
-    for (let i = 0, len = rowData.length; i < len; i++) {
-      const rawValue = rowData[i]
-      const field = this.fields[i].name
-      if (rawValue !== null) {
-        const v = this.fields[i].format === 'binary' ? Buffer.from(rawValue) : rawValue
-        row[field] = this._parsers[i](v)
-      } else {
-        row[field] = null
-      }
-    }
-    return row
-  }
-
-  addRow(row) {
-    this.rows.push(row)
-  }
-
-  addFields(fieldDescriptions) {
-    // clears field definitions
-    // multiple query statements in 1 action can result in multiple sets
-    // of rowDescriptions...eg: 'select NOW(); select 1::int;'
-    // you need to reset the fields
-    this.fields = fieldDescriptions
-    if (this.fields.length) {
-      this._parsers = new Array(fieldDescriptions.length)
-    }
-
-    const row = {}
-
-    for (let i = 0; i < fieldDescriptions.length; i++) {
-      const desc = fieldDescriptions[i]
-      row[desc.name] = null
-
-      if (this._types) {
-        this._parsers[i] = this._types.getTypeParser(desc.dataTypeID, desc.format || 'text')
-      } else {
-        this._parsers[i] = types.getTypeParser(desc.dataTypeID, desc.format || 'text')
-      }
-    }
-
-    this._prebuiltEmptyResultObject = { ...row }
-  }
-}
-
-module.exports = Result

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

@@ -1,83 +0,0 @@
-const { getStream, getSecureStream } = getStreamFuncs()
-
-module.exports = {
-  /**
-   * Get a socket stream compatible with the current runtime environment.
-   * @returns {Duplex}
-   */
-  getStream,
-  /**
-   * Get a TLS secured socket, compatible with the current environment,
-   * using the socket and other settings given in `options`.
-   * @returns {Duplex}
-   */
-  getSecureStream,
-}
-
-/**
- * The stream functions that work in Node.js
- */
-function getNodejsStreamFuncs() {
-  function getStream(ssl) {
-    const net = require('net')
-    return new net.Socket()
-  }
-
-  function getSecureStream(options) {
-    const tls = require('tls')
-    return tls.connect(options)
-  }
-  return {
-    getStream,
-    getSecureStream,
-  }
-}
-
-/**
- * The stream functions that work in Cloudflare Workers
- */
-function getCloudflareStreamFuncs() {
-  function getStream(ssl) {
-    const { CloudflareSocket } = require('pg-cloudflare')
-    return new CloudflareSocket(ssl)
-  }
-
-  function getSecureStream(options) {
-    options.socket.startTls(options)
-    return options.socket
-  }
-  return {
-    getStream,
-    getSecureStream,
-  }
-}
-
-/**
- * Are we running in a Cloudflare Worker?
- *
- * @returns true if the code is currently running inside a Cloudflare Worker.
- */
-function isCloudflareRuntime() {
-  // Since 2022-03-21 the `global_navigator` compatibility flag is on for Cloudflare Workers
-  // which means that `navigator.userAgent` will be defined.
-  // eslint-disable-next-line no-undef
-  if (typeof navigator === 'object' && navigator !== null && typeof navigator.userAgent === 'string') {
-    // eslint-disable-next-line no-undef
-    return navigator.userAgent === 'Cloudflare-Workers'
-  }
-  // In case `navigator` or `navigator.userAgent` is not defined then try a more sneaky approach
-  if (typeof Response === 'function') {
-    const resp = new Response(null, { cf: { thing: true } })
-    if (typeof resp.cf === 'object' && resp.cf !== null && resp.cf.thing) {
-      return true
-    }
-  }
-  return false
-}
-
-function getStreamFuncs() {
-  if (isCloudflareRuntime()) {
-    return getCloudflareStreamFuncs()
-  }
-  return getNodejsStreamFuncs()
-}

package/dist/server/node_modules/pg/lib/type-overrides.js

@@ -1,35 +0,0 @@
-'use strict'
-
-const types = require('pg-types')
-
-function TypeOverrides(userTypes) {
-  this._types = userTypes || types
-  this.text = {}
-  this.binary = {}
-}
-
-TypeOverrides.prototype.getOverrides = function (format) {
-  switch (format) {
-    case 'text':
-      return this.text
-    case 'binary':
-      return this.binary
-    default:
-      return {}
-  }
-}
-
-TypeOverrides.prototype.setTypeParser = function (oid, format, parseFn) {
-  if (typeof format === 'function') {
-    parseFn = format
-    format = 'text'
-  }
-  this.getOverrides(format)[oid] = parseFn
-}
-
-TypeOverrides.prototype.getTypeParser = function (oid, format) {
-  format = format || 'text'
-  return this.getOverrides(format)[oid] || this._types.getTypeParser(oid, format)
-}
-
-module.exports = TypeOverrides

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

@@ -1,217 +0,0 @@
-'use strict'
-
-const defaults = require('./defaults')
-
-const util = require('util')
-const { isDate } = util.types || util // Node 8 doesn't have `util.types`
-
-function escapeElement(elementRepresentation) {
-  const escaped = elementRepresentation.replace(/\\/g, '\\\\').replace(/"/g, '\\"')
-
-  return '"' + escaped + '"'
-}
-
-// convert a JS array to a postgres array literal
-// uses comma separator so won't work for types like box that use
-// a different array separator.
-function arrayString(val) {
-  let result = '{'
-  for (let i = 0; i < val.length; i++) {
-    if (i > 0) {
-      result = result + ','
-    }
-    if (val[i] === null || typeof val[i] === 'undefined') {
-      result = result + 'NULL'
-    } else if (Array.isArray(val[i])) {
-      result = result + arrayString(val[i])
-    } else if (ArrayBuffer.isView(val[i])) {
-      let item = val[i]
-      if (!(item instanceof Buffer)) {
-        const buf = Buffer.from(item.buffer, item.byteOffset, item.byteLength)
-        if (buf.length === item.byteLength) {
-          item = buf
-        } else {
-          item = buf.slice(item.byteOffset, item.byteOffset + item.byteLength)
-        }
-      }
-      result += '\\\\x' + item.toString('hex')
-    } else {
-      result += escapeElement(prepareValue(val[i]))
-    }
-  }
-  result = result + '}'
-  return result
-}
-
-// converts values from javascript types
-// to their 'raw' counterparts for use as a postgres parameter
-// note: you can override this function to provide your own conversion mechanism
-// for complex types, etc...
-const prepareValue = function (val, seen) {
-  // null and undefined are both null for postgres
-  if (val == null) {
-    return null
-  }
-  if (typeof val === 'object') {
-    if (val instanceof Buffer) {
-      return val
-    }
-    if (ArrayBuffer.isView(val)) {
-      const buf = Buffer.from(val.buffer, val.byteOffset, val.byteLength)
-      if (buf.length === val.byteLength) {
-        return buf
-      }
-      return buf.slice(val.byteOffset, val.byteOffset + val.byteLength) // Node.js v4 does not support those Buffer.from params
-    }
-    if (isDate(val)) {
-      if (defaults.parseInputDatesAsUTC) {
-        return dateToStringUTC(val)
-      } else {
-        return dateToString(val)
-      }
-    }
-    if (Array.isArray(val)) {
-      return arrayString(val)
-    }
-
-    return prepareObject(val, seen)
-  }
-  return val.toString()
-}
-
-function prepareObject(val, seen) {
-  if (val && typeof val.toPostgres === 'function') {
-    seen = seen || []
-    if (seen.indexOf(val) !== -1) {
-      throw new Error('circular reference detected while preparing "' + val + '" for query')
-    }
-    seen.push(val)
-
-    return prepareValue(val.toPostgres(prepareValue), seen)
-  }
-  return JSON.stringify(val)
-}
-
-function dateToString(date) {
-  let offset = -date.getTimezoneOffset()
-
-  let year = date.getFullYear()
-  const isBCYear = year < 1
-  if (isBCYear) year = Math.abs(year) + 1 // negative years are 1 off their BC representation
-
-  let ret =
-    String(year).padStart(4, '0') +
-    '-' +
-    String(date.getMonth() + 1).padStart(2, '0') +
-    '-' +
-    String(date.getDate()).padStart(2, '0') +
-    'T' +
-    String(date.getHours()).padStart(2, '0') +
-    ':' +
-    String(date.getMinutes()).padStart(2, '0') +
-    ':' +
-    String(date.getSeconds()).padStart(2, '0') +
-    '.' +
-    String(date.getMilliseconds()).padStart(3, '0')
-
-  if (offset < 0) {
-    ret += '-'
-    offset *= -1
-  } else {
-    ret += '+'
-  }
-
-  ret += String(Math.floor(offset / 60)).padStart(2, '0') + ':' + String(offset % 60).padStart(2, '0')
-  if (isBCYear) ret += ' BC'
-  return ret
-}
-
-function dateToStringUTC(date) {
-  let year = date.getUTCFullYear()
-  const isBCYear = year < 1
-  if (isBCYear) year = Math.abs(year) + 1 // negative years are 1 off their BC representation
-
-  let ret =
-    String(year).padStart(4, '0') +
-    '-' +
-    String(date.getUTCMonth() + 1).padStart(2, '0') +
-    '-' +
-    String(date.getUTCDate()).padStart(2, '0') +
-    'T' +
-    String(date.getUTCHours()).padStart(2, '0') +
-    ':' +
-    String(date.getUTCMinutes()).padStart(2, '0') +
-    ':' +
-    String(date.getUTCSeconds()).padStart(2, '0') +
-    '.' +
-    String(date.getUTCMilliseconds()).padStart(3, '0')
-
-  ret += '+00:00'
-  if (isBCYear) ret += ' BC'
-  return ret
-}
-
-function normalizeQueryConfig(config, values, callback) {
-  // can take in strings or config objects
-  config = typeof config === 'string' ? { text: config } : config
-  if (values) {
-    if (typeof values === 'function') {
-      config.callback = values
-    } else {
-      config.values = values
-    }
-  }
-  if (callback) {
-    config.callback = callback
-  }
-  return config
-}
-
-// Ported from PostgreSQL 9.2.4 source code in src/interfaces/libpq/fe-exec.c
-const escapeIdentifier = function (str) {
-  return '"' + str.replace(/"/g, '""') + '"'
-}
-
-const escapeLiteral = function (str) {
-  let hasBackslash = false
-  let escaped = "'"
-
-  if (str == null) {
-    return "''"
-  }
-
-  if (typeof str !== 'string') {
-    return "''"
-  }
-
-  for (let i = 0; i < str.length; i++) {
-    const c = str[i]
-    if (c === "'") {
-      escaped += c + c
-    } else if (c === '\\') {
-      escaped += c + c
-      hasBackslash = true
-    } else {
-      escaped += c
-    }
-  }
-
-  escaped += "'"
-
-  if (hasBackslash === true) {
-    escaped = ' E' + escaped
-  }
-
-  return escaped
-}
-
-module.exports = {
-  prepareValue: function prepareValueWrapper(value) {
-    // this ensures that extra arguments do not get passed into prepareValue
-    // by accident, eg: from calling values.map(utils.prepareValue)
-    return prepareValue(value)
-  },
-  normalizeQueryConfig,
-  escapeIdentifier,
-  escapeLiteral,
-}