node-firebird 2.3.1 → 2.3.3

package/README.md

@@ -67,11 +67,14 @@ options.role = null; // default
 options.pageSize = 4096; // default when creating database
 options.retryConnectionInterval = 1000; // reconnect interval in case of connection drop
 options.blobAsText = false; // set to true to get blob as text, only affects blob subtype 1
+options.blobChunkSize = 1024; // segment size in bytes used when WRITING blobs (default 1024, max 65535)
+options.blobReadChunkSize = 1024; // buffer size in bytes requested per op_get_segment when READING blobs (default 1024, max 65535)
 options.encoding = 'UTF8'; // default encoding for connection is UTF-8
 options.wireCompression = false; // set to true to enable firebird compression on the wire (works only on FB >= 3 and compression is enabled on server (WireCompression = true in firebird.conf))
 options.wireCrypt = Firebird.WIRE_CRYPT_ENABLE; // default; set to Firebird.WIRE_CRYPT_DISABLE to disable wire encryption (FB >= 3)
 options.pluginName = undefined; // optional, auto-negotiated; can be set to Firebird.AUTH_PLUGIN_SRP256, Firebird.AUTH_PLUGIN_SRP, or Firebird.AUTH_PLUGIN_LEGACY
 options.dbCryptConfig = undefined; // optional; database encryption key for encrypted databases. Use 'base64:<value>' for base64-encoded keys or plain text
+options.connectTimeout = 10000; // optional; timeout in ms for a single pool.get() attach operation (default: no timeout)
 ```
 
 ### Classic
@@ -109,6 +112,60 @@ pool.get(function (err, db) {
 pool.destroy();
 ```
 
+#### Advanced Pooling Features
+
+The pool implementation includes several safeguards for reliability:
+
+1.  **Connection Timeout**: Use `options.connectTimeout` to prevent the pool from hanging if a server accepts the TCP connection but fails to respond to the Firebird wire protocol (e.g., during high load or authentication stalls).
+2.  **Pool Destruction**: Calling `pool.destroy()` now immediately drains the `pending` queue, notifying all waiting callers with an error. It also prevents any further `pool.get()` calls.
+3.  **Slot Recovery**: If a connection attempt times out, the pool slot is correctly freed so subsequent requests can be served. Late-arriving connections are automatically discarded to prevent resource leaks.
+
+#### Pool Lifecycle State Diagram
+
+```mermaid
+stateDiagram-v2
+    [*] --> Active
+    Active --> Destroying: pool.destroy()
+    Destroying --> Destroyed: all connections detached
+    Destroyed --> [*]
+
+    state Active {
+        [*] --> Idle
+        Idle --> Creating: pool.get() [no idle db]
+        Creating --> InUse: attach() success
+        Creating --> Idle: attach() failure/timeout
+        Idle --> InUse: pool.get() [idle db exists]
+        InUse --> Idle: db.detach()
+    }
+
+    state Destroying {
+        [*] --> DrainingPending
+        DrainingPending --> DetachingIdle
+        DetachingIdle --> WaitingForInUse
+        WaitingForInUse --> [*]
+    }
+```
+
+#### Connect Timeout Sequence
+
+```mermaid
+sequenceDiagram
+    participant User
+    participant Pool
+    participant Firebird
+    User->>Pool: pool.get()
+    Pool->>Pool: increment _creating
+    Pool->>Pool: start timer (connectTimeout)
+    Pool->>Firebird: attach(options)
+    Note over Firebird: Server accepts TCP but hangs
+    Pool-->>Pool: timer expires
+    Pool->>Pool: decrement _creating
+    Pool-->>User: callback(Error: Connection timeout)
+    Note over Firebird: Server eventually responds
+    Firebird-->>Pool: attach callback(db)
+    Pool->>Firebird: db.detach() (discard late connection)
+```
+
 ## Database object (db)
 
 ### Database Methods
