prostgles-server 4.2.186 → 4.2.187

package/examples/full-example-typescript/node_modules/pg-pool/test/idle-timeout.js

@@ -1,118 +0,0 @@
-'use strict'
-const co = require('co')
-const expect = require('expect.js')
-
-const describe = require('mocha').describe
-const it = require('mocha').it
-const { fork } = require('child_process')
-const path = require('path')
-
-const Pool = require('../')
-
-const wait = (time) => new Promise((resolve) => setTimeout(resolve, time))
-
-describe('idle timeout', () => {
-  it('should timeout and remove the client', (done) => {
-    const pool = new Pool({ idleTimeoutMillis: 10 })
-    pool.query('SELECT NOW()')
-    pool.on('remove', () => {
-      expect(pool.idleCount).to.equal(0)
-      expect(pool.totalCount).to.equal(0)
-      done()
-    })
-  })
-
-  it(
-    'times out and removes clients when others are also removed',
-    co.wrap(function* () {
-      const pool = new Pool({ idleTimeoutMillis: 10 })
-      const clientA = yield pool.connect()
-      const clientB = yield pool.connect()
-      clientA.release()
-      clientB.release(new Error())
-
-      const removal = new Promise((resolve) => {
-        pool.on('remove', () => {
-          expect(pool.idleCount).to.equal(0)
-          expect(pool.totalCount).to.equal(0)
-          resolve()
-        })
-      })
-
-      const timeout = wait(100).then(() => Promise.reject(new Error('Idle timeout failed to occur')))
-
-      try {
-        yield Promise.race([removal, timeout])
-      } finally {
-        pool.end()
-      }
-    })
-  )
-
-  it(
-    'can remove idle clients and recreate them',
-    co.wrap(function* () {
-      const pool = new Pool({ idleTimeoutMillis: 1 })
-      const results = []
-      for (var i = 0; i < 20; i++) {
-        let query = pool.query('SELECT NOW()')
-        expect(pool.idleCount).to.equal(0)
-        expect(pool.totalCount).to.equal(1)
-        results.push(yield query)
-        yield wait(2)
-        expect(pool.idleCount).to.equal(0)
-        expect(pool.totalCount).to.equal(0)
-      }
-      expect(results).to.have.length(20)
-    })
-  )
-
-  it(
-    'does not time out clients which are used',
-    co.wrap(function* () {
-      const pool = new Pool({ idleTimeoutMillis: 1 })
-      const results = []
-      for (var i = 0; i < 20; i++) {
-        let client = yield pool.connect()
-        expect(pool.totalCount).to.equal(1)
-        expect(pool.idleCount).to.equal(0)
-        yield wait(10)
-        results.push(yield client.query('SELECT NOW()'))
-        client.release()
-        expect(pool.idleCount).to.equal(1)
-        expect(pool.totalCount).to.equal(1)
-      }
-      expect(results).to.have.length(20)
-      return pool.end()
-    })
-  )
-
-  it('unrefs the connections and timeouts so the program can exit when idle when the allowExitOnIdle option is set', function (done) {
-    const child = fork(path.join(__dirname, 'idle-timeout-exit.js'), [], {
-      silent: true,
-      env: { ...process.env, ALLOW_EXIT_ON_IDLE: '1' },
-    })
-    let result = ''
-    child.stdout.setEncoding('utf8')
-    child.stdout.on('data', (chunk) => (result += chunk))
-    child.on('error', (err) => done(err))
-    child.on('close', () => {
-      expect(result).to.equal('completed first\ncompleted second\n')
-      done()
-    })
-  })
-
-  it('keeps old behavior when allowExitOnIdle option is not set', function (done) {
-    const child = fork(path.join(__dirname, 'idle-timeout-exit.js'), [], {
-      silent: true,
-    })
-    let result = ''
-    child.stdout.setEncoding('utf8')
-    child.stdout.on('data', (chunk) => (result += chunk))
-    child.on('error', (err) => done(err))
-    child.on('close', () => {
-      expect(result).to.equal('completed first\ncompleted second\nremoved\n')
-      done()
-    })
-  })
-})

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

