decocms 2.367.1 → 2.367.3

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

@@ -0,0 +1,241 @@
+'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.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.isPreparedStatement = false
+    this._canceledDueToError = false
+    this._promise = null
+  }
+
+  requiresPreparation() {
+    // 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.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 intial 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()) {
+      this.prepare(connection)
+    } 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) {
+    // prepared statements need sync to be called after each command
+    // complete or when an error is encountered
+    this.isPreparedStatement = true
+
+    // 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')
+  }
+
+  // eslint-disable-next-line no-unused-vars
+  handleCopyData(msg, connection) {
+    // noop
+  }
+}
+
+module.exports = Query

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

@@ -0,0 +1,107 @@
+'use strict'
+
+var types = require('pg-types')
+
+var 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) {
+    var 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]) {
+        // COMMMAND 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) {
+    var row = new Array(rowData.length)
+    for (var i = 0, len = rowData.length; i < len; i++) {
+      var rawValue = rowData[i]
+      if (rawValue !== null) {
+        row[i] = this._parsers[i](rawValue)
+      } else {
+        row[i] = null
+      }
+    }
+    return row
+  }
+
+  parseRow(rowData) {
+    var row = { ... this._prebuiltEmptyResultObject }
+    for (var i = 0, len = rowData.length; i < len; i++) {
+      var rawValue = rowData[i]
+      var field = this.fields[i].name
+      if (rawValue !== null) {
+        row[field] = this._parsers[i](rawValue)
+      }
+    }
+    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)
+    }
+    for (var i = 0; i < fieldDescriptions.length; i++) {
+      var desc = fieldDescriptions[i]
+      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._createPrebuiltEmptyResultObject()
+  }
+  _createPrebuiltEmptyResultObject() {
+    var row = {}
+    for (var i = 0; i < this.fields.length; i++) {
+      row[this.fields[i].name] = null
+    }
+    this._prebuiltEmptyResultObject = { ... row }
+  }
+}
+
+module.exports = Result

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

@@ -0,0 +1,28 @@
+/**
+ * Get a socket stream compatible with the current runtime environment.
+ * @returns {Duplex}
+ */
+module.exports.getStream = function getStream(ssl) {
+  const net = require('net')
+  if (typeof net.Socket === 'function') {
+    return new net.Socket()
+  } else {
+    const { CloudflareSocket } = require('pg-cloudflare')
+    return new CloudflareSocket(ssl)
+  }
+}
+
+/**
+ * Get a TLS secured socket, compatible with the current environment,
+ * using the socket and other settings given in `options`.
+ * @returns {Duplex}
+ */
+module.exports.getSecureStream = function getSecureStream(options) {
+  var tls = require('tls')
+  if (tls.connect) {
+    return tls.connect(options)
+  } else {
+    options.socket.startTls(options)
+    return options.socket
+  }
+}

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

@@ -0,0 +1,35 @@
+'use strict'
+
+var 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