@@ -317,6 +374,34 @@ Firebird.attach(options, (err, db) => {
 });
 ```
 
+### Optimizing BLOB Read/Write Chunk Sizes
+
+When working with large blobs (especially over remote or high-latency connections), you can configure the chunk/segment sizes to minimize the number of network round-trips:
+
+*   **blobChunkSize**: The segment size in bytes used when writing blobs (default: `1024`, maximum: `65535`).
+*   **blobReadChunkSize**: The buffer size in bytes requested per segment read operation when reading blobs (default: `1024`, maximum: `65535`).
+
+For example, setting `blobReadChunkSize: 65535` requests 64KB segments at a time, resulting in up to 64x fewer network packets/round-trips when reading large blobs.
+
+```js
+var options = {
+    host: '127.0.0.1',
+    port: 3050,
+    database: 'database.fdb',
+    user: 'SYSDBA',
+    password: 'masterkey',
+    blobChunkSize: 65535,      // Minimize write round-trips
+    blobReadChunkSize: 65535   // Minimize read round-trips
+};
+
+Firebird.attach(options, function (err, db) {
+  if (err) throw err;
+
+  // Insert/Read operations will use the configured 64KB chunk sizes
+  db.detach();
+});
+```
+
 ### Streaming a big data
 
 ```js
@@ -642,15 +727,47 @@ fb.attach(_connection, function (err, svc) {
 });
 ```
 
-### Charset for database connection is always UTF-8
+### Character Set & Encoding Support
+
+Node-Firebird defaults to `UTF-8` for database connections, but fully supports custom client character sets. You can set the connection encoding by specifying `options.encoding` (e.g. `'UTF8'`, `'WIN1252'`, `'ISO8859_1'`, `'LATIN1'`, `'ASCII'`, or `'NONE'`).
+
+Commonly used Firebird character sets are automatically mapped to their corresponding Node.js Buffer encodings:
+
+| Firebird Character Set | Node.js Buffer Encoding | Description / Notes |
+| ---------------------- | ----------------------- | ------------------- |
+| `UTF8`, `UNICODE_FSS`  | `utf8`                  | Unicode. Handles character-level truncation automatically based on charset width. |
+| `WIN1252`, `ISO8859_1`, `LATIN1` | `latin1`      | 8-bit European encodings. Safely decodes special accented characters. |
+| `ASCII`                | `ascii`                 | 7-bit ASCII. |
+| `NONE`                 | `latin1`                | Raw/unspecified character set. Treated as binary-safe 8-bit characters. |
 
-Node Firebird uses UTF-8 as the default charset. If you want a different one, such as Latin1, you will need to go into the library and modify the default_encoding in the index.js file
+Accented characters and fixed-length `CHAR(N)` column whitespace/truncation are handled automatically matching the connection character set width definitions.
 
+#### Custom Charset Connection Example
 ```js
-const default_encoding = 'latin1';
-```
+var options = {
+    host: '127.0.0.1',
+    port: 3050,
+    database: 'win1252_db.fdb',
+    user: 'SYSDBA',
+    password: 'masterkey',
+    encoding: 'WIN1252' // Automatically maps to 'latin1' under the hood
+};
+
+Firebird.attach(options, function (err, db) {
+    if (err) throw err;
 
-This is why you should use **Firebird 2.5** server at least.
+    // Writes 'Ç Ã É Ú Ñ' correctly using Windows-1252 encoding
+    db.query('INSERT INTO ACCENTED_TEST (ID, NAME) VALUES (?, ?)', [1, 'Ç Ã É Ú Ñ'], function (err) {
+        if (err) throw err;
+
+        db.query('SELECT NAME FROM ACCENTED_TEST WHERE ID = 1', function (err, rows) {
+            if (err) throw err;
+            console.log(rows[0].name); // 'Ç Ã É Ú Ñ' (perfectly decoded)
+            db.detach();
+        });
+    });
+});
+```
 
 ### Firebird 3.0+ Support
 
