prostgles-server 4.2.182 → 4.2.183

package/examples/full-example-typescript/node_modules/pg-connection-string/index.js

@@ -0,0 +1,112 @@
+'use strict'
+
+//Parse method copied from https://github.com/brianc/node-postgres
+//Copyright (c) 2010-2014 Brian Carlson (brian.m.carlson@gmail.com)
+//MIT License
+
+//parses a connection string
+function parse(str) {
+  //unix socket
+  if (str.charAt(0) === '/') {
+    const config = str.split(' ')
+    return { host: config[0], database: config[1] }
+  }
+
+  // Check for empty host in URL
+
+  const config = {}
+  let result
+  let dummyHost = false
+  if (/ |%[^a-f0-9]|%[a-f0-9][^a-f0-9]/i.test(str)) {
+    // Ensure spaces are encoded as %20
+    str = encodeURI(str).replace(/\%25(\d\d)/g, '%$1')
+  }
+
+  try {
+    result = new URL(str, 'postgres://base')
+  } catch (e) {
+    // The URL is invalid so try again with a dummy host
+    result = new URL(str.replace('@/', '@___DUMMY___/'), 'postgres://base')
+    dummyHost = true
+  }
+
+  // We'd like to use Object.fromEntries() here but Node.js 10 does not support it
+  for (const entry of result.searchParams.entries()) {
+    config[entry[0]] = entry[1]
+  }
+
+  config.user = config.user || decodeURIComponent(result.username)
+  config.password = config.password || decodeURIComponent(result.password)
+
+  if (result.protocol == 'socket:') {
+    config.host = decodeURI(result.pathname)
+    config.database = result.searchParams.get('db')
+    config.client_encoding = result.searchParams.get('encoding')
+    return config
+  }
+  const hostname = dummyHost ? '' : result.hostname
+  if (!config.host) {
+    // Only set the host if there is no equivalent query param.
+    config.host = decodeURIComponent(hostname)
+  } else if (hostname && /^%2f/i.test(hostname)) {
+    // Only prepend the hostname to the pathname if it is not a URL encoded Unix socket host.
+    result.pathname = hostname + result.pathname
+  }
+  if (!config.port) {
+    // Only set the port if there is no equivalent query param.
+    config.port = result.port
+  }
+
+  const pathname = result.pathname.slice(1) || null
+  config.database = pathname ? decodeURI(pathname) : null
+
+  if (config.ssl === 'true' || config.ssl === '1') {
+    config.ssl = true
+  }
+
+  if (config.ssl === '0') {
+    config.ssl = false
+  }
+
+  if (config.sslcert || config.sslkey || config.sslrootcert || config.sslmode) {
+    config.ssl = {}
+  }
+
+  // Only try to load fs if we expect to read from the disk
+  const fs = config.sslcert || config.sslkey || config.sslrootcert ? require('fs') : null
+
+  if (config.sslcert) {
+    config.ssl.cert = fs.readFileSync(config.sslcert).toString()
+  }
+
+  if (config.sslkey) {
+    config.ssl.key = fs.readFileSync(config.sslkey).toString()
+  }
+
+  if (config.sslrootcert) {
+    config.ssl.ca = fs.readFileSync(config.sslrootcert).toString()
+  }
+
+  switch (config.sslmode) {
+    case 'disable': {
+      config.ssl = false
+      break
+    }
+    case 'prefer':
+    case 'require':
+    case 'verify-ca':
+    case 'verify-full': {
+      break
+    }
+    case 'no-verify': {
+      config.ssl.rejectUnauthorized = false
+      break
+    }
+  }
+
+  return config
+}
+
+module.exports = parse
+
+parse.parse = parse

package/examples/full-example-typescript/node_modules/pg-connection-string/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "pg-connection-string",
+  "version": "2.7.0",
+  "description": "Functions for dealing with a PostgresSQL connection string",
+  "main": "./index.js",
+  "types": "./index.d.ts",
+  "scripts": {
+    "test": "istanbul cover _mocha && npm run check-coverage",
+    "check-coverage": "istanbul check-coverage --statements 100 --branches 100 --lines 100 --functions 100",
+    "coveralls": "cat ./coverage/lcov.info | ./node_modules/.bin/coveralls"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/brianc/node-postgres.git",
+    "directory": "packages/pg-connection-string"
+  },
+  "keywords": [
+    "pg",
+    "connection",
+    "string",
+    "parse"
+  ],
+  "author": "Blaine Bublitz <blaine@iceddev.com> (http://iceddev.com/)",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/brianc/node-postgres/issues"
+  },
+  "homepage": "https://github.com/brianc/node-postgres/tree/master/packages/pg-connection-string",
+  "devDependencies": {
+    "chai": "^4.1.1",
+    "coveralls": "^3.0.4",
+    "istanbul": "^0.4.5",
+    "mocha": "^10.5.2"
+  },
+  "files": [
+    "index.js",
+    "index.d.ts"
+  ],
+  "gitHead": "92cb640fd316972e323ced6256b2acd89b1b58e0"
+}