@@ -1,226 +0,0 @@
-'use strict'
-const expect = require('expect.js')
-const _ = require('lodash')
-
-const describe = require('mocha').describe
-const it = require('mocha').it
-
-const Pool = require('../')
-
-describe('pool', function () {
-  describe('with callbacks', function () {
-    it('works totally unconfigured', function (done) {
-      const pool = new Pool()
-      pool.connect(function (err, client, release) {
-        if (err) return done(err)
-        client.query('SELECT NOW()', function (err, res) {
-          release()
-          if (err) return done(err)
-          expect(res.rows).to.have.length(1)
-          pool.end(done)
-        })
-      })
-    })
-
-    it('passes props to clients', function (done) {
-      const pool = new Pool({ binary: true })
-      pool.connect(function (err, client, release) {
-        release()
-        if (err) return done(err)
-        expect(client.binary).to.eql(true)
-        pool.end(done)
-      })
-    })
-
-    it('can run a query with a callback without parameters', function (done) {
-      const pool = new Pool()
-      pool.query('SELECT 1 as num', function (err, res) {
-        expect(res.rows[0]).to.eql({ num: 1 })
-        pool.end(function () {
-          done(err)
-        })
-      })
-    })
-
-    it('can run a query with a callback', function (done) {
-      const pool = new Pool()
-      pool.query('SELECT $1::text as name', ['brianc'], function (err, res) {
-        expect(res.rows[0]).to.eql({ name: 'brianc' })
-        pool.end(function () {
-          done(err)
-        })
-      })
-    })
-
-    it('passes connection errors to callback', function (done) {
-      const pool = new Pool({ port: 53922 })
-      pool.query('SELECT $1::text as name', ['brianc'], function (err, res) {
-        expect(res).to.be(undefined)
-        expect(err).to.be.an(Error)
-        // a connection error should not polute the pool with a dead client
-        expect(pool.totalCount).to.equal(0)
-        pool.end(function (err) {
-          done(err)
-        })
-      })
-    })
-
-    it('does not pass client to error callback', function (done) {
-      const pool = new Pool({ port: 58242 })
-      pool.connect(function (err, client, release) {
-        expect(err).to.be.an(Error)
-        expect(client).to.be(undefined)
-        expect(release).to.be.a(Function)
-        pool.end(done)
-      })
-    })
-
-    it('removes client if it errors in background', function (done) {
-      const pool = new Pool()
-      pool.connect(function (err, client, release) {
-        release()
-        if (err) return done(err)
-        client.testString = 'foo'
-        setTimeout(function () {
-          client.emit('error', new Error('on purpose'))
-        }, 10)
-      })
-      pool.on('error', function (err) {
-        expect(err.message).to.be('on purpose')
-        expect(err.client).to.not.be(undefined)
-        expect(err.client.testString).to.be('foo')
-        err.client.connection.stream.on('end', function () {
-          pool.end(done)
-        })
-      })
-    })
-
-    it('should not change given options', function (done) {
-      const options = { max: 10 }
-      const pool = new Pool(options)
-      pool.connect(function (err, client, release) {
-        release()
-        if (err) return done(err)
-        expect(options).to.eql({ max: 10 })
-        pool.end(done)
-      })
-    })
-
-    it('does not create promises when connecting', function (done) {
-      const pool = new Pool()
-      const returnValue = pool.connect(function (err, client, release) {
-        release()
-        if (err) return done(err)
-        pool.end(done)
-      })
-      expect(returnValue).to.be(undefined)
-    })
-
-    it('does not create promises when querying', function (done) {
-      const pool = new Pool()
-      const returnValue = pool.query('SELECT 1 as num', function (err) {
-        pool.end(function () {
-          done(err)
-        })
-      })
-      expect(returnValue).to.be(undefined)
-    })
-
-    it('does not create promises when ending', function (done) {
-      const pool = new Pool()
-      const returnValue = pool.end(done)
-      expect(returnValue).to.be(undefined)
-    })
-
-    it('never calls callback syncronously', function (done) {
-      const pool = new Pool()
-      pool.connect((err, client) => {
-        if (err) throw err
-        client.release()
-        setImmediate(() => {
-          let called = false
-          pool.connect((err, client) => {
-            if (err) throw err
-            called = true
-            client.release()
-            setImmediate(() => {
-              pool.end(done)
-            })
-          })
-          expect(called).to.equal(false)
-        })
-      })
-    })
-  })
-
-  describe('with promises', function () {
-    it('connects, queries, and disconnects', function () {
-      const pool = new Pool()
-      return pool.connect().then(function (client) {
-        return client.query('select $1::text as name', ['hi']).then(function (res) {
-          expect(res.rows).to.eql([{ name: 'hi' }])
-          client.release()
-          return pool.end()
-        })
-      })
-    })
-
-    it('executes a query directly', () => {
-      const pool = new Pool()
-      return pool.query('SELECT $1::text as name', ['hi']).then((res) => {
-        expect(res.rows).to.have.length(1)
-        expect(res.rows[0].name).to.equal('hi')
-        return pool.end()
-      })
-    })
-
-    it('properly pools clients', function () {
-      const pool = new Pool({ poolSize: 9 })
-      const promises = _.times(30, function () {
-        return pool.connect().then(function (client) {
-          return client.query('select $1::text as name', ['hi']).then(function (res) {
-            client.release()
-            return res
-          })
-        })
-      })
-      return Promise.all(promises).then(function (res) {
-        expect(res).to.have.length(30)
-        expect(pool.totalCount).to.be(9)
-        return pool.end()
-      })
-    })
-
-    it('supports just running queries', function () {
-      const pool = new Pool({ poolSize: 9 })
-      const text = 'select $1::text as name'
-      const values = ['hi']
-      const query = { text: text, values: values }
-      const promises = _.times(30, () => pool.query(query))
-      return Promise.all(promises).then(function (queries) {
-        expect(queries).to.have.length(30)
-        return pool.end()
-      })
-    })
-
-    it('recovers from query errors', function () {
-      const pool = new Pool()
-
-      const errors = []
-      const promises = _.times(30, () => {
-        return pool.query('SELECT asldkfjasldkf').catch(function (e) {
-          errors.push(e)
-        })
-      })
-      return Promise.all(promises).then(() => {
-        expect(errors).to.have.length(30)
-        expect(pool.totalCount).to.equal(0)
-        expect(pool.idleCount).to.equal(0)
-        return pool.query('SELECT $1::text as name', ['hi']).then(function (res) {
-          expect(res.rows).to.eql([{ name: 'hi' }])
-          return pool.end()
-        })
-      })
-    })
-  })
-})

