@steadybrew/postgresjs 4.2.0 → 4.4.0

package/src/connection.js

@@ -5,7 +5,7 @@ import Stream from 'stream'
 import { performance } from 'perf_hooks'
 
 import { stringify, handleValue, addArrayType } from './types.js'
-import { Errors } from './errors.js'
+import { Errors, callback } from './errors.js'
 import Result from './result.js'
 import Queue from './queue.js'
 import clampedTimeout from './timeout.js'
@@ -13,7 +13,7 @@ import { SSLRequest, tlsConfig, cancelRequest } from './transport.js'
 import { Query, CLOSE } from './query.js'
 import b from './bytes.js'
 
-export default Connection
+export { Connection }
 
 let uid = 1
 
@@ -26,6 +26,8 @@ const Sync = b().S().end()
 const Phase = { Closed: 0, Backoff: 1, Connecting: 2, Initializing: 3, Ready: 4, Draining: 5, Closing: 6 }
 const phaseNames = Object.keys(Phase)
 
+const endsAbortedState = /^\s*(rollback|abort)\b/i
+
 const retryRoutines = new Set([
   'FetchPreparedStatement',
   'RevalidateCachedQuery',
@@ -110,6 +112,7 @@ function Connection(options, queues = {}, { onopen = noop, onend = noop, onclose
     , chunk = null
     , nonce = null
     , query = null
+    , barrier = null
     , final = null
 
   const check = globalThis[Symbol.for('postgres.js:check')]
@@ -222,6 +225,11 @@ function Connection(options, queues = {}, { onopen = noop, onend = noop, onclose
     },
     expired: () => idleTimer.expired() || lifeTimer.expired(),
     owner: null,
+    get active() { return query ? 1 : 0 },
+    get pipelined() { return sent.length },
+    get accepting() { return accepting() },
+    get copying() { return stream !== null },
+    get acquiring() { return acquisition && !acquisition.owner.cancelled ? 1 : 0 },
     count: 0,
     id
   }
@@ -265,8 +273,12 @@ function Connection(options, queues = {}, { onopen = noop, onend = noop, onclose
     return !query && sent.length === 0
   }
 
+  function accepting() {
+    return !query || (!barrier && sent.length < max_pipeline)
+  }
+
   function backoffMs() {
-    return (typeof backoff === 'function' ? backoff(options.shared.retries) : backoff) * 1000
+    return backoffSeconds(backoff, options.shared.retries) * 1000
   }
 
   function standbyPass() {
@@ -443,7 +455,7 @@ function Connection(options, queues = {}, { onopen = noop, onend = noop, onclose
       queryError(pending, err)
       pending.cancelled && pending.cancelled.resolve()
     }
-    query = results = errorResponse = chunk = nextWriteTimer = null
+    query = results = errorResponse = chunk = nextWriteTimer = barrier = null
     result = new Result()
     rows = 0
     nonce = serverSignature = null
@@ -507,8 +519,10 @@ function Connection(options, queues = {}, { onopen = noop, onend = noop, onclose
   }
 
   function submit(q) {
-    if (stream)
-      return queryError(q, Errors.generic('COPY_IN_PROGRESS', 'You cannot execute queries during copy'))
+    if (stream) {
+      queryError(q, Errors.generic('COPY_IN_PROGRESS', 'You cannot execute queries during copy'))
+      return true
+    }
 
     if (q.cancelled)
       return true
@@ -522,17 +536,21 @@ function Connection(options, queues = {}, { onopen = noop, onend = noop, onclose
         : (query = q, query.active = true)
 
       build(q)
-      return write(toBuffer(q))
-        && !q.describeFirst
-        && !q.cursorFn
-        && sent.length < max_pipeline
+      const written = write(toBuffer(q))
+      if (q.describeFirst || q.cursorFn || mayCopy(q))
+        barrier = q
+      return written && accepting()
     } catch (error) {
-      sent.length === 0 && write(Sync)
-      errored(error)
-      return true
+      sent.remove(q) || write(Sync)
+      queryError(q, error)
+      return accepting()
     }
   }
 
+  function mayCopy(q) {
+    return q.options.simple && /\bcopy\b/i.test(q.string)
+  }
+
   function toBuffer(q) {
     if (q.parameters.length >= 65534)
       throw Errors.generic('MAX_PARAMETERS_EXCEEDED', 'Max number of parameters (65534) exceeded')
@@ -591,7 +609,7 @@ function Connection(options, queues = {}, { onopen = noop, onend = noop, onclose
       ? statements[q.signature]
       : { string, types, name: q.prepare ? statementId + statementCount++ : '' }
 
-    typeof options.debug === 'function' && options.debug(id, string, parameters, types)
+    typeof options.debug === 'function' && callback(options.debug, id, string, parameters, types)
   }
 
   function write(x, fn) {
@@ -762,18 +780,21 @@ function Connection(options, queues = {}, { onopen = noop, onend = noop, onclose
     backendParameters[k] = v
     if (options.parameters[k] !== v) {
       options.parameters[k] = v
-      onparameter && onparameter(k, v)
+      callback(onparameter, k, v)
     }
   }
 
-  function ReadyForQuery() {
+  function ReadyForQuery(x) {
+    query === barrier && (barrier = null)
     if (query) {
       if (errorResponse) {
         if (query.initialization)
           return dispatch('initFailed', errorResponse)
+        query.prepared && retryRoutines.has(errorResponse.routine) && delete statements[query.signature]
         query.retried
           ? errored(query.retried)
-          : query.prepared && retryRoutines.has(errorResponse.routine) && query.owner === connection.owner
+          : query.prepared && retryRoutines.has(errorResponse.routine) && query.owner === connection.owner && !barrier
+            && (x[5] !== 69 || endsAbortedState.test(query.string))
             ? retry(query, errorResponse)
             : errored(errorResponse)
       } else {
@@ -1056,7 +1077,6 @@ function Connection(options, queues = {}, { onopen = noop, onend = noop, onclose
   }
 
   function retry(q, error) {
-    delete statements[q.signature]
     q.retried = error
     execute(q)
   }
@@ -1067,7 +1087,8 @@ function Connection(options, queues = {}, { onopen = noop, onend = noop, onclose
 
     let index = 9
     while (x[index++] !== 0);
-    onnotify(
+    callback(
+      onnotify,
       x.toString('utf8', 9, index - 1),
       x.toString('utf8', index, x.length - 1)
     )
@@ -1113,6 +1134,7 @@ function Connection(options, queues = {}, { onopen = noop, onend = noop, onclose
       }
     })
     query.resolve(stream)
+    connection.owner && connection.owner.next()
   }
 
   function CopyOutResponse() {
@@ -1120,6 +1142,7 @@ function Connection(options, queues = {}, { onopen = noop, onend = noop, onclose
       read() { socket.resume() }
     })
     query.resolve(stream)
+    connection.owner && connection.owner.next()
   }
 
   /* c8 ignore next 3 */
@@ -1142,6 +1165,7 @@ function Connection(options, queues = {}, { onopen = noop, onend = noop, onclose
       }
     })
     query.resolve(stream)
+    connection.owner && connection.owner.next()
   }
 
   function CopyData(x) {
@@ -1154,10 +1178,12 @@ function Connection(options, queues = {}, { onopen = noop, onend = noop, onclose
   }
 
   function NoticeResponse(x) {
+    if (onnotice === false)
+      return
+
     onnotice
-      ? onnotice(parseError(x))
+      ? callback(onnotice, parseError(x))
       : console.log(parseError(x)) // eslint-disable-line
-
   }
 
   /* c8 ignore next 3 */
@@ -1308,3 +1334,19 @@ function timer(fn, seconds) {
     fn.apply(null, args)
   }
 }
+
+export function defaultBackoff(retries) {
+  return (0.5 + Math.random() / 2) * Math.min(3 ** retries / 100, 20)
+}
+
+export function backoffSeconds(backoff, retries) {
+  if (typeof backoff !== 'function')
+    return backoff
+
+  try {
+    return backoff(retries)
+  } catch (e) {
+    callback(() => { throw e })
+    return defaultBackoff(retries)
+  }
+}

package/src/errors.js

@@ -6,6 +6,14 @@ export class PostgresError extends Error {
   }
 }
 
+export function callback(fn, ...args) {
+  try {
+    fn && fn(...args)
+  } catch (e) {
+    queueMicrotask(() => { throw e })
+  }
+}
+
 export const Errors = {
   connection,
   postgres,

package/src/index.js

@@ -8,6 +8,7 @@ import {
   Parameter,
   Identifier,
   Builder,
+  escapeIdentifier,
   toPascal,
   pascal,
   toCamel,
@@ -19,12 +20,12 @@ import {
   fromKebab
 } from './types.js'
 
-import Connection from './connection.js'
+import { Connection, defaultBackoff } 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 { Errors, PostgresError, callback } from './errors.js'
 import Subscribe from './subscribe.js'
 import largeObject from './large.js'
 
@@ -81,6 +82,7 @@ function Postgres(a, b) {
     PostgresError,
     options,
     reserve,
+    stats,
     listen,
     begin,
     close,
@@ -150,6 +152,56 @@ function Postgres(a, b) {
     }
   }
 
+  function stats() {
+    let idleCount = 0
+      , busyCount = 0
+      , reservedCount = 0
+      , connectingCount = 0
+      , closingCount = 0
+      , executingCount = 0
+      , waitingCount = queries.length
+
+    for (const c of connections) {
+      executingCount += c.active
+      waitingCount += c.pipelined + c.acquiring + (c.owner ? c.owner.queue.length : 0)
+      c.queue === open
+        ? idleCount++
+        : c.queue === connecting
+          ? connectingCount++
+          : c.queue === ended
+            ? closingCount++
+            : c.queue === reserved
+              ? reservedCount++
+              : (c.queue === busy || c.queue === full) && (c.owner ? reservedCount++ : busyCount++)
+    }
+
+    const totalCount = idleCount + busyCount + reservedCount + connectingCount
+
+    return {
+      max: options.max,
+      totalCount,
+      idleCount,
+      waitingCount,
+      activeCount: busyCount + reservedCount,
+      availableCount: idleCount + options.max - totalCount - closingCount,
+      busyCount,
+      reservedCount,
+      connectingCount,
+      closingCount,
+      executingCount,
+      listenCount: pooled(listen.sql),
+      subscribeCount: pooled(subscribe.sql)
+    }
+  }
+
+  function pooled(sql) {
+    if (!sql)
+      return 0
+
+    const s = sql.stats()
+    return s.totalCount + s.closingCount
+  }
+
   async function listen(name, fn, onlisten) {
     const listener = { fn, onlisten }
 
@@ -167,7 +219,7 @@ function Postgres(a, b) {
         })
       },
       onnotify(c, x) {
-        c in listen.channels && listen.channels[c].listeners.forEach(l => l.fn(x))
+        c in listen.channels && listen.channels[c].listeners.forEach(l => callback(l.fn, x))
       }
     }))
 
@@ -177,7 +229,7 @@ function Postgres(a, b) {
     if (exists) {
       channels[name].listeners.push(listener)
       const result = await channels[name].result
-      listener.onlisten && listener.onlisten()
+      callback(listener.onlisten)
       return { state: result.state, unlisten }
     }
 
@@ -185,7 +237,7 @@ function Postgres(a, b) {
       sql.unsafe('"' + name.replace(/"/g, '""') + '"')
     }`, listeners: [listener] }
     const result = await channels[name].result
-    listener.onlisten && listener.onlisten()
+    callback(listener.onlisten)
     return { state: result.state, unlisten }
 
     async function unlisten() {
@@ -243,9 +295,9 @@ function Postgres(a, b) {
   function send(l, q, expected = Lease.Active) {
     const c = l.connection
     l.state === expected
-      ? c.queue === full
-        ? l.queue.push(q)
-        : c.execute(q) || move(c, full)
+      ? c.copying || (c.queue !== full && c.accepting)
+        ? c.execute(q) || move(c, full)
+        : (move(c, full), q.queue = l.queue, l.queue.push(q))
       : q.reject(leaseError(l.state))
   }
 
@@ -275,6 +327,7 @@ function Postgres(a, b) {
     const l = await lease(false)
     const sql = Sql(q => send(l, q))
     sql.release = () => settle(l, Lease.Released)
+    sql.stats = stats
     return sql
   }
 
@@ -300,14 +353,16 @@ function Postgres(a, b) {
     }
 
     async function finish(statement) {
+      let result
       l.state = Lease.Settling
       try {
-        await statement(Sql(q => send(l, q, Lease.Settling)))
+        result = await statement(Sql(q => send(l, q, Lease.Settling)))
       } catch (e) {
         settle(l, Lease.Discarded)
         throw e
       }
       settle(l, Lease.Released)
+      return result
     }
 
     async function scope(fn, name) {
@@ -322,7 +377,7 @@ function Postgres(a, b) {
       let uncaughtError
         , result
 
-      name && await sql`savepoint ${ sql(name) }`
+      name && await sql.unsafe('savepoint ' + escapeIdentifier(name))
       try {
         result = await new Promise((resolve, reject) => {
           const x = fn(sql)
@@ -333,8 +388,8 @@ function Postgres(a, b) {
           throw uncaughtError
       } catch (e) {
         l.state === Lease.Active && await (name
-          ? sql`rollback to ${ sql(name) }`
-          : finish(final => final`rollback`)
+          ? sql.unsafe('rollback to ' + escapeIdentifier(name))
+          : finish(final => final.unsafe('rollback'))
         )
         throw e instanceof PostgresError && e.code === '25P02' && uncaughtError || e
       }
@@ -342,10 +397,18 @@ function Postgres(a, b) {
       if (l.state !== Lease.Active)
         throw l.error || leaseError(l.state)
 
-      name || await finish(final => prepare
-        ? final`prepare transaction ${ final.unsafe(prepare) }`
-        : final`commit`
-      )
+      if (!name) {
+        const done = await finish(final => prepare
+          ? final.unsafe('prepare transaction ' + prepare)
+          : final.unsafe('commit')
+        )
+        if (done.command === 'ROLLBACK') {
+          throw Object.assign(
+            Errors.generic('TRANSACTION_ROLLED_BACK', 'The server rolled the transaction back instead of committing it'),
+            uncaughtError && { cause: uncaughtError }
+          )
+        }
+      }
 
       return result
 
@@ -374,14 +437,6 @@ function Postgres(a, b) {
     return c
   }
 
-  function callback(fn, ...args) {
-    try {
-      fn && fn(...args)
-    } catch (e) {
-      queueMicrotask(() => { throw e })
-    }
-  }
-
   function json(x) {
     return new Parameter(x, 3802)
   }
@@ -404,11 +459,24 @@ function Postgres(a, b) {
     if (closed.length)
       return connect(closed.shift(), query)
 
-    busy.length
-      ? go(busy.shift(), query)
+    const c = takeBusy()
+    c
+      ? go(c, query)
       : queries.push(query)
   }
 
+  function takeBusy() {
+    while (busy.length) {
+      const c = busy.shift()
+      if (c.accepting)
+        return c
+
+      move(c, full)
+    }
+
+    return null
+  }
+
   function takeOpen() {
     while (open.length) {
       const c = open.shift()
@@ -435,7 +503,7 @@ function Postgres(a, b) {
       if (query.state) {
         query.cancelled = { resolve, reject }
       } else {
-        queries.remove(query)
+        (query.queue || queries).remove(query)
         query.cancelled = true
         query.reject(Errors.generic('57014', 'canceling statement due to user request'))
         resolve()
@@ -493,6 +561,9 @@ function Postgres(a, b) {
     if (initial && initial.reserve)
       return initial.reserve(c)
 
+    if (!initial && !c.accepting)
+      return move(c, full)
+
     if (!initial && !queries.length)
       return move(c, open)
 
@@ -531,7 +602,7 @@ function Postgres(a, b) {
   function onclose(c, e) {
     move(c, closed)
     c.owner && settle(c.owner, Lease.Closed, e)
-    options.onclose && options.onclose(c.id)
+    callback(options.onclose, c.id)
     if (ending)
       return closedWhileEnding(c, e)
 
@@ -586,7 +657,7 @@ function parseOptions(a, b) {
     connect_timeout : 30,
     max_lifetime    : max_lifetime,
     max_pipeline    : 100,
-    backoff         : backoff,
+    backoff         : defaultBackoff,
     keep_alive      : 60,
     prepare         : true,
     debug           : false,
@@ -645,10 +716,6 @@ function tsa(o, url, env) {
   throw new Error('target_session_attrs ' + x + ' is not supported')
 }
 
-function backoff(retries) {
-  return (0.5 + Math.random() / 2) * Math.min(3 ** retries / 100, 20)
-}
-
 function max_lifetime() {
   return 60 * (30 + Math.random() * 30)
 }