@steadybrew/postgresjs 4.0.0-rc1 → 4.1.0

package/cf/src/errors.js

@@ -13,10 +13,10 @@ export const Errors = {
   notSupported
 }
 
-function connection(x, options, socket) {
+function connection(x, options, socket, cause) {
   const { host, port } = socket || options
   const error = Object.assign(
-    new Error(('write ' + x + ' ' + (options.path || (host + ':' + port)))),
+    new Error(('write ' + x + ' ' + (options.path || (host + ':' + port))), cause && { cause }),
     {
       code: x,
       errno: x,

package/cf/src/index.js

@@ -21,12 +21,16 @@ import {
 } from './types.js'
 
 import Connection from './connection.js'
+import { cancelRequest } from './transport.js'
+import clampedTimeout from './timeout.js'
 import { Query, CLOSE } from './query.js'
 import Queue from './queue.js'
 import { Errors, PostgresError } from './errors.js'
 import Subscribe from './subscribe.js'
 import largeObject from './large.js'
 
+const Lease = { Active: 0, Settling: 1, Released: 2, Discarded: 3, Closed: 4 }
+
 Object.assign(Postgres, {
   PostgresError,
   toPascal,
@@ -53,6 +57,7 @@ function Postgres(a, b) {
       , subscribe = options.no_subscribe || Subscribe(Postgres, { ...options })
 
   let ending = false
+  let reconnecting = null
 
   const queries = Queue()
       , connecting = Queue()
@@ -206,9 +211,10 @@ function Postgres(a, b) {
     if (ending)
       throw Errors.connection('CONNECTION_ENDED', options)
 
-    const l = { connection: null, closed: null, onclose: null, reserved: null, queue: Queue() }
-    open.length
-      ? own(open.shift(), l)
+    const l = { state: null, connection: null, error: null, onclose: null, queue: Queue() }
+    const idle = takeOpen()
+    idle
+      ? own(idle, l)
       : auto && !closed.length && busy.length
         ? own(busy.shift(), l)
         : await new Promise((resolve, reject) => {
@@ -222,50 +228,53 @@ function Postgres(a, b) {
 
   function own(c, l) {
     l.connection = c
-    c.lease = l
-    move(c, reserved)
-    c.reserved = l.reserved = () => l.queue.length
-      ? c.execute(l.queue.shift())
-      : move(c, reserved)
-    c.reserved.release = true
-    return c
-  }
-
-  function valid(l) {
-    return !l.closed && l.connection.lease === l && l.connection.reserved === l.reserved
+    l.state = Lease.Active
+    c.owner = l
+    l.next = () => {
+      while (l.queue.length) {
+        if (!c.execute(l.queue.shift()))
+          return
+      }
+      move(c, reserved)
+    }
+    return move(c, reserved)
   }
 
-  function send(l, q) {
+  function send(l, q, expected = Lease.Active) {
     const c = l.connection
-    valid(l)
+    l.state === expected
       ? c.queue === full
         ? l.queue.push(q)
         : c.execute(q) || move(c, full)
-      : q.reject(gone(l))
+      : q.reject(leaseError(l.state))
   }
 
-  function gone(l) {
-    return Errors.connection(l.closed && l.closed.code === 'CONNECTION_ENDED' ? 'CONNECTION_ENDED' : 'CONNECTION_CLOSED', options)
+  function leaseError(state) {
+    return Errors.connection(state === Lease.Closed ? 'CONNECTION_CLOSED' : 'CONNECTION_ENDED', options)
   }
 
-  function finish(l) {
-    const c = l.connection
-    if (l.closed || c.lease !== l)
-      return false
+  function settle(l, outcome, err) {
+    if (l.state === Lease.Released || l.state === Lease.Discarded || l.state === Lease.Closed)
+      return
 
-    const held = c.reserved === l.reserved
-    c.lease = null
-    l.closed = Errors.connection('CONNECTION_ENDED', options)
-    held && (c.reserved = null)
+    const c = l.connection
+    l.state = outcome
+    c.owner = null
     while (l.queue.length)
-      l.queue.shift().reject(gone(l))
-    return held
+      l.queue.shift().reject(leaseError(outcome))
+
+    if (outcome === Lease.Closed) {
+      l.error = err || Errors.connection('CONNECTION_CLOSED', options)
+      return l.onclose && l.onclose(l.error)
+    }
+
+    outcome === Lease.Released ? c.release() : c.terminate()
   }
 
   async function reserve() {
     const l = await lease(false)
     const sql = Sql(q => send(l, q))
-    sql.release = () => finish(l) && l.connection.release()
+    sql.release = () => settle(l, Lease.Released)
     return sql
   }
 
@@ -274,23 +283,33 @@ function Postgres(a, b) {
     const l = await lease(true)
     let savepoints = 0
       , prepare = null
-      , settled = false
 
     try {
       const closing = new Promise((_, reject) => l.onclose = reject)
       return await Promise.race([transaction(), closing])
     } finally {
-      finish(l) && (settled ? l.connection.release() : l.connection.terminate())
+      settle(l, Lease.Discarded)
     }
 
     async function transaction() {
       await Sql(q => send(l, q)).unsafe('begin ' + options.replace(/[^a-z ]/ig, ''), []).execute().catch(e => {
-        e instanceof PostgresError && (settled = true)
+        e instanceof PostgresError && settle(l, Lease.Released)
         throw e
       })
       return scope(fn)
     }
 
+    async function finish(statement) {
+      l.state = Lease.Settling
+      try {
+        await statement(Sql(q => send(l, q, Lease.Settling)))
+      } catch (e) {
+        settle(l, Lease.Discarded)
+        throw e
+      }
+      settle(l, Lease.Released)
+    }
+
     async function scope(fn, name) {
       const sql = Sql(handler)
       sql.savepoint = savepoint
@@ -313,23 +332,20 @@ function Postgres(a, b) {
         if (uncaughtError)
           throw uncaughtError
       } catch (e) {
-        l.closed || await (name
+        l.state === Lease.Active && await (name
           ? sql`rollback to ${ sql(name) }`
-          : sql`rollback`
+          : finish(final => final`rollback`)
         )
-        name || (settled = true)
         throw e instanceof PostgresError && e.code === '25P02' && uncaughtError || e
       }
 
-      if (l.closed)
-        throw l.closed
+      if (l.state !== Lease.Active)
+        throw l.error || leaseError(l.state)
 
-      if (!name) {
-        prepare
-          ? await sql`prepare transaction ${ sql.unsafe(prepare) }`
-          : await sql`commit`
-        settled = true
-      }
+      name || await finish(final => prepare
+        ? final`prepare transaction ${ final.unsafe(prepare) }`
+        : final`commit`
+      )
 
       return result
 
@@ -373,8 +389,9 @@ function Postgres(a, b) {
     if (ending)
       return query.reject(Errors.connection('CONNECTION_ENDED', options, options))
 
-    if (open.length)
-      return go(open.shift(), query)
+    const idle = takeOpen()
+    if (idle)
+      return go(idle, query)
 
     if (closed.length)
       return connect(closed.shift(), query)
@@ -384,6 +401,18 @@ function Postgres(a, b) {
       : queries.push(query)
   }
 
+  function takeOpen() {
+    while (open.length) {
+      const c = open.shift()
+      if (!c.expired())
+        return c
+
+      c.terminate()
+    }
+
+    return null
+  }
+
   function go(c, query) {
     return c.execute(query)
       ? move(c, busy)
@@ -391,17 +420,18 @@ function Postgres(a, b) {
   }
 
   function cancel(query) {
+    if (query.state && query.active)
+      return cancelRequest(options, query.state)
+
     return new Promise((resolve, reject) => {
-      query.state
-        ? query.active
-          ? Connection(options).cancel(query.state, resolve, reject)
-          : query.cancelled = { resolve, reject }
-        : (
-          queries.remove(query),
-          query.cancelled = true,
-          query.reject(Errors.generic('57014', 'canceling statement due to user request')),
-          resolve()
-        )
+      if (query.state) {
+        query.cancelled = { resolve, reject }
+      } else {
+        queries.remove(query)
+        query.cancelled = true
+        query.reject(Errors.generic('57014', 'canceling statement due to user request'))
+        resolve()
+      }
     })
   }
 
@@ -412,11 +442,8 @@ function Postgres(a, b) {
     await 1
     let timer
     return ending = Promise.resolve().then(() => Promise.race([
-      new Promise(r => timeout !== null && (timer = setTimeout(() => destroy(r), timeout * 1000))),
-      Promise.all(connections.map(c => c.end()).concat(
-        listen.sql ? listen.sql.end({ timeout: 0 }) : [],
-        subscribe.sql ? subscribe.sql.end({ timeout: 0 }) : []
-      ))
+      new Promise(r => timeout !== null && (timer = clampedTimeout(() => destroy(r), timeout * 1000))),
+      endConnections()
     ])).then(() => {
       clearTimeout(timer)
       while (queries.length)
@@ -424,6 +451,15 @@ function Postgres(a, b) {
     })
   }
 
+  async function endConnections() {
+    await Promise.all(connections.map(c => c.end()).concat(
+      listen.sql ? listen.sql.end({ timeout: 0 }) : [],
+      subscribe.sql ? subscribe.sql.end({ timeout: 0 }) : []
+    ))
+    if (reconnecting)
+      await reconnecting.end()
+  }
+
   async function close() {
     await Promise.all(connections.map(c => c.end()))
   }
@@ -447,18 +483,18 @@ function Postgres(a, b) {
 
   function onopen(c, initial) {
     if (initial && initial.reserve)
-      return initial.reserve(move(c, reserved))
+      return initial.reserve(c)
 
-    if (queries.length === 0)
+    if (!initial && !queries.length)
       return move(c, open)
 
     let max = Math.ceil(queries.length / (connecting.length + 1))
-      , ready = true
+      , ready = !initial || c.execute(initial)
 
     while (ready && queries.length && max-- > 0) {
       const query = queries.shift()
       if (query.reserve)
-        return query.reserve(move(c, reserved))
+        return query.reserve(c)
 
       ready = c.execute(query)
     }
@@ -480,27 +516,38 @@ function Postgres(a, b) {
         ? query.reject(Errors.connection('CONNECTION_ENDED', options))
         : (drained = true, ready = c.execute(query))
     }
+    drained && move(c, ended)
     return drained
   }
 
-  function abandon(l, e) {
-    l.connection.lease = null
-    l.closed = e || Errors.connection('CONNECTION_CLOSED', options)
-    while (l.queue.length)
-      l.queue.shift().reject(gone(l))
-    l.onclose && l.onclose(e)
-  }
-
   function onclose(c, e) {
     move(c, closed)
-    c.reserved = null
-    c.lease && abandon(c.lease, e)
+    c.owner && settle(c.owner, Lease.Closed, e)
     options.onclose && options.onclose(c.id)
-    if (ending) {
-      while (queries.length)
-        queries.shift().reject(e)
-    } else if (queries.length && c.queue === closed) {
+    if (ending)
+      return closedWhileEnding(c, e)
+
+    if (queries.length && c.queue === closed)
       connect(c, queries.shift())
+  }
+
+  function closedWhileEnding(c, e) {
+    const reconnectFailed = c === reconnecting
+    if (connections.some(x => x !== c && x.queue !== closed))
+      return
+
+    while (queries.length) {
+      const query = queries.shift()
+      if (query.reserve) {
+        query.reject(Errors.connection('CONNECTION_ENDED', options))
+      } else if (reconnectFailed) {
+        query.reject(e)
+      } else {
+        reconnecting = c
+        connect(c, query)
+        c.end()
+        return
+      }
     }
   }
 }
@@ -573,7 +620,7 @@ function parseOptions(a, b) {
     socket          : o.socket,
     transform       : parseTransform(o.transform || { undefined: undefined }),
     parameters      : {},
-    shared          : { retries: 0, typeArrayMap: {} },
+    shared          : { retries: 0, typeArrayMap: new Map() },
     ...mergeUserTypes(o.types)
   }
 

package/cf/src/query.js

@@ -23,10 +23,19 @@ export class Query extends Promise {
     this.state = null
     this.statement = null
 
-    this.resolve = x => (this.active = false, resolve(x))
-    this.reject = x => (this.active = false, reject(x))
+    this.resolve = x => {
+      this.active = false
+      this.settled = true
+      resolve(x)
+    }
+    this.reject = x => {
+      this.active = false
+      this.settled = true
+      reject(x)
+    }
 
     this.active = false
+    this.settled = false
     this.cancelled = null
     this.executed = false
     this.signature = ''
@@ -50,7 +59,13 @@ export class Query extends Promise {
   }
 
   cancel() {
-    return this.canceller && (this.canceller(this), this.canceller = null)
+    if (!this.canceller || this.settled)
+      return Promise.resolve()
+
+    const cancelled = this.canceller(this)
+    this.canceller = null
+    cancelled.catch(() => undefined)
+    return cancelled
   }
 
   simple() {

package/cf/src/timeout.js

@@ -0,0 +1,5 @@
+const maxDelay = 2 ** 31 - 1
+
+export default function clampedTimeout(fn, ms) {
+  return setTimeout(fn, Math.min(ms, maxDelay))
+}

package/cf/src/transport.js

@@ -0,0 +1,88 @@
+import { net } from '../polyfills.js'
+import { tls } from '../polyfills.js'
+import b from './bytes.js'
+import clampedTimeout from './timeout.js'
+
+export const SSLRequest = b().i32(8).i32(80877103).end(8)
+
+export function tlsConfig(options, raw) {
+  const { ssl, sslnegotiation } = options
+  const config = {
+    socket: raw,
+    servername: net.isIP(raw.host) ? undefined : raw.host
+  }
+
+  if (sslnegotiation === 'direct')
+    config.ALPNProtocols = ['postgresql']
+
+  if (ssl === 'require' || ssl === 'allow' || ssl === 'prefer')
+    config.rejectUnauthorized = false
+  else if (typeof ssl === 'object')
+    Object.assign(config, ssl)
+
+  return config
+}
+
+export function cancelRequest(options, backend) {
+  return Promise.resolve()
+    .then(() => options.socket ? options.socket(options) : new net.Socket())
+    .then(socket => sendCancel(options, backend, socket))
+}
+
+function sendCancel(options, { pid, secret }, s) {
+  const { ssl, sslnegotiation, host, port } = options
+  const request = b().i32(16).i32(80877102).i32(pid).i32(secret).end(16)
+
+  return new Promise((resolve, reject) => {
+    let timeout = null
+    const watch = x => {
+      x.once('error', reject)
+      x.on('error', () => undefined)
+      x.once('close', () => (clearTimeout(timeout), resolve()))
+    }
+    const upgrade = () => {
+      try {
+        const raw = s
+        const config = tlsConfig(options, raw)
+        raw.removeAllListeners()
+        s = tls.connect(config)
+        watch(s)
+        s.once('secureConnect', () => s.write(request))
+      } catch (error) {
+        clearTimeout(timeout)
+        s.destroy()
+        reject(error)
+      }
+    }
+    const start = !ssl
+      ? () => s.write(request)
+      : sslnegotiation === 'direct'
+        ? upgrade
+        : () => {
+          s.once('data', x => x[0] === 83 || ssl !== 'prefer' ? upgrade() : s.write(request))
+          s.write(SSLRequest)
+        }
+
+    try {
+      watch(s)
+      options.connect_timeout && (timeout = clampedTimeout(() => s.destroy(), options.connect_timeout * 1000))
+
+      if (options.socket)
+        return start()
+
+      s.once('connect', start)
+
+      if (options.path)
+        return s.connect(options.path)
+
+      s.ssl = ssl
+      s.connect(port[0], host[0])
+      s.host = host[0]
+      s.port = port[0]
+    } catch (error) {
+      clearTimeout(timeout)
+      reject(error)
+    }
+  })
+}
+

package/cf/src/types.js

@@ -87,7 +87,7 @@ export function handleValue(x, parameters, types, options) {
   return '$' + (types.push(
     x instanceof Parameter
       ? (parameters.push(x.value), x.array
-        ? x.array[x.type || inferType(x.value)] || x.type || firstIsString(x.value)
+        ? x.array.get(x.type || inferType(x.value)) || x.type || firstIsString(x.value)
         : x.type
       )
       : (parameters.push(x), inferType(x))
@@ -200,7 +200,7 @@ export function addDefaultArrayTypes(options) {
 }
 
 export function addArrayType(options, oid, typarray) {
-  options.shared.typeArrayMap[oid] = typarray
+  options.shared.typeArrayMap.set(oid, typarray)
   if (!options.parsers[typarray]) {
     const parser = options.parsers[oid]
     options.parsers[typarray] = xs => arrayParser(xs, parser, typarray)