package/examples/full-example-typescript/node_modules/pg-pool/test/lifetime-timeout.js

@@ -1,47 +0,0 @@
-'use strict'
-const co = require('co')
-const expect = require('expect.js')
-
-const describe = require('mocha').describe
-const it = require('mocha').it
-
-const Pool = require('../')
-
-describe('lifetime timeout', () => {
-  it('connection lifetime should expire and remove the client', (done) => {
-    const pool = new Pool({ maxLifetimeSeconds: 1 })
-    pool.query('SELECT NOW()')
-    pool.on('remove', () => {
-      console.log('expired while idle - on-remove event')
-      expect(pool.expiredCount).to.equal(0)
-      expect(pool.totalCount).to.equal(0)
-      done()
-    })
-  })
-  it('connection lifetime should expire and remove the client after the client is done working', (done) => {
-    const pool = new Pool({ maxLifetimeSeconds: 1 })
-    pool.query('SELECT pg_sleep(1.4)')
-    pool.on('remove', () => {
-      console.log('expired while busy - on-remove event')
-      expect(pool.expiredCount).to.equal(0)
-      expect(pool.totalCount).to.equal(0)
-      done()
-    })
-  })
-  it(
-    'can remove expired clients and recreate them',
-    co.wrap(function* () {
-      const pool = new Pool({ maxLifetimeSeconds: 1 })
-      let query = pool.query('SELECT pg_sleep(1.4)')
-      expect(pool.expiredCount).to.equal(0)
-      expect(pool.totalCount).to.equal(1)
-      yield query
-      yield new Promise((resolve) => setTimeout(resolve, 100))
-      expect(pool.expiredCount).to.equal(0)
-      expect(pool.totalCount).to.equal(0)
-      yield pool.query('SELECT NOW()')
-      expect(pool.expiredCount).to.equal(0)
-      expect(pool.totalCount).to.equal(1)
-    })
-  )
-})

package/examples/full-example-typescript/node_modules/pg-pool/test/logging.js

@@ -1,20 +0,0 @@
-const expect = require('expect.js')
-
-const describe = require('mocha').describe
-const it = require('mocha').it
-
-const Pool = require('../')
-
-describe('logging', function () {
-  it('logs to supplied log function if given', function () {
-    const messages = []
-    const log = function (msg) {
-      messages.push(msg)
-    }
-    const pool = new Pool({ log: log })
-    return pool.query('SELECT NOW()').then(function () {
-      expect(messages.length).to.be.greaterThan(0)
-      return pool.end()
-    })
-  })
-})

package/examples/full-example-typescript/node_modules/pg-pool/test/max-uses.js

