Unhandled rejection kills the process when the internal array-types query is cancelled (57014) - repro for #279

      if (needsTypes) {
        initial.reserve && (initial = null)
        return fetchArrayTypes()      // connection.js:564 - promise dropped
      }

  async function fetchArrayTypes() {   // connection.js:768
    needsTypes = false
    const types = await new Query([`
      select b.oid, b.typarray
      ...
    `], [], execute)
    types.forEach(({ oid, typarray }) => addArrayType(oid, typarray))
  }

PostgresError: canceling statement due to statement timeout
    at ErrorResponse (postgres/src/connection.js:815:30)
    at handle (postgres/src/connection.js:489:6)
    at Socket.data (postgres/src/connection.js:324:9)

docker run -d --name pgrepro -e POSTGRES_PASSWORD=pg -e POSTGRES_DB=repro -p 55433:5432 postgres:16
node repro.mjs 'postgres://postgres:[email protected]:55433/repro'

import postgres from 'postgres'

const DBURL = process.argv[2]
const SCHEMA = 'pgjs_dangling_repro'
const ARRAY_TYPES_SQL = `
  select b.oid, b.typarray
  from pg_catalog.pg_type a
  left join pg_catalog.pg_type b on b.oid = a.typelem
  where a.typcategory = 'A'
  group by b.oid, b.typarray
  order by b.oid`

const setup = postgres(DBURL, { max: 1, fetch_types: false, onnotice: () => {} })

const time = async () => {
  const t = performance.now()
  await setup.unsafe(ARRAY_TYPES_SQL)
  return performance.now() - t
}

// make the driver's internal array-types query take > 1ms
await setup.unsafe(`CREATE SCHEMA IF NOT EXISTS ${SCHEMA}`)
let created = 0, elapsed = await time()
while (elapsed < 5 && created < 30000) {
  let ddl = ''
  for (let i = created; i < created + 2000; i++) ddl += `CREATE TYPE ${SCHEMA}.t${i} AS (a int);`
  await setup.unsafe(ddl)
  created += 2000
  elapsed = await time()
}
console.log(`array-types query: ${elapsed.toFixed(1)}ms (${created} helper types)`)

const unhandled = []
process.on('unhandledRejection', (r) => unhandled.push(r))

// fetch_types defaults to true, so connection setup runs fetchArrayTypes();
// statement_timeout makes the server cancel it mid-flight
const victim = postgres(DBURL, { max: 1, connection: { statement_timeout: '1' } })
try { await victim`SELECT 1 AS n` } catch (e) { console.log('caller query rejected with', e.code) }
await new Promise((r) => setTimeout(r, 500))
console.log('unhandled rejections:', unhandled.length)
unhandled.forEach((r) => console.log(String(r.stack).split('\n').slice(0, 3).join('\n')))

await victim.end({ timeout: 3 }).catch(() => {})
// cleanup in batches - DROP SCHEMA CASCADE over thousands of types exceeds max_locks_per_transaction
for (;;) {
  const names = await setup`
    SELECT t.typname FROM pg_catalog.pg_type t
    JOIN pg_catalog.pg_namespace n ON n.oid = t.typnamespace
    WHERE n.nspname = ${SCHEMA} AND t.typtype = 'c' LIMIT 500`
  if (!names.length) break
  await setup.unsafe(names.map(({ typname }) => `DROP TYPE ${SCHEMA}."${typname}" CASCADE;`).join(''))
}
await setup.unsafe(`DROP SCHEMA IF EXISTS ${SCHEMA} CASCADE`)
await setup.end({ timeout: 5 })

array-types query: 5.0ms (6000 helper types)
caller query rejected with 57014
unhandled rejections: 1
PostgresError: canceling statement due to statement timeout
    at ErrorResponse (.../postgres/src/connection.js:815:30)
    at handle (.../postgres/src/connection.js:489:6)

   async function fetchArrayTypes() {
     needsTypes = false
-    const types = await new Query([`
-      ...
-    `], [], execute)
-    types.forEach(({ oid, typarray }) => addArrayType(oid, typarray))
+    try {
+      const types = await new Query([`
+        ...
+      `], [], execute)
+      types.forEach(({ oid, typarray }) => addArrayType(oid, typarray))
+    } catch (err) {
+      errored(err)
+    }
   }