node-firebird 2.3.4 → 2.4.1

package/lib/wire/database.d.ts

@@ -0,0 +1,57 @@
+import Events from 'events';
+declare class Database extends Events.EventEmitter {
+    connection: any;
+    eventid: number;
+    constructor(connection: any);
+    escape(value: any): string;
+    detach(callback?: (err?: any, obj?: any) => void, force?: boolean): this;
+    transaction(options: any, callback?: (err: any, transaction?: any) => void): this;
+    startTransaction(options: any, callback?: (err: any, transaction?: any) => void): this;
+    newStatement(query: string, callback: (err: any, statement?: any) => void): this;
+    execute(query: string, params?: any, callback?: any, options?: any): this;
+    sequentially(query: string, params?: any, on?: any, callback?: any, options?: any): this;
+    query(query: string, params?: any, callback?: any, options?: any): this;
+    drop(callback?: (err?: any) => void): void;
+    attachEvent(callback: (err: any, evt?: any) => void): this;
+    /**
+     * Create a physical tablespace.
+     * Supported in Firebird 6.0+ (Protocol 20+).
+     *
+     * @param {string} name - The name of the tablespace.
+     * @param {string} filePath - The physical file path for the tablespace.
+     * @param {function} [callback] - Asynchronous completion callback.
+     * @returns {Database}
+     */
+    createTablespace(name: string, filePath: string, callback?: any): this;
+    /**
+     * Alter an existing tablespace physical location.
+     * Supported in Firebird 6.0+ (Protocol 20+).
+     *
+     * @param {string} name - The name of the tablespace.
+     * @param {string} filePath - The new physical file path.
+     * @param {function} [callback] - Asynchronous completion callback.
+     * @returns {Database}
+     */
+    alterTablespace(name: string, filePath: string, callback?: any): this;
+    /**
+     * Drop a tablespace.
+     * Supported in Firebird 6.0+ (Protocol 20+).
+     *
+     * @param {string} name - The name of the tablespace.
+     * @param {function} [callback] - Asynchronous completion callback.
+     * @returns {Database}
+     */
+    dropTablespace(name: string, callback?: any): this;
+    /**
+     * Create a schema/namespace. Can optionally partition/map the namespace
+     * to a physical tablespace.
+     * Supported in Firebird 6.0+ (Protocol 20+).
+     *
+     * @param {string} schemaName - The name of the schema.
+     * @param {string} [tablespaceName] - Optional tablespace name to bind this schema namespace.
+     * @param {function} [callback] - Asynchronous completion callback.
+     * @returns {Database}
+     */
+    createSchema(schemaName: string, tablespaceName?: string | ((err?: any) => void), callback?: any): this;
+}
+export = Database;

package/lib/wire/database.js

@@ -1,10 +1,13 @@
-const Events = require('events');
-const { doError } = require('../callback');
-const { escape } = require('../utils');
-const Const = require('./const');
-const EventConnection = require('./eventConnection');
-const FbEventManager = require('./fbEventManager');
-
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+const events_1 = __importDefault(require("events"));
+const callback_1 = require("../callback");
+const utils_1 = require("../utils");
+const const_1 = __importDefault(require("./const"));
+const eventConnection_1 = __importDefault(require("./eventConnection"));
+const fbEventManager_1 = __importDefault(require("./fbEventManager"));
 /***************************************
  *
  *   Database
@@ -39,72 +42,58 @@ const FbEventManager = require('./fbEventManager');
  *   5. Call evtmgr.close(callback) when done to release the aux connection.
  *
  ***************************************/
