postgrejs 3.7.0 → 3.8.0

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 ## Changelog
 
+### [v3.8.0](https://github.com/panates/postgrejs/compare/v3.7.0...v3.8.0) - 
+
+#### 🚀 New Features
+
+- feat: deliver server notices to the connection @Eray Hanoğlu 
+
+#### 🪲 Fixes
+
+- fix: send a string parameter unspecified, so the column decides @Eray Hanoğlu 
+- fix: send a Date parameter unspecified, so the column decides @Eray Hanoğlu 
+- fix: write a lower bound of 1 for an ordinary binary array @Eray Hanoğlu 
+
+#### 🧪 Changes to Test Assests
+
+- test: skip the types PostgreSQL 12 does not have @Eray Hanoğlu 
+
 ### [v3.7.0](https://github.com/panates/postgrejs/compare/v3.6.1...v3.7.0) -  20 September 2026 
 
 #### Breaking Changes :warning:

package/connection/connection.js

@@ -5,6 +5,7 @@ import { withAbortSignal } from '../util/abort-signal.js';
 import { normalizeChannelName } from '../util/channel-name.js';
 import { escapeIdentifier } from '../util/escape-identifier.js';
 import { QueryRequest } from '../util/sql-tag.js';
+import { isUnspecifiedParam } from '../util/unspecified-param.js';
 import { BindParam } from './bind-param.js';
 import { IntlConnection } from './intl-connection.js';
 import { LargeObject, LargeObjectMode } from './large-object.js';
