node-firebird 2.3.4 → 2.4.0

package/lib/wire/fbEventManager.d.ts

@@ -0,0 +1,45 @@
+import Events from 'events';
+declare class FbEventManager extends Events.EventEmitter {
+    db: any;
+    eventconnection: any;
+    events: Record<string, number>;
+    eventid: number;
+    _subscriptionVersion: number;
+    _hasActiveSubscription: boolean;
+    constructor(db: any, eventconnection: any, eventid: number, callback: (err: any, ret?: any) => void);
+    /**
+     * Returns a snapshot of the current state for debugging.
+     * Useful for tracing the state machine during development.
+     *
+     * Stable states: 'IDLE', 'SUBSCRIBED', 'CLOSED'.
+     * Transient states (SUBSCRIBING, CANCELLING, CLOSING) occur while waiting
+     * for op_response on the main connection or for the socket to close; they
+     * are not tracked with dedicated flags to keep the implementation simple,
+     * but they can be inferred: if the socket is open and _hasActiveSubscription
+     * disagrees with what the caller expects, a transitional operation is in
+     * progress.
+     *
+     * @returns {{
+     *   state: string,
+     *   hasActiveSubscription: boolean,
+     *   registeredEvents: Object,
+     *   eventId: number,
+     *   isEventConnectionOpen: boolean,
+     *   isDatabaseConnectionClosed: boolean
+     * }}
+     */
+    getState(): {
+        state: string;
+        hasActiveSubscription: boolean;
+        registeredEvents: Record<string, number>;
+        eventId: number;
+        isEventConnectionOpen: boolean;
+        isDatabaseConnectionClosed: boolean;
+    };
+    _createEventLoop(callback: (err: any, ret?: any) => void): void;
+    _changeEvent(callback: (err: any, ret?: any) => void): void;
+    registerEvent(events: string[], callback: (err: any, ret?: any) => void): any;
+    unregisterEvent(events: string[], callback: (err: any, ret?: any) => void): any;
+    close(callback?: (err?: any) => void): void;
+}
+export = FbEventManager;

package/lib/wire/fbEventManager.js

@@ -1,3 +1,4 @@
+"use strict";
 // FbEventManager – Firebird POST_EVENT subscription manager
 //
 // State machine overview
@@ -63,24 +64,27 @@
 // Asynchronous notifications on the AUX (EventConnection) socket
 // ───────────────────────────────────────────────────────────────
 //   Server → Client : op_event  (fired by Firebird POST_EVENT trigger)
