decocms 2.364.2 → 2.365.0

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

@@ -1,241 +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.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

@@ -1,107 +0,0 @@
-'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

@@ -1,28 +0,0 @@
-/**
- * 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

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

@@ -1,204 +0,0 @@
-'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

@@ -1,64 +0,0 @@
-{
-  "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"
-}