@@ -0,0 +1,204 @@
+'use strict'
+
+const defaults = require('./defaults')
+
+function escapeElement(elementRepresentation) {
+  var 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) {
+  var result = '{'
+  for (var 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 (val[i] instanceof Buffer) {
+      result += '\\\\x' + val[i].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...
+var prepareValue = function (val, seen) {
+  // null and undefined are both null for postgres
+  if (val == null) {
+    return null
+  }
+  if (val instanceof Buffer) {
+    return val
+  }
+  if (ArrayBuffer.isView(val)) {
+    var 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 (val instanceof Date) {
+    if (defaults.parseInputDatesAsUTC) {
+      return dateToStringUTC(val)
+    } else {
+      return dateToString(val)
+    }
+  }
+  if (Array.isArray(val)) {
+    return arrayString(val)
+  }
+  if (typeof val === 'object') {
+    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 pad(number, digits) {
+  number = '' + number
+  while (number.length < digits) {
+    number = '0' + number
+  }
+  return number
+}
+
+function dateToString(date) {
+  var offset = -date.getTimezoneOffset()
+
+  var year = date.getFullYear()
+  var isBCYear = year < 1
+  if (isBCYear) year = Math.abs(year) + 1 // negative years are 1 off their BC representation
+
+  var ret =
+    pad(year, 4) +
+    '-' +
+    pad(date.getMonth() + 1, 2) +
+    '-' +
+    pad(date.getDate(), 2) +
+    'T' +
+    pad(date.getHours(), 2) +
+    ':' +
+    pad(date.getMinutes(), 2) +
+    ':' +
+    pad(date.getSeconds(), 2) +
+    '.' +
+    pad(date.getMilliseconds(), 3)
+
+  if (offset < 0) {
+    ret += '-'
+    offset *= -1
+  } else {
+    ret += '+'
+  }
+
+  ret += pad(Math.floor(offset / 60), 2) + ':' + pad(offset % 60, 2)
+  if (isBCYear) ret += ' BC'
+  return ret
+}
+
+function dateToStringUTC(date) {
+  var year = date.getUTCFullYear()
+  var isBCYear = year < 1
+  if (isBCYear) year = Math.abs(year) + 1 // negative years are 1 off their BC representation
+
+  var ret =
+    pad(year, 4) +
+    '-' +
+    pad(date.getUTCMonth() + 1, 2) +
+    '-' +
+    pad(date.getUTCDate(), 2) +
+    'T' +
+    pad(date.getUTCHours(), 2) +
+    ':' +
+    pad(date.getUTCMinutes(), 2) +
+    ':' +
+    pad(date.getUTCSeconds(), 2) +
+    '.' +
+    pad(date.getUTCMilliseconds(), 3)
+
+  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) {
+  var hasBackslash = false
+  var escaped = "'"
+
+  for (var i = 0; i < str.length; i++) {
+    var 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,
+}

package/dist/server/node_modules/pg/package.json

@@ -0,0 +1,64 @@
+{
+  "name": "pg",
+  "version": "8.11.3",
+  "description": "PostgreSQL client - pure javascript & libpq with the same API",
+  "keywords": [
+    "database",
+    "libpq",
+    "pg",
+    "postgre",
+    "postgres",
+    "postgresql",
+    "rdbms"
+  ],
+  "homepage": "https://github.com/brianc/node-postgres",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/brianc/node-postgres.git",
+    "directory": "packages/pg"
+  },
+  "author": "Brian Carlson <brian.m.carlson@gmail.com>",
+  "main": "./lib",
+  "dependencies": {
+    "buffer-writer": "2.0.0",
+    "packet-reader": "1.0.0",
+    "pg-connection-string": "^2.6.2",
+    "pg-pool": "^3.6.1",
+    "pg-protocol": "^1.6.0",
+    "pg-types": "^2.1.0",
+    "pgpass": "1.x"
+  },
+  "devDependencies": {
+    "@cloudflare/workers-types": "^4.20230404.0",
+    "async": "2.6.4",
+    "bluebird": "3.5.2",
+    "co": "4.6.0",
+    "pg-copy-streams": "0.3.0",
+    "typescript": "^4.0.3",
+    "workerd": "^1.20230419.0",
+    "wrangler": "^2.16.0"
+  },
+  "optionalDependencies": {
+    "pg-cloudflare": "^1.1.1"
+  },
+  "peerDependencies": {
+    "pg-native": ">=3.0.1"
+  },
+  "peerDependenciesMeta": {
+    "pg-native": {
+      "optional": true
+    }
+  },
+  "scripts": {
+    "test": "make test-all"
+  },
+  "files": [
+    "lib",
+    "SPONSORS.md"
+  ],
+  "license": "MIT",
+  "engines": {
+    "node": ">= 8.0.0"
+  },
+  "gitHead": "a84ebb3fe85edafb1b358965bdb5e3de58b12c5d"
+}