@@ -1,97 +0,0 @@
-const expect = require('expect.js')
-const co = require('co')
-
-const describe = require('mocha').describe
-const it = require('mocha').it
-
-const Pool = require('../')
-
-describe('maxUses', () => {
-  it(
-    'can create a single client and use it once',
-    co.wrap(function* () {
-      const pool = new Pool({ maxUses: 2 })
-      expect(pool.waitingCount).to.equal(0)
-      const client = yield pool.connect()
-      const res = yield client.query('SELECT $1::text as name', ['hi'])
-      expect(res.rows[0].name).to.equal('hi')
-      client.release()
-      pool.end()
-    })
-  )
-
-  it(
-    'getting a connection a second time returns the same connection and releasing it also closes it',
-    co.wrap(function* () {
-      const pool = new Pool({ maxUses: 2 })
-      expect(pool.waitingCount).to.equal(0)
-      const client = yield pool.connect()
-      client.release()
-      const client2 = yield pool.connect()
-      expect(client).to.equal(client2)
-      expect(client2._ending).to.equal(false)
-      client2.release()
-      expect(client2._ending).to.equal(true)
-      return yield pool.end()
-    })
-  )
-
-  it(
-    'getting a connection a third time returns a new connection',
-    co.wrap(function* () {
-      const pool = new Pool({ maxUses: 2 })
-      expect(pool.waitingCount).to.equal(0)
-      const client = yield pool.connect()
-      client.release()
-      const client2 = yield pool.connect()
-      expect(client).to.equal(client2)
-      client2.release()
-      const client3 = yield pool.connect()
-      expect(client3).not.to.equal(client2)
-      client3.release()
-      return yield pool.end()
-    })
-  )
-
-  it(
-    'getting a connection from a pending request gets a fresh client when the released candidate is expended',
-    co.wrap(function* () {
-      const pool = new Pool({ max: 1, maxUses: 2 })
-      expect(pool.waitingCount).to.equal(0)
-      const client1 = yield pool.connect()
-      pool.connect().then((client2) => {
-        expect(client2).to.equal(client1)
-        expect(pool.waitingCount).to.equal(1)
-        // Releasing the client this time should also expend it since maxUses is 2, causing client3 to be a fresh client
-        client2.release()
-      })
-      const client3Promise = pool.connect().then((client3) => {
-        // client3 should be a fresh client since client2's release caused the first client to be expended
-        expect(pool.waitingCount).to.equal(0)
-        expect(client3).not.to.equal(client1)
-        return client3.release()
-      })
-      // There should be two pending requests since we have 3 connect requests but a max size of 1
-      expect(pool.waitingCount).to.equal(2)
-      // Releasing the client should not yet expend it since maxUses is 2
-      client1.release()
-      yield client3Promise
-      return yield pool.end()
-    })
-  )
-
-  it(
-    'logs when removing an expended client',
-    co.wrap(function* () {
-      const messages = []
-      const log = function (msg) {
-        messages.push(msg)
-      }
-      const pool = new Pool({ maxUses: 1, log })
-      const client = yield pool.connect()
-      client.release()
-      expect(messages).to.contain('remove expended client')
-      return yield pool.end()
-    })
-  )
-})

package/examples/full-example-typescript/node_modules/pg-pool/test/releasing-clients.js

@@ -1,53 +0,0 @@
-const Pool = require('../')
-
-const expect = require('expect.js')
-
-describe('releasing clients', () => {
-  it('removes a client which cannot be queried', async () => {
-    // make a pool w/ only 1 client
-    const pool = new Pool({ max: 1 })
-    expect(pool.totalCount).to.eql(0)
-    const client = await pool.connect()
-    expect(pool.totalCount).to.eql(1)
-    expect(pool.idleCount).to.eql(0)
-    // reach into the client and sever its connection
-    client.connection.end()
-
-    // wait for the client to error out
-    const err = await new Promise((resolve) => client.once('error', resolve))
-    expect(err).to.be.ok()
-    expect(pool.totalCount).to.eql(1)
-    expect(pool.idleCount).to.eql(0)
-
-    // try to return it to the pool - this removes it because its broken
-    client.release()
-    expect(pool.totalCount).to.eql(0)
-    expect(pool.idleCount).to.eql(0)
-
-    // make sure pool still works
-    const { rows } = await pool.query('SELECT NOW()')
-    expect(rows).to.have.length(1)
-    await pool.end()
-  })
-
-  it('removes a client which is ending', async () => {
-    // make a pool w/ only 1 client
-    const pool = new Pool({ max: 1 })
-    expect(pool.totalCount).to.eql(0)
-    const client = await pool.connect()
-    expect(pool.totalCount).to.eql(1)
-    expect(pool.idleCount).to.eql(0)
-    // end the client gracefully (but you shouldn't do this with pooled clients)
-    client.end()
-
-    // try to return it to the pool
-    client.release()
-    expect(pool.totalCount).to.eql(0)
-    expect(pool.idleCount).to.eql(0)
-
-    // make sure pool still works
-    const { rows } = await pool.query('SELECT NOW()')
-    expect(rows).to.have.length(1)
-    await pool.end()
-  })
-})

