node-firebird 1.1.10 → 2.0.0

package/lib/wire/const.js

@@ -180,6 +180,12 @@ const protocol = {
 
     // Protocol 13 has support for authentication plugins (op_cont_auth).
     PROTOCOL_VERSION13  : (FB_PROTOCOL_FLAG | 13),
+
+    // Protocol 14 has support for wire encryption.
+    PROTOCOL_VERSION14  : (FB_PROTOCOL_FLAG | 14),
+
+    // Protocol 15 has support for conditional accept with early wire encryption.
+    PROTOCOL_VERSION15  : (FB_PROTOCOL_FLAG | 15),
 };
 
 // Protocols types (accept_type)
@@ -197,19 +203,19 @@ const SUPPORTED_PROTOCOL = [
     [protocol.PROTOCOL_VERSION11, connect.ARCHITECTURE_GENERIC, acceptType.ptype_lazy_send, acceptType.ptype_lazy_send, 2],
     [protocol.PROTOCOL_VERSION12, connect.ARCHITECTURE_GENERIC, acceptType.ptype_lazy_send, acceptType.ptype_lazy_send, 3],
     [protocol.PROTOCOL_VERSION13, connect.ARCHITECTURE_GENERIC, acceptType.ptype_lazy_send, acceptType.ptype_lazy_send, 4],
+    [protocol.PROTOCOL_VERSION14, connect.ARCHITECTURE_GENERIC, acceptType.ptype_lazy_send, acceptType.ptype_lazy_send, 5],
+    [protocol.PROTOCOL_VERSION15, connect.ARCHITECTURE_GENERIC, acceptType.ptype_lazy_send, acceptType.ptype_lazy_send, 6],
 ];
 
 const authPlugin = {
     AUTH_PLUGIN_LEGACY : 'Legacy_Auth',
     AUTH_PLUGIN_SRP : 'Srp',
-    // AUTH_PLUGIN_SRP256 : 'Srp256',
+    AUTH_PLUGIN_SRP256 : 'Srp256',
 };
 
 const authOptions = {
-    // AUTH_PLUGIN_LIST : [authPlugin.AUTH_PLUGIN_SRP256, authPlugin.AUTH_PLUGIN_SRP, authPlugin.AUTH_PLUGIN_LEGACY],
-    AUTH_PLUGIN_LIST : [authPlugin.AUTH_PLUGIN_SRP, authPlugin.AUTH_PLUGIN_LEGACY],
-    // AUTH_PLUGIN_SRP_LIST : [authPlugin.AUTH_PLUGIN_SRP256, authPlugin.AUTH_PLUGIN_SRP],
-    AUTH_PLUGIN_SRP_LIST : [authPlugin.AUTH_PLUGIN_SRP],
+    AUTH_PLUGIN_LIST : [authPlugin.AUTH_PLUGIN_SRP256, authPlugin.AUTH_PLUGIN_SRP, authPlugin.AUTH_PLUGIN_LEGACY],
+    AUTH_PLUGIN_SRP_LIST : [authPlugin.AUTH_PLUGIN_SRP256, authPlugin.AUTH_PLUGIN_SRP],
     LEGACY_AUTH_SALT : '9z',
     WIRE_CRYPT_DISABLE : 0,
     WIRE_CRYPT_ENABLE : 1,

package/lib/wire/database.js

@@ -1,6 +1,7 @@
 const Events = require('events');
 const { doError } = require('../callback');
 const { escape } = require('../utils');
+const Const = require('./const');
 const EventConnection = require('./eventConnection');
 const FbEventManager = require('./fbEventManager');
 
@@ -10,189 +11,294 @@ const FbEventManager = require('./fbEventManager');
  *
  ***************************************/
 
-function Database(connection) {
-    this.connection = connection;
-    connection.db = this;
-    this.eventid = 1;
-}
+function readblob(blob, callback) {
+    if (blob === undefined || blob === null) {
+        callback(null, blob);
+        return;
+    }
 
-Database.prototype.__proto__ = Object.create(Events.EventEmitter.prototype, {
-    constructor: {
-        value: Database,
-        enumberable: false
+    if (typeof blob !== 'function') {
+        callback(null, blob);
+        return;
     }
-});
 
-Database.prototype.escape = function(value) {
-    return escape(value, this.connection.accept.protocolVersion);
-};
+    blob(function(err, name, e) {
+        if (err) {
+            callback(err);
+            return;
+        }
 
-Database.prototype.detach = function(callback, force) {
+        if (!e) {
+            callback(null, null);
+            return;
+        }
 
-    var self = this;
+        const chunks = [];
+        let chunksLength = 0;
 
-    if (!force && self.connection._pending.length > 0) {
-        self.connection._detachAuto = true;
-        self.connection._detachCallback = callback;
-        return self;
+        e.on('data', function(chunk) {
+            chunksLength += chunk.length;
+            chunks.push(chunk);
+        });
+
+        e.on('end', function() {
+            callback(null, Buffer.concat(chunks, chunksLength));
+        });
+
+        e.on('error', function(streamErr) {
+            callback(streamErr);
+        });
+    });
+}
+
+function fetchBlobSyncRow(row, meta, callback) {
+    if (!row || !meta || !meta.length) {
+        callback(null, row);
+        return;
     }
 
-    if (self.connection._pooled === false) {
-        self.connection.detach(function (err, obj) {
+    const rowKeys = Object.keys(row);
+    const blobColumns = [];
 
-            self.connection.disconnect();
-            self.emit('detach', false);
+    for (let i = 0; i < meta.length; i++) {
+        if (meta[i] && meta[i].type === Const.SQL_BLOB && rowKeys[i] !== undefined) {
+            blobColumns.push(rowKeys[i]);
+        }
+    }
 
-            if (callback)
-                callback(err, obj);
+    if (!blobColumns.length) {
+        callback(null, row);
+        return;
+    }
 
-        }, force);
-    } else {
-        self.emit('detach', false);
-        if (callback)
-            callback();
+    let pending = blobColumns.length;
+    let blobErr;
+
+    blobColumns.forEach(function(columnName) {
+        readblob(row[columnName], function(err, data) {
+            if (err && !blobErr) {
+                blobErr = err;
+            }
+            row[columnName] = data;
+            pending--;
+            if (pending === 0) {
+                callback(blobErr, row);
+            }
+        });
+    });
+}
+
+class Database extends Events.EventEmitter {
+    constructor(connection) {
+        super();
+        this.connection = connection;
+        connection.db = this;
+        this.eventid = 1;
+    }
+
+    escape(value) {
+        return escape(value, this.connection.accept.protocolVersion);
     }
 
-    return self;
-};
+    detach(callback, force) {
+        var self = this;
 
-Database.prototype.transaction = function(options, callback) {
-    return this.startTransaction(options, callback);
-};
+        if (!force && self.connection._pending.length > 0) {
+            self.connection._detachAuto = true;
+            self.connection._detachCallback = callback;
+            return self;
+        }
 
-Database.prototype.startTransaction = function(options, callback) {
-    this.connection.startTransaction(options, callback);
-    return this;
-};
+        if (self.connection._pooled === false) {
+            self.connection.detach(function (err, obj) {
 
-Database.prototype.newStatement = function (query, callback) {
+                self.connection.disconnect();
+                self.emit('detach', false);
 
-    this.startTransaction(function(err, transaction) {
+                if (callback)
+                    callback(err, obj);
 
-        if (err) {
-            callback(err);
-            return;
+            }, force);
+        } else {
+            self.emit('detach', false);
+            if (callback)
+                callback();
         }
 
-        transaction.newStatement(query, function(err, statement) {
+        return self;
+    }
+
+    transaction(options, callback) {
+        return this.startTransaction(options, callback);
+    }
+
+    startTransaction(options, callback) {
+        this.connection.startTransaction(options, callback);
+        return this;
+    }
+
+    newStatement(query, callback) {
+        this.startTransaction(function(err, transaction) {
 
             if (err) {
                 callback(err);
                 return;
             }
 
-            transaction.commit(function(err) {
-                callback(err, statement);
-            });
-        });
-    });
+            transaction.newStatement(query, function(err, statement) {
 
-    return this;
-};
+                if (err) {
+                    callback(err);
+                    return;
+                }
 
-Database.prototype.execute = function(query, params, callback, custom) {
+                transaction.commit(function(err) {
+                    callback(err, statement);
+                });
+            });
+        });
 
-    if (params instanceof Function) {
-        custom = callback;
-        callback = params;
-        params = undefined;
+        return this;
     }
 
-    var self = this;
-
-    self.connection.startTransaction(function(err, transaction) {
-
-        if (err) {
-            doError(err, callback);
-            return;
+    execute(query, params, callback, custom) {
+        if (params instanceof Function) {
+            custom = callback;
+            callback = params;
+            params = undefined;
         }
 
-        transaction.execute(query, params, function(err, result, meta, isSelect) {
+        var self = this;
+
+        self.connection.startTransaction(function(err, transaction) {
 
             if (err) {
-                transaction.rollback(function() {
-                    doError(err, callback);
-                });
+                doError(err, callback);
                 return;
             }
 
-            transaction.commit(function(err) {
-                if (callback)
-                    callback(err, result, meta, isSelect);
-            });
+            transaction.execute(query, params, function(err, result, meta, isSelect) {
 
-        }, custom);
-    });
+                if (err) {
+                    transaction.rollback(function() {
+                        doError(err, callback);
+                    });
+                    return;
+                }
 
-    return self;
-};
+                transaction.commit(function(err) {
+                    if (callback)
+                        callback(err, result, meta, isSelect);
+                });
 
-Database.prototype.sequentially = function(query, params, on, callback, asArray) {
+            }, custom);
+        });
 
-    if (params instanceof Function) {
-        asArray = callback;
-        callback = on;
-        on = params;
-        params = undefined;
+        return self;
     }
 
-    if (on === undefined){
-        throw new Error('Expected "on" delegate.');
-    }
+    sequentially(query, params, on, callback, asArray) {
+        if (params instanceof Function) {
+            asArray = callback;
+            callback = on;
+            on = params;
+            params = undefined;
+        }
 
-    if (callback instanceof Boolean) {
-        asArray = callback;
-        callback = undefined;
-    }
+        if (on === undefined){
+            throw new Error('Expected "on" delegate.');
+        }
+
+        if (callback instanceof Boolean) {
+            asArray = callback;
+            callback = undefined;
+        }
+
+        var self = this;
+        var _on = function(row, i, meta, next) {
+            var done = false;
+            var finish = function(err) {
+                if (done) {
+                    return;
+                }
+                done = true;
+                next(err);
+            };
 
-    var self = this;
-    self.execute(query, params, callback, { asObject: !asArray, asStream: true, on: on });
-    return self;
-};
+            fetchBlobSyncRow(row, meta, function(blobErr) {
+                if (blobErr) {
+                    finish(blobErr);
+                    return;
+                }
 
-Database.prototype.query = function(query, params, callback) {
+                try {
+                    var ret;
+                    if (on.length >= 3) {
+                        ret = on(row, i, finish);
+                    } else {
+                        ret = on(row, i);
+                    }
+
+                    if (ret && typeof ret.then === 'function') {
+                        ret.then(function() {
+                            finish();
+                        }).catch(finish);
+                    } else if (on.length < 3) {
+                        finish();
+                    }
+                } catch (err) {
+                    finish(err);
+                }
+            });
+        };
 
-    if (params instanceof Function) {
-        callback = params;
-        params = undefined;
+        self.execute(query, params, callback, { asObject: !asArray, asStream: true, on: _on });
+        return self;
     }
 
-    var self = this;
-    self.execute(query, params, callback, { asObject: true, asStream: callback === undefined || callback === null });
-    return self;
-};
+    query(query, params, callback) {
+        if (params instanceof Function) {
+            callback = params;
+            params = undefined;
+        }
 
-Database.prototype.drop = function(callback) {
-    return this.connection.dropDatabase(callback);
-};
+        var self = this;
+        self.execute(query, params, callback, { asObject: true, asStream: callback === undefined || callback === null });
+        return self;
+    }
 
-Database.prototype.attachEvent = function (callback) {
-    var self = this;
-    this.connection.auxConnection(function (err, socket_info) {
+    drop(callback) {
+        return this.connection.dropDatabase(callback);
+    }
 
-        if (err) {
-            doError(err, callback);
-            return;
-        }
+    attachEvent(callback) {
+        var self = this;
+        this.connection.auxConnection(function (err, socket_info) {
 
-        const eventConnection = new EventConnection(self.connection.host, socket_info.port, function (err) {
             if (err) {
                 doError(err, callback);
                 return;
             }
 
-            const evt = new FbEventManager(self, eventConnection, self.eventid++, function (err) {
+            const eventConnection = new EventConnection(socket_info.host, socket_info.port, function (err) {
                 if (err) {
                     doError(err, callback);
                     return;
                 }
 
-                callback(err, evt);
-            });
-        }, self);
-    });
+                const evt = new FbEventManager(self, eventConnection, self.eventid++, function (err) {
+                    if (err) {
+                        doError(err, callback);
+                        return;
+                    }
+
+                    callback(err, evt);
+                });
+            }, self);
+        });
 
-    return this;
+        return this;
+    }
 }
 
 module.exports = Database;

package/lib/wire/eventConnection.js

@@ -3,111 +3,113 @@ const { XdrReader } = require('./serialize');
 const DEFAULT_ENCODING = 'utf8';
 const Const = require('./const');
 
-var EventConnection = function (host, port, callback, db) {
-    var self = this;
-    this.db = db;
-    this.emgr = null;
-    this._isClosed = false;
-    this._isOpened = false;
-    this._socket = net.createConnection(port, host);
-    this._bind_events(host, port, callback);
-    this.error;
-    this.eventcallback;
-};
+class EventConnection {
+    constructor(host, port, callback, db) {
+        var self = this;
+        this.db = db;
+        this.emgr = null;
+        this._isClosed = false;
+        this._isOpened = false;
+        this._socket = net.createConnection(port, host);
+        this._bind_events(host, port, callback);
+        this.error;
+        this.eventcallback;
+    }
 
-EventConnection.prototype._bind_events = function (host, port, callback) {
-    var self = this;
+    _bind_events(host, port, callback) {
+        var self = this;
 
-    self._socket.on('close', function () {
+        self._socket.on('close', function () {
 
-        self._isClosed = true;
-    })
+            self._isClosed = true;
+        })
 
-    self._socket.on('error', function (e) {
+        self._socket.on('error', function (e) {
 
-        self.error = e;
-    })
+            self.error = e;
+        })
 
-    self._socket.on('connect', function () {
-        self._isClosed = false;
-        self._isOpened = true;
-        if (callback)
-            callback();
-    });
+        self._socket.on('connect', function () {
+            self._isClosed = false;
+            self._isOpened = true;
+            if (callback)
+                callback();
+        });
 
-    self._socket.on('data', function (data) {
-        var xdr, buf;
+        self._socket.on('data', function (data) {
+            var xdr, buf;
 
-        if (!self._xdr) {
-            xdr = new XdrReader(data);
-        } else {
-            xdr = self._xdr;
-            delete (self._xdr);
-            buf = Buffer.from(data.length + xdr.buffer.length);
-            xdr.buffer.copy(buf);
-            data.copy(buf, xdr.buffer.length);
-            xdr.buffer = buf;
-        }
+            if (!self._xdr) {
+                xdr = new XdrReader(data);
+            } else {
+                xdr = self._xdr;
+                delete (self._xdr);
+                buf = Buffer.from(data.length + xdr.buffer.length);
+                xdr.buffer.copy(buf);
+                data.copy(buf, xdr.buffer.length);
+                xdr.buffer = buf;
+            }
 
-        try {
-            var item, op;
-            var op_pos = xdr.pos;
-            var tmp_event;
-            while (xdr.pos < xdr.buffer.length) {
-                do {
-                    var r = xdr.readInt();
-                } while (r === Const.op_dummy);
+            try {
+                var item, op;
+                var op_pos = xdr.pos;
+                var tmp_event;
+                while (xdr.pos < xdr.buffer.length) {
+                    do {
+                        var r = xdr.readInt();
+                    } while (r === Const.op_dummy);
 
-                switch (r) {
-                    case Const.op_event:
-                        xdr.readInt(); // db handle
-                        var buf = xdr.readArray();
-                        // first byte is always set to 1
-                        tmp_event = {};
-                        var lst_event = [];
-                        var eventname = '';
-                        var eventcount = 0;
-                        var pos = 1;
-                        while (pos < buf.length) {
-                            var len = buf.readInt8(pos++);
-                            eventname = buf.toString(DEFAULT_ENCODING, pos, pos + len);
-                            var prevcount = self.emgr.events[eventname] || 0;
-                            pos += len;
-                            eventcount = buf.readInt32LE(pos);
-                            tmp_event[eventname] = eventcount;
-                            pos += 4;
-                            if (prevcount !== eventcount)
-                                lst_event.push({ name: eventname, count: eventcount });
-                        }
-                        xdr.readInt64(); // ignore AST INFO
-                        var event_id = xdr.readInt();
-                        // set the new count in global event hash
-                        for (var evt in tmp_event) {
-                            self.emgr.events[evt] = tmp_event[evt];
-                        }
-                        if (self.eventcallback)
-                            return self.eventcallback(null, { eventid: event_id, events: lst_event });
+                    switch (r) {
+                        case Const.op_event:
+                            xdr.readInt(); // db handle
+                            var buf = xdr.readArray();
+                            // first byte is always set to 1
+                            tmp_event = {};
+                            var lst_event = [];
+                            var eventname = '';
+                            var eventcount = 0;
+                            var pos = 1;
+                            while (pos < buf.length) {
+                                var len = buf.readInt8(pos++);
+                                eventname = buf.toString(DEFAULT_ENCODING, pos, pos + len);
+                                var prevcount = self.emgr.events[eventname] || 0;
+                                pos += len;
+                                eventcount = buf.readInt32LE(pos);
+                                tmp_event[eventname] = eventcount;
+                                pos += 4;
+                                if (prevcount !== eventcount)
+                                    lst_event.push({ name: eventname, count: eventcount });
+                            }
+                            xdr.readInt64(); // ignore AST INFO
+                            var event_id = xdr.readInt();
+                            // set the new count in global event hash
+                            for (var evt in tmp_event) {
+                                self.emgr.events[evt] = tmp_event[evt];
+                            }
+                            if (self.eventcallback)
+                                return self.eventcallback(null, { eventid: event_id, events: lst_event });
 
-                    default:
-                        return cb(new Error('Unexpected:' + r));
+                        default:
+                            return cb(new Error('Unexpected:' + r));
+                    }
+                }
+            } catch (err) {
+                if (err instanceof RangeError) { // incomplete packet case
+                    xdr.buffer = xdr.buffer = xdr.buffer.slice(op_pos);
+                    xdr.pos = 0;
+                    self._xdr = xdr;
                 }
             }
-        } catch (err) {
-            if (err instanceof RangeError) { // incomplete packet case
-                xdr.buffer = xdr.buffer = xdr.buffer.slice(op_pos);
-                xdr.pos = 0;
-                self._xdr = xdr;
-            }
-        }
-    })
-}
+        })
+    }
 
-EventConnection.prototype.throwClosed = function (callback) {
-    var err = new Error('Event Connection is closed.');
-    this.db.emit('error', err);
-    if (callback)
-        callback(err);
-    return this;
-};
+    throwClosed(callback) {
+        var err = new Error('Event Connection is closed.');
+        this.db.emit('error', err);
+        if (callback)
+            callback(err);
+        return this;
+    }
+}
 
 module.exports = EventConnection;