package/examples/full-example-typescript/node_modules/pg-cursor/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2010 - 2021 Brian Carlson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/examples/full-example-typescript/node_modules/pg-cursor/README.md

@@ -0,0 +1,37 @@
+node-pg-cursor
+==============
+
+Use a PostgreSQL result cursor from node with an easy to use API.
+
+### install
+
+```sh
+$ npm install pg-cursor
+```
+___note___: this depends on _either_ `npm install pg` or `npm install pg.js`, but you __must__ be using the pure JavaScript client.  This will __not work__ with the native bindings.
+
+### :star: [Documentation](https://node-postgres.com/apis/cursor) :star:
+
+### license
+
+The MIT License (MIT)
+
+Copyright (c) 2013 Brian M. Carlson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

package/examples/full-example-typescript/node_modules/pg-cursor/index.js

@@ -0,0 +1,264 @@
+'use strict'
+const Result = require('pg/lib/result.js')
+const prepare = require('pg/lib/utils.js').prepareValue
+const EventEmitter = require('events').EventEmitter
+const util = require('util')
+
+let nextUniqueID = 1 // concept borrowed from org.postgresql.core.v3.QueryExecutorImpl
+
+class Cursor extends EventEmitter {
+  constructor(text, values, config) {
+    super()
+
+    this._conf = config || {}
+    this.text = text
+    this.values = values ? values.map(prepare) : null
+    this.connection = null
+    this._queue = []
+    this.state = 'initialized'
+    this._result = new Result(this._conf.rowMode, this._conf.types)
+    this._Promise = this._conf.Promise || global.Promise
+    this._cb = null
+    this._rows = null
+    this._portal = null
+    this._ifNoData = this._ifNoData.bind(this)
+    this._rowDescription = this._rowDescription.bind(this)
+  }
+
+  _ifNoData() {
+    this.state = 'idle'
+    this._shiftQueue()
+    if (this.connection) {
+      this.connection.removeListener('rowDescription', this._rowDescription)
+    }
+  }
+
+  _rowDescription() {
+    if (this.connection) {
+      this.connection.removeListener('noData', this._ifNoData)
+    }
+  }
+
+  submit(connection) {
+    this.state = 'submitted'
+    this.connection = connection
+    this._portal = 'C_' + nextUniqueID++
+
+    const con = connection
+
+    con.parse(
+      {
+        text: this.text,
+      },
+      true
+    )
+
+    con.bind(
+      {
+        portal: this._portal,
+        values: this.values,
+      },
+      true
+    )
+
+    con.describe(
+      {
+        type: 'P',
+        name: this._portal, // AWS Redshift requires a portal name
+      },
+      true
+    )
+
+    con.flush()
+
+    if (this._conf.types) {
+      this._result._getTypeParser = this._conf.types.getTypeParser
+    }
+
+    con.once('noData', this._ifNoData)
+    con.once('rowDescription', this._rowDescription)
+  }
+
+  _shiftQueue() {
+    if (this._queue.length) {
+      this._getRows.apply(this, this._queue.shift())
+    }
+  }
+
+  _closePortal() {
+    if (this.state === 'done') return
+
+    // because we opened a named portal to stream results
+    // we need to close the same named portal.  Leaving a named portal
+    // open can lock tables for modification if inside a transaction.
+    // see https://github.com/brianc/node-pg-cursor/issues/56
+    this.connection.close({ type: 'P', name: this._portal })
+
+    // If we've received an error we already sent a sync message.
+    // do not send another sync as it triggers another readyForQuery message.
+    if (this.state !== 'error') {
+      this.connection.sync()
+    }
+
+    this.state = 'done'
+  }
+
+  handleRowDescription(msg) {
+    this._result.addFields(msg.fields)
+    this.state = 'idle'
+    this._shiftQueue()
+  }
+
+  handleDataRow(msg) {
+    const row = this._result.parseRow(msg.fields)
+    this.emit('row', row, this._result)
+    this._rows.push(row)
+  }
+
+  _sendRows() {
+    this.state = 'idle'
+    setImmediate(() => {
+      const cb = this._cb
+      // remove callback before calling it
+      // because likely a new one will be added
+      // within the call to this callback
+      this._cb = null
+      if (cb) {
+        this._result.rows = this._rows
+        cb(null, this._rows, this._result)
+      }
+      this._rows = []
+    })
+  }
+
+  handleCommandComplete(msg) {
+    this._result.addCommandComplete(msg)
+    this._closePortal()
+  }
+
+  handlePortalSuspended() {
+    this._sendRows()
+  }
+
+  handleReadyForQuery() {
+    this._sendRows()
+    this.state = 'done'
+    this.emit('end', this._result)
+  }
+
+  handleEmptyQuery() {
+    this.connection.sync()
+  }
+
+  handleError(msg) {
+    // If this cursor has already closed, don't try to handle the error.
+    if (this.state === 'done') return
+
+    // If we're in an initialized state we've never been submitted
+    // and don't have a connection instance reference yet.
+    // This can happen if you queue a stream and close the client before
+    // the client has submitted the stream.  In this scenario we don't have
+    // a connection so there's nothing to unsubscribe from.
+    if (this.state !== 'initialized') {
+      this.connection.removeListener('noData', this._ifNoData)
+      this.connection.removeListener('rowDescription', this._rowDescription)
+      // call sync to trigger a readyForQuery
+      this.connection.sync()
+    }
+
+    this.state = 'error'
+    this._error = msg
+    // satisfy any waiting callback
+    if (this._cb) {
+      this._cb(msg)
+    }
+    // dispatch error to all waiting callbacks
+    for (let i = 0; i < this._queue.length; i++) {
+      const queuedCallback = this._queue[i][1]
+      queuedCallback.call(this, msg)
+    }
+    this._queue.length = 0
+
+    if (this.listenerCount('error') > 0) {
+      // only dispatch error events if we have a listener
+      this.emit('error', msg)
+    }
+  }
+
+  _getRows(rows, cb) {
+    this.state = 'busy'
+    this._cb = cb
+    this._rows = []
+    const msg = {
+      portal: this._portal,
+      rows: rows,
+    }
+    this.connection.execute(msg, true)
+    this.connection.flush()
+  }
+
+  // users really shouldn't be calling 'end' here and terminating a connection to postgres
+  // via the low level connection.end api
+  end(cb) {
+    if (this.state !== 'initialized') {
+      this.connection.sync()
+    }
+    this.connection.once('end', cb)
+    this.connection.end()
+  }
+
+  close(cb) {
+    let promise
+
+    if (!cb) {
+      promise = new this._Promise((resolve, reject) => {
+        cb = (err) => (err ? reject(err) : resolve())
+      })
+    }
+
+    if (!this.connection || this.state === 'done') {
+      setImmediate(cb)
+      return promise
+    }
+
+    this._closePortal()
+    this.connection.once('readyForQuery', function () {
+      cb()
+    })
+
+    // Return the promise (or undefined)
+    return promise
+  }
+
+  read(rows, cb) {
+    let promise
+
+    if (!cb) {
+      promise = new this._Promise((resolve, reject) => {
+        cb = (err, rows) => (err ? reject(err) : resolve(rows))
+      })
+    }
+
+    if (this.state === 'idle' || this.state === 'submitted') {
+      this._getRows(rows, cb)
+    } else if (this.state === 'busy' || this.state === 'initialized') {
+      this._queue.push([rows, cb])
+    } else if (this.state === 'error') {
+      setImmediate(() => cb(this._error))
+    } else if (this.state === 'done') {
+      setImmediate(() => cb(null, []))
+    } else {
+      throw new Error('Unknown state: ' + this.state)
+    }
+
+    // Return the promise (or undefined)
+    return promise
+  }
+}
+
+Cursor.prototype.end = util.deprecate(
+  Cursor.prototype.end,
+  'Cursor.end is deprecated. Call end on the client itself to end a connection to the database.'
+)
+
+module.exports = Cursor