-
 function readblob(blob, callback) {
     if (blob === undefined || blob === null) {
         callback(null, blob);
         return;
     }
-
     if (typeof blob !== 'function') {
         callback(null, blob);
         return;
     }
-
-    blob(function(err, name, e) {
+    blob(function (err, name, e) {
         if (err) {
             callback(err);
             return;
         }
-
         if (!e) {
             callback(null, null);
             return;
         }
-
         const chunks = [];
         let chunksLength = 0;
-
-        e.on('data', function(chunk) {
+        e.on('data', function (chunk) {
             chunksLength += chunk.length;
             chunks.push(chunk);
         });
-
-        e.on('end', function() {
+        e.on('end', function () {
             callback(null, Buffer.concat(chunks, chunksLength));
         });
-
-        e.on('error', function(streamErr) {
+        e.on('error', function (streamErr) {
             callback(streamErr);
         });
     });
 }
-
 function fetchBlobSyncRow(row, meta, callback) {
     if (!row || !meta || !meta.length) {
         callback(null, row);
         return;
     }
-
     const rowKeys = Object.keys(row);
     const blobColumns = [];
-
     for (let i = 0; i < meta.length; i++) {
-        if (meta[i] && meta[i].type === Const.SQL_BLOB && rowKeys[i] !== undefined) {
+        if (meta[i] && meta[i].type === const_1.default.SQL_BLOB && rowKeys[i] !== undefined) {
             blobColumns.push(rowKeys[i]);
         }
     }
-
     if (!blobColumns.length) {
         callback(null, row);
         return;
     }
-
     let pending = blobColumns.length;
     let blobErr;
-
-    blobColumns.forEach(function(columnName) {
-        readblob(row[columnName], function(err, data) {
+    blobColumns.forEach(function (columnName) {
+        readblob(row[columnName], function (err, data) {
             if (err && !blobErr) {
                 blobErr = err;
             }
@@ -116,116 +105,90 @@ function fetchBlobSyncRow(row, meta, callback) {
         });
     });
 }
-
-class Database extends Events.EventEmitter {
+class Database extends events_1.default.EventEmitter {
     constructor(connection) {
         super();
         this.connection = connection;
         connection.db = this;
         this.eventid = 1;
     }
-
     escape(value) {
-        return escape(value, this.connection.accept.protocolVersion);
+        return (0, utils_1.escape)(value, this.connection.accept.protocolVersion);
     }
-
     detach(callback, force) {
         var self = this;
-
         if (!force && self.connection._pending.length > 0) {
             self.connection._detachAuto = true;
             self.connection._detachCallback = callback;
             return self;
         }
-
         if (self.connection._pooled === false) {
             self.connection.detach(function (err, obj) {
-
                 self.connection.disconnect();
                 self.emit('detach', false);
-
                 if (callback)
                     callback(err, obj);
-
             }, force);
-        } else {
+        }
+        else {
             self.emit('detach', false);
             if (callback)
                 callback();
         }
-
         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) {
-
+        this.startTransaction(function (err, transaction) {
             if (err) {
                 callback(err);
                 return;
             }
-
-            transaction.newStatement(query, function(err, statement) {
-
+            transaction.newStatement(query, function (err, statement) {
                 if (err) {
                     callback(err);
                     return;
                 }
-
-                transaction.commit(function(err) {
+                transaction.commit(function (err) {
                     callback(err, statement);
                 });
             });
         });
-
         return this;
     }
-
     execute(query, params, callback, options) {
         if (params instanceof Function) {
             options = callback;
             callback = params;
             params = undefined;
         }
-
         var self = this;
-
-        self.connection.startTransaction(function(err, transaction) {
-
+        self.connection.startTransaction(function (err, transaction) {
             if (err) {
-                doError(err, callback);
+                (0, callback_1.doError)(err, callback);
                 return;
             }
-
-            transaction.execute(query, params, function(err, result, meta, isSelect) {
-
+            transaction.execute(query, params, function (err, result, meta, isSelect) {
                 if (err) {
-                    transaction.rollback(function() {
-                        doError(err, callback);
+                    transaction.rollback(function () {
+                        (0, callback_1.doError)(err, callback);
                     });
                     return;
                 }
-
-                transaction.commit(function(err) {
+                transaction.commit(function (err) {
                     if (callback)
                         callback(err, result, meta, isSelect);
                 });
-
             }, options);
         });
-
         return self;
     }
-
     sequentially(query, params, on, callback, options = {}) {
         if (params instanceof Function) {
             options = callback;
@@ -233,58 +196,55 @@ class Database extends Events.EventEmitter {
             on = params;
             params = undefined;
         }
-
-        if (on === undefined){
+        if (on === undefined) {
             throw new Error('Expected "on" delegate.');
         }
-
         if (callback instanceof Boolean) {
             options = callback;
             callback = undefined;
         }
-
         var self = this;
-        var _on = function(row, i, meta, next) {
+        var _on = function (row, i, meta, next) {
             var done = false;
-            var finish = function(err) {
+            var finish = function (err) {
                 if (done) {
                     return;
                 }
                 done = true;
                 next(err);
             };
-
-            fetchBlobSyncRow(row, meta, function(blobErr) {
+            fetchBlobSyncRow(row, meta, function (blobErr) {
                 if (blobErr) {
                     finish(blobErr);
                     return;
                 }
-
                 try {
                     var ret;
                     if (on.length >= 3) {
                         ret = on(row, i, finish);
-                    } else {
+                    }
+                    else {
                         ret = on(row, i);
                     }
-
                     if (ret && typeof ret.then === 'function') {
-                        ret.then(function() {
+                        ret.then(function () {
                             finish();
                         }).catch(finish);
-                    } else if (on.length < 3) {
+                    }
+                    else if (on.length < 3) {
                         finish();
                     }
-                } catch (err) {
+                }
+                catch (err) {
                     finish(err);
                 }
             });
         };
-
         // back compatibility - options parameter is a boolean
         if (typeof options === 'boolean') {
             options = { asObject: !options, asStream: true, on: _on };
-        } else {
+        }
+        else {
             options = {
                 asObject: true,
                 asStream: true,
@@ -292,87 +252,130 @@ class Database extends Events.EventEmitter {
                 ...options,
             };
         }
-
         self.execute(query, params, callback, options);
         return self;
     }
-
     query(query, params, callback, options = {}) {
         if (params instanceof Function) {
             options = callback || {};
             callback = params;
             params = undefined;
         }
-
         options = {
             asObject: true,
             asStream: callback === undefined || callback === null,
             ...options
         };
-
         var self = this;
         self.execute(query, params, callback, options);
         return self;
     }
-
     drop(callback) {
         return this.connection.dropDatabase(callback);
     }
-
     attachEvent(callback) {
         var self = this;
+        const eventid = self.eventid++;
         if (process.env.FIREBIRD_DEBUG) {
-            console.log('[fb-debug] Database.attachEvent: calling auxConnection, eventid=%d queue=%d', self.eventid, self.connection._queue.length);
+            console.log('[fb-debug] Database.attachEvent: calling auxConnection, eventid=%d queue=%d', eventid, self.connection._queue.length);
         }
-        this.connection.auxConnection(function (err, socket_info) {
-
+        this.connection.auxConnection(eventid, function (err, socket_info) {
             if (err) {
                 if (process.env.FIREBIRD_DEBUG) {
                     console.log('[fb-debug] Database.attachEvent: auxConnection error:', err.message);
                 }
-                doError(err, callback);
+                (0, callback_1.doError)(err, callback);
                 return;
             }
-
             if (process.env.FIREBIRD_DEBUG) {
                 console.log('[fb-debug] Database.attachEvent: auxConnection ok, connecting to aux port %s:%d', socket_info.host, socket_info.port);
             }
-
             const host = (socket_info.host === '0.0.0.0' || socket_info.host === '::')
                 ? self.connection.options.host
                 : socket_info.host;
-
-            const eventConnection = new EventConnection(
-                host, socket_info.port, function(err) {
+            const eventConnection = new eventConnection_1.default(host, socket_info.port, function (err) {
                 if (err) {
                     if (process.env.FIREBIRD_DEBUG) {
                         console.log('[fb-debug] Database.attachEvent: EventConnection error:', err.message);
                     }
-                    doError(err, callback);
+                    (0, callback_1.doError)(err, callback);
                     return;
                 }
-
                 if (process.env.FIREBIRD_DEBUG) {
-                    console.log('[fb-debug] Database.attachEvent: EventConnection connected, creating FbEventManager eventid=%d', self.eventid);
+                    console.log('[fb-debug] Database.attachEvent: EventConnection connected, creating FbEventManager eventid=%d', eventid);
                 }
-
-                const evt = new FbEventManager(self, eventConnection, self.eventid++, function (err) {
+                const evt = new fbEventManager_1.default(self, eventConnection, eventid, function (err) {
                     if (err) {
-                        doError(err, callback);
+                        (0, callback_1.doError)(err, callback);
                         return;
                     }
-
                     if (process.env.FIREBIRD_DEBUG) {
                         console.log('[fb-debug] Database.attachEvent: FbEventManager ready, eventid=%d', evt.eventid);
                     }
-
                     callback(err, evt);
                 });
             }, self);
         });
-
         return this;
     }
+    /**
+     * Create a physical tablespace.
+     * Supported in Firebird 6.0+ (Protocol 20+).
+     *
+     * @param {string} name - The name of the tablespace.
+     * @param {string} filePath - The physical file path for the tablespace.
+     * @param {function} [callback] - Asynchronous completion callback.
+     * @returns {Database}
+     */
+    createTablespace(name, filePath, callback) {
+        const sql = `CREATE TABLESPACE ${name} FILE '${filePath}'`;
+        return this.execute(sql, [], callback);
+    }
+    /**
+     * Alter an existing tablespace physical location.
+     * Supported in Firebird 6.0+ (Protocol 20+).
+     *
+     * @param {string} name - The name of the tablespace.
+     * @param {string} filePath - The new physical file path.
+     * @param {function} [callback] - Asynchronous completion callback.
+     * @returns {Database}
+     */
+    alterTablespace(name, filePath, callback) {
+        const sql = `ALTER TABLESPACE ${name} SET FILE TO '${filePath}'`;
+        return this.execute(sql, [], callback);
+    }
+    /**
+     * Drop a tablespace.
+     * Supported in Firebird 6.0+ (Protocol 20+).
+     *
+     * @param {string} name - The name of the tablespace.
+     * @param {function} [callback] - Asynchronous completion callback.
+     * @returns {Database}
+     */
+    dropTablespace(name, callback) {
+        const sql = `DROP TABLESPACE ${name}`;
+        return this.execute(sql, [], callback);
+    }
+    /**
+     * Create a schema/namespace. Can optionally partition/map the namespace
+     * to a physical tablespace.
+     * Supported in Firebird 6.0+ (Protocol 20+).
+     *
+     * @param {string} schemaName - The name of the schema.
+     * @param {string} [tablespaceName] - Optional tablespace name to bind this schema namespace.
+     * @param {function} [callback] - Asynchronous completion callback.
+     * @returns {Database}
+     */
+    createSchema(schemaName, tablespaceName, callback) {
+        if (typeof tablespaceName === 'function') {
+            callback = tablespaceName;
+            tablespaceName = undefined;
+        }
+        let sql = `CREATE SCHEMA ${schemaName}`;
+        if (tablespaceName) {
+            sql += ` TABLESPACE ${tablespaceName}`;
+        }
+        return this.execute(sql, [], callback);
+    }
 }
-
 module.exports = Database;

package/lib/wire/eventConnection.d.ts

@@ -0,0 +1,16 @@
+import net from 'net';
+import { XdrReader } from './serialize';
+declare class EventConnection {
+    db: any;
+    emgr: any;
+    _isClosed: boolean;
+    _isOpened: boolean;
+    _socket: net.Socket;
+    _xdr?: XdrReader;
+    error: any;
+    eventcallback: ((err: any, ret?: any) => void) | null;
+    constructor(host: string, port: number, callback: (() => void) | undefined, db: any);
+    _bind_events(host: string, port: number, callback?: () => void): void;
+    throwClosed(callback?: (err: any) => void): this;
+}
+export = EventConnection;

package/lib/wire/eventConnection.js

@@ -1,8 +1,11 @@
-const net = require('net');
-const { XdrReader } = require('./serialize');
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+const net_1 = __importDefault(require("net"));
+const serialize_1 = require("./serialize");
+const const_1 = __importDefault(require("./const"));
 const DEFAULT_ENCODING = 'utf8';
-const Const = require('./const');
-
 class EventConnection {
     constructor(host, port, callback, db) {
         var self = this;
@@ -10,59 +13,49 @@ class EventConnection {
         this.emgr = null;
         this._isClosed = false;
         this._isOpened = false;
-        this._socket = net.createConnection(port, host);
+        this._socket = net_1.default.createConnection(port, host);
         this._bind_events(host, port, callback);
         this.error;
         this.eventcallback;
     }
-
     _bind_events(host, port, callback) {
         var self = this;
-
         self._socket.on('close', function () {
-
             self._isClosed = true;
-        })
-
+        });
         self._socket.on('error', function (e) {
-
             self.error = e;
-        })
-
+        });
         self._socket.on('connect', function () {
             self._isClosed = false;
             self._isOpened = true;
             if (callback)
                 callback();
         });
-
         self._socket.on('data', function (data) {
             var xdr, buf;
-
             if (!self._xdr) {
-                xdr = new XdrReader(data);
-            } else {
+                xdr = new serialize_1.XdrReader(data);
+            }
+            else {
                 xdr = self._xdr;
                 delete (self._xdr);
-                buf = Buffer.from(data.length + xdr.buffer.length);
+                buf = Buffer.alloc(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);
-
+                    } while (r === const_1.default.op_dummy);
                     switch (r) {
-                        case Const.op_event:
+                        case const_1.default.op_event:
                             xdr.readInt(); // db handle
-                            var buf = xdr.readArray();
+                            buf = xdr.readArray();
                             // first byte is always set to 1
                             tmp_event = {};
                             var lst_event = [];
@@ -83,8 +76,13 @@ class EventConnection {
                             xdr.readInt64(); // ignore AST INFO
                             var event_id = xdr.readInt();
                             // set the new count in global event hash
+                            // Only update events that are still registered; do not
+                            // re-add events that unregisterEvent() has deleted, since
+                            // that would cause subscribe() to re-subscribe for them.
                             for (var evt in tmp_event) {
-                                self.emgr.events[evt] = tmp_event[evt];
+                                if (Object.prototype.hasOwnProperty.call(self.emgr.events, evt)) {
+                                    self.emgr.events[evt] = tmp_event[evt];
+                                }
                             }
                             if (self.eventcallback)
                                 self.eventcallback(null, { eventid: event_id, events: lst_event });
@@ -94,18 +92,19 @@ class EventConnection {
                             return;
                     }
                 }
-            } catch (err) {
+            }
+            catch (err) {
                 if (err instanceof RangeError) { // incomplete packet case
                     xdr.buffer = xdr.buffer = xdr.buffer.slice(op_pos);
                     xdr.pos = 0;
                     self._xdr = xdr;
-                } else {
+                }
+                else {
                     throw err;
                 }
             }
-        })
+        });
     }
-
     throwClosed(callback) {
         var err = new Error('Event Connection is closed.');
         this.db.emit('error', err);
@@ -114,5 +113,4 @@ class EventConnection {
         return this;
     }
 }
-
-module.exports = EventConnection;
+module.exports = EventConnection;