node-firebird 2.4.2 → 2.6.0

package/lib/wire/statement.js

@@ -4,6 +4,7 @@
  *   Statement
  *
  ***************************************/
+const callback_1 = require("../callback");
 class Statement {
     constructor(connection) {
         this.connection = connection;
@@ -48,5 +49,34 @@ class Statement {
     fetchAll(transaction, callback) {
         this.connection.fetchAll(this, transaction, callback);
     }
+    /* Promise / async-await API — wrappers over the callback methods above. */
+    executeAsync(transaction, params, options) {
+        var self = this;
+        return (0, callback_1.fromCallback)(function (cb) { self.execute(transaction, params, cb, options); });
+    }
+    fetchAsync(transaction, count) {
+        var self = this;
+        return (0, callback_1.fromCallback)(function (cb) { self.fetch(transaction, count, cb); });
+    }
+    fetchScrollAsync(transaction, direction, offset, count) {
+        var self = this;
+        return (0, callback_1.fromCallback)(function (cb) { self.fetchScroll(transaction, direction, offset, count, cb); });
+    }
+    fetchAllAsync(transaction) {
+        var self = this;
+        return (0, callback_1.fromCallback)(function (cb) { self.fetchAll(transaction, cb); });
+    }
+    closeAsync() {
+        var self = this;
+        return (0, callback_1.fromCallback)(function (cb) { self.close(cb); });
+    }
+    dropAsync() {
+        var self = this;
+        return (0, callback_1.fromCallback)(function (cb) { self.drop(cb); });
+    }
+    releaseAsync() {
+        var self = this;
+        return (0, callback_1.fromCallback)(function (cb) { self.release(cb); });
+    }
 }
 module.exports = Statement;

package/lib/wire/transaction.d.ts

@@ -1,8 +1,3 @@
-/***************************************
- *
- *   Transaction
- *
- ***************************************/
 declare class Transaction {
     connection: any;
     db: any;
@@ -17,5 +12,13 @@ declare class Transaction {
     rollback(callback?: (err?: any) => void): void;
     commitRetaining(callback?: (err?: any) => void): void;
     rollbackRetaining(callback?: (err?: any) => void): void;
+    queryAsync(query: string, params?: any, options?: any): Promise<any[]>;
+    executeAsync(query: string, params?: any, options?: any): Promise<any[]>;
+    sequentiallyAsync(query: string, params?: any, on?: any, options?: any): Promise<void>;
+    newStatementAsync(query: string): Promise<any>;
+    commitAsync(): Promise<void>;
+    rollbackAsync(): Promise<void>;
+    commitRetainingAsync(): Promise<void>;
+    rollbackRetainingAsync(): Promise<void>;
 }
 export = Transaction;

package/lib/wire/transaction.js

@@ -10,6 +10,36 @@ const const_1 = __importDefault(require("./const"));
  *   Transaction
  *
  ***************************************/
+/** The error delivered when options.signal was already aborted on entry. */
+function abortError(signal) {
+    if (signal && signal.reason instanceof Error)
+        return signal.reason;
+    var err = new Error('The operation was aborted');
+    err.name = 'AbortError';
+    err.code = 'ABORT_ERR';
+    return err;
+}
+/**
+ * Wire an AbortSignal to a running statement: on abort, send an out-of-band
+ * op_cancel so the server fails the executing operation with isc_cancelled
+ * (surfaced through the statement's own callback as err.gdscode ===
+ * GDSCode.CANCELLED). Returns the wrapped callback that detaches the
+ * listener once the operation settles.
+ */
+function hookAbortSignal(connection, signal, callback) {
+    var settled = false;
+    var onAbort = function () {
+        if (!settled)
+            connection.cancelOperation(const_1.default.fb_cancel_raise);
+    };
+    signal.addEventListener('abort', onAbort, { once: true });
+    return function (err, result, meta, isSelect) {
+        settled = true;
+        signal.removeEventListener('abort', onAbort);
+        if (callback)
+            callback(err, result, meta, isSelect);
+    };
+}
 class Transaction {
     constructor(connection) {
         this.connection = connection;
@@ -32,6 +62,14 @@ class Transaction {
             callback = params;
             params = undefined;
         }
+        var signal = options && options.signal;
+        if (signal) {
+            if (signal.aborted) {
+                (0, callback_1.doError)(abortError(signal), callback);
+                return;
+            }
+            callback = hookAbortSignal(this.connection, signal, callback);
+        }
         var self = this;
         this.newStatement(query, function (err, statement) {
             if (err) {
@@ -174,5 +212,43 @@ class Transaction {
     rollbackRetaining(callback) {
         this.connection.rollbackRetaining(this, callback);
     }
+    /* Promise / async-await API — wrappers over the callback methods above. */
+    queryAsync(query, params, options) {
+        var self = this;
+        return (0, callback_1.fromCallback)(function (cb) { self.query(query, params, cb, options); });
+    }
+    executeAsync(query, params, options) {
+        var self = this;
+        return (0, callback_1.fromCallback)(function (cb) { self.execute(query, params, cb, options); });
+    }
+    sequentiallyAsync(query, params, on, options) {
+        if (params instanceof Function) {
+            options = on;
+            on = params;
+            params = undefined;
+        }
+        var self = this;
+        return (0, callback_1.fromCallback)(function (cb) { self.sequentially(query, params, on, cb, options); });
+    }
+    newStatementAsync(query) {
+        var self = this;
+        return (0, callback_1.fromCallback)(function (cb) { self.newStatement(query, cb); });
+    }
+    commitAsync() {
+        var self = this;
+        return (0, callback_1.fromCallback)(function (cb) { self.commit(cb); });
+    }
+    rollbackAsync() {
+        var self = this;
+        return (0, callback_1.fromCallback)(function (cb) { self.rollback(cb); });
+    }
+    commitRetainingAsync() {
+        var self = this;
+        return (0, callback_1.fromCallback)(function (cb) { self.commitRetaining(cb); });
+    }
+    rollbackRetainingAsync() {
+        var self = this;
+        return (0, callback_1.fromCallback)(function (cb) { self.rollbackRetaining(cb); });
+    }
 }
 module.exports = Transaction;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "node-firebird",
-    "version": "2.4.2",
+    "version": "2.6.0",
     "description": "Pure JavaScript and Asynchronous Firebird client for Node.js.",
     "keywords": [
         "firebird",

package/src/callback.ts

@@ -20,6 +20,42 @@ export interface FbError extends Error {
 export type SimpleCallback = (err?: any) => void;
 export type Callback<T = any> = (err?: any, result?: T) => void;
 
+/**
+ * Normalize the values the driver passes as the callback error argument.
+ * Most code paths already deliver Error instances, but a few older ones
+ * pass plain objects (status vectors, `{error, message}` wrappers).  A
+ * Promise must reject with an Error, so wrap those while preserving all
+ * their properties (gdscode, gdsparams, status, sqlcode, ...).
+ */
+export function toError(err: any): Error {
+    if (err instanceof Error)
+        return err;
+
+    var error: FbError = new Error(
+        err != null && typeof err === 'object' && err.message ? err.message : String(err)
+    );
+
+    if (err != null && typeof err === 'object')
+        Object.assign(error, err);
+
+    return error;
+}
+
+/**
+ * Run a callback-style operation and return a Promise for its result.
+ * Usage: fromCallback<Database>(cb => attach(options, cb))
+ */
+export function fromCallback<T = any>(executor: (cb: Callback<T>) => void): Promise<T> {
+    return new Promise<T>(function(resolve, reject) {
+        executor(function(err?: any, result?: T) {
+            if (err)
+                reject(toError(err));
+            else
+                resolve(result as T);
+        });
+    });
+}
+
 export function doError(obj: any, callback?: (...args: any[]) => void): void {
     if (callback)
         callback(obj)

package/src/index.ts

@@ -1,5 +1,5 @@
 import Const from './wire/const';
-import { doError, doCallback } from './callback';
+import { doError, doCallback, fromCallback } from './callback';
 import Connection from './wire/connection';
 import Pool from './pool';
 import { escape as escapeValue } from './utils';
@@ -10,6 +10,8 @@ import type {
     ServiceManagerCallback,
     SimpleCallback,
     ConnectionPool,
+    Database,
+    ServiceManager,
 } from './types';
 
 export * from './types';
@@ -155,3 +157,28 @@ export function attachOrCreate(options: Options, callback: DatabaseCallback): vo
 export function pool(max: number, options: Options): ConnectionPool {
 	return new Pool(attach, max, Object.assign({}, options, { isPool: true }));
 }
+
+/*
+ * Promise / async-await API.
+ * Wrappers over the callback functions above; the callback API stays
+ * untouched. Rejections are always Error instances carrying the usual
+ * Firebird properties (gdscode, gdsparams, ...).
+ */
+
+export function attachAsync(options: SvcMgrOptions): Promise<ServiceManager>;
+export function attachAsync(options: Options): Promise<Database>;
+export function attachAsync(options: any): Promise<any> {
+    return fromCallback(function(cb) { attach(options, cb); });
+}
+
+export function createAsync(options: Options): Promise<Database> {
+    return fromCallback(function(cb) { create(options, cb); });
+}
+
+export function attachOrCreateAsync(options: Options): Promise<Database> {
+    return fromCallback(function(cb) { attachOrCreate(options, cb); });
+}
+
+export function dropAsync(options: Options): Promise<void> {
+    return fromCallback(function(cb) { drop(options, cb); });
+}

package/src/pool.ts

@@ -4,6 +4,7 @@
  *
  ***************************************/
 
+import { fromCallback } from './callback';
 import type { Callback } from './callback';
 
 type AttachFn = (options: any, callback: Callback) => void;
@@ -204,6 +205,33 @@ class Pool {
             }
         });
     }
+
+    /* Promise / async-await API — wrappers over the callback methods above. */
+
+    getAsync(): Promise<any> {
+        var self = this;
+        return fromCallback(function(cb) { self.get(cb); });
+    }
+
+    destroyAsync(): Promise<void> {
+        var self = this;
+        return fromCallback(function(cb) { self.destroy(cb); });
+    }
+
+    /**
+     * Run `work` with a connection from the pool, returning it to the pool
+     * (detach) when the returned promise settles — success or failure.
+     */
+    async withConnection<T>(work: (db: any) => Promise<T> | T): Promise<T> {
+        const db = await this.getAsync();
+        try {
+            return await work(db);
+        } finally {
+            // A pooled detach only returns the connection to the pool; do not
+            // let a detach hiccup mask the outcome of `work`.
+            await new Promise<void>(function(resolve) { db.detach(function() { resolve(); }); });
+        }
+    }
 }
 
 export = Pool;

package/src/types.ts

@@ -78,6 +78,15 @@ export type TransactionOptions = {
 export type QueryOptions = {
     timeout?: number;
     scrollable?: boolean;
+    /**
+     * Abort the query when the signal fires (Firebird 2.5+ / protocol 12+).
+     * If the signal is already aborted the query is not sent at all and the
+     * callback/promise fails with an `AbortError`. If it fires mid-flight an
+     * out-of-band op_cancel is sent and the query fails with
+     * `err.gdscode === GDSCode.CANCELLED`. Cancellation is per-attachment:
+     * it cancels whatever is currently executing on the connection.
+     */
+    signal?: AbortSignal;
 }
 
 export interface Database {
@@ -94,6 +103,29 @@ export interface Database {
     alterTablespace(name: string, filePath: string, callback?: QueryCallback): Database;
     dropTablespace(name: string, callback?: QueryCallback): Database;
     createSchema(schemaName: string, tablespaceName?: string | QueryCallback, callback?: QueryCallback): Database;
+
+    // Promise / async-await API (see README § Promises / async–await).
+    // Result metadata is only available through the callback API.
+    queryAsync<T = any>(query: string, params?: any[], options?: QueryOptions): Promise<T[]>;
+    executeAsync<T = any>(query: string, params?: any[], options?: QueryOptions): Promise<T[]>;
+    sequentiallyAsync(query: string, params: any[] | undefined, rowCallback: SequentialCallback, options?: QueryOptions | boolean): Promise<void>;
+    sequentiallyAsync(query: string, rowCallback: SequentialCallback, options?: QueryOptions | boolean): Promise<void>;
+    transactionAsync(options?: TransactionOptions | Isolation): Promise<Transaction>;
+    startTransactionAsync(options?: TransactionOptions | Isolation): Promise<Transaction>;
+    newStatementAsync(query: string): Promise<Statement>;
+    detachAsync(force?: boolean): Promise<void>;
+    dropAsync(): Promise<void>;
+    attachEventAsync(): Promise<any>;
+    /** Starts a transaction, commits when `work` resolves, rolls back when it rejects. */
+    withTransaction<T>(work: (transaction: Transaction) => Promise<T> | T, options?: TransactionOptions | Isolation): Promise<T>;
+    /**
+     * Cancel the operation currently executing on this connection
+     * (Firebird 2.5+ / protocol 12+). The cancelled operation fails through
+     * its own callback/promise with `err.gdscode === GDSCode.CANCELLED`.
+     */
+    cancel(callback?: SimpleCallback): Database;
+    cancel(kind: number, callback?: SimpleCallback): Database;
+    cancelAsync(kind?: number): Promise<void>;
 }
 
 export interface Transaction {
@@ -105,6 +137,17 @@ export interface Transaction {
     commitRetaining(callback?: SimpleCallback): void;
     rollback(callback?: SimpleCallback): void;
     rollbackRetaining(callback?: SimpleCallback): void;
+
+    // Promise / async-await API
+    queryAsync<T = any>(query: string, params?: any[], options?: QueryOptions): Promise<T[]>;
+    executeAsync<T = any>(query: string, params?: any[], options?: QueryOptions): Promise<T[]>;
+    sequentiallyAsync(query: string, params: any[] | undefined, rowCallback: SequentialCallback, options?: QueryOptions | boolean): Promise<void>;
+    sequentiallyAsync(query: string, rowCallback: SequentialCallback, options?: QueryOptions | boolean): Promise<void>;
+    newStatementAsync(query: string): Promise<Statement>;
+    commitAsync(): Promise<void>;
+    commitRetainingAsync(): Promise<void>;
+    rollbackAsync(): Promise<void>;
+    rollbackRetainingAsync(): Promise<void>;
 }
 
 export interface Statement {
@@ -115,6 +158,15 @@ export interface Statement {
     fetch(transaction: Transaction, count: number, callback: QueryCallback): void;
     fetchScroll(transaction: Transaction, direction: 'NEXT' | 'PRIOR' | 'FIRST' | 'LAST' | 'ABSOLUTE' | 'RELATIVE' | number, offset: number, count: number, callback: QueryCallback): void;
     fetchAll(transaction: Transaction, callback: QueryCallback): void;
+
+    // Promise / async-await API
+    executeAsync(transaction: Transaction, params?: any[], options?: QueryOptions): Promise<any>;
+    fetchAsync(transaction: Transaction, count: number | 'all'): Promise<any>;
+    fetchScrollAsync(transaction: Transaction, direction: 'NEXT' | 'PRIOR' | 'FIRST' | 'LAST' | 'ABSOLUTE' | 'RELATIVE' | number, offset?: number, count?: number): Promise<any>;
+    fetchAllAsync(transaction: Transaction): Promise<any>;
+    closeAsync(): Promise<void>;
+    dropAsync(): Promise<void>;
+    releaseAsync(): Promise<void>;
 }
 
 export type SupportedCharacterSet = |
@@ -240,6 +292,12 @@ export interface SvcMgrOptions extends Options {
 export interface ConnectionPool {
     get(callback: DatabaseCallback): void;
     destroy(callback?: SimpleCallback): void;
+
+    // Promise / async-await API
+    getAsync(): Promise<Database>;
+    destroyAsync(): Promise<void>;
+    /** Acquire a connection, run `work`, always return the connection to the pool. */
+    withConnection<T>(work: (db: Database) => Promise<T> | T): Promise<T>;
 }
 
 export interface ReadableOptions {

package/src/wire/connection.ts

@@ -369,6 +369,38 @@ class Connection {
     }
 
 
+    /**
+     * Send an out-of-band op_cancel packet (protocol 12+ / Firebird 2.5+).
+     * The server reads it asynchronously while an operation is executing and
+     * makes that operation fail with isc_cancelled (GDSCode.CANCELLED); the
+     * op_cancel packet itself has no response, so nothing is queued here.
+     */
+    cancelOperation(kind, callback) {
+        if (typeof kind === 'function') {
+            callback = kind;
+            kind = undefined;
+        }
+        kind = kind || Const.fb_cancel_raise;
+
+        if (this._isClosed)
+            return this.throwClosed(callback);
+
+        if (!this.accept || this.accept.protocolVersion < Const.PROTOCOL_VERSION12) {
+            doError(new Error('Query cancellation requires protocol 12+ (Firebird 2.5 or newer)'), callback);
+            return;
+        }
+
+        var msg = this._msg;
+        msg.pos = 0;
+        msg.addInt(Const.op_cancel);
+        msg.addInt(kind);
+        this._socket.write(msg.getData());
+
+        if (callback)
+            callback();
+    }
+
+
     _queueEvent(callback, defer = false) {
         var self = this;
     
@@ -2185,12 +2217,13 @@ function decodeResponse(data: any, callback: any, cnx: any, lowercase_keys: any,
                                 pluginName: accept.pluginName
                             };
 
-                            console.log('--- DEBUG SRP Handshake ---');
-                            console.log('salt:', cnx.serverKeys.salt);
-                            console.log('server public key:', cnx.serverKeys.public.toString(16));
-                            console.log('client public key:', cnx.clientKeys.public.toString(16));
-                            console.log('client private key:', cnx.clientKeys.private.toString(16));
-                            console.log('hashAlgo:', accept.srpAlgo);
+                            if (process.env.FIREBIRD_DEBUG) {
+                                console.log('--- DEBUG SRP Handshake ---');
+                                console.log('salt:', cnx.serverKeys.salt);
+                                console.log('server public key:', cnx.serverKeys.public.toString(16));
+                                console.log('client public key:', cnx.clientKeys.public.toString(16));
+                                console.log('hashAlgo:', accept.srpAlgo);
+                            }
 
                             const _t1 = Date.now();
                             var proof = srp.clientProof(
@@ -2203,8 +2236,11 @@ function decodeResponse(data: any, callback: any, cnx: any, lowercase_keys: any,
                                 accept.srpAlgo
                             );
 
-                            console.log('client proof M1:', proof.authData.toString(16));
-                            console.log('client session key K:', proof.clientSessionKey.toString(16));
+                            if (process.env.FIREBIRD_DEBUG) {
+                                // Never log the private key or the session key: the
+                                // session key is the wire-encryption key material.
+                                console.log('client proof M1:', proof.authData.toString(16));
+                            }
 
                             if (process.env.FIREBIRD_DEBUG) {
                                 console.log('[fb-debug] srp.clientProof(%s): %dms', accept.srpAlgo, Date.now() - _t1);
@@ -2309,12 +2345,13 @@ function decodeResponse(data: any, callback: any, cnx: any, lowercase_keys: any,
                         };
                         var srpAlgo = crypto[pluginName];
 
-                        console.log('--- DEBUG SRP Handshake ---');
-                        console.log('salt:', cnx.serverKeys.salt);
-                        console.log('server public key:', cnx.serverKeys.public.toString(16));
-                        console.log('client public key:', cnx.clientKeys.public.toString(16));
-                        console.log('client private key:', cnx.clientKeys.private.toString(16));
-                        console.log('hashAlgo:', srpAlgo);
+                        if (process.env.FIREBIRD_DEBUG) {
+                            console.log('--- DEBUG SRP Handshake ---');
+                            console.log('salt:', cnx.serverKeys.salt);
+                            console.log('server public key:', cnx.serverKeys.public.toString(16));
+                            console.log('client public key:', cnx.clientKeys.public.toString(16));
+                            console.log('hashAlgo:', srpAlgo);
+                        }
 
                         const _t1 = Date.now();
                         var proof = srp.clientProof(

package/src/wire/const.ts

@@ -132,6 +132,14 @@ const dsql = {
     DSQL_unprepare : 4, // >: 2.5
 };
 
+// fb_cancel_operation kinds sent with op_cancel (protocol 12+ / Firebird 2.5+)
+const cancelKind = {
+    fb_cancel_disable : 1, // disable execution of fb_cancel_raise requests
+    fb_cancel_enable  : 2, // re-enable delivery of cancel requests
+    fb_cancel_raise   : 3, // cancel the operation currently executing on the attachment
+    fb_cancel_abort   : 4, // forcibly abort the attachment's current activity
+};
+
 const fetchOp = {
     fetch_next                : 0,
     fetch_prior               : 1,
@@ -859,6 +867,7 @@ const Const = Object.freeze({
     ...blr,
     ...blobType,
     ...buffer,
+    ...cancelKind,
     ...cnct,
     ...common,
     ...connect,

package/src/wire/database.ts

@@ -1,5 +1,5 @@
 import Events from 'events';
-import { doError } from '../callback';
+import { doError, fromCallback } from '../callback';
 import { escape } from '../utils';
 import Const from './const';
 import EventConnection from './eventConnection';
@@ -322,6 +322,22 @@ class Database extends Events.EventEmitter {
         return this.connection.dropDatabase(callback);
     }
 
+    /**
+     * Cancel the operation currently executing on this connection by sending
+     * an out-of-band op_cancel (Firebird 2.5+ / protocol 12+). The cancelled
+     * operation fails through its own callback with err.gdscode ===
+     * GDSCode.CANCELLED. `kind` defaults to fb_cancel_raise; cancellation is
+     * per-attachment, not per-statement.
+     */
+    cancel(kind?: number | ((err?: any) => void), callback?: (err?: any) => void): this {
+        if (typeof kind === 'function') {
+            callback = kind;
+            kind = undefined;
+        }
+        this.connection.cancelOperation(kind, callback);
+        return this;
+    }
+
     attachEvent(callback: (err: any, evt?: any) => void): this {
         var self = this;
         const eventid = self.eventid++;
@@ -439,6 +455,86 @@ class Database extends Events.EventEmitter {
         }
         return this.execute(sql, [], callback);
     }
+
+    /*
+     * Promise / async-await API.
+     * Each *Async method wraps its callback counterpart; the callback API
+     * stays untouched. Result metadata is only available through the
+     * callback API — the promises resolve with the rows alone.
+     */
+
+    queryAsync(query: string, params?: any, options?: any): Promise<any[]> {
+        var self = this;
+        return fromCallback(function(cb) { self.query(query, params, cb, options); });
+    }
+
+    executeAsync(query: string, params?: any, options?: any): 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> {
+        if (params instanceof Function) {
+            options = on;
+            on = params;
+            params = undefined;
+        }
+        var self = this;
+        return fromCallback(function(cb) { self.sequentially(query, params, on, cb, options); });
+    }
+
+    transactionAsync(options?: any): Promise<any> {
+        var self = this;
+        return fromCallback(function(cb) { self.startTransaction(options, cb); });
+    }
+
+    startTransactionAsync(options?: any): Promise<any> {
+        return this.transactionAsync(options);
+    }
+
+    newStatementAsync(query: string): Promise<any> {
+        var self = this;
+        return fromCallback(function(cb) { self.newStatement(query, cb); });
+    }
+
+    detachAsync(force?: boolean): Promise<void> {
+        var self = this;
+        return fromCallback(function(cb) { self.detach(cb, force); });
+    }
+
+    dropAsync(): Promise<void> {
+        var self = this;
+        return fromCallback(function(cb) { self.drop(cb); });
+    }
+
+    attachEventAsync(): Promise<any> {
+        var self = this;
+        return fromCallback(function(cb) { self.attachEvent(cb); });
+    }
+
+    cancelAsync(kind?: number): Promise<void> {
+        var self = this;
+        return fromCallback(function(cb) { self.cancel(kind, cb); });
+    }
+
+    /**
+     * Run `work` inside a transaction: commits when the returned promise
+     * resolves, rolls back when it rejects (the original error is rethrown,
+     * even if the rollback itself fails).
+     */
+    async withTransaction<T>(work: (transaction: any) => Promise<T> | T, options?: any): Promise<T> {
+        const transaction = await this.transactionAsync(options);
+        try {
+            const result = await work(transaction);
+            await fromCallback(function(cb) { transaction.commit(cb); });
+            return result;
+        } catch (err) {
+            try {
+                await fromCallback(function(cb) { transaction.rollback(cb); });
+            } catch { /* surface the original error, not the rollback failure */ }
+            throw err;
+        }
+    }
 }
 
 export = Database;

package/src/wire/statement.ts

@@ -4,6 +4,8 @@
  *
  ***************************************/
 
+import { fromCallback } from '../callback';
+
 class Statement {
     connection: any;
     query: string;
@@ -66,6 +68,43 @@ class Statement {
     fetchAll(transaction: any, callback: (err: any, result?: any) => void): void {
         this.connection.fetchAll(this, transaction, callback);
     }
+
+    /* Promise / async-await API — wrappers over the callback methods above. */
+
+    executeAsync(transaction: any, params?: any, options?: any): Promise<any> {
+        var self = this;
+        return fromCallback(function(cb) { self.execute(transaction, params, cb, options); });
+    }
+
+    fetchAsync(transaction: any, 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> {
+        var self = this;
+        return fromCallback(function(cb) { self.fetchScroll(transaction, direction, offset, count, cb); });
+    }
+
+    fetchAllAsync(transaction: any): Promise<any> {
+        var self = this;
+        return fromCallback(function(cb) { self.fetchAll(transaction, cb); });
+    }
+
+    closeAsync(): Promise<void> {
+        var self = this;
+        return fromCallback(function(cb) { self.close(cb); });
+    }
+
+    dropAsync(): Promise<void> {
+        var self = this;
+        return fromCallback(function(cb) { self.drop(cb); });
+    }
+
+    releaseAsync(): Promise<void> {
+        var self = this;
+        return fromCallback(function(cb) { self.release(cb); });
+    }
 }
 
 export = Statement;