@steadybrew/postgresjs 4.5.0-rc1 → 4.5.0

package/README.md

@@ -71,22 +71,25 @@ See the [changelog](./CHANGELOG.md#breaking-changes-and-migration) for the full
 
 ## Fixed Postgres.js issues
 
-Upstream issues on [porsager/postgres](https://github.com/porsager/postgres/issues) that this fork fixes, and the version that fixed them. Each fix has a test that reproduces the report. The [changelog](./CHANGELOG.md) has the details.
+Bugs and feature requests from [porsager/postgres](https://github.com/porsager/postgres) that this fork fixes, whether reported in an issue or in a pull request suggesting a fix, and the version that fixed them. Each fix has a test that reproduces the report, except [#1100](https://github.com/porsager/postgres/issues/1100), which rests on a production measurement, and [#1154](https://github.com/porsager/postgres/issues/1154), whose test reproduces the reported stack without a known trigger. The [changelog](./CHANGELOG.md) has the details.
 
 <details>
-<summary>40 bugs and 4 feature requests</summary>
+<summary>54 bugs and 7 feature requests</summary>
 
 **Wrong results and data safety**
 
 | Issue | What happens now | Since |
 | --- | --- | --- |
 | [#1082](https://github.com/porsager/postgres/issues/1082), [#729](https://github.com/porsager/postgres/issues/729) | A query whose values fail to serialize rejects on its own; the query running alongside no longer gets its error, and the next query no longer gets another query's rows | 4.3.0 |
-| [#1216](https://github.com/porsager/postgres/issues/1216) | A transaction handle whose connection closed can't run on a reconnected session, so it can't read another user's rows through RLS | 4.0.0 |
+| [#1216](https://github.com/porsager/postgres/issues/1216) | A transaction handle whose connection closed rejects with `CONNECTION_CLOSED` instead of running inside the next user's transaction, so it can't read their rows through row-level security. | 4.0.0 |
 | [#1248](https://github.com/porsager/postgres/issues/1248) | Statements in a `sql.begin()` callback after its connection closes reject instead of running outside the transaction | 4.0.0 |
-| [#1204](https://github.com/porsager/postgres/issues/1204) | A transaction's connection is never handed to another transaction | 4.0.0 |
+| [#1204](https://github.com/porsager/postgres/issues/1204) | A transaction's connection is not handed to another `sql.begin()` when its socket drains late, so one transaction's `COMMIT` can't commit another's unfinished writes. | 4.0.0 |
 | [#1217](https://github.com/porsager/postgres/issues/1217) | `sql.begin()` rejects with `TRANSACTION_ROLLED_BACK` when the server rolled back the COMMIT | 4.4.0 |
 | [#1249](https://github.com/porsager/postgres/issues/1249), [#1226](https://github.com/porsager/postgres/issues/1226), [#1223](https://github.com/porsager/postgres/issues/1223) | The first query after a reconnect no longer rejects with an error from the closed session | 4.0.0 |
 | [#789](https://github.com/porsager/postgres/issues/789) | `sql.array()` infers the right array type on first use | 4.0.0 |
+| [#1049](https://github.com/porsager/postgres/issues/1049), [#1124](https://github.com/porsager/postgres/issues/1124) | `NULL` elements in arrays parse as `null`, not `NaN` or the string `"NULL"` | 4.0.0 |
+| [#1252](https://github.com/porsager/postgres/issues/1252) | Cancelling a pipelined query that hasn't started no longer gives the next query its result | 4.1.0 |
+| [#1253](https://github.com/porsager/postgres/issues/1253), [#1181](https://github.com/porsager/postgres/issues/1181), [#1119](https://github.com/porsager/postgres/issues/1119) | A query no longer gets empty slots at the start of its result after the previous query on the connection failed or was cancelled partway through its rows | 4.5.0 |
 
 **Hangs**
 
@@ -96,40 +99,57 @@ Upstream issues on [porsager/postgres](https://github.com/porsager/postgres/issu
 | [#1195](https://github.com/porsager/postgres/issues/1195), [#1199](https://github.com/porsager/postgres/issues/1199) | A reservation survives its connection being terminated by the server, and the pool recovers after it is released | 4.0.0 |
 | [#1186](https://github.com/porsager/postgres/issues/1186) | Queries queued on a reserved or transaction handle settle when its connection closes | 4.0.0 |
 | [#1097](https://github.com/porsager/postgres/issues/1097), [#1130](https://github.com/porsager/postgres/issues/1130), [#1242](https://github.com/porsager/postgres/issues/1242), [#861](https://github.com/porsager/postgres/issues/861) | `sql.end()` resolves after a disconnect, after a failed query and after a connection closes inside `sql.begin()`, and waits for queries queued in the pool | 4.0.0 |
-| [#1246](https://github.com/porsager/postgres/issues/1246) | A query sent between a socket error and its close settles | 4.1.0 |
+| [#1246](https://github.com/porsager/postgres/issues/1246) | A query sent between a socket error and its close settles, and a transaction reset mid-statement no longer loses a pool connection | 4.1.0 |
 | [#1193](https://github.com/porsager/postgres/issues/1193) | A connection closed during startup settles its first query instead of reconnecting in a tight loop | 4.0.0 |
 | [#1234](https://github.com/porsager/postgres/issues/1234) | Concurrent queries in `sql.begin()` after a column type change roll the transaction back and return the connection to the pool | 4.4.0 |
+| [#1255](https://github.com/porsager/postgres/issues/1255), [#1261](https://github.com/porsager/postgres/issues/1261) | A reserved connection whose `max_lifetime` passed is closed when released, and `sql.end()` called before the release resolves | 4.0.0 |
+| [#1016](https://github.com/porsager/postgres/pull/1016) | Queries no longer hang after a `COPY ... TO STDOUT` whose reader fell behind | 4.5.0 |
 
 **Crashes**
 
 | Issue | What happens now | Since |
 | --- | --- | --- |
-| [#1066](https://github.com/porsager/postgres/issues/1066), [#1154](https://github.com/porsager/postgres/issues/1154), [#1208](https://github.com/porsager/postgres/issues/1208), [#1133](https://github.com/porsager/postgres/issues/1133) | A reserved or transaction handle whose backend died rejects its statements instead of throwing an uncaught exception | 4.0.0 |
+| [#1154](https://github.com/porsager/postgres/issues/1154), [#1208](https://github.com/porsager/postgres/issues/1208), [#1133](https://github.com/porsager/postgres/issues/1133) | A reserved or transaction connection that the server or network closes rejects its later statements, and `sql.begin()`'s own `ROLLBACK` or `COMMIT`, with `CONNECTION_CLOSED` instead of crashing the process with `Cannot read properties of null (reading 'write')`. | 4.0.0 |
 | [#1192](https://github.com/porsager/postgres/issues/1192), [#1205](https://github.com/porsager/postgres/issues/1205), [#1086](https://github.com/porsager/postgres/issues/1086) | A failed or cancelled type query at startup rejects the query instead of crashing the process | 4.0.0 |
 | [#1088](https://github.com/porsager/postgres/issues/1088) | Timers no longer fail on Cloudflare Workers | 4.0.0 |
+| [#1227](https://github.com/porsager/postgres/issues/1227) | Assigning `err.stack` on a query error no longer throws on Node 22 and newer | 4.5.0 |
+| [#1009](https://github.com/porsager/postgres/pull/1009) | The `camel` and `pascal` transforms no longer throw on a column name ending with an underscore | 4.5.0 |
 
 **Reconnects and failover**
 
 | Issue | What happens now | Since |
 | --- | --- | --- |
 | [#1179](https://github.com/porsager/postgres/issues/1179) | Failed connection attempts back off instead of the whole pool retrying at once | 4.0.0 |
+| [#1250](https://github.com/porsager/postgres/issues/1250) | A connection closed with a statement still buffered reconnects, instead of failing every later statement with `CONNECT_TIMEOUT` | 4.0.0 |
 | [#1174](https://github.com/porsager/postgres/issues/1174), [#815](https://github.com/porsager/postgres/issues/815), [#988](https://github.com/porsager/postgres/issues/988) | With several hosts, retries move to the next host, a connect timeout fails over, and `prefer-standby` falls back to a primary | 4.0.0 |
 
 **Transactions, notices and subscriptions**
 
 | Issue | What happens now | Since |
 | --- | --- | --- |
-| [#823](https://github.com/porsager/postgres/issues/823), [#1189](https://github.com/porsager/postgres/issues/1189), [#1210](https://github.com/porsager/postgres/issues/1210) | `sql.begin()` no longer fails with `UNSAFE_TRANSACTION` under write backpressure or with `max_pipeline: 0` | 4.0.0 |
+| [#823](https://github.com/porsager/postgres/issues/823), [#1189](https://github.com/porsager/postgres/issues/1189), [#1210](https://github.com/porsager/postgres/issues/1210) | `sql.begin()` no longer fails with `UNSAFE_TRANSACTION` or sends a second `BEGIN` on a busy connection when transactions and queries run concurrently, at the pipeline limit, under write backpressure or with `max_pipeline: 0` | 4.0.0 |
 | [#1063](https://github.com/porsager/postgres/issues/1063) | `onnotice: false` silences notices | 4.4.0 |
 | [#1087](https://github.com/porsager/postgres/issues/1087) | `sql.subscribe()` no longer adds a listener on each subscribe or loses changes after a transform throws | 4.4.0 |
 
+**TypeScript**
+
+| Issue | What happens now | Since |
+| --- | --- | --- |
+| [#1158](https://github.com/porsager/postgres/issues/1158), [#1177](https://github.com/porsager/postgres/pull/1177) | `sslnegotiation` is in the option types | 4.5.0 |
+| [#968](https://github.com/porsager/postgres/pull/968) | `socket` is in the option types | 4.5.0 |
+| [#703](https://github.com/porsager/postgres/issues/703), [#1194](https://github.com/porsager/postgres/pull/1194) | `new PostgresError('message')` sets the message, as with `Error`, and the types declare both the message and the fields forms | 4.5.0 |
+
 **Feature requests**
 
 | Issue | What you get | Since |
 | --- | --- | --- |
 | [#443](https://github.com/porsager/postgres/issues/443), [#908](https://github.com/porsager/postgres/issues/908) | `sql.stats()` reports connections in use and idle, and queries waiting | 4.3.0 |
 | [#1100](https://github.com/porsager/postgres/issues/1100) | An `onidle` callback and the `@steadybrew/postgresjs/vercel` adapter | 4.2.0 |
-| [#1164](https://github.com/porsager/postgres/issues/1164) | Built-in array types are decoded with `fetch_types: false` | 4.0.0 |
+| [#1164](https://github.com/porsager/postgres/issues/1164) | Built-in array types are decoded, and plain JavaScript arrays are sent, with `fetch_types: false` | 4.0.0 |
+| [#886](https://github.com/porsager/postgres/issues/886), [#1094](https://github.com/porsager/postgres/issues/1094) | `await using` ends a pool and releases a reserved connection when it goes out of scope | 4.5.0 |
+| [#1225](https://github.com/porsager/postgres/issues/1225) | Queries with values in one round trip instead of two, opt-in with `parameter_types: 'client'` | 4.5.0 |
+
+Bun isn't tested here, so Bun-only reports such as [#1066](https://github.com/porsager/postgres/issues/1066) aren't listed; the same crash on Node is [#1208](https://github.com/porsager/postgres/issues/1208).
 
 </details>
 
@@ -693,11 +713,13 @@ A `COPY` holds its connection until it finishes. Postgres.js cannot tell that a
 Postgres.js supports, [canceling queries in progress](https://www.postgresql.org/docs/7.1/protocol-protocol.html#AEN39000). It works by opening a new connection with a protocol level startup message to cancel the current query running on a specific connection. That means there is no guarantee that the query will be canceled, and due to the possible race conditions it might even result in canceling another query. This is fine for long running queries, but in the case of high load and fast queries it might be better to simply ignore results instead of canceling.
 
 ```js
-const query = sql`select pg_sleep 100`.execute()
+const query = sql`select pg_sleep(100)`.execute()
 setTimeout(() => query.cancel(), 100)
 const result = await query
 ```
 
+A cancelled query rejects with code `57014`. A cancel can arrive too late, in which case the query may still complete, or fail with its own error. `query.cancel()` resolves once the cancel request has been sent. A cancelled query you don't await does not cause an unhandled rejection.
+
 ### Execute
 
 #### ```await sql``.execute()```
@@ -1244,8 +1266,8 @@ const sql = postgres('postgres://username:password@host:port/database', {
     application_name   : 'postgres.js', // Default application_name
     ...                                 // Other connection parameters, see https://www.postgresql.org/docs/current/runtime-config-client.html
   },
-  target_session_attrs : null,          // Use 'read-write' with multiple hosts to
-                                        // ensure only connecting to primary
+  target_session_attrs : null,          // Which kind of server to connect to, see
+                                        // Multi-host connections below
   fetch_types          : true,          // Automatically fetches types on connect
                                         // on initial connection.
   parameter_types      : 'server',      // 'client' or 'warn', see Parameter types (PGPARAMETER_TYPES)
@@ -1292,7 +1314,20 @@ Multiple connection strings can be passed to `postgres()` in the form of `postgr
 
 Connections will be attempted in order of the specified hosts/ports. On a successful connection, all retries will be reset. This ensures that hosts can come up and down seamlessly.
 
-If you specify `target_session_attrs: 'primary'` or `PGTARGETSESSIONATTRS=primary` Postgres.js will only connect to the primary host, allowing for zero downtime failovers.
+`target_session_attrs` (or `PGTARGETSESSIONATTRS`) picks which kind of server to connect to. The values and their meaning are libpq's:
+
+| Value | Connects to |
+|---|---|
+| `null` (default) | any server |
+| `'read-write'` | a server that accepts writes: not a hot standby, and `default_transaction_read_only` off |
+| `'primary'` | a server that is not a hot standby, even if `default_transaction_read_only` is on |
+| `'read-only'` | a hot standby, or a server with `default_transaction_read_only` on |
+| `'standby'` | a hot standby |
+| `'prefer-standby'` | a hot standby if any host is one, otherwise any server |
+
+During a failover or an upgrade, `'read-write'` and `'primary'` wait for the promoted server instead of connecting to a standby whose writes would fail. Read traffic that should keep using standbys during the switch belongs on `'prefer-standby'` or no `target_session_attrs` at all.
+
+With several hosts, a host that answers but is the wrong kind is skipped and the next one is tried at once; if every host answers and none matches, the connection fails immediately with `TARGET_SESSION_ATTRS`. With a single host, or when some host fails to connect, it keeps retrying, bounded by `connect_timeout` per host, because a failover may be in progress.
 
 ### The Connection Pool
 

package/cf/src/connection.js

@@ -106,6 +106,7 @@ function Connection(options, queues = {}, { onopen = noop, onend = noop, onclose
     , hostIndex = 0
     , length = 0
     , rows = 0
+    , copyPaused = false
     , serverSignature = null
     , nextWriteTimer = null
     , incomings = null
@@ -464,6 +465,7 @@ function Connection(options, queues = {}, { onopen = noop, onend = noop, onclose
     query = results = errorResponse = chunk = nextWriteTimer = barrier = null
     result = new Result()
     rows = 0
+    copyPaused = false
     nonce = serverSignature = null
   }
 
@@ -686,6 +688,7 @@ function Connection(options, queues = {}, { onopen = noop, onend = noop, onclose
 
   function errored(err) {
     stream && (stream.destroy(err), stream = null)
+    resumeCopy()
     query && queryError(query, err)
   }
 
@@ -802,7 +805,7 @@ function Connection(options, queues = {}, { onopen = noop, onend = noop, onclose
         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 && !barrier
+          : query.prepared && retryRoutines.has(errorResponse.routine) && query.owner === connection.owner && !barrier && !query.cancelled
             && (x[5] !== 69 || endsAbortedState.test(query.string))
             ? retry(query, errorResponse)
             : errored(errorResponse)
@@ -816,6 +819,7 @@ function Connection(options, queues = {}, { onopen = noop, onend = noop, onclose
 
     query = results = errorResponse = null
     result = new Result()
+    rows = 0
 
     dispatch('ready')
   }
@@ -1048,8 +1052,9 @@ function Connection(options, queues = {}, { onopen = noop, onend = noop, onclose
 
   function mismatchReason(x, xs) {
     return (
+      (x === 'read-write' && xs.in_hot_standby === 'on' && 'is a standby') ||
       (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 === 'read-only' && xs.in_hot_standby === 'off' && 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') ||
@@ -1148,7 +1153,7 @@ function Connection(options, queues = {}, { onopen = noop, onend = noop, onclose
 
   function CopyOutResponse() {
     stream = new Stream.Readable({
-      read() { socket.resume() }
+      read() { copyPaused = false; socket.resume() }
     })
     query.resolve(stream)
     connection.owner && connection.owner.next()
@@ -1158,7 +1163,7 @@ function Connection(options, queues = {}, { onopen = noop, onend = noop, onclose
   function CopyBothResponse() {
     stream = new Stream.Duplex({
       autoDestroy: true,
-      read() { socket.resume() },
+      read() { copyPaused = false; socket.resume() },
       /* c8 ignore next 11 */
       write(chunk, encoding, callback) {
         socket.write(b().d().raw(chunk).end(), callback)
@@ -1178,12 +1183,23 @@ function Connection(options, queues = {}, { onopen = noop, onend = noop, onclose
   }
 
   function CopyData(x) {
-    stream && (stream.push(x.subarray(5)) || socket.pause())
+    if (stream && !stream.push(x.subarray(5))) {
+      copyPaused = true
+      socket.pause()
+    }
   }
 
   function CopyDone() {
     stream && stream.push(null)
     stream = null
+    resumeCopy()
+  }
+
+  function resumeCopy() {
+    if (copyPaused) {
+      copyPaused = false
+      socket.resume()
+    }
   }
 
   function NoticeResponse(x) {

package/cf/src/errors.js

@@ -1,8 +1,8 @@
 export class PostgresError extends Error {
   constructor(x) {
-    super(x.message)
+    super(typeof x === 'string' ? x : x.message)
     this.name = this.constructor.name
-    Object.assign(this, x)
+    typeof x === 'string' || Object.assign(this, x)
   }
 }
 

package/cf/src/index.js

@@ -703,8 +703,8 @@ function parseOptions(a, b) {
     ...Object.entries(defaults).reduce(
       (acc, [k, d]) => {
         const value = k in o ? o[k] : k in query
-          ? (query[k] === 'disable' || query[k] === 'false' ? false : query[k])
-          : env['PG' + k.toUpperCase()] || d
+          ? off(query[k])
+          : env['PG' + k.toUpperCase()] ? off(env['PG' + k.toUpperCase()]) : d
         acc[k] = typeof value === 'string' && ints.includes(k)
           ? +value
           : value
@@ -737,6 +737,10 @@ function parseOptions(a, b) {
   return options
 }
 
+function off(x) {
+  return x === 'disable' || x === 'false' ? false : x
+}
+
 function tsa(o, url, env) {
   const x = o.target_session_attrs || url.searchParams.get('target_session_attrs') || env.PGTARGETSESSIONATTRS
   if (!x || ['read-write', 'read-only', 'primary', 'standby', 'prefer-standby'].includes(x))

package/cf/src/query.js

@@ -55,6 +55,7 @@ export class Query extends Promise {
     if (!this.canceller || this.settled)
       return Promise.resolve()
 
+    Promise.prototype.then.call(this, undefined, () => undefined)
     const cancelled = this.canceller(this)
     this.canceller = null
     cancelled.catch(() => undefined)

package/cf/src/types.js

@@ -347,14 +347,14 @@ function arrayParserLoop(s, x, parser, typarray) {
 export const toCamel = x => {
   let str = x[0]
   for (let i = 1; i < x.length; i++)
-    str += x[i] === '_' ? x[++i].toUpperCase() : x[i]
+    str += x[i] === '_' && i + 1 < x.length ? x[++i].toUpperCase() : x[i]
   return str
 }
 
 export const toPascal = x => {
   let str = x[0].toUpperCase()
   for (let i = 1; i < x.length; i++)
-    str += x[i] === '_' ? x[++i].toUpperCase() : x[i]
+    str += x[i] === '_' && i + 1 < x.length ? x[++i].toUpperCase() : x[i]
   return str
 }
 

package/cjs/src/connection.js

@@ -104,6 +104,7 @@ function Connection(options, queues = {}, { onopen = noop, onend = noop, onclose
     , hostIndex = 0
     , length = 0
     , rows = 0
+    , copyPaused = false
     , serverSignature = null
     , nextWriteTimer = null
     , incomings = null
@@ -462,6 +463,7 @@ function Connection(options, queues = {}, { onopen = noop, onend = noop, onclose
     query = results = errorResponse = chunk = nextWriteTimer = barrier = null
     result = new Result()
     rows = 0
+    copyPaused = false
     nonce = serverSignature = null
   }
 
@@ -684,6 +686,7 @@ function Connection(options, queues = {}, { onopen = noop, onend = noop, onclose
 
   function errored(err) {
     stream && (stream.destroy(err), stream = null)
+    resumeCopy()
     query && queryError(query, err)
   }
 
@@ -800,7 +803,7 @@ function Connection(options, queues = {}, { onopen = noop, onend = noop, onclose
         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 && !barrier
+          : query.prepared && retryRoutines.has(errorResponse.routine) && query.owner === connection.owner && !barrier && !query.cancelled
             && (x[5] !== 69 || endsAbortedState.test(query.string))
             ? retry(query, errorResponse)
             : errored(errorResponse)
@@ -814,6 +817,7 @@ function Connection(options, queues = {}, { onopen = noop, onend = noop, onclose
 
     query = results = errorResponse = null
     result = new Result()
+    rows = 0
 
     dispatch('ready')
   }
@@ -1046,8 +1050,9 @@ function Connection(options, queues = {}, { onopen = noop, onend = noop, onclose
 
   function mismatchReason(x, xs) {
     return (
+      (x === 'read-write' && xs.in_hot_standby === 'on' && 'is a standby') ||
       (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 === 'read-only' && xs.in_hot_standby === 'off' && 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') ||
@@ -1146,7 +1151,7 @@ function Connection(options, queues = {}, { onopen = noop, onend = noop, onclose
 
   function CopyOutResponse() {
     stream = new Stream.Readable({
-      read() { socket.resume() }
+      read() { copyPaused = false; socket.resume() }
     })
     query.resolve(stream)
     connection.owner && connection.owner.next()
@@ -1156,7 +1161,7 @@ function Connection(options, queues = {}, { onopen = noop, onend = noop, onclose
   function CopyBothResponse() {
     stream = new Stream.Duplex({
       autoDestroy: true,
-      read() { socket.resume() },
+      read() { copyPaused = false; socket.resume() },
       /* c8 ignore next 11 */
       write(chunk, encoding, callback) {
         socket.write(b().d().raw(chunk).end(), callback)
@@ -1176,12 +1181,23 @@ function Connection(options, queues = {}, { onopen = noop, onend = noop, onclose
   }
 
   function CopyData(x) {
-    stream && (stream.push(x.subarray(5)) || socket.pause())
+    if (stream && !stream.push(x.subarray(5))) {
+      copyPaused = true
+      socket.pause()
+    }
   }
 
   function CopyDone() {
     stream && stream.push(null)
     stream = null
+    resumeCopy()
+  }
+
+  function resumeCopy() {
+    if (copyPaused) {
+      copyPaused = false
+      socket.resume()
+    }
   }
 
   function NoticeResponse(x) {

package/cjs/src/errors.js

@@ -1,8 +1,8 @@
 const PostgresError = module.exports.PostgresError = class PostgresError extends Error {
   constructor(x) {
-    super(x.message)
+    super(typeof x === 'string' ? x : x.message)
     this.name = this.constructor.name
-    Object.assign(this, x)
+    typeof x === 'string' || Object.assign(this, x)
   }
 }
 

package/cjs/src/index.js

@@ -702,8 +702,8 @@ function parseOptions(a, b) {
     ...Object.entries(defaults).reduce(
       (acc, [k, d]) => {
         const value = k in o ? o[k] : k in query
-          ? (query[k] === 'disable' || query[k] === 'false' ? false : query[k])
-          : env['PG' + k.toUpperCase()] || d
+          ? off(query[k])
+          : env['PG' + k.toUpperCase()] ? off(env['PG' + k.toUpperCase()]) : d
         acc[k] = typeof value === 'string' && ints.includes(k)
           ? +value
           : value
@@ -736,6 +736,10 @@ function parseOptions(a, b) {
   return options
 }
 
+function off(x) {
+  return x === 'disable' || x === 'false' ? false : x
+}
+
 function tsa(o, url, env) {
   const x = o.target_session_attrs || url.searchParams.get('target_session_attrs') || env.PGTARGETSESSIONATTRS
   if (!x || ['read-write', 'read-only', 'primary', 'standby', 'prefer-standby'].includes(x))

package/cjs/src/query.js

@@ -55,6 +55,7 @@ const Query = module.exports.Query = class Query extends Promise {
     if (!this.canceller || this.settled)
       return Promise.resolve()
 
+    Promise.prototype.then.call(this, undefined, () => undefined)
     const cancelled = this.canceller(this)
     this.canceller = null
     cancelled.catch(() => undefined)

package/cjs/src/types.js

@@ -346,14 +346,14 @@ function arrayParserLoop(s, x, parser, typarray) {
 const toCamel = module.exports.toCamel = x => {
   let str = x[0]
   for (let i = 1; i < x.length; i++)
-    str += x[i] === '_' ? x[++i].toUpperCase() : x[i]
+    str += x[i] === '_' && i + 1 < x.length ? x[++i].toUpperCase() : x[i]
   return str
 }
 
 const toPascal = module.exports.toPascal = x => {
   let str = x[0].toUpperCase()
   for (let i = 1; i < x.length; i++)
-    str += x[i] === '_' ? x[++i].toUpperCase() : x[i]
+    str += x[i] === '_' && i + 1 < x.length ? x[++i].toUpperCase() : x[i]
   return str
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@steadybrew/postgresjs",
-  "version": "4.5.0-rc1",
+  "version": "4.5.0",
   "description": "PostgreSQL client for Node.js and Deno, independently maintained by Steady Brew",
   "type": "module",
   "module": "src/index.js",
@@ -32,10 +32,10 @@
     "build:deno": "node transpile.deno.js",
     "build:cf": "node transpile.cf.js",
     "test": "npm run test:startup && npm run test:esm && npm run test:cjs && npm run test:deno",
-    "test:esm": "node tests-startup/run.js --integration && node tests/index.js",
+    "test:esm": "node tests-startup/run.js --integration && node tests/index.js && node tests-startup/run.js --reports",
     "test:startup": "node tests-startup/run.js",
     "test:tracing": "node tests-tracing/run.js",
-    "test:cjs": "npm run build:cjs && node tests-startup/run.js --integration --cjs && cd cjs/tests && node index.js && cd ../../",
+    "test:cjs": "npm run build:cjs && node tests-startup/run.js --integration --cjs && cd cjs/tests && node index.js && cd ../../ && node tests-startup/run.js --reports --cjs",
     "test:deno": "npm run test:deno-socket && npm run build:deno && cd deno/tests && deno run --no-lock --allow-all --unsafely-ignore-certificate-errors index.js && cd ../../",
     "lint": "eslint src && eslint tests && eslint tests-startup --ext .js,.mjs",
     "prepare": "npm run build",

package/src/connection.js

@@ -104,6 +104,7 @@ function Connection(options, queues = {}, { onopen = noop, onend = noop, onclose
     , hostIndex = 0
     , length = 0
     , rows = 0
+    , copyPaused = false
     , serverSignature = null
     , nextWriteTimer = null
     , incomings = null
@@ -462,6 +463,7 @@ function Connection(options, queues = {}, { onopen = noop, onend = noop, onclose
     query = results = errorResponse = chunk = nextWriteTimer = barrier = null
     result = new Result()
     rows = 0
+    copyPaused = false
     nonce = serverSignature = null
   }
 
@@ -684,6 +686,7 @@ function Connection(options, queues = {}, { onopen = noop, onend = noop, onclose
 
   function errored(err) {
     stream && (stream.destroy(err), stream = null)
+    resumeCopy()
     query && queryError(query, err)
   }
 
@@ -800,7 +803,7 @@ function Connection(options, queues = {}, { onopen = noop, onend = noop, onclose
         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 && !barrier
+          : query.prepared && retryRoutines.has(errorResponse.routine) && query.owner === connection.owner && !barrier && !query.cancelled
             && (x[5] !== 69 || endsAbortedState.test(query.string))
             ? retry(query, errorResponse)
             : errored(errorResponse)
@@ -814,6 +817,7 @@ function Connection(options, queues = {}, { onopen = noop, onend = noop, onclose
 
     query = results = errorResponse = null
     result = new Result()
+    rows = 0
 
     dispatch('ready')
   }
@@ -1046,8 +1050,9 @@ function Connection(options, queues = {}, { onopen = noop, onend = noop, onclose
 
   function mismatchReason(x, xs) {
     return (
+      (x === 'read-write' && xs.in_hot_standby === 'on' && 'is a standby') ||
       (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 === 'read-only' && xs.in_hot_standby === 'off' && 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') ||
@@ -1146,7 +1151,7 @@ function Connection(options, queues = {}, { onopen = noop, onend = noop, onclose
 
   function CopyOutResponse() {
     stream = new Stream.Readable({
-      read() { socket.resume() }
+      read() { copyPaused = false; socket.resume() }
     })
     query.resolve(stream)
     connection.owner && connection.owner.next()
@@ -1156,7 +1161,7 @@ function Connection(options, queues = {}, { onopen = noop, onend = noop, onclose
   function CopyBothResponse() {
     stream = new Stream.Duplex({
       autoDestroy: true,
-      read() { socket.resume() },
+      read() { copyPaused = false; socket.resume() },
       /* c8 ignore next 11 */
       write(chunk, encoding, callback) {
         socket.write(b().d().raw(chunk).end(), callback)
@@ -1176,12 +1181,23 @@ function Connection(options, queues = {}, { onopen = noop, onend = noop, onclose
   }
 
   function CopyData(x) {
-    stream && (stream.push(x.subarray(5)) || socket.pause())
+    if (stream && !stream.push(x.subarray(5))) {
+      copyPaused = true
+      socket.pause()
+    }
   }
 
   function CopyDone() {
     stream && stream.push(null)
     stream = null
+    resumeCopy()
+  }
+
+  function resumeCopy() {
+    if (copyPaused) {
+      copyPaused = false
+      socket.resume()
+    }
   }
 
   function NoticeResponse(x) {

package/src/errors.js

@@ -1,8 +1,8 @@
 export class PostgresError extends Error {
   constructor(x) {
-    super(x.message)
+    super(typeof x === 'string' ? x : x.message)
     this.name = this.constructor.name
-    Object.assign(this, x)
+    typeof x === 'string' || Object.assign(this, x)
   }
 }
 

package/src/index.js

@@ -702,8 +702,8 @@ function parseOptions(a, b) {
     ...Object.entries(defaults).reduce(
       (acc, [k, d]) => {
         const value = k in o ? o[k] : k in query
-          ? (query[k] === 'disable' || query[k] === 'false' ? false : query[k])
-          : env['PG' + k.toUpperCase()] || d
+          ? off(query[k])
+          : env['PG' + k.toUpperCase()] ? off(env['PG' + k.toUpperCase()]) : d
         acc[k] = typeof value === 'string' && ints.includes(k)
           ? +value
           : value
@@ -736,6 +736,10 @@ function parseOptions(a, b) {
   return options
 }
 
+function off(x) {
+  return x === 'disable' || x === 'false' ? false : x
+}
+
 function tsa(o, url, env) {
   const x = o.target_session_attrs || url.searchParams.get('target_session_attrs') || env.PGTARGETSESSIONATTRS
   if (!x || ['read-write', 'read-only', 'primary', 'standby', 'prefer-standby'].includes(x))

package/src/query.js

@@ -55,6 +55,7 @@ export class Query extends Promise {
     if (!this.canceller || this.settled)
       return Promise.resolve()
 
+    Promise.prototype.then.call(this, undefined, () => undefined)
     const cancelled = this.canceller(this)
     this.canceller = null
     cancelled.catch(() => undefined)

package/src/types.js

@@ -346,14 +346,14 @@ function arrayParserLoop(s, x, parser, typarray) {
 export const toCamel = x => {
   let str = x[0]
   for (let i = 1; i < x.length; i++)
-    str += x[i] === '_' ? x[++i].toUpperCase() : x[i]
+    str += x[i] === '_' && i + 1 < x.length ? x[++i].toUpperCase() : x[i]
   return str
 }
 
 export const toPascal = x => {
   let str = x[0].toUpperCase()
   for (let i = 1; i < x.length; i++)
-    str += x[i] === '_' ? x[++i].toUpperCase() : x[i]
+    str += x[i] === '_' && i + 1 < x.length ? x[++i].toUpperCase() : x[i]
   return str
 }
 

package/types/index.d.ts

@@ -1,4 +1,4 @@
-import { Readable, Writable } from 'node:stream'
+import { Duplex, Readable, Writable } from 'node:stream'
 
 /**
  * Establish a connection to a PostgreSQL server.
@@ -45,6 +45,8 @@ interface BaseOptions<T extends Record<string, postgres.PostgresType>> {
    * @default false
   */
   ssl: 'require' | 'allow' | 'prefer' | 'verify-full' | boolean | object;
+  /** Set to 'direct' to start TLS immediately with ALPN instead of sending an SSLRequest first */
+  sslnegotiation: 'direct' | 'postgres' | null;
   /**
    * Max number of connections
    * @default 10
@@ -126,6 +128,8 @@ interface BaseOptions<T extends Record<string, postgres.PostgresType>> {
   backoff: boolean | ((attemptNum: number) => number);
   max_lifetime: number | null;
   keep_alive: number | null;
+  /** Function, sync or async, returning the socket-like duplex stream to connect through; it receives the parsed options */
+  socket?: (options: postgres.ParsedOptions) => Duplex | Promise<Duplex>;
 }
 
 
@@ -203,6 +207,8 @@ type Return<T, K extends readonly any[]> =
 
 declare namespace postgres {
   class PostgresError extends Error {
+    constructor(message: string);
+    constructor(fields: Partial<Omit<PostgresError, 'name' | 'stack' | 'cause'>>);
     name: 'PostgresError';
     severity_local: string;
     severity: string;