node-firebird 2.3.4 → 2.4.1

package/{poc/node_modules/node-firebird/lib/wire/connection.js → src/wire/connection.ts}

@@ -1,19 +1,30 @@
-const Events = require('events');
-const os = require('os');
-const path = require('path');
-
-const {XdrWriter, BlrWriter, XdrReader, BitSet, BlrReader} = require('./serialize');
-const {doCallback, doError} = require('../callback');
-const srp = require('../srp');
-const crypt = require('../unix-crypt');
-const Const = require('./const');
-const Xsql = require('./xsqlvar');
-const ServiceManager = require('./service');
-const Database = require('./database');
-const Statement = require('./statement');
-const Transaction = require('./transaction');
-const {lookupMessages, noop, parseDate} = require('../utils');
-const Socket = require("./socket");
+import Events from 'events';
+import os from 'os';
+import path from 'path';
+
+import { XdrWriter, BlrWriter, XdrReader, BitSet, BlrReader } from './serialize';
+import { doCallback, doError } from '../callback';
+import * as srp from '../srp';
+import * as crypt from '../unix-crypt';
+import Const from './const';
+import * as Xsql from './xsqlvar';
+import ServiceManager from './service';
+import Database from './database';
+import Statement from './statement';
+import Transaction from './transaction';
+import { lookupMessages, noop, parseDate } from '../utils';
+import Socket from './socket';
+
+function parseValueIfJson(value: any, options: any) {
+    if (options && options.jsonAsObject && typeof value === 'string' && (value.startsWith('{') || value.startsWith('['))) {
+        try {
+            return JSON.parse(value);
+        } catch (e) {
+            // Ignore parse error and keep as string
+        }
+    }
+    return value;
+}
 
 /***************************************
  *
@@ -22,7 +33,47 @@ const Socket = require("./socket");
  ***************************************/
 
 class Connection {
-    constructor(host, port, callback, options, db, svc) {
+    static decodeResponse: typeof decodeResponse;
+    static fetch_blob_async_transaction: typeof fetch_blob_async_transaction;
+    static fetch_blob_async: typeof fetch_blob_async;
+    static parseValueIfJson: typeof parseValueIfJson;
+    static describe: typeof describe;
+
+    db: any;
+    svc: any;
+    options: any;
+    accept: any;
+    error: any;
+    dbhandle: number | undefined;
+    svchandle: number | undefined;
+    clientKeys: srp.KeyPair | undefined;
+    serverKeys: { salt: string; public: bigint; pluginName: string } | undefined;
+
+    _msg: XdrWriter;
+    _blr: BlrWriter;
+    _queue: any[];
+    _pending: string[];
+    _socket: any;
+    _xdr: any;
+    _isOpened: boolean;
+    _isClosed: boolean;
+    _isDetach: boolean;
+    _isUsed: boolean;
+    _pooled: boolean;
+    _lowercase_keys: boolean | undefined;
+    _detachTimeout: any;
+    _detachCallback: any;
+    _detachAuto: any;
+    _retry_connection_id: any;
+    _retry_connection_interval: number;
+    _max_cached_query: number;
+    _cache_query: Record<string, any> | null;
+    _messageFile: string;
+    _authStartTime: number | undefined;
+    _pendingAccept: any;
+    _inlineBlobs: Map<string, Buffer> | undefined;
+
+    constructor(host: string, port: number, callback: any, options: any, db?: any, svc?: any) {
         var self = this;
         this.db = db;
         this.svc = svc
@@ -40,6 +91,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;
@@ -67,55 +119,76 @@ class Connection {
     }
 
 
+    // Reject every request that is still awaiting a server response (e.g. a
+    // transaction.commit() sent right before the server went away) instead of
+    // leaving its callback to hang forever. Requests already in flight cannot
+    // be transparently resumed on a reconnect: a fresh attach() hands out new
+    // transaction/statement handles, so nothing the server sends back could
+    // ever match a callback queued against the old connection.
+    _rejectPending(err) {
+        var queue = this._queue;
+        this._queue = [];
+        this._pending = [];
+
+        for (var i = 0; i < queue.length; i++) {
+            doError(err, queue[i]);
+        }
+    }
+
+
     _bind_events(host, port, callback) {
-    
+
         var self = this;
-    
+
         self._socket.on('close', function() {
-    
+
             if (!self._isOpened || self._isDetach) {
                 return;
             }
-    
+
             self._isOpened = false;
-    
+            self._isClosed = true;
+
+            var lostError = self.error || new Error('Connection to Firebird server was lost.');
+
             if (!self.db) {
+                self._rejectPending(lostError);
                 if (callback)
                     callback(self.error);
                 return;
             }
-    
+
+            self._rejectPending(lostError);
+
             self._retry_connection_id = setTimeout(function() {
                 self._socket.removeAllListeners();
                 self._socket = null;
-    
+
                 var ctx = new Connection(host, port, function(err) {
                     ctx.connect(self.options, function(err) {
-    
+
                         if (err) {
                             self.db.emit('error', err);
                             return;
                         }
-    
+
                         ctx.attach(self.options, function(err) {
-    
+
                             if (err) {
                                 self.db.emit('error', err);
                                 return;
                             }
-    
-                            ctx._queue = ctx._queue.concat(self._queue);
-                            ctx._pending = ctx._pending.concat(self._pending);
+
                             self.db.emit('reconnect');
-    
+
                         }, self.db);
                     });
-    
+
                     Object.assign(self, ctx);
-    
+
                 }, self.options, self.db);
             }, self._retry_connection_interval);
-    
+
         });
     
         self._socket.on('error', function(e) {
@@ -155,6 +228,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 +245,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).
@@ -307,7 +390,7 @@ class Connection {
 
 
     connect(options, callback) {
-        var pluginName = options.manager ? Const.AUTH_PLUGIN_LEGACY : options.pluginName || Const.AUTH_PLUGIN_LIST[0]; // TODO Srp for service
+        var pluginName = options.pluginName || Const.AUTH_PLUGIN_LIST[0];
         var msg = this._msg;
         var blr = this._blr;
     
@@ -347,10 +430,16 @@ class Connection {
         msg.addInt(Const.CONNECT_VERSION3);
         msg.addInt(Const.ARCHITECTURE_GENERIC);
         msg.addString(options.database || options.filename, Const.DEFAULT_ENCODING);
-        msg.addInt(Const.SUPPORTED_PROTOCOL.length);  // Count of Protocol version understood count.
+        var maxProtocols = options.maxNegotiatedProtocols !== undefined ? options.maxNegotiatedProtocols : 10;
+        var protocolsToSend = Const.SUPPORTED_PROTOCOL;
+        if (protocolsToSend.length > maxProtocols) {
+            protocolsToSend = protocolsToSend.slice(-maxProtocols);
+        }
+
+        msg.addInt(protocolsToSend.length);  // Count of Protocol version understood count.
         msg.addBlr(this._blr);
     
-        for (var protocol of Const.SUPPORTED_PROTOCOL) {
+        for (var protocol of protocolsToSend) {
             msg.addInt(protocol[0]); // Version
             msg.addInt(protocol[1]); // Architecture
             msg.addInt(protocol[2]); // Min type
@@ -380,21 +469,59 @@ class Connection {
             // Wire encryption: send op_crypt if SRP session key is available
             if (ret.sessionKey && ret.protocolVersion >= Const.PROTOCOL_VERSION13 &&
                 options.wireCrypt !== Const.WIRE_CRYPT_DISABLE) {
-                var keyBuf = Buffer.from(ret.sessionKey.toString(16).padStart(40, '0'), 'hex');
-                self.sendOpCrypt('Arc4');
-                self._socket.enableEncryption(keyBuf);
+                var padLen = 40;
+                var keyBuf = Buffer.from(ret.sessionKey.toString(16).padStart(padLen, '0'), 'hex');
+
+                var selectedPlugin = 'Arc4';
+                if (ret.keys) {
+                    var serverPlugins = ret.keys.split(',').map(function(s) { return s.trim().toLowerCase(); });
+                    var preferred = ['chacha64', 'chacha', 'arc4'];
+                    for (var i = 0; i < preferred.length; i++) {
+                        if (serverPlugins.indexOf(preferred[i]) !== -1) {
+                            var mapping = {
+                                chacha64: 'ChaCha64',
+                                chacha: 'ChaCha',
+                                arc4: 'Arc4'
+                            };
+                            selectedPlugin = mapping[preferred[i]];
+                            break;
+                        }
+                    }
+                }
+
+                // Send op_crypt BEFORE enabling encryption (op_crypt is sent plaintext)
+                // The server then enables encryption from its side.
+                // After the op_response to op_crypt, both sides are encrypted.
+                self.sendOpCrypt(selectedPlugin);
+
+                if (selectedPlugin === 'Arc4') {
+                    self._socket.enableEncryption(keyBuf, 'Arc4');
+                }
+
                 self._pending.push('crypt');
-                self._queue.push(function(cryptErr) {
+                self._queue.push(function(cryptErr, response) {
                     if (cryptErr) {
                         doError(cryptErr, callback);
                         return;
                     }
+
+                    if (selectedPlugin !== 'Arc4') {
+                        var iv = response && response.buffer;
+                        if (!iv || (selectedPlugin === 'ChaCha64' && iv.length < 8) || (selectedPlugin === 'ChaCha' && iv.length < 12)) {
+                            var errIv = new Error('Invalid or missing IV for ' + selectedPlugin + ' encryption');
+                            doError(errIv, callback);
+                            return;
+                        }
+                        self._socket.enableEncryption(keyBuf, selectedPlugin, iv);
+                    }
+
                     if (callback)
                         callback(undefined, ret);
                 });
                 return;
             }
 
+
             if (callback)
                 callback(undefined, ret);
         }
@@ -406,7 +533,7 @@ class Connection {
     }
 
 
-    attach(options, callback, db) {
+    attach(options: any, callback?: any, db?: any) {
         this._lowercase_keys = options.lowercase_keys || Const.DEFAULT_LOWERCASE_KEYS;
     
         var database = options.database || options.filename;
@@ -460,6 +587,34 @@ class Connection {
         if (options.sessionTimeZone) {
             blr.addString(Const.isc_dpb_session_time_zone, options.sessionTimeZone, Const.DEFAULT_ENCODING);
         }
+
+        if (options.parallelWorkers !== undefined) {
+            blr.addNumeric(Const.isc_dpb_parallel_workers, options.parallelWorkers);
+        }
+
+        if (options.maxInlineBlobSize !== undefined) {
+            blr.addNumeric(Const.isc_dpb_max_inline_blob_size, options.maxInlineBlobSize);
+        }
+
+        // Firebird 6.0 SQL Schema parameters (Protocol 20+).
+        // These DPB tags configure the session's current schema and the
+        // schema search path for unqualified object name resolution.
+        if (this.accept.protocolVersion >= Const.PROTOCOL_VERSION20) {
+            if (options.defaultSchema) {
+                // Sets CURRENT_SCHEMA for the session.  Equivalent to issuing
+                // SET SCHEMA <name> immediately after connecting.
+                blr.addString(Const.isc_dpb_default_schema, options.defaultSchema, Const.DEFAULT_ENCODING);
+            }
+            if (options.searchPath) {
+                // Comma-separated ordered schema name list, like PostgreSQL's
+                // search_path.  Unqualified object references are resolved by
+                // scanning schemas in this order.
+                const sp = Array.isArray(options.searchPath)
+                    ? options.searchPath.join(',')
+                    : String(options.searchPath);
+                blr.addString(Const.isc_dpb_search_path, sp, Const.DEFAULT_ENCODING);
+            }
+        }
     
         msg.addInt(Const.op_attach);
         msg.addInt(0);  // Database Object ID
@@ -494,11 +649,11 @@ class Connection {
 
 
     detach(callback) {
-    
+
         var self = this;
-    
+
         if (self._isClosed)
-            return;
+            return this.throwClosed(callback);
     
         self._isUsed = false;
         self._isDetach = true;
@@ -519,6 +674,10 @@ class Connection {
 
 
     createDatabase(options, callback) {
+        // Mirror attach(): honour the lowercase_keys option so that db.query()
+        // called on a freshly-created database returns the expected column case.
+        this._lowercase_keys = options.lowercase_keys || Const.DEFAULT_LOWERCASE_KEYS;
+
         var database = options.database || options.filename;
         if (database == null || database.length === 0) {
             doError(new Error('No database specified'), callback);
@@ -566,6 +725,27 @@ class Connection {
         if (options.sessionTimeZone) {
             blr.addString(Const.isc_dpb_session_time_zone, options.sessionTimeZone, Const.DEFAULT_ENCODING);
         }
+
+        if (options.parallelWorkers !== undefined) {
+            blr.addNumeric(Const.isc_dpb_parallel_workers, options.parallelWorkers);
+        }
+
+        if (options.maxInlineBlobSize !== undefined) {
+            blr.addNumeric(Const.isc_dpb_max_inline_blob_size, options.maxInlineBlobSize);
+        }
+
+        // Firebird 6.0 SQL Schema parameters (Protocol 20+).
+        if (this.accept.protocolVersion >= Const.PROTOCOL_VERSION20) {
+            if (options.defaultSchema) {
+                blr.addString(Const.isc_dpb_default_schema, options.defaultSchema, Const.DEFAULT_ENCODING);
+            }
+            if (options.searchPath) {
+                const sp = Array.isArray(options.searchPath)
+                    ? options.searchPath.join(',')
+                    : String(options.searchPath);
+                blr.addString(Const.isc_dpb_search_path, sp, Const.DEFAULT_ENCODING);
+            }
+        }
     
         blr.addNumeric(Const.isc_dpb_sql_dialect, 3);
         blr.addNumeric(Const.isc_dpb_force_write, 1);
@@ -743,9 +923,9 @@ class Connection {
 
 
     commitRetaining(transaction, callback) {
-    
+
         if (this._isClosed)
-            throw new Error('Connection is closed.');
+            return this.throwClosed(callback);
     
         // for auto detach
         this._pending.push('commitRetaining');
@@ -829,7 +1009,7 @@ class Connection {
 
     allocateAndPrepareStatement(transaction, query, plan, callback) {
         var self = this;
-        var mainCallback = function(err, ret) {
+        var mainCallback: any = function(err: any, ret: any) {
             if (!err) {
                 mainCallback.response.handle = ret.handle;
                 describe(ret.buffer, mainCallback.response);
@@ -856,7 +1036,11 @@ class Connection {
         msg.addInt(this.dbhandle);
         mainCallback.lazy_count = 1;
     
-        blr.addBytes(Const.DESCRIBE);
+        const describeBytes = this.accept.protocolVersion >= Const.PROTOCOL_VERSION20 ? Const.DESCRIBE_WITH_SCHEMA : Const.DESCRIBE;
+        if (process.env.FIREBIRD_DEBUG) {
+            console.log('[fb-debug] describeBytes:', describeBytes);
+        }
+        blr.addBytes(describeBytes);
         if (plan)
             blr.addByte(Const.isc_info_sql_get_plan);
     
@@ -909,7 +1093,8 @@ class Connection {
             plan = false;
         }
     
-        blr.addBytes(Const.DESCRIBE);
+        const describeBytes = this.accept.protocolVersion >= Const.PROTOCOL_VERSION20 ? Const.DESCRIBE_WITH_SCHEMA : Const.DESCRIBE;
+        blr.addBytes(describeBytes);
     
         if (plan)
             blr.addByte(Const.isc_info_sql_get_plan);
@@ -1050,6 +1235,12 @@ class Connection {
                 value = params[i];
                 meta = input[i];
 
+                if (statement.connection.options && statement.connection.options.jsonAsObject && value !== null && value !== undefined && typeof value === 'object' && !(value instanceof Date) && !(value instanceof Buffer)) {
+                    if (typeof value.pipe !== 'function') {
+                        value = JSON.stringify(value);
+                    }
+                }
+
                 if (value === null || value === undefined) {
                     switch (meta.type) {
                         case Const.SQL_VARYING:
@@ -1110,29 +1301,33 @@ class Connection {
                             break;
 
                         default:
-                            switch (typeof value) {
-                                case 'bigint':
-                                    ret[i] = new Xsql.SQLParamInt128(value);
-                                    break;
-                                case 'number':
-                                    if (value % 1 === 0) {
-                                        if (value >= Const.MIN_INT && value <= Const.MAX_INT)
-                                            ret[i] = new Xsql.SQLParamInt(value);
-                                        else
-                                            ret[i] = new Xsql.SQLParamInt64(value);
-                                    } else
-                                        ret[i] = new Xsql.SQLParamDouble(value);
-                                    break;
-                                case 'string':
-                                    ret[i] = new Xsql.SQLParamString(value);
-                                    break;
-                                case 'boolean':
-                                    ret[i] = new Xsql.SQLParamBool(value);
-                                    break;
-                                default:
-                                    //throw new Error('Unexpected parametter: ' + JSON.stringify(params) + ' - ' + JSON.stringify(input));
-                                    ret[i] = new Xsql.SQLParamString(value.toString());
-                                    break;
+                            if (Buffer.isBuffer(value)) {
+                                ret[i] = new Xsql.SQLParamBuffer(value);
+                            } else {
+                                switch (typeof value) {
+                                    case 'bigint':
+                                        ret[i] = new Xsql.SQLParamInt128(value);
+                                        break;
+                                    case 'number':
+                                        if (value % 1 === 0) {
+                                            if (value >= Const.MIN_INT && value <= Const.MAX_INT)
+                                                ret[i] = new Xsql.SQLParamInt(value);
+                                            else
+                                                ret[i] = new Xsql.SQLParamInt64(value);
+                                        } else
+                                            ret[i] = new Xsql.SQLParamDouble(value);
+                                        break;
+                                    case 'string':
+                                        ret[i] = new Xsql.SQLParamString(value);
+                                        break;
+                                    case 'boolean':
+                                        ret[i] = new Xsql.SQLParamBool(value);
+                                        break;
+                                    default:
+                                        //throw new Error('Unexpected parametter: ' + JSON.stringify(params) + ' - ' + JSON.stringify(input));
+                                        ret[i] = new Xsql.SQLParamString(value.toString());
+                                        break;
+                                }
                             }
                             step(i + 1);
                     }
@@ -1147,10 +1342,39 @@ class Connection {
         if (input.length) {
     
             if (!(params instanceof Array)) {
-                if (params !== undefined)
+                if (params !== undefined && typeof params === 'object' && params !== null) {
+                    var mappedParams = [];
+                    for (var i = 0; i < input.length; i++) {
+                        mappedParams.push(undefined);
+                    }
+                    var matchedCount = 0;
+                    var nameMap = {};
+                    for (var i = 0; i < input.length; i++) {
+                        var name = input[i].alias || input[i].field;
+                        if (name) {
+                            nameMap[name.toUpperCase()] = i;
+                        }
+                    }
+                    for (var key in params) {
+                        if (Object.prototype.hasOwnProperty.call(params, key)) {
+                            var cleanKey = key.startsWith(':') ? key.substring(1) : key;
+                            var index = nameMap[cleanKey.toUpperCase()];
+                            if (index !== undefined) {
+                                mappedParams[index] = params[key];
+                                matchedCount++;
+                            }
+                        }
+                    }
+                    if (matchedCount > 0) {
+                        params = mappedParams;
+                    } else {
+                        params = [params];
+                    }
+                } else if (params !== undefined) {
                     params = [params];
-                else
+                } else {
                     params = [];
+                }
             }
     
             if (params.length !== input.length) {
@@ -1170,7 +1394,7 @@ class Connection {
     }
 
 
-    sendExecute(op, statement, transaction, callback, parameters) {
+    sendExecute(op: number, statement: any, transaction: any, callback: any, parameters?: any[]) {
         var msg = this._msg;
         var blr = this._blr;
         msg.pos = 0;
@@ -1191,7 +1415,7 @@ class Connection {
                 var nullBits = new BitSet();
     
                 for (var i = 0; i < parameters.length; i++) {
-                    nullBits.set(i, (parameters[i].value === null) & 1);
+                    nullBits.set(i, parameters[i].value === null ? 1 : 0);
                 }
     
                 var nullBuffer = nullBits.toBuffer();
@@ -1241,6 +1465,14 @@ class Connection {
             // TODO impl statement timout
             msg.addInt(statement.options?.timeout || 0); // p_sqldata_timeout
         }
+
+        if (this.accept.protocolVersion >= Const.PROTOCOL_VERSION18) {
+            msg.addInt(statement.options?.scrollable ? 1 : 0); // p_sqldata_cursor_flags (1 = CURSOR_TYPE_SCROLLABLE)
+        }
+
+        if (this.accept.protocolVersion >= Const.PROTOCOL_VERSION19) {
+            msg.addInt(statement.options?.maxInlineBlobSize !== undefined ? statement.options.maxInlineBlobSize : (this.options?.maxInlineBlobSize || 0)); // p_sqldata_inline_blob_size
+        }
     
         callback.statement = statement;
         this._queueEvent(callback);
@@ -1274,6 +1506,57 @@ class Connection {
     }
 
 
+    fetchScroll(statement, transaction, direction, offset, count, callback) {
+        if (typeof count === 'function') {
+            callback = count;
+            count = undefined;
+        }
+        if (typeof offset === 'function') {
+            callback = offset;
+            offset = undefined;
+            count = undefined;
+        }
+
+        var msg = this._msg;
+        var blr = this._blr;
+    
+        msg.pos = 0;
+        blr.pos = 0;
+    
+        let dirInt = 0;
+        if (typeof direction === 'number') {
+            dirInt = direction;
+        } else if (typeof direction === 'string') {
+            const dirUpper = direction.toUpperCase();
+            switch (dirUpper) {
+                case 'NEXT':     dirInt = 0; break;
+                case 'PRIOR':    dirInt = 1; break;
+                case 'FIRST':    dirInt = 2; break;
+                case 'LAST':     dirInt = 3; break;
+                case 'ABSOLUTE': dirInt = 4; break;
+                case 'RELATIVE': dirInt = 5; break;
+                default:
+                    throw new Error('Invalid fetch direction: ' + direction);
+            }
+        }
+
+        const offsetVal = offset || 0;
+        const fetchCount = count || 1;
+
+        msg.addInt(Const.op_fetch_scroll);
+        msg.addInt(statement.handle);
+        CalcBlr(blr, statement.output);
+        msg.addBlr(blr);
+        msg.addInt(0); // message number
+        msg.addInt(fetchCount); // fetch count
+        msg.addInt(dirInt); // fetch operation
+        msg.addInt(offsetVal); // fetch position (offset)
+    
+        callback.statement = statement;
+        this._queueEvent(callback);
+    }
+
+
     fetchAll(statement, transaction, callback) {
         const self = this;
         const custom = statement.options || {};
@@ -1287,12 +1570,25 @@ 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;
+                        ret.data[blob.row][blob.column] = parseValueIfJson(blob.value, statement.connection.options);
                     }
 
                     doSynchronousLoop(ret.data, (row, _i, next) => {
@@ -1354,7 +1650,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);
     }
@@ -1386,7 +1682,7 @@ class Connection {
     }
 
 
-    svcattach(options, callback, svc) {
+    svcattach(options: any, callback?: any, svc?: any) {
         this._lowercase_keys = options.lowercase_keys || Const.DEFAULT_LOWERCASE_KEYS;
         var database = options.database || options.filename;
         var user = options.user || Const.DEFAULT_USER;
@@ -1485,9 +1781,11 @@ class Connection {
 
     svcdetach(callback) {
         var self = this;
-    
-        if (self._isClosed)
+
+        if (self._isClosed) {
+            doError(new Error('Connection is closed.'), callback);
             return;
+        }
     
         self._isUsed = false;
         self._isDetach = true;
@@ -1507,7 +1805,13 @@ class Connection {
 
 
 
-    auxConnection(callback) {
+    auxConnection(eventid, callback) {
+        if (typeof eventid === 'function') {
+            // Preserve the older auxConnection(callback) call shape; plain
+            // auxiliary connections historically used event id 0.
+            callback = eventid;
+            eventid = 0;
+        }
         var self = this;
         if (self._isClosed)
             return this.throwClosed(callback);
@@ -1516,10 +1820,10 @@ class Connection {
         msg.addInt(Const.op_connect_request);
         msg.addInt(1); // async
         msg.addInt(self.dbhandle);
-        msg.addInt(0);
+        msg.addInt(eventid);
         if (process.env.FIREBIRD_DEBUG) {
-            console.log('[fb-debug] auxConnection: sending op_connect_request(53) dbhandle=%d queue_before=%d xdr_saved=%s',
-                self.dbhandle, self._queue.length, Boolean(self._xdr));
+            console.log('[fb-debug] auxConnection: sending op_connect_request(53) dbhandle=%d eventid=%d queue_before=%d xdr_saved=%s',
+                self.dbhandle, eventid, self._queue.length, Boolean(self._xdr));
         }
         function cb(err, ret) {
     
@@ -1561,7 +1865,7 @@ class Connection {
         // prepare EPB
         blr.addByte(1) // epb_version
         for (var event in events) {
-            var event_buffer = Buffer.from(event, 'UTF8');
+            var event_buffer = Buffer.from(event, 'utf8');
             blr.addByte(event_buffer.length);
             blr.addBytes(event_buffer);
             blr.addInt32(events[event]);
@@ -1613,10 +1917,30 @@ const opcodeNames = Object.fromEntries(
     Object.entries(Const).filter(([k]) => k.startsWith('op_')).map(([k, v]) => [v, k])
 );
 
-function decodeResponse(data, callback, cnx, lowercase_keys, cb) {
+function decodeResponse(data: any, callback: any, cnx: any, lowercase_keys: any, cb: (err?: any, obj?: any) => void) {
     try {
         do {
             var r = data.r || data.readInt();
+            if (data.r) {
+                data.r = null;
+            }
+            if (r === Const.op_dummy) {
+                continue;
+            }
+            if (r === Const.op_inline_blob) {
+                if (process.env.FIREBIRD_DEBUG) {
+                    console.log('[fb-debug] decodeResponse: opcode=op_inline_blob');
+                }
+                var tran_id = data.readInt();
+                var blob_id = data.readQuad();
+                var blob_data = data.readArray();
+                if (!cnx._inlineBlobs) {
+                    cnx._inlineBlobs = new Map();
+                }
+                const cacheKey = `${blob_id.high}:${blob_id.low}`;
+                cnx._inlineBlobs.set(cacheKey, blob_data);
+                r = Const.op_dummy; // Continue loop to read next opcode
+            }
         } while (r === Const.op_dummy);
 
         if (process.env.FIREBIRD_DEBUG) {
@@ -1718,7 +2042,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) {
@@ -1729,7 +2053,7 @@ function decodeResponse(data, callback, cnx, lowercase_keys, cb) {
                                 }
                             }
 
-                            data.frow[key] = value;
+                            data.frow[key] = parseValueIfJson(value, cnx.options);
                         } catch (e) {
                             // uncomplete packet read
                             data.pos = _xdrpos;
@@ -1783,7 +2107,7 @@ function decodeResponse(data, callback, cnx, lowercase_keys, cb) {
             case Const.op_accept:
             case Const.op_cond_accept:
             case Const.op_accept_data:
-                let accept = {
+                let accept: any = {
                     protocolVersion: data.readInt(),
                     protocolArchitecture: data.readInt(),
                     protocolMinimumType: data.readInt(),
@@ -1805,29 +2129,39 @@ function decodeResponse(data, callback, cnx, lowercase_keys, cb) {
                     accept.pluginName = data.readString(Const.DEFAULT_ENCODING);
                     var is_authenticated = data.readInt();
                     var keys = data.readString(Const.DEFAULT_ENCODING); // keys
+                    accept.keys = keys;
 
                     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) {
                             var crypto = {
                                 Srp: 'sha1',
-                                Srp256: 'sha256'
+                                Srp256: 'sha256',
+                                Srp384: 'sha384',
+                                Srp512: 'sha512'
                             };
                             accept.srpAlgo = crypto[accept.pluginName];
 
-                            // TODO : Fallback Srp256 to Srp ?
-                            /*if (!d.buffer) {
+                            if (!d.buffer) {
+                                cnx._pendingAccept = accept;
                                 cnx.sendOpContAuth(
                                     cnx.clientKeys.public.toString(16),
-                                    DEFAULT_ENCODING,
+                                    Const.DEFAULT_ENCODING,
                                     accept.pluginName
                                 );
-
-                                return cb(new Error('login'));
-                            }*/
+                                return;
+                            }
 
                             // Check buffer contains salt
                             var saltLen = d.buffer.readUInt16LE(0);
@@ -1837,17 +2171,27 @@ function decodeResponse(data, callback, cnx, lowercase_keys, cb) {
 
                             // Check buffer contains key
                             var keyLen = d.buffer.readUInt16LE(saltLen + 2);
-                            var keyStart = saltLen + 4;
-                            if (d.buffer.length - keyStart !== keyLen) {
-                                console.log('key error'); // TODO : Throw error
+                            if (d.buffer.length < saltLen + 4) {
+                                var errBuf = new Error('Invalid buffer size for ' + accept.pluginName + ' login');
+                                doError(errBuf, callback);
+                                return cb(errBuf);
                             }
+                            var keyStart = (saltLen + 2 + 3) & ~3;
 
                             // Server keys
                             cnx.serverKeys = {
                                 salt: d.buffer.slice(2, saltLen + 2).toString('utf8'),
-                                public: BigInt('0x' + d.buffer.slice(keyStart, d.buffer.length).toString('utf8'))
+                                public: BigInt('0x' + d.buffer.slice(keyStart, d.buffer.length).toString('utf8')),
+                                pluginName: accept.pluginName
                             };
 
+                            console.log('--- DEBUG SRP Handshake ---');
+                            console.log('salt:', cnx.serverKeys.salt);
+                            console.log('server public key:', cnx.serverKeys.public.toString(16));
+                            console.log('client public key:', cnx.clientKeys.public.toString(16));
+                            console.log('client private key:', cnx.clientKeys.private.toString(16));
+                            console.log('hashAlgo:', accept.srpAlgo);
+
                             const _t1 = Date.now();
                             var proof = srp.clientProof(
                                 cnx.options.user.toUpperCase(),
@@ -1858,6 +2202,10 @@ function decodeResponse(data, callback, cnx, lowercase_keys, cb) {
                                 cnx.clientKeys.private,
                                 accept.srpAlgo
                             );
+
+                            console.log('client proof M1:', proof.authData.toString(16));
+                            console.log('client session key K:', proof.clientSessionKey.toString(16));
+
                             if (process.env.FIREBIRD_DEBUG) {
                                 console.log('[fb-debug] srp.clientProof(%s): %dms', accept.srpAlgo, Date.now() - _t1);
                             }
@@ -1917,14 +2265,88 @@ function decodeResponse(data, callback, cnx, lowercase_keys, cb) {
 
                 // During SRP mutual authentication, the server sends op_cont_auth
                 // with its proof (M2) after receiving the client's proof (M1).
-                // When we have an active auth exchange for this plugin, just wait
-                // for the subsequent op_accept instead of treating it as an error.
-                if (cnx._pendingAccept && cnx._pendingAccept.pluginName === pluginName) {
-                    if (process.env.FIREBIRD_DEBUG) {
-                        console.log('[fb-debug] auth: server SRP proof (M2) received, waiting for op_accept t=%dms',
-                            cnx._authStartTime ? Date.now() - cnx._authStartTime : -1);
+                // When we have an active auth exchange for this plugin:
+                if (cnx._pendingAccept && (cnx._pendingAccept.pluginName === pluginName || Const.AUTH_PLUGIN_SRP_LIST.indexOf(pluginName) !== -1)) {
+                    if (cnx._pendingAccept.pluginName !== pluginName) {
+                        cnx._pendingAccept.pluginName = pluginName;
+                    }
+                    // The server can switch SRP hash variants mid-handshake: after
+                    // the client answers with e.g. Srp256, some accounts make the
+                    // server come back with a fresh op_cont_auth naming a different
+                    // SRP plugin (e.g. plain Srp/sha1), reusing the same salt/B.
+                    // That must be treated as a brand-new challenge - recomputing
+                    // the proof with the new plugin's hash algorithm - rather than
+                    // as the server's M2 proof, otherwise the client silently waits
+                    // forever for an op_accept the server will never send (#254).
+                    if (!cnx.serverKeys || cnx.serverKeys.pluginName !== pluginName) {
+                        // Check buffer contains salt
+                        var saltLen = d.buffer.readUInt16LE(0);
+                        if (saltLen > 32 * 2) {
+                            console.log('salt to long'); // TODO : Throw error
+                        }
+
+                        // Check buffer contains key
+                        var keyLen = d.buffer.readUInt16LE(saltLen + 2);
+                        if (d.buffer.length < saltLen + 4) {
+                            var errBuf = new Error('Invalid buffer size for ' + pluginName + ' login');
+                            doError(errBuf, callback);
+                            return cb(errBuf);
+                        }
+                        var keyStart = (saltLen + 2 + 3) & ~3;
+
+                        // Server keys
+                        cnx.serverKeys = {
+                            salt: d.buffer.slice(2, saltLen + 2).toString('utf8'),
+                            public: BigInt('0x' + d.buffer.slice(keyStart, d.buffer.length).toString('utf8')),
+                            pluginName: pluginName
+                        };
+
+                        var crypto = {
+                            Srp: 'sha1',
+                            Srp256: 'sha256',
+                            Srp384: 'sha384',
+                            Srp512: 'sha512'
+                        };
+                        var srpAlgo = crypto[pluginName];
+
+                        console.log('--- DEBUG SRP Handshake ---');
+                        console.log('salt:', cnx.serverKeys.salt);
+                        console.log('server public key:', cnx.serverKeys.public.toString(16));
+                        console.log('client public key:', cnx.clientKeys.public.toString(16));
+                        console.log('client private key:', cnx.clientKeys.private.toString(16));
+                        console.log('hashAlgo:', srpAlgo);
+
+                        const _t1 = Date.now();
+                        var proof = srp.clientProof(
+                            cnx.options.user.toUpperCase(),
+                            cnx.options.password,
+                            cnx.serverKeys.salt,
+                            cnx.clientKeys.public,
+                            cnx.serverKeys.public,
+                            cnx.clientKeys.private,
+                            srpAlgo
+                        );
+
+                        if (process.env.FIREBIRD_DEBUG) {
+                            console.log('[fb-debug] srp.clientProof(%s): %dms', srpAlgo, Date.now() - _t1);
+                        }
+
+                        cnx._pendingAccept.authData = proof.authData.toString(16);
+                        cnx._pendingAccept.sessionKey = proof.clientSessionKey;
+
+                        cnx.sendOpContAuth(
+                            cnx._pendingAccept.authData,
+                            Const.DEFAULT_ENCODING,
+                            pluginName
+                        );
+                        return; // wait for server SRP proof (M2) and/or op_accept
+                    } else {
+                        if (process.env.FIREBIRD_DEBUG) {
+                            console.log('[fb-debug] auth: server SRP proof (M2) received, waiting for op_accept t=%dms',
+                                cnx._authStartTime ? Date.now() - cnx._authStartTime : -1);
+                        }
+                        return; // Server SRP proof received - wait for op_accept
                     }
-                    return; // Server SRP proof received - wait for op_accept
                 }
 
                 // Firebird 4/5 (protocols 16/17) chained-auth: after the client sends
@@ -1976,6 +2398,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);
@@ -2055,7 +2478,7 @@ function decodeResponse(data, callback, cnx, lowercase_keys, cb) {
     }
 }
 
-function parseOpResponse(data, response, cb) {
+function parseOpResponse(data: any, response: any, cb?: (err?: any, response?: any) => void) {
     var handle = data.readInt();
 
     if (!response.handle) {
@@ -2072,7 +2495,7 @@ function parseOpResponse(data, response, cb) {
         response.buffer = buf;
     }
 
-    var num, op, item = {};
+    var num: any, op: any, item: any = {};
     while (true) {
         op = data.readInt();
 
@@ -2129,10 +2552,10 @@ function parseOpResponse(data, response, cb) {
     }
 }
 
-function describe(buff, statement) {
+function describe(buff: Buffer, statement: any) {
     var br = new BlrReader(buff);
-    var parameters = null;
-    var type, param;
+    var parameters: any = null;
+    var type: any, param: any;
 
     while (br.pos < br.buffer.length) {
         switch (br.readByteCode()) {
@@ -2215,6 +2638,12 @@ function describe(buff, statement) {
                         case Const.isc_info_sql_relation:
                             param.relation = br.readString(Const.DEFAULT_ENCODING);
                             break;
+                        case Const.isc_info_sql_relation_schema:
+                            // Firebird 6.0 (Protocol 20+): schema that owns the
+                            // source relation.  Empty string means the default
+                            // (PUBLIC) schema or a non-schema-aware server.
+                            param.relationSchema = br.readString(Const.DEFAULT_ENCODING);
+                            break;
                         case Const.isc_info_sql_owner:
                             param.owner = br.readString(Const.DEFAULT_ENCODING);
                             break;
@@ -2233,9 +2662,24 @@ function describe(buff, statement) {
                 }
         }
     }
+
+    function unpackCharSetCollation(params: any[]) {
+        if (!params) return;
+        for (let i = 0; i < params.length; i++) {
+            const p = params[i];
+            if (p && (p.type === Const.SQL_TEXT || p.type === Const.SQL_VARYING)) {
+                if (p.subType !== undefined) {
+                    p.charSetId = p.subType & 0xFF;
+                    p.collationId = p.subType >> 8;
+                }
+            }
+        }
+    }
+    unpackCharSetCollation(statement.input);
+    unpackCharSetCollation(statement.output);
 }
 
-function CalcBlr(blr, xsqlda) {
+function CalcBlr(blr: BlrWriter, xsqlda: any[]) {
     blr.addBytes([Const.blr_version5, Const.blr_begin, Const.blr_message, 0]); // + message number
     blr.addWord(xsqlda.length * 2);
 
@@ -2249,10 +2693,17 @@ function CalcBlr(blr, xsqlda) {
     blr.addByte(Const.blr_eoc);
 }
 
-function fetch_blob_async_transaction(statement, id, column, row) {
+function fetch_blob_async_transaction(statement: any, id: any, column: any, row: any) {
     const infoValue = { row, column, value: '' };
 
     return (transactionArg) => {
+        const cacheKey = `${id.high}:${id.low}`;
+        if (statement.connection._inlineBlobs && statement.connection._inlineBlobs.has(cacheKey)) {
+            const data = statement.connection._inlineBlobs.get(cacheKey);
+            infoValue.value = data ? data.toString(Const.DEFAULT_ENCODING) : '';
+            return Promise.resolve(infoValue);
+        }
+
         const singleTransaction = transactionArg === undefined;
 
         let promiseTransaction;
@@ -2324,11 +2775,11 @@ function fetch_blob_async_transaction(statement, id, column, row) {
     };
 }
 
-function fetch_blob_async(statement, id, name, row) {
+function fetch_blob_async(statement: any, id: any, name: any, row: any) {
     const cbTransaction = (transaction, close, callback) => {
         statement.connection._pending.push('openBlob');
         statement.connection.openBlob(id, transaction, (err, blob) => {
-            let e = new Events.EventEmitter();
+            let e: any = new Events.EventEmitter();
 
             e.pipe = (stream) => {
                 e.on('data', (chunk) => {
@@ -2390,6 +2841,32 @@ function fetch_blob_async(statement, id, name, row) {
     return (transaction, callback) => {
         // callback(error, nameField, eventEmitter, row)
         const singleTransaction = callback === undefined;
+        const actualCallback = singleTransaction ? transaction : callback;
+
+        const cacheKey = `${id.high}:${id.low}`;
+        if (statement.connection._inlineBlobs && statement.connection._inlineBlobs.has(cacheKey)) {
+            const data = statement.connection._inlineBlobs.get(cacheKey);
+            let e: any = new Events.EventEmitter();
+            e.pipe = (stream) => {
+                e.on('data', (chunk) => {
+                    stream.write(chunk);
+                });
+                e.on('end', () => {
+                    stream.end();
+                });
+            };
+
+            actualCallback(null, name, e, row);
+
+            setImmediate(() => {
+                if (data) {
+                    e.emit('data', data);
+                }
+                e.emit('end');
+            });
+            return;
+        }
+
         if (singleTransaction) {
             callback = transaction;
             statement.connection.startTransaction(Const.ISOLATION_READ_UNCOMMITTED, (err, transaction) => {
@@ -2405,7 +2882,7 @@ function fetch_blob_async(statement, id, name, row) {
     };
 }
 
-function doSynchronousLoop(data, processData, done) {
+function doSynchronousLoop(data: any[], processData: (row: any, index: number, next: (err?: any) => void) => void, done: (err?: any) => void) {
     if (!data || !data.length) {
         done();
         return;
@@ -2430,9 +2907,9 @@ function doSynchronousLoop(data, processData, done) {
     loop(0);
 }
 
-function executeStreamRow(custom, row, index, output, next) {
+function executeStreamRow(custom: any, row: any, index: number, output: any, next: (err?: any) => void) {
     let done = false;
-    const finish = (err) => {
+    const finish = (err?: any) => {
         if (done) {
             return;
         }
@@ -2456,7 +2933,7 @@ function executeStreamRow(custom, row, index, output, next) {
     }
 }
 
-function bufferReader(buffer, max, writer, cb, beg, end) {
+function bufferReader(buffer: Buffer, max: number, writer: (b: Buffer, next: () => void) => void, cb: () => void, beg?: number, end?: number) {
 
     if (!beg)
         beg = 0;
@@ -2487,7 +2964,7 @@ function bufferReader(buffer, max, writer, cb, beg, end) {
  * - plain string - encodes as UTF-8
  * - undefined/null/empty - returns empty buffer
  */
-function parseDbCryptConfig(config) {
+function parseDbCryptConfig(config: string | null | undefined): Buffer {
     if (!config) {
         return Buffer.alloc(0);
     }
@@ -2507,4 +2984,9 @@ function parseDbCryptConfig(config) {
     return Buffer.from(config, 'utf8');
 }
 
-module.exports = Connection;
+Connection.decodeResponse = decodeResponse;
+Connection.fetch_blob_async_transaction = fetch_blob_async_transaction;
+Connection.fetch_blob_async = fetch_blob_async;
+Connection.parseValueIfJson = parseValueIfJson;
+Connection.describe = describe;
+export = Connection;