node-firebird 2.8.1 → 2.10.0

package/src/wire/service.ts

@@ -2,7 +2,7 @@ import Events from 'events';
 import stream from 'stream';
 import Const from './const';
 import { BlrReader } from './serialize';
-import { doError } from '../callback';
+import { doError, fromCallback } from '../callback';
 
 /***************************************
  *
@@ -994,7 +994,7 @@ class ServiceManager extends Events.EventEmitter {
         var buffersize = options.buffersize || 2048;
         var timeout = options.timeout || 60;
         var self = this;
-        this.connection.svcquery([Const.isc_info_svc_line], buffersize, timeout, function (err, data) {
+        this.connection.svcquery([Const.isc_info_svc_line], buffersize, timeout, function (err: any, data: any) {
             if (err || !data.buffer) {
                 doError(new Error(err||'Bad query return'), callback);
                 return;
@@ -1007,7 +1007,7 @@ class ServiceManager extends Events.EventEmitter {
         var buffersize = options.buffersize || (8 * 1024);
         var timeout = options.timeout || 60;
         var self = this;
-        this.connection.svcquery([Const.isc_info_svc_to_eof], buffersize, timeout, function (err, data) {
+        this.connection.svcquery([Const.isc_info_svc_to_eof], buffersize, timeout, function (err: any, data: any) {
             if (err || !data.buffer) {
                 doError(new Error(err||'Bad query return'), callback);
                 return;
@@ -1020,7 +1020,7 @@ class ServiceManager extends Events.EventEmitter {
         var buffersize = options.buffersize || 2048;
         var timeout = options.timeout || 60;
         var self = this;
-        this.connection.svcquery([Const.isc_info_svc_running], buffersize, timeout, function (err, data) {
+        this.connection.svcquery([Const.isc_info_svc_running], buffersize, timeout, function (err: any, data: any) {
             if (err || !data.buffer) {
                 doError(new Error(err||'Bad query return'), callback);
                 return;
@@ -1033,7 +1033,7 @@ class ServiceManager extends Events.EventEmitter {
         var buffersize = options.buffersize || 2048;
         var timeout = options.timeout || 60;
         var self = this;
-        this.connection.svcquery([Const.isc_info_svc_get_users], buffersize, timeout, function (err, data) {
+        this.connection.svcquery([Const.isc_info_svc_get_users], buffersize, timeout, function (err: any, data: any) {
             if (err || !data.buffer) {
                 doError(new Error(err||'Bad query return'), callback);
                 return;
@@ -1046,7 +1046,7 @@ class ServiceManager extends Events.EventEmitter {
         var buffersize = options.buffersize || 2048;
         var timeout = options.timeout || 60;
         var self = this;
-        this.connection.svcquery([Const.isc_info_svc_limbo_trans], buffersize, timeout, function (err, data) {
+        this.connection.svcquery([Const.isc_info_svc_limbo_trans], buffersize, timeout, function (err: any, data: any) {
             if (err || !data.buffer) {
                 doError(new Error(err||'Bad query return'), callback);
                 return;
@@ -1055,6 +1055,188 @@ class ServiceManager extends Events.EventEmitter {
         });
     }
 
+    /* Promise / async-await API — wrappers over the callback methods above. */
+
+    detachAsync(force?: boolean): Promise<void> {
+        var self = this;
+        return fromCallback(function(cb) { self.detach(cb, force); });
+    }
+
+    backupAsync(options: any): Promise<stream.Readable> {
+        var self = this;
+        return fromCallback(function(cb) { self.backup(options, cb); });
+    }
+
+    nbackupAsync(options: any): Promise<stream.Readable> {
+        var self = this;
+        return fromCallback(function(cb) { self.nbackup(options, cb); });
+    }
+
+    restoreAsync(options: any): Promise<stream.Readable> {
+        var self = this;
+        return fromCallback(function(cb) { self.restore(options, cb); });
+    }
+
+    nrestoreAsync(options: any): Promise<stream.Readable> {
+        var self = this;
+        return fromCallback(function(cb) { self.nrestore(options, cb); });
+    }
+
+    setDialectAsync(db: string, dialect: number): Promise<any> {
+        var self = this;
+        return fromCallback(function(cb) { self.setDialect(db, dialect, cb); });
+    }
+
+    setSweepintervalAsync(db: string, sweepinterval: number): Promise<any> {
+        var self = this;
+        return fromCallback(function(cb) { self.setSweepinterval(db, sweepinterval, cb); });
+    }
+
+    setCachebufferAsync(db: string, nbpages: number): Promise<any> {
+        var self = this;
+        return fromCallback(function(cb) { self.setCachebuffer(db, nbpages, cb); });
+    }
+
+    BringOnlineAsync(db: string): Promise<any> {
+        var self = this;
+        return fromCallback(function(cb) { self.BringOnline(db, cb); });
+    }
+
+    ShutdownAsync(db: string, kind: number, delay: number, mode?: any): Promise<any> {
+        var self = this;
+        return fromCallback(function(cb) { self.Shutdown(db, kind, delay, mode, cb); });
+    }
+
+    setShadowAsync(db: string, val: boolean): Promise<any> {
+        var self = this;
+        return fromCallback(function(cb) { self.setShadow(db, val, cb); });
+    }
+
+    setForcewriteAsync(db: string, val: boolean): Promise<any> {
+        var self = this;
+        return fromCallback(function(cb) { self.setForcewrite(db, val, cb); });
+    }
+
+    setReservespaceAsync(db: string, val: boolean): Promise<any> {
+        var self = this;
+        return fromCallback(function(cb) { self.setReservespace(db, val, cb); });
+    }
+
+    setReadonlyModeAsync(db: string): Promise<any> {
+        var self = this;
+        return fromCallback(function(cb) { self.setReadonlyMode(db, cb); });
+    }
+
+    setReadwriteModeAsync(db: string): Promise<any> {
+        var self = this;
+        return fromCallback(function(cb) { self.setReadwriteMode(db, cb); });
+    }
+
+    validateAsync(options: any): Promise<stream.Readable> {
+        var self = this;
+        return fromCallback(function(cb) { self.validate(options, cb); });
+    }
+
+    commitAsync(db: string, transactid: number): Promise<any> {
+        var self = this;
+        return fromCallback(function(cb) { self.commit(db, transactid, cb); });
+    }
+
+    rollbackAsync(db: string, transactid: number): Promise<any> {
+        var self = this;
+        return fromCallback(function(cb) { self.rollback(db, transactid, cb); });
+    }
+
+    recoverAsync(db: string, transactid: number): Promise<any> {
+        var self = this;
+        return fromCallback(function(cb) { self.recover(db, transactid, cb); });
+    }
+
+    getStatsAsync(options: any): Promise<stream.Readable> {
+        var self = this;
+        return fromCallback(function(cb) { self.getStats(options, cb); });
+    }
+
+    getLogAsync(options: any): Promise<stream.Readable> {
+        var self = this;
+        return fromCallback(function(cb) { self.getLog(options, cb); });
+    }
+
+    getUsersAsync(username?: string | null): Promise<any> {
+        var self = this;
+        return fromCallback(function(cb) { self.getUsers(username === undefined ? null : username, cb); });
+    }
+
+    addUserAsync(username: string, password: string, options?: any): Promise<any> {
+        var self = this;
+        return fromCallback(function(cb) { self.addUser(username, password, options, cb); });
+    }
+
+    editUserAsync(username: string, options: any): Promise<any> {
+        var self = this;
+        return fromCallback(function(cb) { self.editUser(username, options, cb); });
+    }
+
+    removeUserAsync(username: string, rolename?: string | null): Promise<any> {
+        var self = this;
+        return fromCallback(function(cb) { self.removeUser(username, rolename === undefined ? null : rolename, cb); });
+    }
+
+    getFbserverInfosAsync(infos?: any, options?: any): Promise<any> {
+        var self = this;
+        return fromCallback(function(cb) { self.getFbserverInfos(infos || {}, options || {}, cb); });
+    }
+
+    startTraceAsync(options: any): Promise<stream.Readable> {
+        var self = this;
+        return fromCallback(function(cb) { self.startTrace(options, cb); });
+    }
+
+    suspendTraceAsync(options: any): Promise<stream.Readable> {
+        var self = this;
+        return fromCallback(function(cb) { self.suspendTrace(options, cb); });
+    }
+
+    resumeTraceAsync(options: any): Promise<stream.Readable> {
+        var self = this;
+        return fromCallback(function(cb) { self.resumeTrace(options, cb); });
+    }
+
+    stopTraceAsync(options: any): Promise<stream.Readable> {
+        var self = this;
+        return fromCallback(function(cb) { self.stopTrace(options, cb); });
+    }
+
+    getTraceListAsync(options?: any): Promise<stream.Readable> {
+        var self = this;
+        return fromCallback(function(cb) { self.getTraceList(options || {}, cb); });
+    }
+
+    readlineAsync(options?: any): Promise<{ result: number, line: string }> {
+        var self = this;
+        return fromCallback(function(cb) { self.readline(options || {}, cb); });
+    }
+
+    readeofAsync(options?: any): Promise<{ result: number, line: string }> {
+        var self = this;
+        return fromCallback(function(cb) { self.readeof(options || {}, cb); });
+    }
+
+    hasRunningActionAsync(options?: any): Promise<any> {
+        var self = this;
+        return fromCallback(function(cb) { self.hasRunningAction(options || {}, cb); });
+    }
+
+    readusersAsync(options?: any): Promise<any> {
+        var self = this;
+        return fromCallback(function(cb) { self.readusers(options || {}, cb); });
+    }
+
+    readlimboAsync(options?: any): Promise<any> {
+        var self = this;
+        return fromCallback(function(cb) { self.readlimbo(options || {}, cb); });
+    }
+
 }
 
 export = ServiceManager;

