@depup/mysql2 3.23.2-depup.0 → 3.23.4-depup.0

package/README.md

@@ -13,16 +13,10 @@ npm install @depup/mysql2
 
 | Field | Value |
 |-------|-------|
-| Original | [mysql2](https://www.npmjs.com/package/mysql2) @ 3.23.2 |
-| Processed | 2026-07-27 |
+| Original | [mysql2](https://www.npmjs.com/package/mysql2) @ 3.23.4 |
+| Processed | 2026-08-20 |
 | Smoke test | passed |
-| Deps updated | 1 |
-
-## Dependency Changes
-
-| Dependency | From | To |
-|------------|------|-----|
-| iconv-lite | ^0.7.2 | ^0.7.3 |
+| Deps updated | 0 |
 
 ---
 

package/changes.json

@@ -1,10 +1,5 @@
 {
-  "bumped": {
-    "iconv-lite": {
-      "from": "^0.7.2",
-      "to": "^0.7.3"
-    }
-  },
-  "timestamp": "2026-07-27T16:45:19.802Z",
-  "totalUpdated": 1
+  "bumped": {},
+  "timestamp": "2026-08-20T08:13:41.208Z",
+  "totalUpdated": 0
 }

package/lib/base/connection.js

@@ -20,7 +20,7 @@ const Tls = require('tls');
 const Timers = require('timers');
 const EventEmitter = require('events').EventEmitter;
 const Readable = require('stream').Readable;
-const Queue = require('denque');
+const Queue = require('../ring_queue.js');
 const SqlString = require('sql-escaper');
 const { createLRU } = require('lru.min');
 const PacketParser = require('../packet_parser.js');
@@ -104,7 +104,8 @@ class BaseConnection extends EventEmitter {
       this.handlePacket(p);
     });
     this.stream.on('data', (data) => {
-      if (this.connectTimeout) {
+      // Server-side connections do not run ClientHandshake.
+      if (this.connectTimeout && this.config.isServer) {
         Timers.clearTimeout(this.connectTimeout);
         this.connectTimeout = null;
       }
@@ -133,6 +134,10 @@ class BaseConnection extends EventEmitter {
     if (!this.config.isServer) {
       handshakeCommand = new Commands.ClientHandshake(this.config.clientFlags);
       handshakeCommand.on('end', () => {
+        if (this.connectTimeout) {
+          Timers.clearTimeout(this.connectTimeout);
+          this.connectTimeout = null;
+        }
         // this happens when handshake finishes early either because there was
         // some fatal error or the server sent an error packet instead of
         // an hello packet (for example, 'Too many connections' error)
@@ -160,7 +165,6 @@ class BaseConnection extends EventEmitter {
           connectChannel,
           () =>
             new Promise((resolve, reject) => {
-              /* eslint-disable prefer-const */
               let onConnect, onError;
               onConnect = (param) => {
                 this.removeListener('error', onError);
@@ -170,7 +174,6 @@ class BaseConnection extends EventEmitter {
                 this.removeListener('connect', onConnect);
                 reject(err);
               };
-              /* eslint-enable prefer-const */
               this.once('connect', onConnect);
               this.once('error', onError);
             }),
@@ -271,13 +274,11 @@ class BaseConnection extends EventEmitter {
       // connection handshake is special because we allow it to be implicit
       // if error happened during handshake, but there are others commands in queue
       // then bubble error to other commands and not to connection
-    } else if (
-      !(
-        this._command &&
-        this._command.constructor === Commands.ClientHandshake &&
-        this._commands.length > 0
-      )
-    ) {
+    } else if (!(
+      this._command &&
+      this._command.constructor === Commands.ClientHandshake &&
+      this._commands.length > 0
+    )) {
       bubbleErrorToConnection = true;
     }
     while ((command = this._commands.shift())) {
@@ -583,7 +584,7 @@ class BaseConnection extends EventEmitter {
     return cmd;
   }
 
-  format(sql, values) {
+  format(sql, values, namedPlaceholders) {
     if (typeof this.config.queryFormat === 'function') {
       return this.config.queryFormat.call(
         this,
@@ -596,6 +597,9 @@ class BaseConnection extends EventEmitter {
       sql: sql,
       values: values,
     };
+    if (typeof namedPlaceholders !== 'undefined') {
+      opts.namedPlaceholders = namedPlaceholders;
+    }
     this._resolveNamedPlaceholders(opts);
     return SqlString.format(
       opts.sql,
@@ -619,7 +623,10 @@ class BaseConnection extends EventEmitter {
 
   _resolveNamedPlaceholders(options) {
     let unnamed;
-    if (this.config.namedPlaceholders || options.namedPlaceholders) {
+    if (typeof options.namedPlaceholders === 'undefined') {
+      options.namedPlaceholders = this.config.namedPlaceholders;
+    }
+    if (options.namedPlaceholders) {
       if (Array.isArray(options.values)) {
         // if an array is provided as the values, assume the conversion is not necessary.
         // this allows the usage of unnamed placeholders even if the namedPlaceholders flag is enabled.
@@ -644,7 +651,8 @@ class BaseConnection extends EventEmitter {
     this._resolveNamedPlaceholders(cmdQuery);
     const rawSql = this.format(
       cmdQuery.sql,
-      cmdQuery.values !== undefined ? cmdQuery.values : []
+      cmdQuery.values !== undefined ? cmdQuery.values : [],
+      cmdQuery.namedPlaceholders
     );
     cmdQuery.sql = rawSql;
 
@@ -997,7 +1005,6 @@ class BaseConnection extends EventEmitter {
       return cb(null, this);
     }
 
-    /* eslint-disable prefer-const */
     let onError, onConnect;
 
     onError = (param) => {
@@ -1009,7 +1016,6 @@ class BaseConnection extends EventEmitter {
       this.removeListener('error', onError);
       cb(null, param);
     };
-    /* eslint-enable prefer-const */
 
     this.once('error', onError);
     this.once('connect', onConnect);

package/lib/base/pool.js

@@ -4,7 +4,7 @@ const process = require('process');
 const SqlString = require('sql-escaper');
 const EventEmitter = require('events').EventEmitter;
 const PoolConnection = require('../pool_connection.js');
-const Queue = require('denque');
+const Queue = require('../ring_queue.js');
 const BaseConnection = require('./connection.js');
 const Errors = require('../constants/errors.js');
 const {
@@ -53,6 +53,23 @@ class BasePool extends EventEmitter {
     }
   }
 
+  /**
+   * Creates a per-connection copy of the pool connection config.
+   *
+   * Commands like `changeUser` mutate `connection.config` in place. Sharing a
+   * single config object between every pooled connection made those mutations
+   * leak into connections created later. The prototype is preserved so the
+   * copy is still a `ConnectionConfig`.
+   */
+  _createConnectionConfig() {
+    const { connectionConfig } = this.config;
+
+    return Object.create(
+      Object.getPrototypeOf(connectionConfig),
+      Object.getOwnPropertyDescriptors(connectionConfig)
+    );
+  }
+
   getConnection(cb) {
     const _getConnection = (cb) => {
       if (this._closed) {
@@ -72,7 +89,7 @@ class BasePool extends EventEmitter {
         this._allConnections.length < this.config.connectionLimit
       ) {
         connection = new PoolConnection(this, {
-          config: this.config.connectionConfig,
+          config: this._createConnectionConfig(),
         });
         this._allConnections.push(connection);
         return connection.connect((err) => {
@@ -254,7 +271,11 @@ class BasePool extends EventEmitter {
         });
       } catch (e) {
         conn.release();
-        throw e;
+        if (typeof cmdQuery.onResult === 'function') {
+          cmdQuery.onResult(e);
+        } else {
+          cmdQuery.emit('error', e);
+        }
       }
     });
     return cmdQuery;

package/lib/commands/binlog_dump.js

@@ -68,7 +68,8 @@ class RotateEvent {
 class FormatDescriptionEvent {
   constructor(packet) {
     this.binlogVersion = packet.readInt16();
-    this.serverVersion = packet.readString(50).replace(/\u0000.*/, ''); // eslint-disable-line no-control-regex
+    // biome-ignore lint/suspicious/noControlCharactersInRegex: the server version string is NUL-terminated
+    this.serverVersion = packet.readString(50).replace(/\u0000.*/, '');
     this.createTimestamp = packet.readInt32();
     this.eventHeaderLength = packet.readInt8(); // should be 19
     this.eventsLength = packet.readBuffer();

package/lib/commands/query.js

@@ -20,7 +20,12 @@ class Query extends Command {
     this.sql = options.sql;
     this.values = options.values;
     this._queryOptions = options;
-    this.namedPlaceholders = options.namedPlaceholders || false;
+    this.namedPlaceholders = Object.prototype.hasOwnProperty.call(
+      options,
+      'namedPlaceholders'
+    )
+      ? options.namedPlaceholders
+      : undefined;
     this.onResult = callback;
     this.timeout = options.timeout;
     this.queryTimeout = null;
@@ -44,7 +49,6 @@ class Query extends Command {
     throw new Error(err);
   }
 
-  /* eslint no-unused-vars: ["error", { "argsIgnorePattern": "^_" }] */
   start(_packet, connection) {
     if (connection.config.debug) {
       console.log('        Sending query command: %s', this.sql);

package/lib/compressed_protocol.js

@@ -33,7 +33,6 @@ class Queue {
 }
 
 function handleCompressedPacket(packet) {
-  // eslint-disable-next-line consistent-this, no-invalid-this
   const connection = this;
   const deflatedLength = packet.readInt24();
   const body = packet.readBuffer();
@@ -71,7 +70,6 @@ function writeCompressed(buffer) {
   if (buffer.length > MAX_COMPRESSED_LENGTH) {
     for (start = 0; start < buffer.length; start += MAX_COMPRESSED_LENGTH) {
       writeCompressed.call(
-        // eslint-disable-next-line no-invalid-this
         this,
         buffer.slice(start, start + MAX_COMPRESSED_LENGTH)
       );
@@ -79,7 +77,6 @@ function writeCompressed(buffer) {
     return;
   }
 
-  // eslint-disable-next-line no-invalid-this, consistent-this
   const connection = this;
 
   let packetLen = buffer.length;

package/lib/packets/encode_parameter.js

@@ -15,7 +15,6 @@ function toParameter(value, encoding, timezone, jsonAsString) {
   let type = Types.VAR_STRING;
   let length;
   let writer = function (value) {
-    // eslint-disable-next-line no-invalid-this
     return Packet.prototype.writeLengthCodedString.call(this, value, encoding);
   };
   if (value !== null) {
@@ -41,7 +40,6 @@ function toParameter(value, encoding, timezone, jsonAsString) {
           type = Types.DATETIME;
           length = 12;
           writer = function (value) {
-            // eslint-disable-next-line no-invalid-this
             return Packet.prototype.writeDate.call(this, value, timezone);
           };
         } else if (isJSON(value)) {

package/lib/packets/packet.js

@@ -405,7 +405,7 @@ class Packet {
     return (
       (sign === -1 ? '-' : '') +
       [leftPad(2, d * 24 + H), leftPad(2, M), leftPad(2, S)].join(':') +
-      (ms ? `.${ms}`.replace(/0+$/, '') : '')
+      (ms ? `.${leftPad(6, ms)}`.replace(/0+$/, '') : '')
     );
   }
 

package/lib/packets/resultset_header.js

@@ -80,7 +80,6 @@ class ResultSetHeader {
               packet.readLengthCodedString(encoding);
           } else if (type === sessionInfoTypes.STATE_GTIDS) {
             // TODO: find if the first length coded string means anything. Usually comes as empty
-            // eslint-disable-next-line no-unused-vars
             const _unknownString = packet.readLengthCodedString(encoding);
             const gtid = packet.readLengthCodedString(encoding);
             stateChanges.gtids = gtid.split(',');

package/lib/ring_queue.js

@@ -0,0 +1,353 @@
+/**
+ * Simplified abstraction adapted from denque (https://github.com/invertase/denque/tree/539105bb57854e997dd469221cdc52a0ad80e0a2)
+ * License: Apache-2.0 (https://github.com/invertase/denque/blob/master/LICENSE)
+ */
+
+'use strict';
+
+const MIN_SHRINK_TAIL = 10000;
+
+class RingQueue {
+  constructor() {
+    this._list = new Array(4);
+    this._mask = 3;
+    this._head = 0;
+    this._tail = 0;
+  }
+
+  get length() {
+    return (this._tail - this._head) & this._mask;
+  }
+
+  size() {
+    return this.length;
+  }
+
+  isEmpty() {
+    return this._head === this._tail;
+  }
+
+  push(item) {
+    // biome-ignore lint/correctness/noUndeclaredVariables: arguments distinguishes push() from push(undefined)
+    if (arguments.length === 0) {
+      return this.length;
+    }
+
+    this._list[this._tail] = item;
+    this._tail = (this._tail + 1) & this._mask;
+
+    if (this._tail === this._head) {
+      this._grow();
+    }
+
+    return this.length;
+  }
+
+  unshift(item) {
+    // biome-ignore lint/correctness/noUndeclaredVariables: arguments distinguishes unshift() from unshift(undefined)
+    if (arguments.length === 0) {
+      return this.length;
+    }
+
+    this._head = (this._head - 1) & this._mask;
+    this._list[this._head] = item;
+
+    if (this._tail === this._head) {
+      this._grow();
+    }
+
+    return this.length;
+  }
+
+  shift() {
+    const head = this._head;
+
+    if (head === this._tail) {
+      return undefined;
+    }
+
+    const item = this._list[head];
+    this._list[head] = undefined;
+    this._head = (head + 1) & this._mask;
+
+    if (
+      head < 2 &&
+      this._tail > MIN_SHRINK_TAIL &&
+      this._tail <= this._list.length >>> 2
+    ) {
+      this._shrink();
+    }
+
+    return item;
+  }
+
+  pop() {
+    const tail = this._tail;
+
+    if (tail === this._head) {
+      return undefined;
+    }
+
+    const capacity = this._list.length;
+    this._tail = (tail - 1) & this._mask;
+
+    const item = this._list[this._tail];
+    this._list[this._tail] = undefined;
+
+    if (this._head < 2 && tail > MIN_SHRINK_TAIL && tail <= capacity >>> 2) {
+      this._shrink();
+    }
+
+    return item;
+  }
+
+  peekAt(index) {
+    if (index !== (index | 0)) {
+      return undefined;
+    }
+
+    if (index >= 0) {
+      if (index >= this.length) {
+        return undefined;
+      }
+
+      return this._list[(this._head + index) & this._mask];
+    }
+
+    const size = this.length;
+
+    if (index < -size) {
+      return undefined;
+    }
+
+    return this._list[(this._head + index + size) & this._mask];
+  }
+
+  get(index) {
+    return this.peekAt(index);
+  }
+
+  peek() {
+    if (this._head === this._tail) {
+      return undefined;
+    }
+
+    return this._list[this._head];
+  }
+
+  peekFront() {
+    return this.peek();
+  }
+
+  peekBack() {
+    return this.peekAt(-1);
+  }
+
+  removeOne(index) {
+    if (index !== (index | 0)) {
+      return undefined;
+    }
+
+    const size = this.length;
+
+    if (index >= size || index < -size) {
+      return undefined;
+    }
+
+    if (index < 0) {
+      index += size;
+    }
+
+    const mask = this._mask;
+    let slot = (this._head + index) & mask;
+    const item = this._list[slot];
+    const isCloserToHead = index < size / 2;
+
+    if (isCloserToHead) {
+      for (let moves = index; moves > 0; moves--) {
+        const previous = (slot - 1) & mask;
+        this._list[slot] = this._list[previous];
+        slot = previous;
+      }
+
+      this._list[slot] = undefined;
+      this._head = (this._head + 1) & mask;
+    } else {
+      for (let moves = size - 1 - index; moves > 0; moves--) {
+        const next = (slot + 1) & mask;
+        this._list[slot] = this._list[next];
+        slot = next;
+      }
+
+      this._list[slot] = undefined;
+      this._tail = (this._tail - 1) & mask;
+    }
+
+    return item;
+  }
+
+  remove(index, count) {
+    if (index !== (index | 0)) {
+      return undefined;
+    }
+
+    if (this._head === this._tail) {
+      return undefined;
+    }
+
+    const size = this.length;
+
+    if (index >= size || index < -size || count < 1) {
+      return undefined;
+    }
+
+    if (index < 0) {
+      index += size;
+    }
+
+    if (count === 1 || !count) {
+      return [this.removeOne(index)];
+    }
+
+    if (count !== (count | 0)) {
+      return undefined;
+    }
+
+    if (index + count > size) {
+      count = size - index;
+    }
+
+    const items = this.toArray();
+    const removed = items.splice(index, count);
+    this._rebuild(items);
+
+    return removed;
+  }
+
+  splice(index, count, ...newItems) {
+    if (index !== (index | 0)) {
+      return undefined;
+    }
+
+    const size = this.length;
+
+    if (index < 0) {
+      index += size;
+    }
+
+    if (index > size) {
+      return undefined;
+    }
+
+    if (newItems.length === 0) {
+      return this.remove(index, count);
+    }
+
+    if (index < 0) {
+      return undefined;
+    }
+
+    const removalCount = count === undefined ? 1 : count;
+
+    if (removalCount !== (removalCount | 0) || removalCount < 0) {
+      return undefined;
+    }
+
+    const items = this.toArray();
+    let removed;
+
+    if (removalCount === 0) {
+      removed = [];
+      items.splice(index, 0, ...newItems);
+    } else if (index >= size) {
+      removed = undefined;
+      items.splice(index, 0, ...newItems);
+    } else {
+      removed = items.splice(index, removalCount, ...newItems);
+    }
+
+    this._rebuild(items);
+
+    return removed;
+  }
+
+  clear() {
+    this._list = new Array(this._list.length);
+    this._head = 0;
+    this._tail = 0;
+  }
+
+  toArray() {
+    const head = this._head;
+    const tail = this._tail;
+
+    if (head <= tail) {
+      return this._list.slice(head, tail);
+    }
+
+    const capacity = this._list.length;
+    const items = new Array(this.length);
+    let count = 0;
+
+    for (let slot = head; slot < capacity; slot++) {
+      items[count++] = this._list[slot];
+    }
+
+    for (let slot = 0; slot < tail; slot++) {
+      items[count++] = this._list[slot];
+    }
+
+    return items;
+  }
+
+  _grow() {
+    const list = this._list;
+    const capacity = list.length;
+
+    if (this._head === 0) {
+      this._tail = capacity;
+      list.length = capacity << 1;
+    } else {
+      const grown = new Array(capacity << 1);
+      let count = 0;
+
+      for (let slot = this._head; slot < capacity; slot++) {
+        grown[count++] = list[slot];
+      }
+
+      for (let slot = 0; slot < this._tail; slot++) {
+        grown[count++] = list[slot];
+      }
+
+      this._list = grown;
+      this._head = 0;
+      this._tail = capacity;
+    }
+
+    this._mask = (this._mask << 1) | 1;
+  }
+
+  _shrink() {
+    this._list.length >>>= 1;
+    this._mask >>>= 1;
+  }
+
+  _rebuild(items) {
+    let capacity = this._list.length;
+
+    while (items.length >= capacity) {
+      capacity <<= 1;
+    }
+
+    this._list = new Array(capacity);
+    this._mask = capacity - 1;
+    this._head = 0;
+    this._tail = items.length;
+
+    for (let i = 0; i < items.length; i++) {
+      this._list[i] = items[i];
+    }
+  }
+}
+
+module.exports = RingQueue;

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@depup/mysql2",
-  "version": "3.23.2-depup.0",
+  "version": "3.23.4-depup.0",
   "description": "fast mysql driver. Implements core protocol, prepared statements, ssl and compression in native JS (with updated dependencies)",
   "main": "index.js",
   "typings": "typings/mysql/index",
   "type": "commonjs",
   "scripts": {
-    "lint": "eslint . && prettier --check .",
-    "lint:fix": "eslint . --fix && prettier --write .",
+    "lint": "biome lint --error-on-warnings && prettier --check .",
+    "lint:fix": "biome lint --write . && prettier --write .",
     "test": "poku",
     "test:bun": "bun poku",
     "test:deno": "deno run -A npm:poku",
@@ -62,7 +62,6 @@
   "license": "MIT",
   "dependencies": {
     "aws-ssl-profiles": "^1.1.2",
-    "denque": "^2.1.0",
     "generate-function": "^2.3.1",
     "iconv-lite": "^0.7.3",
     "long": "^5.3.2",
@@ -74,43 +73,30 @@
     "@types/node": ">= 8"
   },
   "devDependencies": {
-    "@eslint/eslintrc": "^3.3.3",
-    "@eslint/js": "^9.39.2",
-    "@eslint/markdown": "^8.0.1",
+    "@biomejs/biome": "^2.5.7",
     "@ianvs/prettier-plugin-sort-imports": "^4.7.1",
-    "@pokujs/multi-suite": "^1.0.0",
-    "@rollup/plugin-commonjs": "^29.0.2",
+    "@pokujs/multi-suite": "^1.0.2",
+    "@rollup/plugin-commonjs": "^29.0.3",
     "@rollup/plugin-json": "^6.1.0",
     "@rollup/plugin-node-resolve": "^16.0.3",
-    "@types/node": "^26.0.0",
-    "@typescript-eslint/eslint-plugin": "^8.56.0",
-    "@typescript-eslint/parser": "^8.56.0",
+    "@types/node": "^26.2.0",
     "assert-diff": "^3.0.4",
     "benchmark": "^2.1.4",
-    "c8": "^11.0.0",
+    "c8": "^12.0.0",
     "error-stack-parser": "^2.1.4",
-    "eslint-config-prettier": "^10.1.8",
-    "eslint-plugin-async-await": "^0.0.0",
-    "eslint-plugin-prettier": "^5.5.5",
-    "globals": "^17.3.0",
-    "poku": "^4.1.0",
+    "poku": "^4.5.0",
     "portfinder": "^1.0.38",
-    "prettier": "^3.8.1",
-    "rollup": "^4.59.0",
-    "tsx": "^4.21.0",
-    "typescript": "^5.9.3"
+    "prettier": "^3.9.6",
+    "rollup": "^4.62.4",
+    "tsx": "^4.23.11",
+    "typescript": "^7.0.2"
   },
   "depup": {
-    "changes": {
-      "iconv-lite": {
-        "from": "^0.7.2",
-        "to": "^0.7.3"
-      }
-    },
-    "depsUpdated": 1,
+    "changes": {},
+    "depsUpdated": 0,
     "originalPackage": "mysql2",
-    "originalVersion": "3.23.2",
-    "processedAt": "2026-07-27T16:45:28.701Z",
+    "originalVersion": "3.23.4",
+    "processedAt": "2026-08-20T08:13:45.307Z",
     "smokeTest": "passed"
   }
 }

package/typings/mysql/lib/Pool.d.ts

@@ -70,6 +70,16 @@ declare class Pool extends QueryableBase(ExecutableBase(EventEmitter)) {
 
   unprepare(sql: string): PrepareStatementInfo;
 
+  /**
+   * Escaping helpers, available on a `Pool` just like on a `Connection`.
+   */
+  escape(value: any): string;
+
+  escapeId(value: string): string;
+  escapeId(values: string[]): string;
+
+  format(sql: string, values?: any | any[] | { [param: string]: any }): string;
+
   promise(promiseImpl?: PromiseConstructor): PromisePool;
 
   config: PoolOptions;

package/typings/mysql/lib/PoolConnection.d.ts

@@ -1,11 +1,16 @@
 import { Connection } from './Connection.js';
-import { Pool as PromisePool } from '../../../promise.js';
+import { PoolConnection as PromisePoolConnection } from '../../../promise.js';
 
 declare class PoolConnection extends Connection {
   connection: Connection;
   release(): void;
   [Symbol.dispose](): void;
-  promise(promiseImpl?: PromiseConstructor): PromisePool;
+  /**
+   * Returns a promise-based wrapper around this pooled connection.
+   *
+   * Note: this resolves to a `PoolConnection` from `mysql2/promise`, not to a `Pool`.
+   */
+  promise(promiseImpl?: PromiseConstructor): PromisePoolConnection;
 }
 
 export { PoolConnection };

package/typings/mysql/lib/Tracing.d.ts

@@ -52,17 +52,13 @@ export declare function tracePromise<T extends object, R>(
 ): Promise<R>;
 
 export declare const queryChannel:
-  | TracingChannel<QueryTraceContext>
-  | undefined;
+  TracingChannel<QueryTraceContext> | undefined;
 export declare const executeChannel:
-  | TracingChannel<ExecuteTraceContext>
-  | undefined;
+  TracingChannel<ExecuteTraceContext> | undefined;
 export declare const connectChannel:
-  | TracingChannel<ConnectTraceContext>
-  | undefined;
+  TracingChannel<ConnectTraceContext> | undefined;
 export declare const poolConnectChannel:
-  | TracingChannel<PoolConnectTraceContext>
-  | undefined;
+  TracingChannel<PoolConnectTraceContext> | undefined;
 
 export declare function getServerContext(config: {
   socketPath?: string;