package/examples/full-example-typescript/node_modules/pg-pool/test/setup.js

@@ -1,10 +0,0 @@
-const crash = (reason) => {
-  process.on(reason, (err) => {
-    console.error(reason, err.stack)
-    process.exit(-1)
-  })
-}
-
-crash('unhandledRejection')
-crash('uncaughtError')
-crash('warning')

package/examples/full-example-typescript/node_modules/pg-pool/test/sizing.js

@@ -1,58 +0,0 @@
-const expect = require('expect.js')
-const co = require('co')
-const _ = require('lodash')
-
-const describe = require('mocha').describe
-const it = require('mocha').it
-
-const Pool = require('../')
-
-describe('pool size of 1', () => {
-  it(
-    'can create a single client and use it once',
-    co.wrap(function* () {
-      const pool = new Pool({ max: 1 })
-      expect(pool.waitingCount).to.equal(0)
-      const client = yield pool.connect()
-      const res = yield client.query('SELECT $1::text as name', ['hi'])
-      expect(res.rows[0].name).to.equal('hi')
-      client.release()
-      pool.end()
-    })
-  )
-
-  it(
-    'can create a single client and use it multiple times',
-    co.wrap(function* () {
-      const pool = new Pool({ max: 1 })
-      expect(pool.waitingCount).to.equal(0)
-      const client = yield pool.connect()
-      const wait = pool.connect()
-      expect(pool.waitingCount).to.equal(1)
-      client.release()
-      const client2 = yield wait
-      expect(client).to.equal(client2)
-      client2.release()
-      return yield pool.end()
-    })
-  )
-
-  it(
-    'can only send 1 query at a time',
-    co.wrap(function* () {
-      const pool = new Pool({ max: 1 })
-
-      // the query text column name changed in PostgreSQL 9.2
-      const versionResult = yield pool.query('SHOW server_version_num')
-      const version = parseInt(versionResult.rows[0].server_version_num, 10)
-      const queryColumn = version < 90200 ? 'current_query' : 'query'
-
-      const queryText = 'SELECT COUNT(*) as counts FROM pg_stat_activity WHERE ' + queryColumn + ' = $1'
-      const queries = _.times(20, () => pool.query(queryText, [queryText]))
-      const results = yield Promise.all(queries)
-      const counts = results.map((res) => parseInt(res.rows[0].counts, 10))
-      expect(counts).to.eql(_.times(20, (i) => 1))
-      return yield pool.end()
-    })
-  )
-})

package/examples/full-example-typescript/node_modules/pg-pool/test/submittable.js

@@ -1,19 +0,0 @@
-'use strict'
-const Cursor = require('pg-cursor')
-const expect = require('expect.js')
-const describe = require('mocha').describe
-const it = require('mocha').it
-
-const Pool = require('../')
-
-describe('submittle', () => {
-  it('is returned from the query method', false, (done) => {
-    const pool = new Pool()
-    const cursor = pool.query(new Cursor('SELECT * from generate_series(0, 1000)'))
-    cursor.read((err, rows) => {
-      expect(err).to.be(undefined)
-      expect(!!rows).to.be.ok()
-      cursor.close(done)
-    })
-  })
-})

package/examples/full-example-typescript/node_modules/pg-pool/test/verify.js

@@ -1,24 +0,0 @@
-'use strict'
-const expect = require('expect.js')
-
-const describe = require('mocha').describe
-const it = require('mocha').it
-
-const Pool = require('../')
-
-describe('verify', () => {
-  it('verifies a client with a callback', (done) => {
-    const pool = new Pool({
-      verify: (client, cb) => {
-        cb(new Error('nope'))
-      },
-    })
-
-    pool.connect((err, client) => {
-      expect(err).to.be.an(Error)
-      expect(err.message).to.be('nope')
-      pool.end()
-      done()
-    })
-  })
-})