node-firebird 2.4.2 → 2.6.0

package/src/wire/transaction.ts

@@ -1,4 +1,4 @@
-import { doCallback, doError } from '../callback';
+import { doCallback, doError, fromCallback } from '../callback';
 import { noop } from '../utils';
 import Const from './const';
 
@@ -8,6 +8,38 @@ import Const from './const';
  *
  ***************************************/
 
+/** The error delivered when options.signal was already aborted on entry. */
+function abortError(signal: any): Error {
+    if (signal && signal.reason instanceof Error)
+        return signal.reason;
+    var err: any = 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: any, signal: any, callback: any): any {
+    var settled = false;
+    var onAbort = function() {
+        if (!settled)
+            connection.cancelOperation(Const.fb_cancel_raise);
+    };
+    signal.addEventListener('abort', onAbort, { once: true });
+    return function(err?: any, result?: any, meta?: any, isSelect?: boolean) {
+        settled = true;
+        signal.removeEventListener('abort', onAbort);
+        if (callback)
+            callback(err, result, meta, isSelect);
+    };
+}
+
 class Transaction {
     connection: any;
     db: any;
@@ -38,6 +70,15 @@ class Transaction {
             params = undefined;
         }
 
+        var signal = options && options.signal;
+        if (signal) {
+            if (signal.aborted) {
+                doError(abortError(signal), callback);
+                return;
+            }
+            callback = hookAbortSignal(this.connection, signal, callback);
+        }
+
         var self = this;
         this.newStatement(query, function(err: any, statement: any) {
 
@@ -207,6 +248,53 @@ class Transaction {
     rollbackRetaining(callback?: (err?: any) => void): 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[]> {
+        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); });
+    }
+
+    newStatementAsync(query: string): Promise<any> {
+        var self = this;
+        return fromCallback(function(cb) { self.newStatement(query, cb); });
+    }
+
+    commitAsync(): Promise<void> {
+        var self = this;
+        return fromCallback(function(cb) { self.commit(cb); });
+    }
+
+    rollbackAsync(): Promise<void> {
+        var self = this;
+        return fromCallback(function(cb) { self.rollback(cb); });
+    }
+
+    commitRetainingAsync(): Promise<void> {
+        var self = this;
+        return fromCallback(function(cb) { self.commitRetaining(cb); });
+    }
+
+    rollbackRetainingAsync(): Promise<void> {
+        var self = this;
+        return fromCallback(function(cb) { self.rollbackRetaining(cb); });
+    }
 }
 
 export = Transaction;