postgrejs 3.1.3 → 3.3.0

package/protocol/frontend.js

@@ -39,31 +39,31 @@ export class Frontend {
         this._io = new SmartBuffer(options?.buffer);
     }
     getSSLRequestMessage() {
-        return this._io
-            .start()
-            .writeUInt32BE(8) // Length of message contents in bytes, including self.
-            .writeUInt16BE(1234)
-            .writeUInt16BE(5679)
-            .flush();
+        const io = this._io.start();
+        io.writeUInt32BE(8); // Length of message contents in bytes, including self.
+        io.writeUInt16BE(1234);
+        io.writeUInt16BE(5679);
+        return io.flush();
     }
     getStartupMessage(args, minorVersion = Protocol.VERSION_MINOR) {
-        const io = this._io
-            .start()
-            .writeInt32BE(0) // Preserve length
-            .writeInt16BE(Protocol.VERSION_MAJOR)
-            .writeInt16BE(minorVersion);
+        const io = this._io.start();
+        io.writeInt32BE(0); // Preserve length
+        io.writeInt16BE(Protocol.VERSION_MAJOR);
+        io.writeInt16BE(minorVersion);
         const entries = Object.entries(args);
         const l = entries.length;
         let k;
         let v;
         for (let i = 0; i < l; i++) {
             [k, v] = entries[i];
-            if (k !== 'client_encoding')
-                io.writeCString(k, 'utf8').writeCString(v, 'utf8');
+            if (k !== 'client_encoding') {
+                io.writeCString(k, 'utf8');
+                io.writeCString(v, 'utf8');
+            }
         }
-        io.writeCString('client_encoding', 'utf8')
-            .writeCString('UTF8', 'utf8')
-            .writeUInt8(0);
+        io.writeCString('client_encoding', 'utf8');
+        io.writeCString('UTF8', 'utf8');
+        io.writeUInt8(0);
         return setLengthAndFlush(io, 0);
     }
     /**
@@ -73,51 +73,46 @@ export class Frontend {
      * down the normal one.
      */
     getCancelRequestMessage(processID, secretKey) {
-        return this._io
-            .start()
-            .writeUInt32BE(12 + secretKey.length) // Length of message contents in bytes, including self.
-            .writeUInt16BE(1234)
-            .writeUInt16BE(5678)
-            .writeUInt32BE(processID)
-            .writeBuffer(secretKey)
-            .flush();
+        const io = this._io.start();
+        io.writeUInt32BE(12 + secretKey.length); // Length of message contents in bytes, including self.
+        io.writeUInt16BE(1234);
+        io.writeUInt16BE(5678);
+        io.writeUInt32BE(processID);
+        io.writeBytes(secretKey);
+        return io.flush();
     }
     getPasswordMessage(password) {
-        const io = this._io
-            .start()
-            .writeInt8(Protocol.FrontendMessageCode.PasswordMessage)
-            .writeInt32BE(0) // Preserve header
-            .writeCString(password, 'utf8');
+        const io = this._io.start();
+        io.writeInt8(Protocol.FrontendMessageCode.PasswordMessage);
+        io.writeInt32BE(0); // Preserve header
+        io.writeCString(password, 'utf8');
         return setLengthAndFlush(io, 1);
     }
     getSASLMessage(sasl) {
-        const io = this._io
-            .start()
-            .writeInt8(Protocol.FrontendMessageCode.PasswordMessage)
-            .writeInt32BE(0) // Preserve header
-            .writeCString(sasl.mechanism, 'utf8')
-            .writeLString(sasl.clientFirstMessage);
+        const io = this._io.start();
+        io.writeInt8(Protocol.FrontendMessageCode.PasswordMessage);
+        io.writeInt32BE(0); // Preserve header
+        io.writeCString(sasl.mechanism, 'utf8');
+        io.writeLString(sasl.clientFirstMessage);
         return setLengthAndFlush(io, 1);
     }
     getSASLFinalMessage(session) {
-        const io = this._io
-            .start()
-            .writeInt8(Protocol.FrontendMessageCode.PasswordMessage)
-            .writeInt32BE(0) // Preserve header
-            .writeString(session.clientFinalMessage);
+        const io = this._io.start();
+        io.writeInt8(Protocol.FrontendMessageCode.PasswordMessage);
+        io.writeInt32BE(0); // Preserve header
+        io.writeString(session.clientFinalMessage);
         return setLengthAndFlush(io, 1);
     }
     getParseMessage(args) {
         if (args.statement && args.statement.length > 63)
             throw new Error('Query name length must be lower than 63');
         const { paramTypes } = args;
-        const io = this._io
-            .start()
-            .writeInt8(Protocol.FrontendMessageCode.Parse)
-            .writeInt32BE(0) // Preserve header
-            .writeCString(args.statement || '', 'utf8')
-            .writeCString(args.sql, 'utf8')
-            .writeUInt16BE(paramTypes?.length || 0);
+        const io = this._io.start();
+        io.writeInt8(Protocol.FrontendMessageCode.Parse);
+        io.writeInt32BE(0); // Preserve header
+        io.writeCString(args.statement || '', 'utf8');
+        io.writeCString(args.sql, 'utf8');
+        io.writeUInt16BE(paramTypes?.length || 0);
         if (paramTypes) {
             let i;
             const l = paramTypes.length;
@@ -132,19 +127,18 @@ export class Frontend {
             throw new Error('Portal name length must be lower than 63');
         if (args.statement && args.statement.length > 63)
             throw new Error('Query name length must be lower than 63');
-        const io = this._io
-            .start()
-            .writeInt8(Protocol.FrontendMessageCode.Bind)
-            .writeInt32BE(0) // Preserve header
-            .writeCString(args.portal || '', 'utf8')
-            .writeCString(args.statement || '', 'utf8');
+        const io = this._io.start();
+        io.writeInt8(Protocol.FrontendMessageCode.Bind);
+        io.writeInt32BE(0); // Preserve header
+        io.writeCString(args.portal || '', 'utf8');
+        io.writeCString(args.statement || '', 'utf8');
         const { params, paramTypes, queryOptions } = args;
         const columnFormat = queryOptions.columnFormat != null
             ? queryOptions.columnFormat
             : DEFAULT_COLUMN_FORMAT;
         if (params && params.length) {
             io.writeInt16BE(params.length);
-            const formatOffset = io.offset;
+            const formatOffset = io.position;
             const l = params.length;
             let i;
             for (i = 0; i < l; i++) {
@@ -172,7 +166,7 @@ export class Frontend {
                         io.buffer.writeInt16BE(Protocol.DataFormat.binary, formatOffset + i * 2);
                         // Preserve data length
                         io.writeInt32BE(0);
-                        const dataOffset = io.offset;
+                        const dataOffset = io.position;
                         if (dt.elementsOID) {
                             // If data type is array
                             v = Array.isArray(v) ? v : [v];
@@ -181,7 +175,7 @@ export class Frontend {
                         else {
                             dt.encodeBinary(io, v, queryOptions);
                         }
-                        io.buffer.writeInt32BE(io.length - dataOffset, dataOffset - 4); // Update length
+                        io.buffer.writeInt32BE(io.size - dataOffset, dataOffset - 4); // Update length
                     }
                     else if (typeof dt.encodeText === 'function') {
                         v = dt.elementsOID
@@ -195,9 +189,9 @@ export class Frontend {
                     io.buffer.writeInt16BE(Protocol.DataFormat.binary, formatOffset + i * 2);
                     // Preserve data length
                     io.writeInt32BE(0);
-                    const dataOffset = io.offset;
-                    io.writeBuffer(v);
-                    io.buffer.writeInt32BE(io.length - dataOffset, dataOffset - 4); // Update length
+                    const dataOffset = io.position;
+                    io.writeBytes(v);
+                    io.buffer.writeInt32BE(io.size - dataOffset, dataOffset - 4); // Update length
                 }
                 else {
                     io.writeLString('' + v, 'utf8');
@@ -230,12 +224,11 @@ export class Frontend {
                 ? 'Portal'
                 : 'Statement name length must be lower than 63');
         }
-        const io = this._io
-            .start()
-            .writeInt8(Protocol.FrontendMessageCode.Describe)
-            .writeInt32BE(0) // Preserve header
-            .writeUInt8(args.type.charCodeAt(0))
-            .writeCString(args.name || '', 'utf8');
+        const io = this._io.start();
+        io.writeInt8(Protocol.FrontendMessageCode.Describe);
+        io.writeInt32BE(0); // Preserve header
+        io.writeUInt8(args.type.charCodeAt(0));
+        io.writeCString(args.name || '', 'utf8');
         return setLengthAndFlush(io, 1);
     }
     getExecuteMessage(args) {
@@ -243,12 +236,11 @@ export class Frontend {
             (args.fetchCount < 0 || args.fetchCount > 4294967295)) {
             throw new Error('fetchCount can be between 0 and 4294967295');
         }
-        const io = this._io
-            .start()
-            .writeInt8(Protocol.FrontendMessageCode.Execute)
-            .writeInt32BE(0) // Preserve header
-            .writeCString(args.portal || '', 'utf8')
-            .writeUInt32BE(args.fetchCount || 0);
+        const io = this._io.start();
+        io.writeInt8(Protocol.FrontendMessageCode.Execute);
+        io.writeInt32BE(0); // Preserve header
+        io.writeCString(args.portal || '', 'utf8');
+        io.writeUInt32BE(args.fetchCount || 0);
         return setLengthAndFlush(io, 1);
     }
     getCloseMessage(args) {
@@ -257,20 +249,18 @@ export class Frontend {
                 ? 'Portal'
                 : 'Statement name length must be lower than 63');
         }
-        const io = this._io
-            .start()
-            .writeInt8(Protocol.FrontendMessageCode.Close)
-            .writeInt32BE(0) // Preserve header
-            .writeUInt8(args.type.charCodeAt(0))
-            .writeCString(args.name || '', 'utf8');
+        const io = this._io.start();
+        io.writeInt8(Protocol.FrontendMessageCode.Close);
+        io.writeInt32BE(0); // Preserve header
+        io.writeUInt8(args.type.charCodeAt(0));
+        io.writeCString(args.name || '', 'utf8');
         return setLengthAndFlush(io, 1);
     }
     getQueryMessage(sql) {
-        const io = this._io
-            .start()
-            .writeInt8(Protocol.FrontendMessageCode.Query)
-            .writeInt32BE(0) // Preserve header
-            .writeCString(sql || '', 'utf8');
+        const io = this._io.start();
+        io.writeInt8(Protocol.FrontendMessageCode.Query);
+        io.writeInt32BE(0); // Preserve header
+        io.writeCString(sql || '', 'utf8');
         return setLengthAndFlush(io, 1);
     }
     getFunctionCallMessage(args) {
@@ -279,12 +269,11 @@ export class Frontend {
         const fl = formats.length;
         const l = values.length;
         let i;
-        const io = this._io
-            .start()
-            .writeInt8(Protocol.FrontendMessageCode.FunctionCall)
-            .writeInt32BE(0) // Preserve header
-            .writeInt32BE(functionId)
-            .writeInt16BE(fl);
+        const io = this._io.start();
+        io.writeInt8(Protocol.FrontendMessageCode.FunctionCall);
+        io.writeInt32BE(0); // Preserve header
+        io.writeInt32BE(functionId);
+        io.writeInt16BE(fl);
         for (i = 0; i < fl; i++)
             io.writeInt16BE(formats[i]);
         io.writeInt16BE(l);
@@ -293,8 +282,10 @@ export class Frontend {
             v = values[i];
             if (v == null)
                 io.writeInt32BE(-1);
-            else
-                io.writeInt32BE(v.length).writeBuffer(v);
+            else {
+                io.writeInt32BE(v.length);
+                io.writeBytes(v);
+            }
         }
         io.writeInt16BE(resultFormat ?? DataFormat.text);
         return setLengthAndFlush(io, 1);
@@ -315,11 +306,10 @@ export class Frontend {
         return StaticCopyDoneBuffer;
     }
     getCopyFailMessage(message) {
-        const io = this._io
-            .start()
-            .writeInt8(Protocol.FrontendMessageCode.CopyFail)
-            .writeInt32BE(0) // Preserve header
-            .writeCString(message || '', 'utf8');
+        const io = this._io.start();
+        io.writeInt8(Protocol.FrontendMessageCode.CopyFail);
+        io.writeInt32BE(0); // Preserve header
+        io.writeCString(message || '', 'utf8');
         return setLengthAndFlush(io, 1);
     }
     getFlushMessage() {
@@ -333,6 +323,6 @@ export class Frontend {
     }
 }
 function setLengthAndFlush(io, lengthOffset) {
-    io.buffer.writeUInt32BE(io.length - lengthOffset, lengthOffset);
+    io.buffer.writeUInt32BE(io.size - lengthOffset, lengthOffset);
     return io.flush();
 }

package/protocol/pg-socket.d.ts

@@ -22,8 +22,6 @@ export declare class PgSocket extends SafeEventEmitter {
     private _secretKey?;
     private _protocolNegotiation?;
     private _captureQueue;
-    private _pendingWrites;
-    private _flushScheduled;
     private _hosts;
     private _hostIndex;
     private _sessionAttrsChecked;
@@ -235,39 +233,14 @@ export declare class PgSocket extends SafeEventEmitter {
     protected _handleNegotiateProtocolVersion(msg: Protocol.NegotiateProtocolVersionMessage): void;
     protected _handleBackendKeyData(msg: Protocol.BackendKeyDataMessage): void;
     protected _handleCommandComplete(msg: any): Protocol.CommandCompleteMessage;
-    /**
-     * Queues `data` for the socket instead of writing it straight through:
-     * everything handed to _send() during the same synchronous burst (e.g.
-     * many concurrent query() calls fired via Promise.all over one
-     * connection) is flushed together on the next tick, corked, so Node
-     * turns the whole batch into a single underlying writev rather than one
-     * socket write per call. Measured against postgres.js, which coalesces
-     * the same way at the application level (its connection.js write()/
-     * nextWrite() pair, flushing on a 1KB threshold or setImmediate): 50
-     * concurrent prepared executes cost it 3 socket writes where this cost
-     * us 50, and that write path was the single largest non-idle item in a
-     * CPU profile of the scenario.
-     *
-     * nextTick rather than setImmediate, deliberately: it still batches a
-     * whole synchronous burst, but a lone query doesn't have to wait for the
-     * event loop's check phase before its bytes go out - which would trade
-     * away the sequential/single-query scenarios to win the concurrent ones.
-     *
-     * Returns whether the socket could accept the data at all; the write
-     * itself is reported through `cb` (and a socket that dies before the
-     * flush rejects every pending capture via _failPendingCaptures()).
-     */
     protected _send(data: Buffer | Buffer[], cb?: Callback): boolean;
     /**
-     * Writes COPY bytes straight through instead of queueing them for the
-     * next tick like _send() does. Two reasons: during a copy the capture
-     * queue holds exactly one entry (the Query that opened it), so _send()'s
-     * "batch only when more than one request is in flight" test would never
-     * fire and every chunk would be written on its own anyway; and the
-     * caller needs write()'s own return value to know when to stop, which a
-     * deferred write cannot give it.
+     * Same write as _send(), but reporting backpressure instead of
+     * writability: a COPY IN producer needs write()'s own return value to
+     * know when to stop pushing, whereas _send()'s callers only need to know
+     * whether the socket could take the bytes at all. Kept separate rather
+     * than folded into _send() precisely so those two meanings of `false`
+     * cannot be confused at a call site.
      */
     protected _sendCopy(data: Buffer | Buffer[], cb?: Callback): boolean;
-    /** Arrow property, not a method: used as a bare process.nextTick callback. */
-    private _flushPendingWrites;
 }

package/protocol/pg-socket.js

@@ -26,8 +26,6 @@ export class PgSocket extends SafeEventEmitter {
     _secretKey;
     _protocolNegotiation;
     _captureQueue = new DoublyLinked();
-    _pendingWrites = [];
-    _flushScheduled = false;
     _hosts = [];
     _hostIndex = 0;
     _sessionAttrsChecked = false;
@@ -421,9 +419,6 @@ export class PgSocket extends SafeEventEmitter {
         this._processID = undefined;
         this._secretKey = undefined;
         this._saslSession = undefined;
-        // Anything still queued belonged to the connection being reset - it
-        // must never reach a freshly connected socket.
-        this._pendingWrites = [];
     }
     _handleConnect() {
         const socket = this._socket;
@@ -740,65 +735,38 @@ export class PgSocket extends SafeEventEmitter {
             result.rowCount = parseInt(m[2], 10);
         return result;
     }
-    /**
-     * Queues `data` for the socket instead of writing it straight through:
-     * everything handed to _send() during the same synchronous burst (e.g.
-     * many concurrent query() calls fired via Promise.all over one
-     * connection) is flushed together on the next tick, corked, so Node
-     * turns the whole batch into a single underlying writev rather than one
-     * socket write per call. Measured against postgres.js, which coalesces
-     * the same way at the application level (its connection.js write()/
-     * nextWrite() pair, flushing on a 1KB threshold or setImmediate): 50
-     * concurrent prepared executes cost it 3 socket writes where this cost
-     * us 50, and that write path was the single largest non-idle item in a
-     * CPU profile of the scenario.
-     *
-     * nextTick rather than setImmediate, deliberately: it still batches a
-     * whole synchronous burst, but a lone query doesn't have to wait for the
-     * event loop's check phase before its bytes go out - which would trade
-     * away the sequential/single-query scenarios to win the concurrent ones.
-     *
-     * Returns whether the socket could accept the data at all; the write
-     * itself is reported through `cb` (and a socket that dies before the
-     * flush rejects every pending capture via _failPendingCaptures()).
-     */
     _send(data, cb) {
-        if (!this._socket || !this._socket.writable)
+        const socket = this._socket;
+        if (!socket || !socket.writable)
             return false;
-        if (Array.isArray(data)) {
+        if (!Array.isArray(data)) {
+            socket.write(data, cb);
+            return true;
+        }
+        socket.cork();
+        try {
             const l = data.length;
-            for (let i = 0; i < l; i++)
-                this._pendingWrites.push({
-                    data: data[i],
-                    cb: i === l - 1 ? cb : undefined,
-                });
+            let i;
+            for (i = 0; i < l; i++)
+                socket.write(data[i], i === l - 1 ? cb : undefined);
         }
-        else
-            this._pendingWrites.push({ data, cb });
-        if (this._captureQueue.length > 1) {
-            if (!this._flushScheduled) {
-                this._flushScheduled = true;
-                process.nextTick(this._flushPendingWrites);
-            }
+        finally {
+            socket.uncork();
         }
-        else
-            this._flushPendingWrites();
         return true;
     }
     /**
-     * Writes COPY bytes straight through instead of queueing them for the
-     * next tick like _send() does. Two reasons: during a copy the capture
-     * queue holds exactly one entry (the Query that opened it), so _send()'s
-     * "batch only when more than one request is in flight" test would never
-     * fire and every chunk would be written on its own anyway; and the
-     * caller needs write()'s own return value to know when to stop, which a
-     * deferred write cannot give it.
+     * Same write as _send(), but reporting backpressure instead of
+     * writability: a COPY IN producer needs write()'s own return value to
+     * know when to stop pushing, whereas _send()'s callers only need to know
+     * whether the socket could take the bytes at all. Kept separate rather
+     * than folded into _send() precisely so those two meanings of `false`
+     * cannot be confused at a call site.
      */
     _sendCopy(data, cb) {
         const socket = this._socket;
         if (!socket || !socket.writable)
             return false;
-        this._flushPendingWrites();
         if (!Array.isArray(data))
             return socket.write(data, cb);
         socket.cork();
@@ -814,27 +782,4 @@ export class PgSocket extends SafeEventEmitter {
             socket.uncork();
         }
     }
-    /** Arrow property, not a method: used as a bare process.nextTick callback. */
-    _flushPendingWrites = () => {
-        this._flushScheduled = false;
-        const pending = this._pendingWrites;
-        if (!pending.length)
-            return;
-        this._pendingWrites = [];
-        const socket = this._socket;
-        if (!socket || !socket.writable)
-            return;
-        socket.cork();
-        try {
-            const l = pending.length;
-            let i;
-            for (i = 0; i < l; i++) {
-                const { data, cb } = pending[i];
-                socket.write(data, cb);
-            }
-        }
-        finally {
-            socket.uncork();
-        }
-    };
 }

package/protocol/pgoutput.js

@@ -106,7 +106,7 @@ export class PgOutputDecoder {
                 const lsn = readLsn(io);
                 const prefix = io.readCString();
                 const length = io.readUInt32BE();
-                return { kind: 'message', prefix, lsn, content: io.readBuffer(length) };
+                return { kind: 'message', prefix, lsn, content: io.readBytes(length) };
             }
             default:
                 return { kind: 'unknown', code };
@@ -134,7 +134,7 @@ export class PgOutputDecoder {
             }
             else {
                 const length = io.readUInt32BE();
-                out[column.name] = io.readBuffer(length).toString('utf8');
+                out[column.name] = io.readBytes(length).toString('utf8');
             }
         }
         return out;

package/protocol/smart-buffer.d.ts

@@ -1,37 +1,19 @@
-import { BufferReader } from './buffer-reader.js';
+import { FlexyBuffer } from 'flexy-buffer';
 export interface SmartBufferConfig {
     pageSize?: number;
     maxLength?: number;
-    houseKeepInterval?: number;
+    houseKeepMs?: number;
 }
-export declare class SmartBuffer extends BufferReader {
+/**
+ * Adds the PostgreSQL wire format's two string encodings on top of
+ * flexy-buffer's `FlexyBuffer`: a NUL-terminated C string, and a
+ * length-prefixed string where a `null`/`undefined` value is written as a
+ * length of -1 with no bytes following.
+ */
+export declare class SmartBuffer extends FlexyBuffer {
     static DEFAULT_PAGE_SIZE: number;
     static DEFAULT_MAX_SIZE: number;
-    private readonly _houseKeepInterval;
-    private _houseKeepTimer?;
-    private _stMaxPages;
-    private _length;
-    readonly pageSize: number;
-    readonly maxSize: number;
     constructor(cfg?: SmartBufferConfig);
-    get capacity(): number;
-    get length(): number;
-    start(): this;
-    flush(): Buffer;
-    growSize(len: number): this;
-    writeCString(str: string, encoding?: BufferEncoding): this;
-    writeLString(str?: string, encoding?: BufferEncoding): this;
-    writeString(str: string, encoding?: BufferEncoding): this;
-    writeInt8(n: number): this;
-    writeUInt8(n: number): this;
-    writeUInt16BE(n: number): this;
-    writeUInt32BE(n: number): this;
-    writeInt16BE(n: number): this;
-    writeInt32BE(n: number): this;
-    writeBigInt64BE(n: bigint | number): this;
-    writeFloatBE(n: number): this;
-    writeDoubleBE(n: number): this;
-    writeBuffer(buffer: Buffer): this;
-    private ensureSize;
-    private _houseKeep;
+    writeCString(str: string, encoding?: BufferEncoding): number;
+    writeLString(str?: string, encoding?: BufferEncoding): number;
 }