package/examples/full-example-typescript/node_modules/pg-cursor/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "pg-cursor",
+  "version": "2.12.1",
+  "description": "Query cursor extension for node-postgres",
+  "main": "index.js",
+  "directories": {
+    "test": "test"
+  },
+  "scripts": {
+    "test": "mocha"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/brianc/node-postgres.git",
+    "directory": "packages/pg-cursor"
+  },
+  "author": "Brian M. Carlson",
+  "license": "MIT",
+  "devDependencies": {
+    "mocha": "^10.5.2",
+    "pg": "^8.13.1"
+  },
+  "peerDependencies": {
+    "pg": "^8"
+  },
+  "gitHead": "95d7e620ef8b51743b4cbca05dd3c3ce858ecea7"
+}

package/examples/full-example-typescript/node_modules/pg-cursor/test/close.js

@@ -0,0 +1,65 @@
+const assert = require('assert')
+const Cursor = require('../')
+const pg = require('pg')
+
+const text = 'SELECT generate_series as num FROM generate_series(0, 50)'
+describe('close', function () {
+  beforeEach(function (done) {
+    const client = (this.client = new pg.Client())
+    client.connect(done)
+  })
+
+  this.afterEach(function (done) {
+    this.client.end(done)
+  })
+
+  it('can close a finished cursor without a callback', function (done) {
+    const cursor = new Cursor(text)
+    this.client.query(cursor)
+    this.client.query('SELECT NOW()', done)
+    cursor.read(100, function (err) {
+      assert.ifError(err)
+      cursor.close()
+    })
+  })
+
+  it('can close a finished cursor a promise', function (done) {
+    const cursor = new Cursor(text)
+    this.client.query(cursor)
+    cursor.read(100, (err) => {
+      assert.ifError(err)
+      cursor.close().then(() => {
+        this.client.query('SELECT NOW()', done)
+      })
+    })
+  })
+
+  it('closes cursor early', function (done) {
+    const cursor = new Cursor(text)
+    this.client.query(cursor)
+    this.client.query('SELECT NOW()', done)
+    cursor.read(25, function (err) {
+      assert.ifError(err)
+      cursor.close()
+    })
+  })
+
+  it('works with callback style', function (done) {
+    const cursor = new Cursor(text)
+    const client = this.client
+    client.query(cursor)
+    cursor.read(25, function (err, rows) {
+      assert.ifError(err)
+      assert.strictEqual(rows.length, 25)
+      cursor.close(function (err) {
+        assert.ifError(err)
+        client.query('SELECT NOW()', done)
+      })
+    })
+  })
+
+  it('is a no-op to "close" the cursor before submitting it', function (done) {
+    const cursor = new Cursor(text)
+    cursor.close(done)
+  })
+})

