@steadybrew/postgresjs 4.0.0 → 4.2.0-rc1

package/src/connection.js

@@ -8,6 +8,8 @@ import { stringify, handleValue, addArrayType } from './types.js'
 import { Errors } from './errors.js'
 import Result from './result.js'
 import Queue from './queue.js'
+import clampedTimeout from './timeout.js'
+import { SSLRequest, tlsConfig, cancelRequest } from './transport.js'
 import { Query, CLOSE } from './query.js'
 import b from './bytes.js'
 
@@ -17,12 +19,12 @@ let uid = 1
 
 const Sync = b().S().end()
     , Flush = b().H().end()
-    , SSLRequest = b().i32(8).i32(80877103).end(8)
     , ExecuteUnnamed = Buffer.concat([b().E().str(b.N).i32(0).end(), Sync])
     , DescribeUnnamed = b().D().str('S').str(b.N).end()
     , noop = () => { /* noop */ }
 
-const Phase = { Closed: 0, Backoff: 1, Opening: 2, Negotiating: 3, Authenticating: 4, Initializing: 5, Ready: 6, Draining: 7, Closing: 8 }
+const Phase = { Closed: 0, Backoff: 1, Connecting: 2, Initializing: 3, Ready: 4, Draining: 5, Closing: 6 }
+const phaseNames = Object.keys(Phase)
 
 const retryRoutines = new Set([
   'FetchPreparedStatement',
@@ -74,18 +76,20 @@ function Connection(options, queues = {}, { onopen = noop, onend = noop, onclose
   const sent = Queue()
       , id = uid++
       , backend = { pid: null, secret: null }
-      , idleTimer = timer(end, options.idle_timeout)
-      , lifeTimer = timer(end, options.max_lifetime)
+      , idleTimer = timer(() => dispatch('end'), options.idle_timeout)
+      , lifeTimer = timer(() => dispatch('end'), options.max_lifetime)
 
   let socket = null
     , phase = Phase.Closed
     , generation = 0
     , acquisition = null
-    , endRequested = false
     , endWaiters = []
     , inheritedBackoff = null
     , backoffTimer = null
-    , connectTimer = null
+    , backoffUntil = 0
+    , attemptTimer = null
+    , deadlineTimer = null
+    , closeTimer = null
     , errorResponse = null
     , result = new Result()
     , incoming = Buffer.alloc(0)
@@ -108,38 +112,153 @@ function Connection(options, queues = {}, { onopen = noop, onend = noop, onclose
     , query = null
     , final = null
 
+  const check = globalThis[Symbol.for('postgres.js:check')]
+  let depth = 0
+
+  const starting = {
+    acquire: refuse,
+    deadline: expire,
+    attemptTimeout: () => afterFailure(Errors.connection('CONNECT_TIMEOUT', options, socket), 'timeout'),
+    socketError: err => afterFailure(err, 'socket'),
+    socketClose: () => afterFailure(errorResponse || Errors.connection('CONNECTION_CLOSED', options, socket), 'dropped'),
+    protocolError: err => afterFailure(err, 'protocol'),
+    authFailed: enterClosed,
+    writable: noop,
+    end: () => endAcquisition(null),
+    terminate: () => enterClosed(Errors.connection('CONNECTION_DESTROYED', options, socket))
+  }
+
+  const on = {
+    [Phase.Closed]: {
+      acquire,
+      execute: refuse,
+      end: () => endWaiters.splice(0).forEach(resolve => resolve()),
+      terminate: noop
+    },
+    [Phase.Backoff]: {
+      acquire: refuse,
+      execute: refuse,
+      backoffElapsed: enterConnecting,
+      deadline: expire,
+      end: () => (inheritedBackoff = { at: performance.now(), delay: backoffUntil - performance.now() }, endAcquisition(acquisition.lastError)),
+      terminate: () => enterClosed(Errors.connection('CONNECTION_DESTROYED', options, socket))
+    },
+    [Phase.Connecting]: {
+      ...starting,
+      execute: refuse,
+      socketCreated: attach,
+      factoryFailed: err => afterFailure(err, 'factory'),
+      socketReady: () => ssl ? negotiate() : authenticate(),
+      sslReply: x => x[0] === 83
+        ? upgrade()
+        : ssl === 'prefer'
+          ? authenticate()
+          : afterFailure(Errors.generic('SSL_NOT_SUPPORTED', 'The server does not support SSL connections'), 'protocol'),
+      secure: authenticate,
+      serverError: err => afterFailure(err, 'rejected'),
+      ready: () => (transition(Phase.Initializing), initialized())
+    },
+    [Phase.Initializing]: {
+      ...starting,
+      execute: q => q.initialization ? submit(q) : refuse(q),
+      serverError: err => afterFailure(err, 'dropped'),
+      initFailed: enterClosed,
+      ready: initialized
+    },
+    [Phase.Ready]: {
+      acquire: refuse,
+      execute: submit,
+      ready: () => pipelined() || (connection.owner ? connection.owner.next() : onopen(connection)),
+      serverError: lost,
+      socketError: lost,
+      socketClose: hadError => lost(closedBy(errorResponse), hadError),
+      protocolError: errored,
+      writable: () => !query && !connection.owner && onopen(connection),
+      end: () => idle() && !connection.owner
+        ? closing()
+        : (transition(Phase.Draining), connection.owner || onend(connection)),
+      terminate: () => idle() ? enterClosed() : enterClosed(Errors.connection('CONNECTION_DESTROYED', options, socket)),
+      release: () => onopen(connection)
+    },
+    [Phase.Draining]: {
+      acquire: refuse,
+      execute: submit,
+      ready: () => pipelined() || (connection.owner ? connection.owner.next() : drained()),
+      serverError: lost,
+      socketError: lost,
+      socketClose: hadError => lost(closedBy(errorResponse), hadError),
+      protocolError: errored,
+      writable: noop,
+      end: noop,
+      terminate: () => idle() ? enterClosed() : enterClosed(Errors.connection('CONNECTION_DESTROYED', options, socket)),
+      release: () => idle() ? drained() : onend(connection)
+    },
+    [Phase.Closing]: {
+      acquire: refuse,
+      execute: refuse,
+      ready: noop,
+      serverError: noop,
+      socketError: noop,
+      socketClose: hadError => hadError ? lost(Errors.connection('CONNECTION_CLOSED', options, socket)) : enterClosed(),
+      closeTimeout: () => enterClosed(),
+      protocolError: errored,
+      writable: noop,
+      end: noop,
+      terminate: () => enterClosed()
+    }
+  }
+
   const connection = {
     queue: queues.closed,
     idleTimer,
-    connect: acquire,
-    terminate,
+    connect: request => dispatch('acquire', request),
+    terminate: () => dispatch('terminate'),
     execute,
-    cancel,
-    release,
-    end,
+    release: () => dispatch('release'),
+    end: () => {
+      const done = new Promise(resolve => endWaiters.push(resolve))
+      dispatch('end')
+      return done
+    },
+    expired: () => idleTimer.expired() || lifeTimer.expired(),
+    owner: null,
     count: 0,
     id
   }
 
+  check && Object.defineProperty(connection, Symbol.for('postgres.js:phase'), { get: () => phaseNames[phase] })
+  check && check('created', connection, queues)
+
   queues.closed && queues.closed.push(connection)
 
   return connection
 
   function transition(next) {
+    check && check('edge', connection, phaseNames[phase], phaseNames[next])
     generation++
     phase = next
   }
 
-  function starting() {
-    return phase >= Phase.Opening && phase <= Phase.Initializing
+  function dispatch(event, arg) {
+    const handler = on[phase][event]
+    if (!handler)
+      return check && check('unhandled', connection, phaseNames[phase], event)
+
+    depth++
+    try {
+      return handler(arg)
+    } finally {
+      depth--
+      check && depth === 0 && check('settled', connection, queues)
+    }
   }
 
-  function held() {
-    return connection.reserved || connection.queue === queues.reserved
+  function refuse(request) {
+    queryError(request, Errors.connection('CONNECTION_CLOSED', options))
   }
 
   function drained() {
-    ondrain(connection) || closing(true)
+    ondrain(connection) || closing()
   }
 
   function idle() {
@@ -150,47 +269,38 @@ function Connection(options, queues = {}, { onopen = noop, onend = noop, onclose
     return (typeof backoff === 'function' ? backoff(options.shared.retries) : backoff) * 1000
   }
 
-  function acquire(owner) {
-    if (phase !== Phase.Closed)
-      return queryError(owner, Errors.connection('CONNECTION_CLOSED', options))
+  function standbyPass() {
+    return target_session_attrs === 'prefer-standby' && host.length > 1 && acquisition.pass === 'standby'
+  }
 
-    acquisition = { owner, attempts: 0, hostsTried: 0, lastError: null, deadline: null, expired: false }
+  function acquire(owner) {
+    acquisition = { owner, ending: false, pass: 'standby', hostsTried: 0, attempting: null, mismatches: [], lastError: null }
     const wait = inheritedBackoff ? inheritedBackoff.at + inheritedBackoff.delay - performance.now() : 0
     inheritedBackoff = null
-    wait > 0 ? enterBackoff(wait) : enterOpening()
+    wait > 0 ? enterBackoff(wait) : enterConnecting()
   }
 
   function enterBackoff(ms) {
     transition(Phase.Backoff)
-    const a = acquisition
-    const attempt = generation
-    const left = a.deadline === null ? Infinity : Math.max(0, a.deadline - performance.now())
-    a.expired = left <= ms
-    backoffTimer = setTimeout(() => {
-      backoffTimer = null
-      attempt === generation && (a.expired
-        ? enterClosed(a.lastError || Errors.connection('CONNECT_TIMEOUT', options))
-        : enterOpening())
-    }, Math.min(ms, left))
-  }
-
-  function enterOpening() {
-    transition(Phase.Opening)
+    backoffUntil = performance.now() + ms
+    backoffTimer = clampedTimeout(() => (backoffTimer = null, dispatch('backoffElapsed')), ms)
+  }
+
+  function enterConnecting() {
+    transition(Phase.Connecting)
     const a = acquisition
     const attempt = generation
     const ms = options.connect_timeout * 1000
     if (ms) {
-      const now = performance.now()
-      a.deadline === null && (a.deadline = now + ms * host.length)
-      const left = a.deadline - now
-      connectTimer = setTimeout(() => connectTimedOut(left <= ms), Math.min(ms, left))
+      deadlineTimer === null && (deadlineTimer = clampedTimeout(() => (deadlineTimer = null, dispatch('deadline')), ms * host.length))
+      host.length > 1 && (attemptTimer = clampedTimeout(() => (attemptTimer = null, dispatch('attemptTimeout')), ms))
     }
     a.hostsTried++
     backendParameters = {}
     Promise.resolve()
       .then(() => options.socket ? options.socket(options) : new net.Socket())
-      .then(created => attempt === generation ? attach(created) : dispose(created))
-      .catch(err => attempt === generation && fail(err))
+      .then(created => attempt === generation ? dispatch('socketCreated', created) : dispose(created))
+      .catch(err => attempt === generation && dispatch('factoryFailed', err))
   }
 
   function dispose(created) {
@@ -198,16 +308,21 @@ function Connection(options, queues = {}, { onopen = noop, onend = noop, onclose
     created.destroy()
   }
 
+  function listen(s) {
+    s.on('error', err => dispatch('socketError', err))
+    s.on('close', hadError => dispatch('socketClose', hadError))
+    s.on('drain', () => dispatch('writable'))
+  }
+
   function attach(created) {
+    listen(created)
     socket = created
-    created.on('error', error)
-    created.on('close', closed)
-    created.on('drain', drain)
+    acquisition.attempting = options.socket ? 'custom socket' : options.path || host[hostIndex] + ':' + port[hostIndex]
 
     if (options.socket)
-      return ssl ? negotiate() : authenticate()
+      return dispatch('socketReady')
 
-    created.on('connect', ssl ? negotiate : authenticate)
+    created.on('connect', () => dispatch('socketReady'))
 
     if (options.path)
       return created.connect(options.path)
@@ -221,110 +336,96 @@ function Connection(options, queues = {}, { onopen = noop, onend = noop, onclose
   }
 
   function negotiate() {
-    transition(Phase.Negotiating)
     if (sslnegotiation === 'direct')
       return upgrade()
 
-    const attempt = generation
-    socket.once('data', x => attempt === generation && (
-      x[0] === 83
-        ? upgrade()
-        : ssl === 'prefer'
-          ? authenticate()
-          : fail(Errors.generic('SSL_NOT_SUPPORTED', 'The server does not support SSL connections'))
-    ))
+    socket.once('data', x => dispatch('sslReply', x))
     write(SSLRequest)
   }
 
   function upgrade() {
     try {
       const raw = socket
-      const config = tlsConfig(raw)
+      const config = tlsConfig(options, raw)
       raw.removeAllListeners()
       socket = tls.connect(config)
-      socket.on('secureConnect', authenticate)
-      socket.on('error', error)
-      socket.on('close', closed)
-      socket.on('drain', drain)
+      socket.on('secureConnect', () => dispatch('secure'))
+      listen(socket)
     } catch (err) {
-      fail(err)
+      afterFailure(err, 'protocol')
     }
   }
 
-  function tlsConfig(raw) {
-    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
-  }
-
   function authenticate() {
-    transition(Phase.Authenticating)
     try {
       statements = {}
       needsTypes = options.fetch_types
       statementId = Math.random().toString(36).slice(2)
       statementCount = 1
-      lifeTimer.start()
       socket.on('data', data)
       keep_alive && socket.setKeepAlive && socket.setKeepAlive(true, 1000 * keep_alive)
       write(StartupMessage())
     } catch (err) {
-      fail(err)
+      afterFailure(err, 'protocol')
     }
   }
 
-  function connectTimedOut(expiring) {
-    connectTimer = null
-    if (!starting())
-      return
-    expiring && (acquisition.expired = true)
-    fail(Errors.connection('CONNECT_TIMEOUT', options, socket), true)
+  function expire() {
+    enterClosed(acquisition.lastError || Errors.connection('CONNECT_TIMEOUT', options, socket))
   }
 
-  function fail(err, persist = host.length > 1) {
+  function mismatched(reason) {
     const a = acquisition
-    a.attempts++
-    a.lastError = err && err.code === 'CONNECT_TIMEOUT' && a.lastError ? a.lastError : err
-    clearTimeout(connectTimer)
-    connectTimer = null
-    detach()
-    resetSocketState(err)
-
-    if (endRequested)
-      return enterClosed(err)
-
-    if (a.expired || (a.deadline !== null && performance.now() >= a.deadline))
-      return enterClosed(a.lastError)
+    a.mismatches.push(a.attempting + ' ' + reason)
+    afterFailure(closedBy(Errors.generic('TARGET_SESSION_ATTRS',
+      'No host matched target_session_attrs=' + target_session_attrs + ': ' + a.mismatches.join(', '))), 'mismatch')
+  }
 
-    if (a.hostsTried < host.length)
-      return enterBackoff(0)
+  function afterFailure(err, cause) {
+    const a = acquisition
+    a.lastError = cause === 'timeout' && a.lastError ? a.lastError : err
 
-    options.shared.retries++
-    if (!persist) {
+    if (a.ending) {
       inheritedBackoff = { at: performance.now(), delay: backoffMs() }
       return enterClosed(err)
     }
 
-    a.hostsTried = 0
-    enterBackoff(backoffMs())
+    let delay = 0
+    if (a.hostsTried === host.length) {
+      a.hostsTried = 0
+      const mismatches = a.mismatches
+      a.mismatches = []
+      if (standbyPass()) {
+        a.pass = 'any'
+      } else {
+        a.pass = 'standby'
+        options.shared.retries++
+        if (host.length > 1 && mismatches.length === host.length) {
+          inheritedBackoff = { at: performance.now(), delay: backoffMs() }
+          return enterClosed(err)
+        }
+
+        // A single endpoint that is read-only now is often mid-failover behind one DNS name, so retry until the deadline.
+        if (host.length === 1 && cause !== 'dropped' && cause !== 'mismatch') {
+          inheritedBackoff = { at: performance.now(), delay: backoffMs() }
+          return enterClosed(err)
+        }
+
+        delay = backoffMs()
+      }
+    }
+
+    clearTimeout(attemptTimer)
+    attemptTimer = null
+    endSession(err)
+    enterBackoff(delay)
   }
 
-  function detach() {
-    clearTimeout(connectTimer)
-    connectTimer = null
-    idleTimer.cancel()
+  function endSession(err) {
     lifeTimer.cancel()
+    clearTimeout(closeTimer)
+    closeTimer = null
+    clearImmediate(nextWriteTimer)
     incoming = Buffer.alloc(0)
     remaining = 0
     incomings = null
@@ -334,117 +435,85 @@ function Connection(options, queues = {}, { onopen = noop, onend = noop, onclose
       socket.destroy()
       socket = null
     }
+    stream && (stream.destroy(err), stream = null)
+    final && (final(err), final = null)
+    query && queryError(query, err)
+    while (sent.length) {
+      const pending = sent.shift()
+      queryError(pending, err)
+      pending.cancelled && pending.cancelled.resolve()
+    }
+    query = results = errorResponse = chunk = nextWriteTimer = null
+    result = new Result()
+    rows = 0
+    nonce = serverSignature = null
   }
 
-  function enterClosed(err = Errors.connection('CONNECTION_CLOSED', options, socket)) {
-    if (phase === Phase.Closed)
-      return
-
+  function enterClosed(err = Errors.connection('CONNECTION_CLOSED', options, socket), reported = err) {
     const a = acquisition
     const waiters = endWaiters
-    clearTimeout(backoffTimer)
-    backoffTimer = null
-    detach()
-    resetSocketState(err)
+    clearAcquisitionTimers()
+    endSession(err)
     acquisition = null
-    endRequested = false
     endWaiters = []
     transition(Phase.Closed)
     a && queryError(a.owner, err)
     waiters.forEach(resolve => resolve())
-    onclose(connection, err)
+    onclose(connection, reported)
+  }
+
+  function clearAcquisitionTimers() {
+    clearTimeout(attemptTimer)
+    attemptTimer = null
+    clearTimeout(deadlineTimer)
+    deadlineTimer = null
+    clearTimeout(backoffTimer)
+    backoffTimer = null
   }
 
-  function closing(quit) {
+  function closing() {
     transition(Phase.Closing)
-    idleTimer.cancel()
+    onend(connection)
     lifeTimer.cancel()
-    quit && socket.readyState === 'open'
-      ? socket.end(b().X().end())
-      : socket.destroy()
+    if (socket.readyState === 'open') {
+      socket.end(b().X().end())
+      const ms = options.connect_timeout * 1000
+      ms && (closeTimer = clampedTimeout(() => (closeTimer = null, dispatch('closeTimeout')), ms))
+    } else {
+      socket.destroy()
+    }
   }
 
   function handoff() {
-    const owner = acquisition.owner
+    const { owner, ending } = acquisition
     transition(Phase.Ready)
-    clearTimeout(connectTimer)
-    connectTimer = null
+    clearAcquisitionTimers()
     acquisition = null
     options.shared.retries = 0
+    lifeTimer.start()
 
-    if (endRequested) {
-      endRequested = false
-      if (owner.reserve)
-        return (queryError(owner, Errors.connection('CONNECTION_ENDED', options)), closing(true))
+    if (ending) {
       if (owner.cancelled)
-        return closing(true)
+        return closing()
       transition(Phase.Draining)
       return execute(owner)
     }
 
-    owner.reserve
-      ? onopen(connection, owner)
-      : owner.cancelled
-        ? onopen(connection)
-        : execute(owner)
-  }
-
-  async function cancel({ pid, secret }, resolve, reject) {
-    let timeout = null
-    try {
-      let s = await Promise.resolve(options.socket ? options.socket(options) : new net.Socket())
-      const request = b().i32(16).i32(80877102).i32(pid).i32(secret).end(16)
-      const watch = x => {
-        x.once('error', reject)
-        x.on('error', noop)
-        x.once('close', () => (clearTimeout(timeout), resolve()))
-      }
-      const upgrade = () => {
-        const raw = s
-        const config = tlsConfig(raw)
-        raw.removeAllListeners()
-        s = tls.connect(config)
-        watch(s)
-        s.once('secureConnect', () => s.write(request))
-      }
-      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)
-          }
-
-      watch(s)
-      options.connect_timeout && (timeout = setTimeout(() => 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) {
-      reject(error)
-    }
+    onopen(connection, owner.cancelled ? undefined : owner)
   }
 
   function execute(q) {
-    if (phase !== Phase.Ready && phase !== Phase.Draining && !(phase === Phase.Initializing && q.initialization))
-      return queryError(q, Errors.connection('CONNECTION_CLOSED', options))
+    return dispatch('execute', q)
+  }
 
+  function submit(q) {
     if (stream)
       return queryError(q, Errors.generic('COPY_IN_PROGRESS', 'You cannot execute queries during copy'))
 
     if (q.cancelled)
-      return
+      return true
+
+    q.owner === undefined && (q.owner = connection.owner)
 
     try {
       q.state = backend
@@ -540,24 +609,6 @@ function Connection(options, queues = {}, { onopen = noop, onend = noop, onclose
     return x
   }
 
-  function resetSocketState(err) {
-    clearImmediate(nextWriteTimer)
-    stream && (stream.destroy(err), stream = null)
-    final && (final(err), final = null)
-    query && queryError(query, err)
-    while (sent.length)
-      queryError(sent.shift(), err)
-    query = results = errorResponse = chunk = nextWriteTimer = null
-    result = new Result()
-    rows = 0
-    nonce = serverSignature = null
-  }
-
-  /* c8 ignore next 3 */
-  function drain() {
-    phase === Phase.Ready && !query && !held() && onopen(connection)
-  }
-
   function data(x) {
     if (incomings) {
       incomings.push(x)
@@ -585,7 +636,7 @@ function Connection(options, queues = {}, { onopen = noop, onend = noop, onclose
         handle(incoming.subarray(0, length + 1))
       } catch (e) {
         query && (query.cursorFn || query.describeFirst) && write(Sync)
-        starting() ? fail(e) : errored(e)
+        dispatch('protocolError', e)
       }
       if (socket !== source)
         return
@@ -595,22 +646,15 @@ function Connection(options, queues = {}, { onopen = noop, onend = noop, onclose
     }
   }
 
-  function error(err) {
-    if (starting())
-      return fail(err)
-
-    if (phase === Phase.Ready || phase === Phase.Draining)
-      socketFailed(err)
+  function lost(err, counted = true) {
+    counted && options.shared.retries++
+    inheritedBackoff = { at: performance.now(), delay: backoffMs() }
+    enterClosed(err, err.code === 'CONNECTION_CLOSED' ? err : closedBy(err))
   }
 
-  function socketFailed(err) {
-    errored(err)
-    while (sent.length)
-      queryError(sent.shift(), err)
-    query = null
-    options.shared.retries++
-    inheritedBackoff = { at: performance.now(), delay: backoffMs() }
-    closing(false)
+  // CONNECTION_CLOSED stays the code callers retry on; the FATAL, socket error or target_session_attrs mismatch is its cause.
+  function closedBy(cause) {
+    return Errors.connection('CONNECTION_CLOSED', options, socket, cause)
   }
 
   function errored(err) {
@@ -635,68 +679,16 @@ function Connection(options, queues = {}, { onopen = noop, onend = noop, onclose
     query.reject(err)
   }
 
-  function end() {
-    if (phase === Phase.Closed)
-      return Promise.resolve()
-
-    const done = new Promise(resolve => endWaiters.push(resolve))
-
-    if (phase === Phase.Closing || phase === Phase.Draining)
-      return done
-
-    if (phase === Phase.Ready) {
-      !held() && onend(connection)
-      idle() && !held()
-        ? closing(true)
-        : transition(Phase.Draining)
-      return done
-    }
-
-    if (acquisition.owner.reserve)
+  function endAcquisition(err) {
+    const a = acquisition
+    if (a.owner.reserve)
       enterClosed(Errors.connection('CONNECTION_ENDED', options))
-    else if (phase === Phase.Backoff && acquisition.attempts > 0)
-      enterClosed(acquisition.lastError)
-    else if (!endRequested)
-      (endRequested = true, onend(connection))
-
-    return done
-  }
-
-  function terminate() {
-    if (phase === Phase.Closed)
-      return
-
-    const destroyed = Errors.connection('CONNECTION_DESTROYED', options, socket)
-    if (phase === Phase.Closing)
-      return socket.destroy()
-
-    if (phase !== Phase.Ready && phase !== Phase.Draining)
-      return enterClosed(destroyed)
-
-    const inflight = !idle()
-    resetSocketState(destroyed)
-    enterClosed(inflight ? destroyed : undefined)
-  }
-
-  function release() {
-    phase === Phase.Ready
-      ? onopen(connection)
-      : phase === Phase.Draining && idle() && drained()
+    else if (err)
+      enterClosed(err)
+    else if (!a.ending)
+      (a.ending = true, onend(connection))
   }
 
-  function closed(hadError) {
-    const err = Errors.connection('CONNECTION_CLOSED', options, socket)
-    if (starting())
-      return fail(errorResponse || err, true)
-
-    if (!inheritedBackoff && (phase !== Phase.Closing || hadError)) {
-      hadError && options.shared.retries++
-      inheritedBackoff = { at: performance.now(), delay: backoffMs() }
-    }
-    enterClosed(err)
-  }
-
-
   /* Handlers */
   function handle(xs, x = xs[0]) {
     (
@@ -774,14 +766,14 @@ function Connection(options, queues = {}, { onopen = noop, onend = noop, onclose
     }
   }
 
-  function ReadyForQuery(x) {
+  function ReadyForQuery() {
     if (query) {
       if (errorResponse) {
         if (query.initialization)
-          return enterClosed(errorResponse)
+          return dispatch('initFailed', errorResponse)
         query.retried
           ? errored(query.retried)
-          : query.prepared && retryRoutines.has(errorResponse.routine)
+          : query.prepared && retryRoutines.has(errorResponse.routine) && query.owner === connection.owner
             ? retry(query, errorResponse)
             : errored(errorResponse)
       } else {
@@ -795,37 +787,26 @@ function Connection(options, queues = {}, { onopen = noop, onend = noop, onclose
     query = results = errorResponse = null
     result = new Result()
 
-    if (phase === Phase.Authenticating || phase === Phase.Initializing)
-      return initialized()
-
-    if (phase === Phase.Closing)
-      return
-
-    while (sent.length && (query = sent.shift()) && (query.active = true, query.cancelled))
-      Connection(options).cancel(query.state, query.cancelled.resolve, query.cancelled.reject)
+    dispatch('ready')
+  }
 
-    if (query)
-      return
+  function pipelined() {
+    query = sent.length ? sent.shift() : null
+    if (query) {
+      query.active = true
+      query.cancelled && cancelRequest(options, query.state).then(query.cancelled.resolve, query.cancelled.reject)
+    }
 
-    connection.reserved
-      ? !connection.reserved.release && x[5] === 73
-        ? phase === Phase.Draining
-          ? drained()
-          : (connection.reserved = null, onopen(connection))
-        : connection.reserved()
-      : phase === Phase.Draining
-        ? drained()
-        : onopen(connection)
+    return query
   }
 
   function initialized() {
     if (target_session_attrs) {
       if (!backendParameters.in_hot_standby || !backendParameters.default_transaction_read_only)
         return fetchState()
-      if (tryNext(target_session_attrs, backendParameters)) {
-        acquisition.mismatch = true
-        return fail(Errors.connection('CONNECTION_CLOSED', options, socket), true)
-      }
+      const reason = mismatchReason(target_session_attrs, backendParameters)
+      if (reason)
+        return mismatched(reason)
     }
 
     if (needsTypes)
@@ -849,7 +830,7 @@ function Connection(options, queues = {}, { onopen = noop, onend = noop, onclose
 
     final && (final(), final = null)
 
-    if (result.command === 'BEGIN' && max !== 1 && !connection.reserved)
+    if (result.command === 'BEGIN' && max !== 1 && !query.owner)
       return errored(Errors.generic('UNSAFE_TRANSACTION', 'Only use sql.begin, sql.reserved or max: 1'))
 
     if (query.options.simple)
@@ -927,7 +908,7 @@ function Connection(options, queues = {}, { onopen = noop, onend = noop, onclose
       type === 12 ? SASLFinal :
       type !== 0 ? UnknownAuth :
       noop
-    )(x, type, attempt)).catch(err => attempt === generation && enterClosed(err))
+    )(x, type, attempt)).catch(err => attempt === generation && dispatch('authFailed', err))
   }
 
   /* c8 ignore next 5 */
@@ -1001,7 +982,7 @@ function Connection(options, queues = {}, { onopen = noop, onend = noop, onclose
     if (x.toString('utf8', 9).split(b.N, 1)[0].slice(2) === serverSignature)
       return
     /* c8 ignore next 5 */
-    enterClosed(Errors.generic('SASL_SIGNATURE_MISMATCH', 'The server did not return the correct signature'))
+    dispatch('authFailed', Errors.generic('SASL_SIGNATURE_MISMATCH', 'The server did not return the correct signature'))
   }
 
   function Pass() {
@@ -1035,13 +1016,14 @@ function Connection(options, queues = {}, { onopen = noop, onend = noop, onclose
     `, types => types.forEach(({ oid, typarray }) => addArrayType(options, oid, typarray)))
   }
 
-  function tryNext(x, xs) {
+  function mismatchReason(x, xs) {
     return (
-      (x === 'read-write' && xs.default_transaction_read_only === 'on') ||
-      (x === 'read-only' && xs.default_transaction_read_only === 'off') ||
-      (x === 'primary' && xs.in_hot_standby === 'on') ||
-      (x === 'standby' && xs.in_hot_standby === 'off') ||
-      (x === 'prefer-standby' && xs.in_hot_standby === 'off' && host.length > 1 && !acquisition.mismatch)
+      (x === 'read-write' && xs.default_transaction_read_only === 'on' && 'is read-only') ||
+      (x === 'read-only' && xs.default_transaction_read_only === 'off' && 'is read-write') ||
+      (x === 'primary' && xs.in_hot_standby === 'on' && 'is a standby') ||
+      (x === 'standby' && xs.in_hot_standby === 'off' && 'is a primary') ||
+      (x === 'prefer-standby' && xs.in_hot_standby === 'off' && standbyPass() && 'is a primary') ||
+      null
     )
   }
 
@@ -1056,7 +1038,6 @@ function Connection(options, queues = {}, { onopen = noop, onend = noop, onclose
   }
 
   function initialize(string, resolve, simple = false) {
-    transition(Phase.Initializing)
     const attempt = generation
     const q = new Query([string], [], q => attempt === generation
       ? execute(q)
@@ -1070,10 +1051,7 @@ function Connection(options, queues = {}, { onopen = noop, onend = noop, onclose
       (query.cursorFn || query.describeFirst) && write(Sync)
       errorResponse = Errors.postgres(parseError(x))
     } else {
-      const err = Errors.postgres(parseError(x))
-      phase === Phase.Ready || phase === Phase.Draining
-        ? socketFailed(err)
-        : phase === Phase.Authenticating && fail(err)
+      dispatch('serverError', Errors.postgres(parseError(x)))
     }
   }
 
@@ -1305,21 +1283,28 @@ function xor(a, b) {
 function timer(fn, seconds) {
   seconds = typeof seconds === 'function' ? seconds() : seconds
   if (!seconds)
-    return { cancel: noop, start: noop }
+    return { cancel: noop, start: noop, expired: () => false }
 
   let timer
+    , due = null
   return {
     cancel() {
       timer && (clearTimeout(timer), timer = null)
+      due = null
     },
     start(...args) {
       timer && clearTimeout(timer)
-      timer = setTimeout(() => done(args), seconds * 1000)
+      due = Date.now() + seconds * 1000
+      timer = clampedTimeout(() => done(args), seconds * 1000)
+    },
+    expired() {
+      return due !== null && Date.now() >= due
     }
   }
 
   function done(args) {
     timer = null
+    due = null
     fn.apply(null, args)
   }
 }