update initialize & finalize processing of function node

packages/node_modules/@node-red/editor-client/src/js/ui/library.js

@@ -50,18 +50,6 @@ RED.library = (function() {
         '</form>'+
     '</div>'
 
-    function toSingleLine(text) {
-        var result = text.replace(/\\/g, "\\\\").replace(/\n/g, "\\n");
-        return result;
-    }
-
-    function fromSingleLine(text) {
-        var result = text.replace(/\\[\\n]/g, function(s) {
-            return ((s === "\\\\") ? "\\" : "\n");
-        });
-        return result;
-    }
-    
     function saveToLibrary() {
         var elementPrefix = activeLibrary.elementPrefix || "node-input-";
         var name = $("#"+elementPrefix+"name").val().trim();
@@ -80,10 +68,8 @@ RED.library = (function() {
             var field = activeLibrary.fields[i];
             if (field == "name") {
                 data.name = name;
-            } else if(field == "initialize") {
+            } else if (typeof(field) === 'object') {
-                data.initialize = toSingleLine(activeLibrary.initEditor.getValue());
+                data[field.name] = field.get();
-            } else if(field == "finalize") {
-                data.finalize = toSingleLine(activeLibrary.finalizeEditor.getValue());
             } else {
                 data[field] = $("#"+elementPrefix+field).val();
             }
@@ -539,13 +525,9 @@ RED.library = (function() {
                                 var elementPrefix = activeLibrary.elementPrefix || "node-input-";
                                 for (var i=0; i<activeLibrary.fields.length; i++) {
                                     var field = activeLibrary.fields[i];
-                                    if (field === "initialize") {
+                                    if (typeof(field) === 'object') {
-                                        var text = fromSingleLine(selectedLibraryItem.initialize);
+                                        var val = selectedLibraryItem[field.name];
-                                        activeLibrary.initEditor.setValue(text, -1);
+                                        field.set(val);
-                                    }
-                                    else if (field === "finalize") {
-                                        var text = fromSingleLine(selectedLibraryItem.finalize);
-                                        activeLibrary.finalizeEditor.setValue(text, -1);
                                     }
                                     else {
                                         $("#"+elementPrefix+field).val(selectedLibraryItem[field]);

packages/node_modules/@node-red/nodes/core/function/10-function.html

@@ -22,7 +22,7 @@
             </div>
         </div>
 
-        <div id="func-tab-code" style="display:none">
+        <div id="func-tab-body" style="display:none">
             <div class="form-row" style="margin-bottom: 0px;">
                 <input type="hidden" id="node-input-func" autofocus="autofocus">
                 <input type="hidden" id="node-input-noerr">
@@ -90,14 +90,14 @@
                 label: that._("function.label.initialize")
             });
             tabs.addTab({
-                id: "func-tab-code",
+                id: "func-tab-body",
                 label: that._("function.label.function")
             });
             tabs.addTab({
                 id: "func-tab-finalize",
                 label: that._("function.label.finalize")
             });
-            tabs.activateTab("func-tab-code");
+            tabs.activateTab("func-tab-body");
 
             $( "#node-input-outputs" ).spinner({
                 min:0,
@@ -109,74 +109,66 @@
                 }
             });
 
+            var globals = {
+                msg:true,
+                context:true,
+                RED: true,
+                util: true,
+                flow: true,
+                global: true,
+                console: true,
+                Buffer: true,
+                setTimeout: true,
+                clearTimeout: true,
+                setInterval: true,
+                clearInterval: true
+            };
             this.editor = RED.editor.createEditor({
                 id: 'node-input-func-editor',
                 mode: 'ace/mode/nrjavascript',
                 value: $("#node-input-func").val(),
-                globals: {
+                globals: globals
-                    msg:true,
-                    context:true,
-                    RED: true,
-                    util: true,
-                    flow: true,
-                    global: true,
-                    console: true,
-                    Buffer: true,
-                    setTimeout: true,
-                    clearTimeout: true,
-                    setInterval: true,
-                    clearInterval: true
-                }
             });
-
             this.initEditor = RED.editor.createEditor({
                 id: 'node-input-init-editor',
                 mode: 'ace/mode/nrjavascript',
                 value: $("#node-input-initialize").val(),
-                globals: {
+                globals: globals
-                    msg:true,
-                    context:true,
-                    RED: true,
-                    util: true,
-                    flow: true,
-                    global: true,
-                    console: true,
-                    Buffer: true,
-                    setTimeout: true,
-                    clearTimeout: true,
-                    setInterval: true,
-                    clearInterval: true
-                }
             });
 
             this.finalizeEditor = RED.editor.createEditor({
                 id: 'node-input-finalize-editor',
                 mode: 'ace/mode/nrjavascript',
                 value: $("#node-input-finalize").val(),
-                globals: {
+                globals: globals
-                    msg:true,
-                    context:true,
-                    RED: true,
-                    util: true,
-                    flow: true,
-                    global: true,
-                    console: true,
-                    Buffer: true,
-                    setTimeout: true,
-                    clearTimeout: true,
-                    setInterval: true,
-                    clearInterval: true
-                }
             });
 
             RED.library.create({
                 url:"functions", // where to get the data from
                 type:"function", // the type of object the library is for
                 editor:this.editor, // the field name the main text body goes to
-                initEditor: this.initEditor, // editor for initializer
-                finalizeEditor: this.finalizeEditor, // editor for finalizer
                 mode:"ace/mode/nrjavascript",
-                fields:['name','outputs', 'initialize', 'finalize'],
+                fields:[
+                    'name', 'outputs',
+                    {
+                        name: 'initialize',
+                        get: function() {
+                            return that.initEditor.getValue();
+                        },
+                        set: function(v) {
+                            that.initEditor.setValue(v, -1);
+                        }
+                    },
+                    {
+                        name: 'finalize',
+                        get: function() {
+                            return that.finalizeEditor.getValue();
+                        },
+                        set: function(v) {
+                            that.finalizeEditor.setValue(v, -1);
+                        }
+                    }
+                ],
                 ext:"js"
             });
             this.editor.focus();

packages/node_modules/@node-red/nodes/core/function/10-function.js

@@ -57,19 +57,99 @@ module.exports = function(RED) {
         }
     }
 
+    function createVMOpt(node, kind) {
+        var opt = {
+            filename: 'Function node'+kind+':'+node.id+(node.name?' ['+node.name+']':''), // filename for stack traces
+            displayErrors: true
+            // Using the following options causes node 4/6 to not include the line number
+            // in the stack output. So don't use them.
+            // lineOffset: -11, // line number offset to be used for stack traces
+            // columnOffset: 0, // column number offset to be used for stack traces
+        };
+        return opt;
+    }
+
+    function updateErrorInfo(err) {
+        if (err.stack) {
+            var stack = err.stack.toString();
+            var m = /^([^:]+):([^:]+):(\d+).*/.exec(stack);
+            if (m) {
+                var line = parseInt(m[3]) -1;
+                var kind = "body:";
+                if (/setup/.exec(m[1])) {
+                    kind = "setup:";
+                }
+                if (/cleanup/.exec(m[1])) {
+                    kind = "cleanup:";
+                }
+                err.message += " ("+kind+"line "+line+")";
+            }
+        }
+    }
+
+    function processAsyncResult(result, callbacks) {
+        var promises = callbacks;
+        if (Array.isArray(result)) {
+            promises = promises.concat(result);
+        }
+        else if(result) {
+            promises = promises.concat([result]);
+        }
+        return Promise.all(promises);
+    }
+
     function FunctionNode(n) {
         RED.nodes.createNode(this,n);
         var node = this;
-        this.name = n.name;
+        node.name = n.name;
-        this.func = n.func;
+        node.func = n.func;
-        this.ini = n.initialize;
+        node.ini = n.initialize;
-        this.fin = n.finalize;
+        node.fin = n.finalize;
 
         var handleNodeDoneCall = true;
+
+        var callbackPromises = [];
+        function createAsyncCallback() {
+            var result = undefined;
+            var callbacks = undefined;
+
+            var promise = new Promise((resolve, reject) => {
+                if (result) {
+                    if (result.error) {
+                        reject(result.error);
+                    }
+                    else {
+                        resolve(result.value);
+                    }
+                }
+                else {
+                    callbacks = {
+                        resolve: resolve,
+                        reject: reject
+                    };
+                }
+            });
+            var cb = function(err, val) {
+                if (callbacks) {
+                    if (err) {
+                        callbacks.reject(err);
+                    }
+                    else {
+                        callbacks.resolve(val);
+                    }
+                }
+                else {
+                    result = { error: err, value: val };
+                }
+            };
+            callbackPromises.push(promise);
+            return cb;
+        }
+        
         // Check to see if the Function appears to call `node.done()`. If so,
         // we will assume it is well written and does actually call node.done().
         // Otherwise, we will call node.done() after the function returns regardless.
-        if (/node\.done\s*\(\s*\)/.test(this.func)) {
+        if (/node\.done\s*\(\s*\)/.test(node.func)) {
             handleNodeDoneCall = false;
         }
 
@@ -89,13 +169,15 @@ module.exports = function(RED) {
                                  "send:function(msgs,cloneMsg){ __node__.send(__send__,__msgid__,msgs,cloneMsg);},"+
                                  "done:__done__"+
                               "};\n"+
-                              this.func+"\n"+
+                              node.func+"\n"+
                            "})(msg,send,done);";
-        var iniText = "(function () {\n"+this.ini +"\n})();";
+        var iniText = "(function () {\n"+node.ini +"\n})();";
-        var finText = "(function () {\n"+this.fin +"\n})();";
+        var finText = "(function () {\n"+node.fin +"\n})();";
-        this.topic = n.topic;
+        var finScript = null;
-        this.outstandingTimers = [];
+        var finOpt = null;
-        this.outstandingIntervals = [];
+        node.topic = n.topic;
+        node.outstandingTimers = [];
+        node.outstandingIntervals = [];
         var sandbox = {
             console:console,
             util:util,
@@ -186,12 +268,12 @@ module.exports = function(RED) {
                 arguments[0] = function() {
                     sandbox.clearTimeout(timerId);
                     try {
-                        func.apply(this,arguments);
+                        func.apply(node,arguments);
                     } catch(err) {
                         node.error(err,{});
                     }
                 };
-                timerId = setTimeout.apply(this,arguments);
+                timerId = setTimeout.apply(node,arguments);
                 node.outstandingTimers.push(timerId);
                 return timerId;
             },
@@ -207,12 +289,12 @@ module.exports = function(RED) {
                 var timerId;
                 arguments[0] = function() {
                     try {
-                        func.apply(this,arguments);
+                        func.apply(node,arguments);
                     } catch(err) {
                         node.error(err,{});
                     }
                 };
-                timerId = setInterval.apply(this,arguments);
+                timerId = setInterval.apply(node,arguments);
                 node.outstandingIntervals.push(timerId);
                 return timerId;
             },
@@ -222,7 +304,9 @@ module.exports = function(RED) {
                 if (index > -1) {
                     node.outstandingIntervals.splice(index,1);
                 }
-            }
+            },
+            promisify: (util.hasOwnProperty("promisify") ? util.promisify : undefined),
+            asyncCallback: createAsyncCallback
         };
         if (util.hasOwnProperty('promisify')) {
             sandbox.setTimeout[util.promisify.custom] = function(after, value) {
@@ -233,88 +317,110 @@ module.exports = function(RED) {
         }
         var context = vm.createContext(sandbox);
         try {
-            vm.runInContext(iniText, context);
+            var iniScript = null;
-            this.script = vm.createScript(functionText, {
+            var iniOpt = null;
-                filename: 'Function node:'+this.id+(this.name?' ['+this.name+']':''), // filename for stack traces
+            if (iniText || (iniText === "")) {
-                displayErrors: true
+                iniOpt = createVMOpt(node, " setup");
-                // Using the following options causes node 4/6 to not include the line number
+                iniScript = new vm.Script(iniText, iniOpt);
-                // in the stack output. So don't use them.
+            }
-                // lineOffset: -11, // line number offset to be used for stack traces
+            node.script = vm.createScript(functionText, createVMOpt(node, ""));
-                // columnOffset: 0, // column number offset to be used for stack traces
+            if (finText || (finText === "")) {
-            });
+                finOpt = createVMOpt(node, "cleanup");
-            this.on("input", function(msg,send,done) {
+                finScript = new vm.Script(finText, finOpt);
-                try {
+            }
-                    var start = process.hrtime();
+            var promise = Promise.resolve();
-                    context.msg = msg;
+            if (iniScript) {
-                    context.send = send;
+                var result = vm.runInContext(iniText, context, iniOpt);
-                    context.done = done;
+                if (result || callbackPromises) {
+                    promise = processAsyncResult(result, callbackPromises);
+                }
+            }
+            promise.then(function (v) {
+                node.on("input", function(msg,send,done) {
+                    try {
+                        var start = process.hrtime();
+                        context.msg = msg;
+                        context.send = send;
+                        context.done = done;
 
-                    this.script.runInContext(context);
+                        node.script.runInContext(context);
-                    sendResults(this,send,msg._msgid,context.results,false);
+                        sendResults(node,send,msg._msgid,context.results,false);
-                    if (handleNodeDoneCall) {
+                        if (handleNodeDoneCall) {
-                        done();
+                            done();
-                    }
+                        }
 
-                    var duration = process.hrtime(start);
+                        var duration = process.hrtime(start);
-                    var converted = Math.floor((duration[0] * 1e9 + duration[1])/10000)/100;
+                        var converted = Math.floor((duration[0] * 1e9 + duration[1])/10000)/100;
-                    this.metric("duration", msg, converted);
+                        node.metric("duration", msg, converted);
-                    if (process.env.NODE_RED_FUNCTION_TIME) {
+                        if (process.env.NODE_RED_FUNCTION_TIME) {
-                        this.status({fill:"yellow",shape:"dot",text:""+converted});
+                            node.status({fill:"yellow",shape:"dot",text:""+converted});
-                    }
+                        }
-                } catch(err) {
+                    } catch(err) {
-                    if ((typeof err === "object") && err.hasOwnProperty("stack")) {
+                        if ((typeof err === "object") && err.hasOwnProperty("stack")) {
-                        //remove unwanted part
+                            //remove unwanted part
-                        var index = err.stack.search(/\n\s*at ContextifyScript.Script.runInContext/);
+                            var index = err.stack.search(/\n\s*at ContextifyScript.Script.runInContext/);
-                        err.stack = err.stack.slice(0, index).split('\n').slice(0,-1).join('\n');
+                            err.stack = err.stack.slice(0, index).split('\n').slice(0,-1).join('\n');
-                        var stack = err.stack.split(/\r?\n/);
+                            var stack = err.stack.split(/\r?\n/);
 
-                        //store the error in msg to be used in flows
+                            //store the error in msg to be used in flows
-                        msg.error = err;
+                            msg.error = err;
 
-                        var line = 0;
+                            var line = 0;
-                        var errorMessage;
+                            var errorMessage;
-                        if (stack.length > 0) {
+                            if (stack.length > 0) {
-                            while (line < stack.length && stack[line].indexOf("ReferenceError") !== 0) {
+                                while (line < stack.length && stack[line].indexOf("ReferenceError") !== 0) {
-                                line++;
+                                    line++;
-                            }
+                                }
 
-                            if (line < stack.length) {
+                                if (line < stack.length) {
-                                errorMessage = stack[line];
+                                    errorMessage = stack[line];
-                                var m = /:(\d+):(\d+)$/.exec(stack[line+1]);
+                                    var m = /:(\d+):(\d+)$/.exec(stack[line+1]);
-                                if (m) {
+                                    if (m) {
-                                    var lineno = Number(m[1])-1;
+                                        var lineno = Number(m[1])-1;
-                                    var cha = m[2];
+                                        var cha = m[2];
-                                    errorMessage += " (line "+lineno+", col "+cha+")";
+                                        errorMessage += " (line "+lineno+", col "+cha+")";
+                                    }
                                 }
                             }
+                            if (!errorMessage) {
+                                errorMessage = err.toString();
+                            }
+                            done(errorMessage);
                         }
-                        if (!errorMessage) {
+                        else if (typeof err === "string") {
-                            errorMessage = err.toString();
+                            done(err);
+                        }
+                        else {
+                            done(JSON.stringify(err));
                         }
-                        done(errorMessage);
                     }
-                    else if (typeof err === "string") {
+                });
-                        done(err);
+                node.on("close", function() {
+                    if (finScript) {
+                        try {
+                            finScript.runInContext(context, finOpt);
+                        }
+                        catch (err) {
+                            node.error(err);
+                        }
                     }
-                    else {
+                    while (node.outstandingTimers.length > 0) {
-                        done(JSON.stringify(err));
+                        clearTimeout(node.outstandingTimers.pop());
                     }
-                }
+                    while (node.outstandingIntervals.length > 0) {
+                        clearInterval(node.outstandingIntervals.pop());
+                    }
+                    node.status({});
+                });
+            }).catch((error) => {
+                node.error(error);
             });
-            this.on("close", function() {
+        }
-                vm.runInContext(finText, context);
+        catch(err) {
-                while (node.outstandingTimers.length > 0) {
-                    clearTimeout(node.outstandingTimers.pop());
-                }
-                while (node.outstandingIntervals.length > 0) {
-                    clearInterval(node.outstandingIntervals.pop());
-                }
-                this.status({});
-            });
-        } catch(err) {
             // eg SyntaxError - which v8 doesn't include line number information
             // so we can't do better than this
-            this.error(err);
+            updateErrorInfo(err);
+            node.error(err);
         }
     }
     RED.nodes.registerType("function",FunctionNode);

packages/node_modules/@node-red/runtime/lib/storage/localfilesystem/library.js

@@ -25,6 +25,17 @@ var settings;
 var libDir;
 var libFlowsDir;
 
+function toSingleLine(text) {
+    var result = text.replace(/\\/g, "\\\\").replace(/\n/g, "\\n");
+    return result;
+}
+
+function fromSingleLine(text) {
+    var result = text.replace(/\\[\\n]/g, function(s) {
+        return ((s === "\\\\") ? "\\" : "\n");
+    });
+    return result;
+}
 
 function getFileMeta(root,path) {
     var fn = fspath.join(root,path);
@@ -43,7 +54,7 @@ function getFileMeta(root,path) {
         for (var i=0;i<parts.length;i+=1) {
             var match = /^\/\/ (\w+): (.*)/.exec(parts[i]);
             if (match) {
-                meta[match[1]] = match[2];
+                meta[match[1]] = fromSingleLine(match[2]);
             } else {
                 read = size;
                 break;
@@ -172,7 +183,7 @@ module.exports = {
         var headers = "";
         for (var i in meta) {
             if (meta.hasOwnProperty(i)) {
-                headers += "// "+i+": "+meta[i]+"\n";
+                headers += "// "+i+": "+toSingleLine(meta[i])+"\n";
             }
         }
         if (type === "flows" && settings.flowFilePretty) {