-
-const Events = require('events');
-const { doError } = require('../callback');
-
-class FbEventManager extends Events.EventEmitter {
+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");
+class FbEventManager extends events_1.default.EventEmitter {
     constructor(db, eventconnection, eventid, callback) {
         super();
         this.db = db;
         this.eventconnection = eventconnection;
         this.events = {};
         this.eventid = eventid;
+        // Guards _hasActiveSubscription against late callbacks from an older
+        // register/unregister cycle after a newer subscription change started.
+        this._subscriptionVersion = 0;
         // True when an op_que_events subscription is currently active on the
         // main connection (so close() and _changeEvent know whether to send
         // op_cancel_events before tearing down or re-subscribing).
         this._hasActiveSubscription = false;
         this._createEventLoop(callback);
     }
-
     /**
      * Returns a snapshot of the current state for debugging.
      * Useful for tracing the state machine during development.
@@ -109,7 +113,6 @@ class FbEventManager extends Events.EventEmitter {
         const dbConnClosed = this.db.connection
             ? this.db.connection._isClosed
             : true;
-
         // Derive a human-readable stable-state label.
         // Transitional states (SUBSCRIBING / CANCELLING / CLOSING) are not
         // individually flagged; callers that need finer granularity can
@@ -117,12 +120,13 @@ class FbEventManager extends Events.EventEmitter {
         let state;
         if (dbConnClosed || !evtConnOpen) {
             state = 'CLOSED';
-        } else if (this._hasActiveSubscription) {
+        }
+        else if (this._hasActiveSubscription) {
             state = 'SUBSCRIBED';
-        } else {
+        }
+        else {
             state = 'IDLE';
         }
-
         return {
             state,
             hasActiveSubscription: this._hasActiveSubscription,
@@ -132,16 +136,13 @@ class FbEventManager extends Events.EventEmitter {
             isDatabaseConnectionClosed: dbConnClosed,
         };
     }
-
     _createEventLoop(callback) {
         var self = this;
         var cnx = this.db.connection;
         this.eventconnection.emgr = this;
-
         if (process.env.FIREBIRD_DEBUG) {
             console.log('[fb-debug] FbEventManager._createEventLoop: eventid=%d', self.eventid);
         }
-
         // Re-subscribe after each op_event notification so that further
         // trigger fires continue to be delivered.
         function loop() {
@@ -156,42 +157,31 @@ class FbEventManager extends Events.EventEmitter {
             }
             cnx.queEvents(self.events, self.eventid, function (err) {
                 if (err) {
-                    doError(err, callback);
+                    (0, callback_1.doError)(err, callback);
                     return;
                 }
                 // subscription renewed, nothing else to do
             });
         }
-
         this.eventconnection.eventcallback = function (err, ret) {
             if (err || (self.eventid !== ret.eventid)) {
-                doError(err || new Error('Bad eventid'), callback);
+                (0, callback_1.doError)(err || new Error('Bad eventid'), callback);
                 return;
             }
-
             ret.events.forEach(function (event) {
                 self.emit('post_event', event.name, event.count);
             });
-
             loop();
         };
-
         // Resolve attachEvent on the next tick – no subscription is needed
         // until the caller registers at least one event name via registerEvent().
         // process.nextTick ensures the outer `const evt = new FbEventManager(...)`
         // assignment in database.js completes before this callback fires.
-        process.nextTick(function() { callback(null); });
+        process.nextTick(function () { callback(null); });
     }
-
     _changeEvent(callback) {
         var self = this;
-
-        // Temporarily suppress the event loop to prevent stale op_event
-        // notifications from pushing spurious queEvents onto the main
-        // connection queue while we're reconfiguring the subscription.
-        var savedCallback = self.eventconnection.eventcallback;
-        self.eventconnection.eventcallback = null;
-
+        const changeVersion = ++self._subscriptionVersion;
         function subscribe() {
             // If no events remain, mark subscription as inactive and return.
             // Sending queEvents with an empty EPB after op_cancel_events does
@@ -199,71 +189,64 @@ class FbEventManager extends Events.EventEmitter {
             // permanently block the main connection queue.
             if (Object.keys(self.events).length === 0) {
                 self._hasActiveSubscription = false;
-                self.eventconnection.eventcallback = savedCallback;
                 callback(null);
                 return;
             }
-
+            // Firebird can deliver the initial op_event baseline before the
+            // matching op_response reaches the main connection. Mark the
+            // subscription active before sending queEvents so that this early
+            // op_event can re-queue the next one-shot request.
+            self._hasActiveSubscription = true;
             self.db.connection.queEvents(self.events, self.eventid, function (err, ret) {
-                self.eventconnection.eventcallback = savedCallback;
                 if (err) {
-                    doError(err, callback);
+                    if (self._subscriptionVersion === changeVersion) {
+                        self._hasActiveSubscription = false;
+                    }
+                    (0, callback_1.doError)(err, callback);
                     return;
                 }
-                self._hasActiveSubscription = true;
                 callback(null, ret);
             });
         }
-
         if (self._hasActiveSubscription) {
             // Cancel the current subscription before setting up a new one.
             self.db.connection.closeEvents(this.eventid, function (err) {
                 if (err) {
-                    self.eventconnection.eventcallback = savedCallback;
-                    doError(err, callback);
+                    (0, callback_1.doError)(err, callback);
                     return;
                 }
                 self._hasActiveSubscription = false;
                 subscribe();
             });
-        } else {
+        }
+        else {
             // No active subscription yet (first registerEvent call, or after
             // all events were unregistered) – go straight to subscribing.
             subscribe();
         }
     }
-
     registerEvent(events, callback) {
         var self = this;
-
         if (self.db.connection._isClosed || self.eventconnection._isClosed)
             return self.eventconnection.throwClosed(callback);
-
         events.forEach((event) => self.events[event] = self.events[event] || 0);
         self._changeEvent(callback);
     }
-
     unregisterEvent(events, callback) {
         var self = this;
-
         if (self.db.connection._isClosed || self.eventconnection._isClosed)
             return self.eventconnection.throwClosed(callback);
-
-        events.forEach(function (event) { delete self.events[event] });
+        events.forEach(function (event) { delete self.events[event]; });
         self._changeEvent(callback);
     }
-
     close(callback) {
         var self = this;
-
         if (process.env.FIREBIRD_DEBUG) {
             console.log('[fb-debug] FbEventManager.close() called, _hasActiveSubscription=%s eventid=%d', self._hasActiveSubscription, self.eventid);
         }
-
         // Prevent the event loop from re-queuing on stale op_event notifications
         // that may arrive between closeEvents and socket.end()
         self.eventconnection.eventcallback = null;
-
         // Gracefully close the event socket using a FIN (end()) rather than a RST
         // (destroy()), then wait for the 'close' event which confirms both sides have
         // exchanged FINs.  This gives Firebird (all versions 3/4/5) time to fully
@@ -279,7 +262,8 @@ class FbEventManager extends Events.EventEmitter {
                 if (process.env.FIREBIRD_DEBUG) {
                     console.log('[fb-debug] endAndWaitForClose: socket already destroyed, calling back immediately');
                 }
-                if (cb) cb();
+                if (cb)
+                    cb();
                 return;
             }
             var fired = false;
@@ -291,36 +275,33 @@ class FbEventManager extends Events.EventEmitter {
                     if (process.env.FIREBIRD_DEBUG) {
                         console.log('[fb-debug] endAndWaitForClose done() via %s, eventid=%d', source, self.eventid);
                     }
-                    if (cb) cb();
+                    if (cb)
+                        cb();
                 }
             }
-            sock.once('close', function() { done('close-event'); });
+            sock.once('close', function () { done('close-event'); });
             if (process.env.FIREBIRD_DEBUG) {
                 console.log('[fb-debug] endAndWaitForClose: calling sock.end(), eventid=%d sock.destroyed=%s', self.eventid, sock.destroyed);
             }
             sock.end();
             // Safety fallback: if Firebird never sends its FIN (e.g. an error
             // occurs on the server side), resolve after 200 ms so tests don't hang.
-            timer = setTimeout(function() { done('200ms-timer'); }, 200);
+            timer = setTimeout(function () { done('200ms-timer'); }, 200);
         }
-
         if (!self._hasActiveSubscription) {
             // No active subscription (attachEvent without registerEvent, or
             // all events were unregistered) – nothing to cancel.
             endAndWaitForClose(callback);
             return;
         }
-
         self.db.connection.closeEvents(this.eventid, function (err) {
             if (err) {
-                doError(err, callback);
+                (0, callback_1.doError)(err, callback);
                 return;
             }
-
             self._hasActiveSubscription = false;
             endAndWaitForClose(callback);
         });
     }
 }
-
 module.exports = FbEventManager;

package/lib/wire/serialize.d.ts

@@ -0,0 +1,97 @@
+export declare class BlrWriter {
+    buffer: Buffer;
+    pos: number;
+    constructor(size?: number);
+    ensure(len: number): void;
+    addByte(b: number): void;
+    addShort(b: number): void;
+    addSmall(b: number): void;
+    addWord(b: number): void;
+    addInt32(b: number): void;
+    addByteInt32(c: number, b: number): void;
+    addNumeric(c: number, v: number): void;
+    addBytes(b: number[] | Buffer): void;
+    addString(c: number, s: string, encoding: BufferEncoding): void;
+    addBuffer(b: Buffer): void;
+    addString2(c: number, s: string, encoding: BufferEncoding): void;
+    addMultiblockPart(c: number, s: string, encoding: BufferEncoding): void;
+}
+/***************************************
+ *
+ *   BLR Reader
+ *
+ ***************************************/
+export declare class BlrReader {
+    buffer: Buffer;
+    pos: number;
+    constructor(buffer: Buffer);
+    readByteCode(): number;
+    readInt32(): number;
+    readInt(): any;
+    readString(encoding?: BufferEncoding): string;
+    readSegment(): Buffer;
+}
+/***************************************
+ *
+ *   XDR Writer
+ *
+ ***************************************/
+export declare class XdrWriter {
+    buffer: Buffer;
+    pos: number;
+    constructor(size?: number);
+    ensure(len: number): void;
+    addInt(value: number): void;
+    addInt64(value: number): void;
+    addInt128(value: number | bigint | string): void;
+    addDecFloat16(value: number | string | bigint): void;
+    addDecFloat34(value: number | string | bigint): void;
+    addUInt(value: number): void;
+    addString(s: string, encoding: BufferEncoding): void;
+    addText(s: string, encoding: BufferEncoding): void;
+    addParamBuffer(b: Buffer): void;
+    addBlr(blr: BlrWriter): void;
+    getData(): Buffer;
+    addDouble(value: number): void;
+    addQuad(quad: {
+        low: number;
+        high: number;
+    }): void;
+    addBuffer(buffer: Buffer): void;
+    addAlignment(len: number): void;
+}
+/***************************************
+ *
+ *   XDR Reader
+ *
+ ***************************************/
+export declare class XdrReader {
+    buffer: Buffer;
+    pos: number;
+    constructor(buffer: Buffer);
+    readInt(): number;
+    readUInt(): number;
+    readInt64(): number;
+    readInt128(): bigint;
+    readDecFloat16(): string | number;
+    readDecFloat34(): string | number;
+    readShort(): number;
+    readQuad(): {
+        low: number;
+        high: number;
+    };
+    readFloat(): number;
+    readDouble(): number;
+    readArray(): Buffer<ArrayBuffer>;
+    readBuffer(len?: number, toAlign?: boolean): Buffer | undefined;
+    readString(encoding: BufferEncoding): string;
+    readText(len: number, encoding: BufferEncoding): string;
+}
+export declare class BitSet {
+    data: number[];
+    constructor(buffer?: Buffer);
+    scale(index: number): void;
+    set(index: number, value?: boolean | number): void;
+    get(index: number): number;
+    toBuffer(): Buffer;
+}