@@ -631,7 +632,18 @@ export class Connection extends SafeEventEmitter {
     }
     async _query(sql, options) {
         const typeMap = options?.typeMap || GlobalTypeMap;
-        const paramTypes = options?.params?.map(prm => prm instanceof BindParam ? prm.oid : typeMap.determine(prm));
+        const paramTypes = options?.params?.map(prm => prm instanceof BindParam
+            ? prm.oid
+            : // A Date and a string go out with no declared type, so the
+                // server resolves each from where it lands - neither can say
+                // what it is, and naming a type for them is what made a `Date`
+                // move by the client's offset and a string unusable anywhere a
+                // `varchar` is not what the context wanted. See
+                // `isUnspecifiedParam()` for what that costs. The text they go
+                // out as is written in getBindMessage().
+                isUnspecifiedParam(prm)
+                    ? 0
+                    : typeMap.determine(prm));
         const effectiveAutoCommit = options?.autoCommit != null
             ? options.autoCommit
             : this._intlCon.config.autoCommit;

package/connection/intl-connection.js

@@ -124,6 +124,10 @@ export class IntlConnection extends SafeEventEmitter {
         // ordinary shutdown from the backend being terminated under us.
         this.socket.on('close', (reason) => this.emit('close', reason));
         this.socket.on('notification', payload => this.emit('notification', payload));
+        // Covers a notice that arrives while no statement is running. One
+        // raised *by* a statement is dispatched to that statement's own
+        // message loop instead, which is why each of those forwards it too.
+        this.socket.on('notice', payload => this.emit('notice', payload));
         this.socket.on('connecting', () => this.emit('connecting'));
         this._onErrorSavePoint = 'SP_' + Math.round(Math.random() * 100000000);
     }
@@ -561,6 +565,9 @@ export class IntlConnection extends SafeEventEmitter {
                                 new Error('COPY TO STDOUT is not supported by execute() - use copyTo() instead');
                         break;
                     case Protocol.BackendMessageCode.NoticeResponse:
+                        // Not an error: handed over, and the loop carries on.
+                        this.emit('notice', msg);
+                        break;
                     case Protocol.BackendMessageCode.EmptyQueryResponse:
                         break;
                     case Protocol.BackendMessageCode.RowDescription:
@@ -825,10 +832,13 @@ export class IntlConnection extends SafeEventEmitter {
                 after: savepoint ? 'RELEASE ' + savepoint : undefined,
             }, (code, msg, done) => {
                 switch (code) {
+                    case Protocol.BackendMessageCode.NoticeResponse:
+                        // Not an error: handed over, and the loop carries on.
+                        this.emit('notice', msg);
+                        break;
                     case Protocol.BackendMessageCode.ParseComplete:
                     case Protocol.BackendMessageCode.BindComplete:
                     case Protocol.BackendMessageCode.NoData:
-                    case Protocol.BackendMessageCode.NoticeResponse:
                         break;
                     // The server stopped at the fetchCount limit rather than
                     // running out of rows. The Sync that closes this call
@@ -910,10 +920,13 @@ export class IntlConnection extends SafeEventEmitter {
                 describe: { type: 'S', name: statementName },
             }, (code, msg, done) => {
                 switch (code) {
+                    case Protocol.BackendMessageCode.NoticeResponse:
+                        // Not an error: handed over, and the loop carries on.
+                        this.emit('notice', msg);
+                        break;
                     case Protocol.BackendMessageCode.ParseComplete:
                     case Protocol.BackendMessageCode.ParameterDescription:
                     case Protocol.BackendMessageCode.NoData:
-                    case Protocol.BackendMessageCode.NoticeResponse:
                         break;
                     case Protocol.BackendMessageCode.RowDescription:
                         fields = msg.fields;
@@ -1091,9 +1104,12 @@ export class IntlConnection extends SafeEventEmitter {
                 await this.socket
                     .sendPipelineMessages({ statements }, (code, msg, done) => {
                     switch (code) {
+                        case Protocol.BackendMessageCode.NoticeResponse:
+                            // Not an error: handed over, and the loop carries on.
+                            this.emit('notice', msg);
+                            break;
                         case Protocol.BackendMessageCode.ParseComplete:
                         case Protocol.BackendMessageCode.BindComplete:
-                        case Protocol.BackendMessageCode.NoticeResponse:
                             break;
                         case Protocol.BackendMessageCode.NoData:
                             pendingFields = undefined;
@@ -1234,8 +1250,11 @@ export class IntlConnection extends SafeEventEmitter {
                 execute: { fetchCount: 0 },
             }, (code, msg, done) => {
                 switch (code) {
-                    case Protocol.BackendMessageCode.BindComplete:
                     case Protocol.BackendMessageCode.NoticeResponse:
+                        // Not an error: handed over, and the loop carries on.
+                        this.emit('notice', msg);
+                        break;
+                    case Protocol.BackendMessageCode.BindComplete:
                         break;
                     case Protocol.BackendMessageCode.DataRow:
                         (pendingRows || (pendingRows = [])).push(msg);
@@ -1348,9 +1367,12 @@ export class IntlConnection extends SafeEventEmitter {
                 after: savepoint ? 'RELEASE ' + savepoint : undefined,
             }, (code, msg, done) => {
                 switch (code) {
+                    case Protocol.BackendMessageCode.NoticeResponse:
+                        // Not an error: handed over, and the loop carries on.
+                        this.emit('notice', msg);
+                        break;
                     case Protocol.BackendMessageCode.ParseComplete:
                     case Protocol.BackendMessageCode.BindComplete:
-                    case Protocol.BackendMessageCode.NoticeResponse:
                         break;
                     // See queryOnce() for what a suspended portal means here.
                     case Protocol.BackendMessageCode.PortalSuspended:

package/connection/pool.js

@@ -157,6 +157,12 @@ export class Pool extends SafeEventEmitter {
             connection.on('execute', (...args) => this.emit('execute', ...args));
         if (this.listenerCount('query'))
             connection.on('query', (...args) => this.emit('query', ...args));
+        // Forwarded with the connection that raised it, the way 'destroy'
+        // names its own subject: a caller using pool.query() never sees the
+        // Connection, so without this a notice raised by their statement has
+        // nowhere to go at all.
+        if (this.listenerCount('notice'))
+            connection.on('notice', msg => this.emit('notice', msg, connection));
         return connection;
     }
     /**

package/connection/prepared-statement.d.ts

@@ -68,6 +68,17 @@ export declare class PreparedStatement extends SafeEventEmitter implements Async
      *   takes, minus `fetchCount` and `cursor`, which a batch cannot honour.
      */
     executeBatch(paramSets: any[][], options?: QueryOptions): Promise<BatchResult>;
+    /**
+     * A notice reaches both this statement and the connection it ran on.
+     *
+     * These are the three loops the statement keeps for its own close and
+     * cancel traffic; an `execute()` runs through the connection's loop
+     * instead and is forwarded there. Without this second hop a notice
+     * arriving on one of these three would be the only kind a caller
+     * holding a `Connection` never saw. Hard to provoke - `DEALLOCATE`
+     * does not normally raise one - which is why there is no test for it.
+     */
+    protected _emitNotice(msg: any): void;
     protected _executeBatchWithTransaction(paramSets: any[][], options: QueryOptions): Promise<BatchResult>;
     protected _executeWithTransaction(options?: QueryOptions): Promise<QueryResult>;
     /**

package/connection/prepared-statement.js

@@ -114,6 +114,20 @@ export class PreparedStatement extends SafeEventEmitter {
             return withAbortSignal(options.signal, () => intlCon.cancel(), () => this._executeBatchWithTransaction(paramSets, options));
         return this._executeBatchWithTransaction(paramSets, options);
     }
+    /**
+     * A notice reaches both this statement and the connection it ran on.
+     *
+     * These are the three loops the statement keeps for its own close and
+     * cancel traffic; an `execute()` runs through the connection's loop
+     * instead and is forwarded there. Without this second hop a notice
+     * arriving on one of these three would be the only kind a caller
+     * holding a `Connection` never saw. Hard to provoke - `DEALLOCATE`
+     * does not normally raise one - which is why there is no test for it.
+     */
+    _emitNotice(msg) {
+        this.emit('notice', msg);
+        getIntlConnection(this.connection).emit('notice', msg);
+    }
     _executeBatchWithTransaction(paramSets, options) {
         const intlCon = getIntlConnection(this.connection);
         return this._withTransaction(options, () => intlCon.executeBatchReused(this.name, this._fields, this.paramTypes, paramSets, options));
@@ -268,7 +282,7 @@ export class PreparedStatement extends SafeEventEmitter {
             }, (code, msg, done) => {
                 switch (code) {
                     case Protocol.BackendMessageCode.NoticeResponse:
-                        this.emit('notice', msg);
+                        this._emitNotice(msg);
                         break;
                     case Protocol.BackendMessageCode.CloseComplete:
                         // Arrives twice (once per Close) - neither call is terminal.
@@ -299,7 +313,7 @@ export class PreparedStatement extends SafeEventEmitter {
             const closePromise = socket.sendCloseMessage({ type: 'S', name: this.name }, (code, msg, done) => {
                 switch (code) {
                     case Protocol.BackendMessageCode.NoticeResponse:
-                        this.emit('notice', msg);
+                        this._emitNotice(msg);
                         break;
                     case Protocol.BackendMessageCode.CloseComplete:
                         done();
@@ -314,7 +328,7 @@ export class PreparedStatement extends SafeEventEmitter {
             const syncPromise = socket.sendSyncMessage((code, msg, done) => {
                 switch (code) {
                     case Protocol.BackendMessageCode.NoticeResponse:
-                        this.emit('notice', msg);
+                        this._emitNotice(msg);
                         break;
                     case Protocol.BackendMessageCode.ReadyForQuery:
                         intoCon.transactionStatus = msg.status;

package/data-types/classes/numeric.d.ts

@@ -9,10 +9,14 @@
  * to a plain number; this class is what the rest become, and it carries
  * the digits exactly as the server wrote them.
  *
- * It is a class rather than a bare string so that it can be told apart:
- * `determine()` types a bare string as `varchar`, which the server then
- * refuses to put in a numeric column, so a string could be read but not
- * written back. A `Numeric` round-trips.
+ * It is a class rather than a bare string so that the value keeps
+ * saying what it is. A bare string parameter does reach a numeric
+ * column - it goes out with no declared type and the server resolves it
+ * there (see `util/unspecified-param.ts`) - but only where there is a
+ * column to resolve it from: `determine()` answers `varchar` for it, an
+ * inlined literal is written with no cast, and a decoded one is
+ * indistinguishable from text. A `Numeric` carries the type with the
+ * digits.
  *
  * There is deliberately no `valueOf()`. Arithmetic on one of these has
  * to be an explicit decision - `Symbol.toPrimitive` hands back the exact

package/data-types/classes/numeric.js

@@ -9,10 +9,14 @@
  * to a plain number; this class is what the rest become, and it carries
  * the digits exactly as the server wrote them.
  *
- * It is a class rather than a bare string so that it can be told apart:
- * `determine()` types a bare string as `varchar`, which the server then
- * refuses to put in a numeric column, so a string could be read but not
- * written back. A `Numeric` round-trips.
+ * It is a class rather than a bare string so that the value keeps
+ * saying what it is. A bare string parameter does reach a numeric
+ * column - it goes out with no declared type and the server resolves it
+ * there (see `util/unspecified-param.ts`) - but only where there is a
+ * column to resolve it from: `determine()` answers `varchar` for it, an
+ * inlined literal is written with no cast, and a decoded one is
+ * indistinguishable from text. A `Numeric` carries the type with the
+ * digits.
  *
  * There is deliberately no `valueOf()`. Arithmetic on one of these has
  * to be an explicit decision - `Symbol.toPrimitive` hands back the exact

package/data-types/int2-vector-type.js

@@ -10,7 +10,10 @@ export const Int2VectorType = {
     encodeBinary(buf, v) {
         encodeBinaryArray(buf, v, DataTypeOIDs.int2, {}, (io, x) => {
             io.writeInt16BE(x);
-        });
+        }, 
+        // A vector is genuinely 0-based, unlike every ordinary array -
+        // `array_lower(pg_index.indkey, 1)` is 0 on the server.
+        undefined, 0);
     },
     encodeCalculateDim(v) {
         return [v.length];

package/data-types/oid-vector-type.js

@@ -16,7 +16,10 @@ export const OidVectorType = {
     encodeBinary(buf, v) {
         encodeBinaryArray(buf, v, DataTypeOIDs.oid, {}, (io, x) => {
             io.writeUInt32BE(x);
-        });
+        }, 
+        // A vector is genuinely 0-based, unlike every ordinary array -
+        // `array_lower(pg_index.indkey, 1)` is 0 on the server.
+        undefined, 0);
     },
     encodeCalculateDim(v) {
         return [v.length];

package/data-types/timestamptz-type.js

@@ -67,6 +67,15 @@ export const TimestamptzType = {
             return d;
         return TimestamptzType.decodeText(buf.toString('latin1', offset, offset + len), options);
     },
+    /**
+     * Unreachable through `determine()`: TimestampType, TimeType and
+     * DateType are all consulted before this one and every Date is claimed
+     * by one of them. Nothing depends on it - a Date parameter goes out
+     * unspecified and the column decides what it means (see
+     * format-datetime.ts's formatDateParam) - so this stays as the
+     * truthful answer to a direct call rather than being narrowed to
+     * describe a walk it never wins.
+     */
     isType(v) {
         return v instanceof Date;
     },

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "postgrejs",
   "description": "Professional PostgreSQL client NodeJS",
-  "version": "3.7.0",
+  "version": "3.8.0",
   "author": "Panates",
   "license": "BSD-3-Clause",
   "dependencies": {

package/protocol/frontend.js

@@ -1,7 +1,9 @@
 import { DEFAULT_COLUMN_FORMAT } from '../constants.js';
 import { DataTypeMap } from '../data-type-map.js';
 import { encodeBinaryArray } from '../util/encode-binaryarray.js';
+import { formatDateParam } from '../util/format-datetime.js';
 import { stringifyArrayLiteral } from '../util/stringify-arrayliteral.js';
+import { arrayLeaf } from '../util/unspecified-param.js';
 import { Protocol } from './protocol.js';
 import { SmartBuffer } from './smart-buffer.js';
 const DataFormat = Protocol.DataFormat;
@@ -186,6 +188,21 @@ export class Frontend {
                         io.writeLString(v, 'utf8');
                     }
                 }
+                else if (v instanceof Date) {
+                    // No declared type, so the server resolves it from the column
+                    // - which is the whole point, and why the text has to carry
+                    // the zone. `String(v)` is a JavaScript date string the server
+                    // cannot parse at all, which is what a prepared statement with
+                    // no paramTypes used to send.
+                    io.writeLString(formatDateParam(v, queryOptions), 'utf8');
+                }
+                else if (Array.isArray(v)) {
+                    // Also undeclared, so the server reads an array literal and
+                    // takes the element type from the column. `'' + v` would hand
+                    // it `a,b`, which is not one - the elements have to be quoted
+                    // and the braces written, and a nested array needs its own.
+                    io.writeLString(stringifyArrayLiteral(v, queryOptions, arrayLeaf(v) instanceof Date ? formatDateParam : undefined), 'utf8');
+                }
                 else if (Buffer.isBuffer(v)) {
                     // Set param format to binary
                     io.buffer.writeInt16BE(Protocol.DataFormat.binary, formatOffset + i * 2);

package/util/decode-binaryarray.js

@@ -38,7 +38,14 @@ export function decodeBinaryArray(buf, offset, decoder, options = {}) {
     };
     for (let d = 0; d < ndims; d++) {
         dims[d] = io.readInt32BE();
-        io.readInt32BE(); // LBound
+        // The lower bound is read and dropped, deliberately. A server-side
+        // array really can have a non-default one, and a JavaScript array is
+        // always 0-based, so carrying it would mean deciding what a decoded
+        // array is supposed to represent - a wider change than the encoder's.
+        // Note that this is also what hid the encoder writing 0: a value
+        // written and read back through this client looked right, and only
+        // SQL against the stored value saw the difference.
+        io.readInt32BE();
     }
     return readDim(0);
 }

package/util/encode-binaryarray.d.ts

@@ -1,4 +1,15 @@
 import type { DataMappingOptions } from '../interfaces/data-mapping-options.js';
 import type { SmartBuffer } from '../protocol/smart-buffer.js';
 import type { EncodeBinaryFunction, EncodeCalculateDimFunction, OID } from '../types.js';
-export declare function encodeBinaryArray(io: SmartBuffer, value: any[], itemOid: OID, options: DataMappingOptions, encode: EncodeBinaryFunction, encodeCalculateDimFn?: EncodeCalculateDimFunction): void;
+/**
+ * Writes an array in the binary wire format.
+ *
+ * `lowerBound` is the index the first element answers to in SQL, and it
+ * is 1 for every ordinary array - `array_lower('{1,2}'::int4[], 1)` is
+ * 1, and a value written with 0 comes back subscripted from 0, so
+ * `arr[1]` is its *second* element and `::text` renders the
+ * explicit-bounds form `[0:2]={…}`. `oidvector` and `int2vector` are the
+ * exception and really are 0-based - confirmed against the catalog,
+ * `array_lower(pg_index.indkey, 1)` is 0 - so they pass 0 themselves.
+ */
+export declare function encodeBinaryArray(io: SmartBuffer, value: any[], itemOid: OID, options: DataMappingOptions, encode: EncodeBinaryFunction, encodeCalculateDimFn?: EncodeCalculateDimFunction, lowerBound?: number): void;

package/util/encode-binaryarray.js

@@ -1,6 +1,17 @@
 import { DataTypeOIDs } from '../constants.js';
 import { arrayCalculateDim } from './array-calculatedim.js';
-export function encodeBinaryArray(io, value, itemOid, options, encode, encodeCalculateDimFn) {
+/**
+ * Writes an array in the binary wire format.
+ *
+ * `lowerBound` is the index the first element answers to in SQL, and it
+ * is 1 for every ordinary array - `array_lower('{1,2}'::int4[], 1)` is
+ * 1, and a value written with 0 comes back subscripted from 0, so
+ * `arr[1]` is its *second* element and `::text` renders the
+ * explicit-bounds form `[0:2]={…}`. `oidvector` and `int2vector` are the
+ * exception and really are 0-based - confirmed against the catalog,
+ * `array_lower(pg_index.indkey, 1)` is 0 - so they pass 0 themselves.
+ */
+export function encodeBinaryArray(io, value, itemOid, options, encode, encodeCalculateDimFn, lowerBound = 1) {
     encodeCalculateDimFn = encodeCalculateDimFn || arrayCalculateDim;
     itemOid = itemOid || DataTypeOIDs.varchar;
     const dim = encodeCalculateDimFn(value);
@@ -12,7 +23,7 @@ export function encodeBinaryArray(io, value, itemOid, options, encode, encodeCal
     let d;
     for (d = 0; d < ndims; d++) {
         io.writeInt32BE(dim[d]); // Number of items in dimension
-        io.writeInt32BE(0); // LBound always 0.
+        io.writeInt32BE(lowerBound); // Index the first element answers to
     }
     let hasNull = false;
     let pos;

package/util/format-datetime.d.ts

@@ -8,3 +8,21 @@ export declare function formatTimestamp(v: Date | number | string, options?: Dat
  * ignores `utcDates`, which only governs the zone-less types.
  */
 export declare function formatTimestamptz(v: Date | number | string): string;
+/**
+ * A `Date` as a parameter, rendered the way `pg` renders one: the wall
+ * clock in the process's own zone, followed by that zone's offset.
+ *
+ * It is the only rendering that is right for both column kinds at once,
+ * which is why the parameter path uses it instead of declaring a type.
+ * A `timestamptz` column honours the offset and stores the instant; a
+ * `timestamp` column discards it and keeps the wall clock - so the
+ * server decides, from the column, what one JavaScript `Date` could
+ * never say on its own. Declaring `timestamp` instead moved the instant
+ * by the client's offset, and declaring `timestamptz` moved the wall
+ * clock by it; measured against `pg` in three session zones, this
+ * matches in all six.
+ *
+ * Under `utcDates` the UTC components go out with a zero offset, which
+ * is the same rule the zone-less encoders follow.
+ */
+export declare function formatDateParam(v: Date | number | string, options?: DataMappingOptions): string;

package/util/format-datetime.js

@@ -69,3 +69,36 @@ export function formatTimestamptz(v) {
         return d;
     return d.toISOString().replace('T', ' ').replace('Z', '+00');
 }
+/**
+ * A `Date` as a parameter, rendered the way `pg` renders one: the wall
+ * clock in the process's own zone, followed by that zone's offset.
+ *
+ * It is the only rendering that is right for both column kinds at once,
+ * which is why the parameter path uses it instead of declaring a type.
+ * A `timestamptz` column honours the offset and stores the instant; a
+ * `timestamp` column discards it and keeps the wall clock - so the
+ * server decides, from the column, what one JavaScript `Date` could
+ * never say on its own. Declaring `timestamp` instead moved the instant
+ * by the client's offset, and declaring `timestamptz` moved the wall
+ * clock by it; measured against `pg` in three session zones, this
+ * matches in all six.
+ *
+ * Under `utcDates` the UTC components go out with a zero offset, which
+ * is the same rule the zone-less encoders follow.
+ */
+export function formatDateParam(v, options) {
+    const d = coerce(v);
+    if (typeof d === 'string')
+        return d;
+    const p = parts(d, options);
+    const clock = `${pad(p.year, 4)}-${pad(p.month)}-${pad(p.day)}` +
+        ` ${pad(p.hour)}:${pad(p.minute)}:${pad(p.second)}.${pad(p.ms, 3)}`;
+    if (options?.utcDates)
+        return clock + '+00:00';
+    // getTimezoneOffset() counts minutes west of UTC, the opposite way
+    // round from how an offset is written.
+    const offset = -d.getTimezoneOffset();
+    const sign = offset < 0 ? '-' : '+';
+    const abs = Math.abs(offset);
+    return `${clock}${sign}${pad(Math.floor(abs / 60))}:${pad(abs % 60)}`;
+}

package/util/sql-tag.js

@@ -2,6 +2,9 @@ import { BindParam } from '../connection/bind-param.js';
 import { DataTypeMap, GlobalTypeMap } from '../data-type-map.js';
 import { escapeIdentifier } from './escape-identifier.js';
 import { escapeLiteral } from './escape-literal.js';
+import { formatDateParam } from './format-datetime.js';
+import { stringifyArrayLiteral } from './stringify-arrayliteral.js';
+import { arrayLeaf, isUnspecifiedParam } from './unspecified-param.js';
 /**
  * A statement built by the `sql` tag: its text with the values pulled out.
  *
@@ -171,6 +174,18 @@ function encodeLiteral(value, typeMap, options) {
     }
     if (v == null)
         return 'null';
+    // A Date and a string go in bare, exactly as they go out as
+    // parameters with no declared type (see unspecified-param.ts): an
+    // unadorned literal is `unknown` and takes the type of wherever it
+    // lands. The cast this path adds everywhere else is what keeps
+    // query() and execute() meaning the same thing, and for these two it
+    // is what would break that - `'{"a":1}'::varchar` is refused by a
+    // json column that takes the parameter without complaint.
+    if (oid == null && isUnspecifiedParam(v)) {
+        if (!Array.isArray(v))
+            return escapeLiteral(v instanceof Date ? formatDateParam(v, options) : '' + v);
+        return escapeLiteral(stringifyArrayLiteral(v, options, arrayLeaf(v) instanceof Date ? formatDateParam : undefined));
+    }
     oid = oid ?? typeMap.determine(v);
     /* c8 ignore start - typeMap.determine() always falls back to the
        "unknown" oid rather than returning null/undefined, so this can't

package/util/stringify-for-sql.js

@@ -2,6 +2,7 @@ import { DataTypeOIDs } from '../constants.js';
 import { GlobalTypeMap } from '../data-type-map.js';
 import { UuidType } from '../data-types/uuid-type.js';
 import { escapeLiteral } from './escape-literal.js';
+import { formatDateParam } from './format-datetime.js';
 export function stringifyArrayForSQL(v, options, encode) {
     const arr = v.map(x => stringifyValueForSQL(x, options, encode));
     return 'ARRAY[' + arr.join(',') + ']';
@@ -51,6 +52,12 @@ export function stringifyValueForSQL(v, options, encode) {
         return v.toString();
     if (typeof v === 'string' && UuidType.isType(v))
         return escapeLiteral('' + v) + '::uuid';
+    // A Date is written bare, with its offset and no cast, so that it
+    // means the same inlined as it does bound - the server resolves it
+    // from the column either way. See format-datetime.ts's
+    // formatDateParam().
+    if (v instanceof Date)
+        return escapeLiteral(formatDateParam(v, options));
     if (typeof v === 'object')
         return stringifyObjectForSQL(v, options);
     // A string is deliberately written bare. determine() would answer

package/util/unspecified-param.d.ts

@@ -0,0 +1,32 @@
+/**
+ * The first value inside `v` that is not itself an array - what an array
+ * parameter's element type would be read from. A scalar answers itself.
+ */
+export declare function arrayLeaf(v: any): any;
+/**
+ * Whether a parameter goes out with no declared type (OID 0), as text,
+ * for the server to resolve from wherever it lands.
+ *
+ * Two kinds of value cannot say what they are:
+ *
+ * - A `Date` is an instant or a wall clock depending on the column, and
+ *   declaring either one moves the other. See `format-datetime.ts`.
+ * - A string is whichever of PostgreSQL's text-input types the context
+ *   calls for. `determine()` answers `varchar`, and declaring that stops
+ *   the server inferring: `insert into t(j) values($1)` into a `json`
+ *   column, `id = $1` against a `uuid`, `coalesce($1, 1)` and an enum
+ *   column all fail with "expression is of type character varying".
+ *   Unspecified, every one of them works.
+ *
+ * This is what `pg` sends for both, and the divergence from it is what
+ * the shapes above were failing on. It is not free: a parameter with no
+ * context to be resolved from - `$1 is null`, `array_agg($1)`,
+ * `concat($1, 1)` - now raises "could not determine data type", exactly
+ * as it does under `pg`. A cast (`$1::text`) or a named type
+ * (`new BindParam(DataTypeOIDs.varchar, v)`) says which type is meant.
+ *
+ * Numbers, booleans and Buffers keep their declared types: they are
+ * already right nearly everywhere, and sending them as text would give
+ * up the binary encoding for no correctness gain.
+ */
+export declare function isUnspecifiedParam(v: any): boolean;

package/util/unspecified-param.js

@@ -0,0 +1,40 @@
+/**
+ * The first value inside `v` that is not itself an array - what an array
+ * parameter's element type would be read from. A scalar answers itself.
+ */
+export function arrayLeaf(v) {
+    let x = v;
+    while (Array.isArray(x))
+        x = x[0];
+    return x;
+}
+/**
+ * Whether a parameter goes out with no declared type (OID 0), as text,
+ * for the server to resolve from wherever it lands.
+ *
+ * Two kinds of value cannot say what they are:
+ *
+ * - A `Date` is an instant or a wall clock depending on the column, and
+ *   declaring either one moves the other. See `format-datetime.ts`.
+ * - A string is whichever of PostgreSQL's text-input types the context
+ *   calls for. `determine()` answers `varchar`, and declaring that stops
+ *   the server inferring: `insert into t(j) values($1)` into a `json`
+ *   column, `id = $1` against a `uuid`, `coalesce($1, 1)` and an enum
+ *   column all fail with "expression is of type character varying".
+ *   Unspecified, every one of them works.
+ *
+ * This is what `pg` sends for both, and the divergence from it is what
+ * the shapes above were failing on. It is not free: a parameter with no
+ * context to be resolved from - `$1 is null`, `array_agg($1)`,
+ * `concat($1, 1)` - now raises "could not determine data type", exactly
+ * as it does under `pg`. A cast (`$1::text`) or a named type
+ * (`new BindParam(DataTypeOIDs.varchar, v)`) says which type is meant.
+ *
+ * Numbers, booleans and Buffers keep their declared types: they are
+ * already right nearly everywhere, and sending them as text would give
+ * up the binary encoding for no correctness gain.
+ */
+export function isUnspecifiedParam(v) {
+    const x = arrayLeaf(v);
+    return typeof x === 'string' || x instanceof Date;
+}