@@ -704,17 +821,18 @@ Firebird.attach({
 - Empty or undefined values send an empty response to the callback
 - This feature requires Firebird 3.0.1+ (protocol 14/15) for encrypted databases
 
-### Firebird 4.0 and 5.0
+### Firebird 4.0 and 5.0 Support
 
-Firebird 4 wire protocol (versions 16 and 17) is now supported with the following features:
+Firebird 4.0+ wire protocol (versions 16 and 17) is fully supported, including:
 
-- **Protocol versions 16 and 17** — Full support for Firebird 4.0+ wire protocol
-- **DECFLOAT data types** — Support for DECFLOAT(16) and DECFLOAT(34) using IEEE 754 Decimal64 and Decimal128 formats
-- **INT128 data type** — Native support for 128-bit integers
-- **Extended metadata identifiers** — Support for identifiers up to 63 characters
-- **Backward compatibility** — Automatically negotiates the best protocol version with the server
+- **Protocol versions 16 and 17** — Full support for Firebird 4.0+ and 5.0+ wire protocols (automatic fallback/negotiation).
+- **DECFLOAT data types** — Production-ready support for `DECFLOAT(16)` (Decimal64, 8 bytes) and `DECFLOAT(34)` (Decimal128, 16 bytes) complying with the full IEEE 754-2008 standard using BID (Binary Integer Decimal) encoding. Supports special values such as `NaN`, `+Infinity`, `-Infinity`, `+0`, and `-0`.
+- **INT128 data type** — Native support for 128-bit integers using Node.js `BigInt`.
+- **Statement Timeout** — Support for query and statement-level execution timeouts (Protocol 16+).
+- **Time Zone Support** — Native support for `TIME WITH TIME ZONE` and `TIMESTAMP WITH TIME ZONE` (represented as JavaScript `Date` objects).
+- **Extended metadata identifiers** — Support for identifiers up to 63 characters.
 
-The driver will automatically negotiate the best protocol version supported by both the client and server. No configuration changes are required for Firebird 4.0 servers.
+No configuration changes are required for Firebird 4.0 or 5.0 servers. The driver will automatically negotiate the best protocol version supported by both the client and server.
 
 ```js
 Firebird.attach({
@@ -728,27 +846,12 @@ Firebird.attach({
   
   // DECFLOAT and INT128 types are automatically supported
   db.query('SELECT CAST(123.456 AS DECFLOAT(16)) AS df16, CAST(9876543210 AS INT128) AS i128 FROM RDB$DATABASE', function(err, result) {
-    console.log(result); // { df16: 123.456, i128: '9876543210' }
+    console.log(result); // { df16: 123.456, i128: 9876543210n }
     db.detach();
   });
 });
 ```
 
-**Important Notes:**
-
-1. **Statement Timeouts:** Statement timeouts (a Protocol 16 feature) are not yet implemented. This will be added in a future release.
-
-2. **DECFLOAT Encoding:** The current DECFLOAT implementation uses a simplified encoding/decoding mechanism and does NOT implement proper IEEE 754 Decimal64/Decimal128 formats. For production use with DECFLOAT types requiring full precision and standards compliance, consider:
-   - Using a proper IEEE 754 Decimal library (e.g., `decimal128` npm package)
-   - Contributing a full IEEE 754 implementation to this driver
-   - Working with DECFLOAT values as strings or Buffers to preserve exact precision
-
-For legacy Firebird 4 servers with SRP authentication only, use the following configuration in `firebird.conf`:
-Firebird 4 wire protocol (versions 16 and 17) is partially supported, including:
-- **Time Zone Support**: Native support for `TIME WITH TIME ZONE` and `TIMESTAMP WITH TIME ZONE` (Protocol 16+).
-- **INT128 support**: Native support for 128-bit integers.
-- **Statement Timeout**: Support for statement-level timeouts.
-
 #### Using Timezones (FB 4.0+)
 
 Columns of type `TIMESTAMP WITH TIME ZONE` and `TIME WITH TIME ZONE` are automatically mapped to JavaScript `Date` objects. Values are read as UTC and represented in the local timezone of the Node.js process.
@@ -765,8 +868,7 @@ db.query('INSERT INTO FB4_TABLE (TS_TZ_COL) VALUES (?)', [new Date()], function(
 });
 ```
 
-Srp256 authentication and wire encryption are now supported natively,
-so you only need the following minimal configuration in `firebird.conf`:
+For legacy Firebird 4 servers with SRP authentication only, use the following configuration in `firebird.conf`:
 
 ```bash
 AuthServer = Srp256, Srp
@@ -781,6 +883,91 @@ For more details see:
 - [Firebird 5 migration guide — authorization](https://ib-aid.com/download/docs/fb5migrationguide.html#_authorization_from_firebird_2_5_client_libraries)
 
 
+## Extensive Examples
+
+### Firebird 4.0+ DECFLOAT & INT128 Usage
+```js
+Firebird.attach({
+  host: '127.0.0.1',
+  database: '/path/to/fb4.fdb',
+  user: 'SYSDBA',
+  password: 'masterkey',
+}, function(err, db) {
+  if (err) throw err;
+
+  // Insert DECFLOAT and INT128 types
+  db.query(
+    'INSERT INTO INVENTORY (ID, PRICE, SERIAL_NUMBER) VALUES (?, ?, ?)',
+    [1n, '12.34567890123456', 987654321098765432109876543210n],
+    function(err) {
+      if (err) throw err;
+
+      // Select them back
+      db.query('SELECT PRICE, SERIAL_NUMBER FROM INVENTORY WHERE ID = 1', function(err, result) {
+        if (err) throw err;
+        console.log(typeof result[0].price);          // 'string' (e.g. '12.34567890123456')
+        console.log(typeof result[0].serial_number);   // 'bigint' (e.g. 987654321098765432109876543210n)
+        db.detach();
+      });
+    }
+  );
+});
+```
+
+### Statement Timeouts (Firebird 4.0+)
+Setting a statement timeout allows the client to automatically abort queries that take too long on the server.
+```js
+Firebird.attach(options, function(err, db) {
+  if (err) throw err;
+
+  // Specify a statement-level execution timeout of 1000ms
+  db.query(
+    'SELECT * FROM MY_LARGE_TABLE',
+    [],
+    function(err, result) {
+      if (err) {
+        if (err.message.includes('timeout')) {
+          console.error('Query timed out!');
+        } else {
+          console.error('Error:', err);
+        }
+      }
+      db.detach();
+    },
+    { timeout: 1000 } // timeout option passed to query/execute
+  );
+});
+```
+
+### Advanced Connection Pooling & Life-cycle
+```js
+var pool = Firebird.pool(10, {
+    host: '127.0.0.1',
+    database: 'db.fdb',
+    user: 'SYSDBA',
+    password: 'masterkey',
+    connectTimeout: 5000 // 5 seconds connect timeout for pool.get()
+});
+
+// Retrieve a connection
+pool.get(function(err, db) {
+    if (err) {
+        console.error('Could not get connection from pool:', err);
+        return;
+    }
+
+    db.query('SELECT * FROM TABLE', function(err, result) {
+        // Return connection back to the pool
+        db.detach();
+    });
+});
+
+// Close all pool connections and reject pending requests
+process.on('SIGTERM', function() {
+    pool.destroy();
+});
+```
+
 ## Contributors
 
 - Henri Gourvest, <https://github.com/hgourvest>

package/lib/index.d.ts

@@ -114,10 +114,32 @@ declare module 'node-firebird' {
         retryConnectionInterval?: number;
         encoding?: SupportedCharacterSet;
         blobAsText?: boolean; // only affects for blob subtype 1
+        /**
+         * Segment size in bytes used when WRITING blobs (op_batch_segments).
+         * Default 1024, max 65535. Use 65535 to minimize round-trips on
+         * remote/high-latency connections.
+         */
+        blobChunkSize?: number;
+        /**
+         * Buffer size in bytes requested per op_get_segment when READING
+         * blobs. Default 1024, max 65535. Use 65535 to minimize round-trips
+         * on remote/high-latency connections (~64x fewer round-trips).
+         */
+        blobReadChunkSize?: number;
         wireCrypt?: number; // WIRE_CRYPT_DISABLE or WIRE_CRYPT_ENABLE
         wireCompression?: boolean;
         pluginName?: string;
         dbCryptConfig?: string; // Database encryption key callback config (base64: prefix for base64, or plain string)
+        /**
+         * Timeout in milliseconds for a single pool.get() attach operation.
+         * If attach() does not complete within this time the slot is freed,
+         * the caller receives an error, and any late-arriving connection is
+         * safely discarded. Set to 0 or omit to disable (default: no timeout).
+         *
+         * Recommended value: 5000–10000 ms depending on network latency and
+         * expected Firebird server response time under load.
+         */
+        connectTimeout?: number;
     }
 
     export interface SvcMgrOptions extends Options {

package/lib/pool.js

@@ -6,17 +6,23 @@
 
 class Pool {
     constructor(attach, max, options) {
-        this.attach = attach;
-        this.internaldb = []; // connection created by the pool (for destroy)
-        this.pooldb = []; // available connection in the pool
-        this.dbinuse = 0; // connection currently in use into the pool
-        this._creating = 0; // connections currently being created
-        this.max = max || 4;
-        this.pending = [];
-        this.options = options;
+        this.attach    = attach;
+        this.internaldb = []; // connections created by the pool (for destroy)
+        this.pooldb    = []; // connections available in the pool (idle)
+        this.dbinuse   = 0;  // connections currently handed out to callers
+        this._creating = 0;  // connections currently being created (attach in flight)
+        this.max       = max || 4;
+        this.pending   = []; // callbacks waiting for a free slot
+        this.options   = options;
+        this._destroyed = false; // true after destroy() — prevents further use
     }
 
     get(callback) {
+        // [Fix 2] Reject immediately if the pool has already been destroyed.
+        if (this._destroyed) {
+            callback(new Error('Pool has been destroyed'), null);
+            return this;
+        }
         var self = this;
         self.pending.push(callback);
         self.check();
@@ -25,6 +31,10 @@ class Pool {
 
     check() {
         var self = this;
+
+        // [Fix 2] Do not serve requests on a destroyed pool.
+        if (self._destroyed) return self;
+
         if ((self.dbinuse + self._creating) >= self.max)
             return self;
 
@@ -32,12 +42,74 @@ class Pool {
         if (!cb)
             return self;
         if (self.pooldb.length) {
+            var db = self.pooldb.shift();
+            // Discard connections that have been closed or destroyed while idle
+            if (db.connection && (db.connection._isClosed || db.connection._isDetach || !db.connection._socket || db.connection._socket.destroyed)) {
+                var idx = self.internaldb.indexOf(db);
+                if (idx !== -1) self.internaldb.splice(idx, 1);
+                self.pending.unshift(cb);
+                setImmediate(function () { self.check(); });
+                return self;
+            }
+            // Idle connection available — hand it out immediately.
             self.dbinuse++;
-            cb(null, self.pooldb.shift());
+            cb(null, db);
         } else {
+            // No idle connection — create a new one via attach().
             self._creating++;
+
+            var timedOut = false;
+            var timer    = null;
+
+            // [Fix 1] Optional per-attach timeout.
+            // If attach() does not call back within connectTimeout ms (e.g. because
+            // the server accepted TCP but stalled on the Firebird wire protocol), we
+            // free the slot and notify the caller. Any connection that arrives late
+            // is discarded in the attach() callback below.
+            if (self.options.connectTimeout > 0) {
+                timer = setTimeout(function () {
+                    timedOut = true;
+                    self._creating--;
+                    cb(new Error(
+                        'Connection timeout after ' + self.options.connectTimeout + 'ms'
+                    ), null);
+                    // Free the slot so the next pending request can be served.
+                    setImmediate(function () { self.check(); });
+                }, self.options.connectTimeout);
+            }
+
             this.attach(self.options, function (err, db) {
+
+                // [Fix 1] Timeout already fired — discard this late connection.
+                // Without this guard the socket would stay open until the OS-level
+                // TCP timeout (potentially minutes), leaking a file descriptor.
+                if (timedOut) {
+                    if (db) {
+                        try {
+                            // _pooled = false forces a real op_detach / socket close
+                            // instead of a silent pool-return emit.
+                            if (db.connection) db.connection._pooled = false;
+                            db.detach();
+                        } catch (e) { /* ignore cleanup errors */ }
+                    }
+                    return;
+                }
+
+                if (timer) clearTimeout(timer);
                 self._creating--;
+
+                // [Fix 3] Pool was destroyed while attach() was in flight.
+                if (self._destroyed) {
+                    if (db) {
+                        try {
+                            if (db.connection) db.connection._pooled = false;
+                            db.detach();
+                        } catch (e) { /* ignore cleanup errors */ }
+                    }
+                    cb(new Error('Pool has been destroyed'), null);
+                    return;
+                }
+
                 if (!err) {
                     self.dbinuse++;
                     self.internaldb.push(db);
@@ -45,7 +117,7 @@ class Pool {
                         // also in pool (could be a twice call to detach)
                         if (self.pooldb.indexOf(db) !== -1 || self.internaldb.indexOf(db) === -1)
                             return;
-                        // if not usable don't put in again in the pool and remove reference on it
+                        // if not usable don't put it back in the pool
                         if (db.connection._isClosed || db.connection._isDetach || db.connection._pooled === false)
                             self.internaldb.splice(self.internaldb.indexOf(db), 1);
                         else
@@ -68,6 +140,16 @@ class Pool {
 
     destroy(callback) {
         var self = this;
+        self._destroyed = true;
+
+        // [Fix 4] Drain pending callbacks so callers are not left hanging.
+        // This is critical when destroy() is called as a recovery measure after
+        // a timeout: without draining, every concurrent pool.get() that had not
+        // yet received a slot would hang until the process exits.
+        var draining = self.pending.splice(0);
+        draining.forEach(function (cb) {
+            try { cb(new Error('Pool is being destroyed'), null); } catch (e) { /* ignore */ }
+        });
 
         var connectionCount = this.internaldb.length;
 
@@ -100,6 +182,11 @@ class Pool {
                 self.pooldb.splice(_db_in_pool, 1);
                 db.connection._pooled = false;
                 db.detach(detachCallback);
+            } else {
+                // [Fix 5] Connection is currently in use (dbinuse > 0).
+                // The caller is responsible for releasing it via detach().
+                // Count it down here so the destroy() callback is not blocked forever.
+                detachCallback();
             }
         });
     }

package/lib/srp.js

@@ -24,7 +24,11 @@ const PRIME = {
  * @param a BigInt Client private key.
  * @returns {{private: BigInt, public: BigInt}}
  */
-exports.clientSeed = function(a = toBigInt(crypto.randomBytes(SRP_KEY_SIZE))) {
+exports.clientSeed = function(a = toBigInt(crypto.randomBytes(SRP_KEY_SIZE)) % PRIME.N) {
+    // a must be in [0, N): clientSession() reduces the exponent (a + ux) mod N
+    // to match the Firebird engine, but A = g^a is computed from the raw a.
+    // When random a >= N (~10% of 1024-bit values), the proof diverges from
+    // the server's session key, causing sporadic auth failures.
     var A = modPow(PRIME.g, a, PRIME.N);
 
     dump('a', a);
@@ -127,6 +131,13 @@ function hexPad(hex) {
 }
 exports.hexPad = hexPad;
 
+/**
+ * The SRP prime modulus N (1024-bit, same value used by Firebird).
+ * Exported so tests and tooling can assert key-size invariants without
+ * duplicating the constant.
+ */
+exports.PRIME_N = PRIME.N;
+
 /**
  * Pad key with SRP_KEY_SIZE.
  *

package/lib/wire/connection.js

@@ -40,6 +40,7 @@ class Connection {
         this._isUsed = false;
         this._pooled = options.isPool||false;
         if (options && options.blobChunkSize > 65535) options.blobChunkSize = 65535;
+        if (options && options.blobReadChunkSize > 65535) options.blobReadChunkSize = 65535;
         this.options = options;
         this._bind_events(host, port, callback);
         this.error;
@@ -155,6 +156,7 @@ class Connection {
     
             while (xdr.pos < xdr.buffer.length) {
                 var cb = self._queue[0], pos = xdr.pos;
+                var lazySnapshot = cb ? cb.lazy_count : undefined;
     
                 decodeResponse(xdr, cb, self, self._lowercase_keys, function (err, obj) {
     
@@ -171,8 +173,17 @@ class Connection {
                                     xdr.buffer.length, pos, self._queue.length);
                             }
 
-                            if (self.accept && self.accept.protocolMinimumType === Const.ptype_lazy_send && self._queue.length > 0) {
-                                self._queue[0].lazy_count = 2;
+                            // Restore lazy_count to its value before this (failed)
+                            // decode attempt. Forcing lazy_count = 2 here made the
+                            // decoder expect a second op_response that never arrives
+                            // whenever a single large response (e.g. op_get_segment
+                            // with a big buffer) spans multiple TCP packets.
+                            if (cb) {
+                                if (lazySnapshot === undefined) {
+                                    delete cb.lazy_count;
+                                } else {
+                                    cb.lazy_count = lazySnapshot;
+                                }
                             }
                         } else {
                             // Any other error (truly unknown opcode not handled above).
@@ -1287,9 +1298,22 @@ class Connection {
             }
 
             if (ret && ret.data && ret.data.length) {
-                const arrPromise = (ret.arrBlob || []).map((value) => value(transaction));
+                // Read blobs sequentially instead of in parallel to avoid
+                // exceeding Firebird's per-connection open-blob-handle limit,
+                // which causes a server-side deadlock when many rows contain
+                // BLOBs and blobAsText is true. See issue #387.
+                const arrBlobFns = ret.arrBlob || [];
+                const readBlobsSequentially = (index, results) => {
+                    if (index >= arrBlobFns.length) {
+                        return Promise.resolve(results);
+                    }
+                    return arrBlobFns[index](transaction).then((v) => {
+                        results.push(v);
+                        return readBlobsSequentially(index + 1, results);
+                    });
+                };
 
-                Promise.all(arrPromise).then((arrBlob) => {
+                readBlobsSequentially(0, []).then((arrBlob) => {
                     for (let i = 0; i < arrBlob.length; i++) {
                         const blob = arrBlob[i];
                         ret.data[blob.row][blob.column] = blob.value;
@@ -1354,7 +1378,7 @@ class Connection {
         msg.pos = 0;
         msg.addInt(Const.op_get_segment);
         msg.addInt(blob.handle);
-        msg.addInt(1024); // buffer length
+        msg.addInt(this.options.blobReadChunkSize || 1024); // buffer length (max 65535)
         msg.addInt(0); // ???
         this._queueEvent(callback);
     }
@@ -1718,7 +1742,7 @@ function decodeResponse(data, callback, cnx, lowercase_keys, cb) {
                             _xdrpos = data.pos;
                             const key = custom.asObject ? data.fcols[data.fcolumn] : data.fcolumn;
                             const row = data.frows.length;
-                            let value = item.decode(data, lowerV13);
+                            let value = item.decode(data, lowerV13, cnx.options);
 
                             if (item.type === Const.SQL_BLOB && value !== null) {
                                 if (item.subType === Const.isc_blob_text && cnx.options.blobAsText) {
@@ -1808,7 +1832,15 @@ function decodeResponse(data, callback, cnx, lowercase_keys, cb) {
 
                     if (is_authenticated === 0) {
                         if (cnx.options.pluginName && cnx.options.pluginName !== accept.pluginName) {
-                            doError(new Error('Server don\'t accept plugin : ' + cnx.options.pluginName + ', but support : ' + accept.pluginName), callback);
+                            var errPlugin = new Error('Server don\'t accept plugin : ' + cnx.options.pluginName + ', but support : ' + accept.pluginName);
+                            doError(errPlugin, callback);
+                            return cb(errPlugin);
+                        }
+
+                        if (Const.AUTH_PLUGIN_SRP_LIST.indexOf(accept.pluginName) !== -1 && !cnx.clientKeys) {
+                            var errPlugin = new Error('Server accepted plugin : ' + accept.pluginName + ', but client did not initialize SRP keys');
+                            doError(errPlugin, callback);
+                            return cb(errPlugin);
                         }
 
                         if (Const.AUTH_PLUGIN_SRP_LIST.indexOf(accept.pluginName) !== -1) {
@@ -1976,6 +2008,7 @@ function decodeResponse(data, callback, cnx, lowercase_keys, cb) {
                 // Database encryption key callback
                 // Read server data (plugin data sent by server)
                 var serverPluginData = data.readArray();
+                data.readInt(); // p_cc_reply
                 
                 // Get client response from dbCryptConfig option
                 var clientPluginData = parseDbCryptConfig(cnx.options.dbCryptConfig);

package/lib/wire/socket.js

@@ -55,6 +55,7 @@ class Socket {
     constructor(port, host) {
         this._socket = net.createConnection(port, host);
         this._socket.setNoDelay(true);
+        this._socket.setKeepAlive(true, 60000); // 1 minute delay to detect dead/stale connections
         this.compressor = null;
         this.compressorBuffer = [];
         this.decompressor = null;
@@ -99,7 +100,14 @@ class Socket {
      */
     write(data, defer = false) {
         if (defer) {
-            this.buffer = Buffer.from(data);
+            // Accumulate deferred packets instead of overwriting.  Multiple
+            // deferred ops (e.g. op_close_blob followed immediately by
+            // op_free_statement) must all be kept until the next flush;
+            // overwriting the buffer silently drops packets and desynchronises
+            // the request/response queue, causing the connection to hang.
+            this.buffer = this.buffer
+                ? Buffer.concat([this.buffer, Buffer.from(data)])
+                : Buffer.from(data);
             return;
         }
 
@@ -167,6 +175,10 @@ class Socket {
             return this[field].bind(this);
         }
 
+        if (typeof target[field] === 'function') {
+            return target[field].bind(target);
+        }
+
         return target[field];
     }
 }