Add node done API

packages/node_modules/@node-red/runtime/lib/nodes/Node.js

@@ -27,6 +27,8 @@ function Node(n) {
     this.type = n.type;
     this.z = n.z;
     this._closeCallbacks = [];
+    this._inputCallback = null;
+    this._inputCallbacks = null;
 
     if (n.name) {
         this.name = n.name;
@@ -43,6 +45,10 @@ function Node(n) {
         // as part of its constructure - config._flow will overwrite this._flow
         // which we can tolerate as they are the same object.
         Object.defineProperty(this,'_flow', {value: n._flow, enumerable: false, writable: true })
+        this._asyncDelivery = n._flow.asyncMessageDelivery;
+    }
+    if (this._asyncDelivery === undefined) {
+        this._asyncDelivery = true;
     }
     this.updateWires(n.wires);
 }
@@ -79,17 +85,95 @@ Node.prototype.context = function() {
     return this._context;
 }
 
-Node.prototype._on = Node.prototype.on;
+Node.prototype._complete = function(msg,error) {
+    if (error) {
+        // For now, delegate this to this.error
+        // But at some point, the timeout handling will need to know about
+        // this as well.
+        this.error(error,msg);
+    } else {
+        this._flow.handleComplete(this,msg);
+    }
+}
 
+Node.prototype._on = Node.prototype.on;
 Node.prototype.on = function(event, callback) {
     var node = this;
     if (event == "close") {
         this._closeCallbacks.push(callback);
+    } else if (event === "input") {
+        if (this._inputCallback) {
+            this._inputCallbacks = [this._inputCallback, callback];
+            this._inputCallback = null;
+        } else if (this._inputCallbacks) {
+            this._inputCallbacks.push(callback);
+        } else {
+            this._inputCallback = callback;
+        }
     } else {
         this._on(event, callback);
     }
 };
 
+Node.prototype._emit = Node.prototype.emit;
+Node.prototype.emit = function(event,arg) {
+    var node = this;
+    if (event === "input") {
+        // When Pluggable Message Routing arrives, this will be called from
+        // that and will already be sync/async depending on the router.
+        if (this._asyncDelivery) {
+            setImmediate(function() {
+                node._emitInput(arg);
+            });
+        } else {
+            this._emitInput(arg);
+        }
+    } else {
+        this._emit(event,arg);
+    }
+}
+
+Node.prototype._emitInput = function(arg) {
+    var node = this;
+    if (node._inputCallback) {
+        try {
+            node._inputCallback(arg,function(err) { node._complete(arg,err); });
+        } catch(err) {
+            node.error(err,arg);
+        }
+    } else if (node._inputCallbacks) {
+        var c = node._inputCallbacks.length;
+        for (var i=0;i<c;i++) {
+            var cb = node._inputCallbacks[i];
+            if (cb.length === 2) {
+                c++;
+            }
+            try {
+                node._inputCallbacks[i](arg,function(err) {
+                    c--;
+                    if (c === 0) {
+                        node._complete(arg,err);
+                    }
+                });
+            } catch(err) {
+                node.error(err,msg);
+            }
+        }
+    }
+}
+
+Node.prototype._removeAllListeners = Node.prototype.removeAllListeners;
+Node.prototype.removeAllListeners = function(name) {
+    if (name === "input") {
+        this._inputCallback = null;
+        this._inputCallbacks = null;
+    } else if (name === "close") {
+        this._closeCallbacks = [];
+    } else {
+        this._removeAllListeners(name);
+    }
+}
+
 Node.prototype.close = function(removed) {
     //console.log(this.type,this.id,removed);
     var promises = [];
@@ -233,11 +317,7 @@ Node.prototype.receive = function(msg) {
         msg._msgid = redUtil.generateId();
     }
     this.metric("receive",msg);
-    try {
-        this.emit("input", msg);
-    } catch(err) {
-        this.error(err,msg);
-    }
+    this.emit("input",msg);
 };
 
 function log_helper(self, level, msg) {