package/examples/full-example-typescript/node_modules/pg-cursor/test/error-handling.js

@@ -0,0 +1,118 @@
+'use strict'
+const assert = require('assert')
+const Cursor = require('../')
+const pg = require('pg')
+
+const text = 'SELECT generate_series as num FROM generate_series(0, 4)'
+
+describe('error handling', function () {
+  it('can continue after error', function (done) {
+    const client = new pg.Client()
+    client.connect()
+    const cursor = client.query(new Cursor('asdfdffsdf'))
+    cursor.read(1, function (err) {
+      assert(err)
+      client.query('SELECT NOW()', function (err) {
+        assert.ifError(err)
+        client.end()
+        done()
+      })
+    })
+  })
+
+  it('errors queued reads', async () => {
+    const client = new pg.Client()
+    await client.connect()
+
+    const cursor = client.query(new Cursor('asdfdffsdf'))
+
+    const immediateRead = cursor.read(1)
+    const queuedRead1 = cursor.read(1)
+    const queuedRead2 = cursor.read(1)
+
+    assert(
+      await immediateRead.then(
+        () => null,
+        (err) => err
+      )
+    )
+    assert(
+      await queuedRead1.then(
+        () => null,
+        (err) => err
+      )
+    )
+    assert(
+      await queuedRead2.then(
+        () => null,
+        (err) => err
+      )
+    )
+
+    client.end()
+  })
+})
+
+describe('read callback does not fire sync', () => {
+  it('does not fire error callback sync', (done) => {
+    const client = new pg.Client()
+    client.connect()
+    const cursor = client.query(new Cursor('asdfdffsdf'))
+    let after = false
+    cursor.read(1, function (err) {
+      assert(err, 'error should be returned')
+      assert.strictEqual(after, true, 'should not call read sync')
+      after = false
+      cursor.read(1, function (err) {
+        assert(err, 'error should be returned')
+        assert.strictEqual(after, true, 'should not call read sync')
+        client.end()
+        done()
+      })
+      after = true
+    })
+    after = true
+  })
+
+  it('does not fire result sync after finished', (done) => {
+    const client = new pg.Client()
+    client.connect()
+    const cursor = client.query(new Cursor('SELECT NOW()'))
+    let after = false
+    cursor.read(1, function (err) {
+      assert(!err)
+      assert.strictEqual(after, true, 'should not call read sync')
+      cursor.read(1, function (err) {
+        assert(!err)
+        after = false
+        cursor.read(1, function (err) {
+          assert(!err)
+          assert.strictEqual(after, true, 'should not call read sync')
+          client.end()
+          done()
+        })
+        after = true
+      })
+    })
+    after = true
+  })
+})
+
+describe('proper cleanup', function () {
+  it('can issue multiple cursors on one client', function (done) {
+    const client = new pg.Client()
+    client.connect()
+    const cursor1 = client.query(new Cursor(text))
+    cursor1.read(8, function (err, rows) {
+      assert.ifError(err)
+      assert.strictEqual(rows.length, 5)
+      const cursor2 = client.query(new Cursor(text))
+      cursor2.read(8, function (err, rows) {
+        assert.ifError(err)
+        assert.strictEqual(rows.length, 5)
+        client.end()
+        done()
+      })
+    })
+  })
+})