node-firebird 1.1.10 → 2.0.1

package/lib/index.d.ts

@@ -7,7 +7,7 @@ declare module 'node-firebird' {
     type TransactionCallback = (err: any, transaction: Transaction) => void;
     type QueryCallback = (err: any, result: any[]) => void;
     type SimpleCallback = (err: any) => void;
-    type SequentialCallback = (row: any, index: number) => void;
+    type SequentialCallback = (row: any, index: number, next?: (err?: any) => void) => void | Promise<void>;
 
     export const AUTH_PLUGIN_LEGACY: string;
     export const AUTH_PLUGIN_SRP: string;
@@ -110,6 +110,10 @@ declare module 'node-firebird' {
         retryConnectionInterval?: number;
         encoding?: SupportedCharacterSet;
         blobAsText?: boolean; // only affects for blob subtype 1
+        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)
     }
 
     export interface SvcMgrOptions extends Options {

package/lib/index.js

@@ -12,7 +12,7 @@ if (typeof(setImmediate) === 'undefined') {
 
 exports.AUTH_PLUGIN_LEGACY = Const.AUTH_PLUGIN_LEGACY;
 exports.AUTH_PLUGIN_SRP = Const.AUTH_PLUGIN_SRP;
-// exports.AUTH_PLUGIN_SRP256 = Const.AUTH_PLUGIN_SRP256;
+exports.AUTH_PLUGIN_SRP256 = Const.AUTH_PLUGIN_SRP256;
 
 exports.WIRE_CRYPT_DISABLE = Const.WIRE_CRYPT_DISABLE;
 exports.WIRE_CRYPT_ENABLE = Const.WIRE_CRYPT_ENABLE;

package/lib/pool.js

@@ -4,104 +4,105 @@
  *
  ***************************************/
 
-function Pool(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.max = max || 4;
-    this.pending = [];
-    this.options = options;
-}
-
-Pool.prototype.get = function(callback) {
-    var self = this;
-    self.pending.push(callback);
-    self.check();
-    return self;
-};
-
-Pool.prototype.check = function() {
+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;
+    }
 
-    var self = this;
-    if (self.dbinuse >= self.max)
+    get(callback) {
+        var self = this;
+        self.pending.push(callback);
+        self.check();
         return self;
+    }
 
-    var cb = self.pending.shift();
-    if (!cb)
-        return self;
-    self.dbinuse++;
-    if (self.pooldb.length) {
-        cb(null, self.pooldb.shift());
-    } else {
-        this.attach(self.options, function (err, db) {
-            if (!err) {
-                self.internaldb.push(db);
-                db.on('detach', function () {
-                    // 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 (db.connection._isClosed || db.connection._isDetach || db.connection._pooled === false)
-                        self.internaldb.splice(self.internaldb.indexOf(db), 1);
-                    else
-                        self.pooldb.push(db);
+    check() {
+        var self = this;
+        if ((self.dbinuse + self._creating) >= self.max)
+            return self;
+
+        var cb = self.pending.shift();
+        if (!cb)
+            return self;
+        if (self.pooldb.length) {
+            self.dbinuse++;
+            cb(null, self.pooldb.shift());
+        } else {
+            self._creating++;
+            this.attach(self.options, function (err, db) {
+                self._creating--;
+                if (!err) {
+                    self.dbinuse++;
+                    self.internaldb.push(db);
+                    db.on('detach', function () {
+                        // 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 (db.connection._isClosed || db.connection._isDetach || db.connection._pooled === false)
+                            self.internaldb.splice(self.internaldb.indexOf(db), 1);
+                        else
+                            self.pooldb.push(db);
 
-                    if (db.connection._pooled)
                         self.dbinuse--;
-                    self.check();
-                });
-            } else {
-                // attach fail so not in the pool
-                self.dbinuse--;
-            }
+                        self.check();
+                    });
+                }
 
-            cb(err, db);
+                cb(err, db);
+            });
+        }
+        setImmediate(function() {
+            self.check();
         });
+
+        return self;
     }
-    setImmediate(function() {
-        self.check();
-    });
 
-    return self;
-};
+    destroy(callback) {
+        var self = this;
 
-Pool.prototype.destroy = function(callback) {
-    var self = this;
+        var connectionCount = this.internaldb.length;
 
-    var connectionCount = this.internaldb.length;
+        if (connectionCount === 0 && callback) {
+            callback();
+        }
 
-    if (connectionCount === 0 && callback) {
-        callback();
-    }
+        function detachCallback(err) {
+            if (err) {
+                if (callback) {
+                    callback(err);
+                }
+                return;
+            }
 
-    function detachCallback(err) {
-        if (err) {
-            if (callback) {
-                callback(err);
+            connectionCount--;
+            if (connectionCount === 0 && callback) {
+                callback();
             }
-            return;
         }
 
-        connectionCount--;
-        if (connectionCount === 0 && callback) {
-            callback();
-        }
+        this.internaldb.forEach(function(db) {
+            if (db.connection._pooled === false) {
+                detachCallback();
+                return;
+            }
+            // check if the db is not free into the pool otherwise user should manual detach it
+            var _db_in_pool = self.pooldb.indexOf(db);
+            if (_db_in_pool !== -1) {
+                self.pooldb.splice(_db_in_pool, 1);
+                db.connection._pooled = false;
+                db.detach(detachCallback);
+            }
+        });
     }
-
-    this.internaldb.forEach(function(db) {
-        if (db.connection._pooled === false) {
-            detachCallback();
-            return;
-        }
-        // check if the db is not free into the pool otherwise user should manual detach it
-        var _db_in_pool = self.pooldb.indexOf(db);
-        if (_db_in_pool !== -1) {
-            self.pooldb.splice(_db_in_pool, 1);
-            db.connection._pooled = false;
-            db.detach(detachCallback);
-        }
-    });
-};
+}
 
 module.exports = Pool;

package/lib/srp.js

@@ -181,6 +181,9 @@ function clientSession(user, password, salt, A, B, a) {
         diff = diff.add(PRIME.N);
     }
 
+    // Note: While the SRP specification says exponents should not be reduced mod N,
+    // the Firebird engine implementation does reduce these exponents mod N.
+    // We must match the server's behavior for authentication to succeed.
     var ux = u.multiply(x).mod(PRIME.N);
     var aux = a.add(ux).mod(PRIME.N);
     var sessionSecret = diff.modPow(aux, PRIME.N);