package/src/wire/socket.ts

@@ -91,8 +91,15 @@ class ChaChaCipher {
 class Socket {
     static Arc4 = Arc4;
 
+    // The constructor returns a Proxy whose get trap falls through to the
+    // underlying net.Socket, so callers can use net.Socket members not
+    // reimplemented here. Declare the ones the driver relies on (type-only,
+    // nothing is emitted).
+    declare end: net.Socket['end'];
+    declare removeAllListeners: net.Socket['removeAllListeners'];
+
     _socket: net.Socket;
-    compress: boolean;
+    compress: boolean = false;
     compressor: zlib.Deflate | null;
     compressorBuffer: Buffer[];
     decompressor: zlib.Inflate | null;
@@ -102,10 +109,12 @@ class Socket {
     encryptCipher: any;
     decryptCipher: any;
 
-    constructor(port: number, host: string) {
+    constructor(port: number, host: string, enableKeepAlive = true, keepAliveInitialDelay = 60000) {
         this._socket = net.createConnection(port, host);
         this._socket.setNoDelay(true);
-        this._socket.setKeepAlive(true, 60000); // 1 minute delay to detect dead/stale connections
+        // TCP keepalive probing detects dead/stale connections; the delay is
+        // how long the socket must be idle before the first probe.
+        this._socket.setKeepAlive(enableKeepAlive, keepAliveInitialDelay);
         this.compressor = null;
         this.compressorBuffer = [];
         this.decompressor = null;
@@ -137,7 +146,7 @@ class Socket {
                 }
 
                 if (this.compress) {
-                    this.decompressor.write(data, () => {
+                    this.decompressor!.write(data, () => {
                         mainCb(Buffer.concat(this.decompressorBuffer));
                         this.decompressorBuffer = []; // Reset buffer
                     });
@@ -176,7 +185,7 @@ class Socket {
         }
 
         if (this.compress) {
-            this.compressor.write(data, () => {
+            this.compressor!.write(data, () => {
                 var compressedData = Buffer.concat(this.compressorBuffer);
                 this.compressorBuffer = []; // Reset buffer
 
@@ -236,8 +245,8 @@ class Socket {
             const stretchedKey = crypto.createHash('sha256').update(sessionKey).digest();
             const ivlen = pluginName === 'ChaCha64' ? 8 : (iv ? iv.length : 16);
 
-            this.encryptCipher = new ChaChaCipher(stretchedKey, iv, ivlen, true);
-            this.decryptCipher = new ChaChaCipher(stretchedKey, iv, ivlen, false);
+            this.encryptCipher = new ChaChaCipher(stretchedKey, iv!, ivlen, true);
+            this.decryptCipher = new ChaChaCipher(stretchedKey, iv!, ivlen, false);
         } else {
             throw new Error('Unsupported encryption plugin: ' + pluginName);
         }
@@ -248,7 +257,7 @@ class Socket {
      */
     get(target: any, field: string | symbol): any {
         if (field in this) {
-            return this[field].bind(this);
+            return (this as any)[field].bind(this);
         }
 
         if (typeof target[field] === 'function') {

package/src/wire/statement.ts

@@ -4,55 +4,79 @@
  *
  ***************************************/
 
-import { fromCallback } from '../callback';
+import { doError, fromCallback, type Callback, type SimpleCallback } from '../callback';
+import { bindNamedParams, isNamedParamsObject } from '../named-params';
+import type Connection from './connection';
+import type Transaction from './transaction';
+import type { SQLVarBase } from './xsqlvar';
+import type { QueryOptions, QueryParams } from '../types';
 
 class Statement {
-    connection: any;
-    query: string;
-    type: number;
-    output: any[];
-    input: any[];
-    options: any;
-    handle: number;
-    plan: string;
-    [key: string]: any;
-
-    constructor(connection: any) {
+    connection: Connection;
+    // populated externally from the op_allocate_statement /
+    // op_prepare_statement responses (see describe() in connection.ts),
+    // hence the definite assignment assertions
+    query!: string;
+    type!: number;
+    output!: SQLVarBase[];
+    input!: SQLVarBase[];
+    /** per-execute query options (asObject/asStream/timeout/...) */
+    options: QueryOptions & { [key: string]: any } | undefined;
+    handle!: number;
+    plan!: string;
+    /**
+     * Placeholder names in positional order when this statement was
+     * prepared from SQL with named placeholders (namedPlaceholders on),
+     * null/undefined otherwise. Set by Transaction.newStatement.
+     */
+    namedParams?: string[] | null;
+    /** set when an execute/fetch on this statement errored — the statement
+     *  is dropped on release instead of going back into the cache */
+    _failed?: boolean;
+    /** rows fetched so far by the current cursor (decodeResponse) */
+    nbrowsfetched?: number;
+
+    constructor(connection: Connection) {
         this.connection = connection;
     }
 
-    close(callback?: (err?: any) => void): void {
+    close(callback?: SimpleCallback): void {
         this.connection.closeStatement(this, callback);
     }
 
-    drop(callback?: (err?: any) => void): void {
+    drop(callback?: SimpleCallback): void {
         this.connection.dropStatement(this, callback);
     }
 
-    release(callback?: (err?: any) => void): void {
-        var cache_query = this.connection.getCachedQuery(this.query);
-        if (cache_query)
-            this.connection.closeStatement(this, callback);
-        else
-            this.connection.dropStatement(this, callback);
+    release(callback?: SimpleCallback): void {
+        this.connection.releaseStatement(this, callback);
     }
 
-    execute(transaction: any, params?: any, callback?: any, options?: any): void {
+    execute(transaction: Transaction, params?: any, callback?: any, options?: any): void {
         if (params instanceof Function) {
             options = callback;
             callback = params;
             params = undefined;
         }
 
+        if (this.namedParams && isNamedParamsObject(params)) {
+            try {
+                params = bindNamedParams(this.namedParams, params);
+            } catch (err) {
+                doError(err, callback);
+                return;
+            }
+        }
+
         this.options = options;
         this.connection.executeStatement(transaction, this, params, callback, options);
     }
 
-    fetch(transaction: any, count: number | string, callback: (err: any, result?: any) => void): void {
+    fetch(transaction: Transaction, count: number | string, callback: Callback): void {
         this.connection.fetch(this, transaction, count, callback);
     }
 
-    fetchScroll(transaction: any, direction: string | number, offset?: any, count?: any, callback?: any): void {
+    fetchScroll(transaction: Transaction, direction: string | number, offset?: any, count?: any, callback?: any): void {
         if (typeof count === 'function') {
             callback = count;
             count = undefined;
@@ -65,41 +89,54 @@ class Statement {
         this.connection.fetchScroll(this, transaction, direction, offset, count, callback);
     }
 
-    fetchAll(transaction: any, callback: (err: any, result?: any) => void): void {
+    fetchAll(transaction: Transaction, callback: Callback): void {
         this.connection.fetchAll(this, transaction, callback);
     }
 
     /**
      * Execute this statement once per row via the Firebird 4 batch API
-     * (protocol 16+). `rows` is an array of parameter arrays.
+     * (protocol 16+). `rows` is an array of parameter arrays — or, when the
+     * statement was prepared with named placeholders, of values-by-name
+     * objects (the two forms can be mixed).
      */
-    executeBatch(transaction: any, rows: any[][], callback?: any, options?: any): void {
+    executeBatch(transaction: Transaction, rows: QueryParams[], callback?: any, options?: any): void {
+        var names = this.namedParams;
+        if (names && Array.isArray(rows)) {
+            try {
+                rows = rows.map(function(row: any) {
+                    return isNamedParamsObject(row) ? bindNamedParams(names as string[], row) : row;
+                });
+            } catch (err) {
+                doError(err, callback);
+                return;
+            }
+        }
         this.connection.executeBatch(transaction, this, rows, callback, options);
     }
 
     /* Promise / async-await API — wrappers over the callback methods above. */
 
-    executeAsync(transaction: any, params?: any, options?: any): Promise<any> {
+    executeAsync(transaction: Transaction, params?: any, options?: any): Promise<any> {
         var self = this;
         return fromCallback(function(cb) { self.execute(transaction, params, cb, options); });
     }
 
-    executeBatchAsync(transaction: any, rows: any[][], options?: any): Promise<any> {
+    executeBatchAsync(transaction: Transaction, rows: QueryParams[], options?: any): Promise<any> {
         var self = this;
         return fromCallback(function(cb) { self.executeBatch(transaction, rows, cb, options); });
     }
 
-    fetchAsync(transaction: any, count: number | string): Promise<any> {
+    fetchAsync(transaction: Transaction, count: number | string): Promise<any> {
         var self = this;
         return fromCallback(function(cb) { self.fetch(transaction, count, cb); });
     }
 
-    fetchScrollAsync(transaction: any, direction: string | number, offset?: any, count?: any): Promise<any> {
+    fetchScrollAsync(transaction: Transaction, direction: string | number, offset?: any, count?: any): Promise<any> {
         var self = this;
         return fromCallback(function(cb) { self.fetchScroll(transaction, direction, offset, count, cb); });
     }
 
-    fetchAllAsync(transaction: any): Promise<any> {
+    fetchAllAsync(transaction: Transaction): Promise<any> {
         var self = this;
         return fromCallback(function(cb) { self.fetchAll(transaction, cb); });
     }