node-firebird 2.9.0 → 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,47 +4,55 @@
  *
  ***************************************/
 
-import { doError, 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;
+    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;
-    [key: string]: any;
+    /** 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: any) {
+    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;
@@ -64,11 +72,11 @@ class Statement {
         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;
@@ -81,7 +89,7 @@ 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);
     }
 
@@ -91,7 +99,7 @@ class Statement {
      * 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 {
@@ -108,27 +116,27 @@ class Statement {
 
     /* 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); });
     }

package/src/wire/transaction.ts

@@ -1,7 +1,13 @@
-import { doCallback, doError, fromCallback } from '../callback';
+import { doCallback, doError, fromCallback, type Callback, type SimpleCallback } from '../callback';
 import { parseNamedPlaceholders } from '../named-params';
 import { noop } from '../utils';
 import Const from './const';
+import makeQueryStream from './query-stream';
+import type Connection from './connection';
+import type Database from './database';
+import type Statement from './statement';
+import type { BatchCb, StatementCb, InternalQueryOptions } from './wire-types';
+import type { BatchOptions, BatchResult, QueryOptions, QueryParams, QueryStreamOptions, SequentialCallback } from '../types';
 
 /***************************************
  *
@@ -26,7 +32,7 @@ function abortError(signal: any): Error {
  * GDSCode.CANCELLED). Returns the wrapped callback that detaches the
  * listener once the operation settles.
  */
-function hookAbortSignal(connection: any, signal: any, callback: any): any {
+function hookAbortSignal(connection: Connection, signal: AbortSignal, callback: any): any {
     var settled = false;
     var onAbort = function() {
         if (!settled)
@@ -42,26 +48,29 @@ function hookAbortSignal(connection: any, signal: any, callback: any): any {
 }
 
 class Transaction {
-    connection: any;
-    db: any;
-    handle: number;
-    [key: string]: any;
+    connection: Connection;
+    db: Database;
+    // populated externally from the op_transaction response
+    handle!: number;
 
-    constructor(connection: any) {
+    constructor(connection: Connection) {
         this.connection = connection;
         this.db = connection.db;
     }
 
     /** Per-call options.namedPlaceholders overrides the connection option. */
-    private namedPlaceholdersEnabled(options?: any): boolean {
+    private namedPlaceholdersEnabled(options?: InternalQueryOptions): boolean {
         if (options && options.namedPlaceholders !== undefined)
             return !!options.namedPlaceholders;
         return !!(this.connection.options && this.connection.options.namedPlaceholders);
     }
 
-    newStatement(query: string, callback: (err: any, statement?: any) => void, options?: any): void {
+    newStatement(query: string, callback: StatementCb, options?: InternalQueryOptions): void {
         var cnx = this.connection;
         var self = this;
+        // the public strict callback shape and the internal optional-args
+        // shape only differ in optionality; treat it as the internal one
+        var cb = callback as Callback<Statement>;
 
         // With namedPlaceholders on, prepare the positional rewrite and
         // remember the name order on the statement so statement.execute can
@@ -75,13 +84,13 @@ class Transaction {
             }
         }
 
-        var deliver = function(err: any, statement?: any) {
+        var deliver = function(err: any, statement?: Statement) {
             if (statement)
                 statement.namedParams = names;
-            callback(err, statement);
+            cb(err, statement);
         };
 
-        var query_cache = cnx.getCachedQuery(query);
+        var query_cache = cnx.takeCachedStatement(query);
 
         if (query_cache) {
             deliver(null, query_cache);
@@ -90,7 +99,7 @@ class Transaction {
         }
     }
 
-    execute(query: string, params?: any, callback?: any, options?: any): void {
+    execute(query: string, params?: QueryParams | Callback, callback?: any, options?: InternalQueryOptions): void {
         if (params instanceof Function) {
             options = callback;
             callback = params;
@@ -107,15 +116,19 @@ class Transaction {
         }
 
         var self = this;
-        this.newStatement(query, function(err: any, statement: any) {
+        this.newStatement(query, function(err: any, statement?: Statement) {
 
-            if (err) {
+            if (err || !statement) {
                 doError(err, callback);
                 return;
             }
 
             function dropError(err: any) {
-                statement.release();
+                // do not put a statement that just failed back into the cache
+                // (statement is guaranteed by the guard above; hoisting keeps
+                // the narrowing from reaching this function declaration)
+                statement!._failed = true;
+                statement!.release();
                 doCallback(err, callback);
             }
 
@@ -178,7 +191,7 @@ class Transaction {
         }, options);
     }
 
-    sequentially(query: string, params?: any, on?: any, callback?: any, options: any = {}): this {
+    sequentially(query: string, params?: any, on?: any, callback?: any, options: InternalQueryOptions | boolean = {}): this {
         if (params instanceof Function) {
             options = callback;
             callback = on;
@@ -196,7 +209,7 @@ class Transaction {
         }
 
         var self = this;
-        var _on = function(row: any, i: number, meta: any, next: (err?: any) => void) {
+        var _on = function(row: any, i: number, meta: any[], next: (err?: any) => void) {
             var done = false;
             var finish = function(err?: any) {
                 if (done) {
@@ -242,7 +255,17 @@ class Transaction {
         return self;
     }
 
-    query(query: string, params?: any, callback?: any, options: any = {}): void {
+    /**
+     * Run `query` inside this transaction and return an object-mode
+     * Readable emitting one row per chunk, with real backpressure (see
+     * Database.queryStream). The transaction is NOT committed when the
+     * stream ends — commit or roll back yourself.
+     */
+    queryStream(query: string, params?: QueryParams, options?: QueryStreamOptions) {
+        return makeQueryStream(this, query, params, options);
+    }
+
+    query(query: string, params?: QueryParams | Callback, callback?: any, options: InternalQueryOptions = {}): void {
         if (params instanceof Function) {
             callback = params;
             params = undefined;
@@ -269,15 +292,17 @@ class Transaction {
      * commit or roll back yourself (or use db.executeBatch for
      * all-or-nothing semantics).
      */
-    executeBatch(query: string, rows: any[][], callback?: any, options?: any): void {
+    executeBatch(query: string, rows: QueryParams[], callback?: BatchCb, options?: BatchOptions & QueryOptions): void {
         var self = this;
-        this.newStatement(query, function(err: any, statement: any) {
-            if (err) {
+        this.newStatement(query, function(err: any, statement?: Statement) {
+            if (err || !statement) {
                 doError(err, callback);
                 return;
             }
 
-            statement.executeBatch(self, rows, function(err: any, result: any) {
+            statement.executeBatch(self, rows, function(err: any, result: BatchResult) {
+                if (err)
+                    statement._failed = true;
                 statement.release();
                 if (callback)
                     callback(err, result);
@@ -285,40 +310,40 @@ class Transaction {
         }, options);
     }
 
-    executeBatchAsync(query: string, rows: any[][], options?: any): Promise<any> {
+    executeBatchAsync(query: string, rows: QueryParams[], options?: BatchOptions & QueryOptions): Promise<BatchResult> {
         var self = this;
         return fromCallback(function(cb) { self.executeBatch(query, rows, cb, options); });
     }
 
-    commit(callback?: (err?: any) => void): void {
+    commit(callback?: SimpleCallback): void {
         this.connection.commit(this, callback);
     }
 
-    rollback(callback?: (err?: any) => void): void {
+    rollback(callback?: SimpleCallback): void {
         this.connection.rollback(this, callback);
     }
 
-    commitRetaining(callback?: (err?: any) => void): void {
+    commitRetaining(callback?: SimpleCallback): void {
         this.connection.commitRetaining(this, callback);
     }
 
-    rollbackRetaining(callback?: (err?: any) => void): void {
+    rollbackRetaining(callback?: SimpleCallback): void {
         this.connection.rollbackRetaining(this, callback);
     }
 
     /* Promise / async-await API — wrappers over the callback methods above. */
 
-    queryAsync(query: string, params?: any, options?: any): Promise<any[]> {
+    queryAsync(query: string, params?: QueryParams, options?: InternalQueryOptions): Promise<any[]> {
         var self = this;
         return fromCallback(function(cb) { self.query(query, params, cb, options); });
     }
 
-    executeAsync(query: string, params?: any, options?: any): Promise<any[]> {
+    executeAsync(query: string, params?: QueryParams, options?: InternalQueryOptions): Promise<any[]> {
         var self = this;
         return fromCallback(function(cb) { self.execute(query, params, cb, options); });
     }
 
-    sequentiallyAsync(query: string, params?: any, on?: any, options?: any): Promise<void> {
+    sequentiallyAsync(query: string, params?: any, on?: SequentialCallback, options?: InternalQueryOptions | boolean): Promise<void> {
         if (params instanceof Function) {
             options = on;
             on = params;
@@ -328,7 +353,7 @@ class Transaction {
         return fromCallback(function(cb) { self.sequentially(query, params, on, cb, options); });
     }
 
-    newStatementAsync(query: string): Promise<any> {
+    newStatementAsync(query: string): Promise<Statement> {
         var self = this;
         return fromCallback(function(cb) { self.newStatement(query, cb); });
     }