node-red-contrib-prib-functions 0.22.0 → 0.23.2

package/README.md

@@ -111,53 +111,104 @@ Messages generates a message for each row or record.
 
 Transformations:
 
-*   Array to CSV
-*   Array to HTML
-*   Array to ISO8385
-*   Array to Messages
-*   Array to xlsx / xlsx object (excel uses [xlsx][7])  
+*   Array to
+    * CSV
+    * HTML
+    * ISO8385
+    * Messages
+    * xlsx / xlsx object (excel uses [xlsx][7])  
 *   AVRO to JSON (uses [avsc][6])
-*   Buffer to comprossed 
+*   Buffer to compressed 
 *   Confluence to JSON
-*   Compressed to Buffer
-*   Compressed to String
-*   COmpressed to JSON
-*   CSV to Array
-*   CSV to HTML
-*   CSV to Messages
-*   CSVWithHeader to Array
-*   CSVWithHeader to HTML
-*   CSVWithHeader to JSON
+*   Compressed to
+    * Buffer
+    * String
+    * JSON
+*   CSV to
+    * Array
+    * HTML
+    * Messages
+*   CSVWithHeader to
+    * Array
+    * HTML
+    * JSON
+*   Date to
+    * is between
+    * ISO string 
+    * locale string
+    * range limit
 *   ISO8385 to Array
 *   ISO8385 to JSON
-*   JSON to Array
-*   JSON to Confluence
-*   JSON to CSV
-*   JSON to AVRO (uses [avsc][6])
-*   JSON to ISO8385
-*   JSON to Messages
-*   JSON to String
-*   JSON to xlsx / xlsx object (excel uses [xlsx][7])  
-*   JSON to XML (uses [fast-xml-parser][4])
-*   String to JSON
-*   path to Basename
-*   path to Dirname
-*   path to Extname
-*   path to Format
-*   path to Is Absolute
-*   path to Join
-*   path to Parse
-*   path to Normalize
-*   path to Resolve
+*   JSON to 
+    * Array
+    * Confluence
+    * CSV
+    * AVRO (uses [avsc][6])
+    * ISO8385
+    * Messages
+    * String
+    * xlsx / xlsx object (excel uses [xlsx][7])  
+    * XML (uses [fast-xml-parser][4])
+* Number
+    * is between
+    * range limit
+*   path
+    * Basename
+    * Dirname
+    * Extname
+    * Format
+    * Is Absolute
+    * Join
+    * Parse
+    * Normalize
+    * Resolve
 *   snappy compress (uses [snappy][5], must install separately)
 *   snappy uncompress (uses [snappy][5], must install separately)
+*   String to
+    * Append
+    * Array By Delimiter
+    * At
+    * Camelize
+    * Capitalize
+    * Compressed
+    * Char At
+    * Char Code At"
+    * Code Point At
+    * Concat
+    * Date
+    * Delimiter On Case
+    * _ to space
+    * _ to space Capitilize
+    * Drop square bracket prefix
+    * Ends With
+    * Float
+    * Get Word
+    * Integer
+    * is Between
+    * Lower Case
+    * Number
+    * Prepend
+    * JSON
+    * Range Limit
+    * Split
+    * Starts With
+    * Timestamp
+    * Title
+    * Title Grammatical
+    * Trim
+    * Trim End
+    * Trim Start
+    * Upper Case
+    * Xml String Encode
+
+
 *   xlsx / xlsx object to array/JSON (excel uses [xlsx][7])  
 *   XML to JSON (uses [fast-xml-parser][4])
 
 Note, snappy needs to be installed separately as can have issues with auto install as build binaries.
 
 With xlsx object one can use the function in [xlsx][7] against the object in functions node.
-
+"
 Example AVRO with schema
 
 ![Transform AVRO](documentation/transformArvo.jpg "Transform AVRO example")
@@ -302,6 +353,7 @@ Test/example flow in test/generalTest.json
 ------------------------------------------------------------
 
 # Version
+0.23.0 Removes bug in test, more translation
 
 0.22.0 Add autocovariance + autocorealationship to real time data analystics, improves test
 

package/lib/common.js

@@ -0,0 +1,128 @@
+const error=(node,message,shortMessage,logger)=>{
+	if(logger && logger.active) logger.send({label:"error",node:node.id,error:error,shortMessage});
+	node.error(message);
+	node.status({fill:"red",shape:"ring",text:shortMessage});
+}
+const evalFunction(id,mapping,logger)=>{
+	logger&&logger.sendInfo({label:"evalFunction",id:id,mapping:mapping})
+	try{
+		return eval(mapping);
+	} catch(ex) {
+		logger.sendError({label:"evalFunction error",id:id,mapping:mapping,error:ex.message})
+		throw Error(id+" "+ex.message);
+	}
+}
+const evalInFunction=(node,propertyName)=>{
+	try{
+	    const nodeContext = node.context();
+		const flow = nodeContext.flow;
+		const global = nodeContext.global;
+		const property=node[propertyName];
+		if(property==null) throw Error("no value for "+propertyName);
+		const propertyType=propertyName+"-type";
+		if(! (propertyType in node)) return evalFunction(propertyName,"()=>node."+property) 
+		switch (node[propertyType]){
+		case "num":
+		case "json":
+			return evalFunction(propertyName,"()=>"+property);
+		case "node":
+			return evalFunction(propertyName,"()=>nodeContext.get("+property+")");
+		case "flow":
+			if(flow) throw Error("context store may be memoryonly so flow doesn't work")
+			return evalFunction(propertyName,"()=>flow.get("+property+")");
+		case "global":
+			return evalFunction(propertyName,"()=>global.get("+property+")");
+		case "env":
+			return evalFunction(propertyName,"()=>env.get("+property+")");
+		case "msg":
+			return evalFunction(propertyName,"(msg)=>msg."+property);
+		default:
+			logger.sendInfo({label:"setData unknown type",action:node.action,propertyType:propertyType,type:node[propertyType]});
+			throw Error("unknown type "+node[propertyType])
+		}
+	} catch(ex) {
+		logger.sendError({label:"setup",error:ex.message,stack:ex.stack});
+		throw Error(property+" "+ex.message);
+	}
+}
+
+const argsArray=(node,msg)=>{
+	const args=[];
+	node.argFunction.forEach(callFunction=> {
+		const result=callFunction(msg);
+		args.push(result);
+	});
+	return args;
+}
+const setArgsFunction=(node)=>{
+    node.argFunction=[];
+    node.args.forEach(property=>{
+        try{
+            node.argFunction.push(evalInFunction(node,property).bind(this));
+        } catch(ex) {
+            throw Error("args "+property+" "+ex.message)
+        }
+    })
+}
+
+
+const setTargetFunction=(node)=>{
+    if(node.target) throw Error("target is null")
+    if(node.hasOwnProperty("target-type")) {
+        node.setData=evalFunction("target","data=>data)")
+        return
+    }
+    const nodeContext = node.context()
+    const type=node["target-type"]
+    switch(type){
+        case "node":
+        node.setData=evalFunction("target","data=>nodeContext.set("+node.target+",data)")
+            break
+        case "flow":
+            if(nodeContext.flow) throw Error("context store may be memory only so flow doesn't work")
+            node.setData=evalFunction("target","data=>nodeContext.flow.set("+node.target+",data)")
+            break
+        case "global":
+            node.setData=evalFunction("target","data=>nodeContext.global.set("+node.target+",data)")
+            break
+        case "msg":
+            node.setData=evalFunction("target","(data,msg)=>{msg."+node.target+"=data;}")
+            break
+        default:
+            throw Error("setData unknown type "+type)
+    }
+}
+
+const baseProcess=(msg,call=sourceMatrix[node.action])=>{
+    const value=node.getSource(msg);
+    if(value==null) throw Error("source data not found");
+    const valueObject=(value instanceof Matrix?value:new Matrix(value));
+    return call.apply(valueObject,argsArray(node,msg));
+}
+const baseProcessAndSet=(msg)=>{
+    const result=baseProcess(msg);
+    node.setData.apply(node,[result,msg]);
+}
+function createProcess(msg){
+    const sourceMatrix=new Matrix({rowsMax:node.rows,columns:node.columns,dataType:node.dataType});
+    if(!(node.initialState in sourceMatrix)) throw Error("Invalid initial state "+node.initialState);
+    sourceMatrix[node.initialState]()
+    node.setData.apply(node,[sourceMatrix,msg]);
+}
+function defineProcess(msg){
+    const sourceMatrix=new Matrix({rows:node.rows,columns:node.columns,dataType:node.dataType});
+    node.setData.apply(node,[sourceMatrix,msg]);
+}
+function defineEmptyProcess(msg){
+    if(logger.active) logger.sendInfo({label:"define",arg:{rowsMax:node.row,columns:node.column}});
+    const sourceMatrix=new Matrix({rowsMax:node.rows,columns:node.columns});
+    node.setData.apply(node,[sourceMatrix,msg]);
+}
+function createSize(msg){
+    const sourceMatrix=new Matrix({rows:node.size,columns:node.size});
+    node.setData.apply(node,[sourceMatrix[node.action](),msg]);
+}
+function createDummy(msg){
+    const sourceMatrix=new Matrix(1,1);
+    node.setData.apply(node,[sourceMatrix[node.action].apply(sourceMatrix,argsArray(node,msg)),msg]);
+}

package/lib/objectExtensions.js

@@ -1,71 +1,54 @@
-if(!Array.prototype.move)
-    Array.prototype.move = function(from, to) {
-         if(from<to) to--;
-         this.splice(to, 0, this.splice(from, 1)[0]);
-     };
-if(!Number.prototype.between)
-    Number.prototype.between  = function (min, max) {
-         return !(this < min || this > max);
-     };
-if(!String.prototype.in)
-    String.prototype.in = function (str) {
-         for (var i = 0; i < arguments.length; i++)
-             if(this==arguments[i]) return true;
-         return false;
-        };
-if(!String.prototype.startsWith)
-    String.prototype.startsWith = function (str) {
-         return this.slice(0, str.length) == str;
-        };
-if(!String.prototype.toTitle)
-    String.prototype.toTitle = function () {
-         var title=this.substr(0,1).toUpperCase()
-             ,lastLowerCase=false;
-         for(var i=1 ; i<this.length; i++ ) {
-             char=this.substr(i,1);
-             if(char==char.toUpperCase()) {
-                 if(lastLowerCase) title+=' ';
-                 lastLowerCase=false;
-                 if(char=='_') continue;
-                 if(char==' ') continue;
-             } else lastLowerCase=true;
-             title+=char;
-         }
-         return title;
-       };
-if(!String.prototype.to)
-    String.prototype.to = function (type) {
-        if (this==null) return null;
-        if (type==null) return value;
-        return this['to'+type.capitalize()];
+const defineMethod=(object,name,call)=>{
+    if(name in object.prototype) return
+    try{
+        Object.defineProperty(object.prototype, name, {
+            enumerable: false,
+              value: call
+        }) 
+    } catch(ex){
+        console.error("defining "+name,ex.message)
     }
-if(!String.prototype.toReal)
-    String.prototype.toReal = function () {
-        return parseFloat(this);
-    };
-if(!String.prototype.toInt)
- String.prototype.toInt = function () {
-        return parseInt(this);
-    };
-if(!String.prototype.toTimestamp)
-    String.prototype.toTimestamp = function () {
-        return Date.parse(this.substr(0,4)+'/'+this.substr(5,2)+'/'+this.substr(8,11))
-         + parseInt(this.substr(21,3));
-    };
-if(!String.prototype.toTime)
-    String.prototype.toTime = function () {
-        return  Date.parse(this);
-    };
-if(!String.prototype.toDatetime)
-    String.prototype.toDatetime = String.prototype.toTime;
-if(!String.prototype.toDate)
-    String.prototype.toDate = String.prototype.toTime;
-if(!String.prototype.CRLF2BR)
-    String.prototype.CRLF2BR = function () {
-        return  this.replace("\n\r","<br/>").replace("\n","<br/>");
-    };
+}
+const toDateType=aDate=>aDate instanceof Date? aDate : new Date(Date.parse(aDate))
+const toDateTypeZulu=aDate=>aDate instanceof Date? aDate : new Date(aDate)
+defineMethod(Array,'move',function(from, to) {
+    if(from<to) to--
+    this.splice(to, 0, this.splice(from, 1)[0])
+})
+defineMethod(String,"in",function (...str) {
+    for (var i = 0; i < arguments.length; i++)
+        if(this==arguments[i]) return true
+   return false
+})
+defineMethod(String,"capitalize",function() {return this.charAt(0).toUpperCase() + this.slice(1)})
+defineMethod(String,"toCapitalized",function() {return this.charAt(0).toUpperCase() + this.slice(1)})
+defineMethod(String,"to",function (type) {
+    if(type==null) return value
+    return this['to'+type.capitalize()]
+})
+defineMethod(String,"toReal",function (){return parseFloat(this)})
+defineMethod(String,"toTitle", function (){return this.replace(/\w\S*/g, text => text.capitalize())})
+
+defineMethod(String,"toTitleGrammatical", function (){   
+    const lowerCaseList = ['a', 'an', 'the', 'and', 'but', 'or', 'for', 'nor', 'as', 'at', 
+        'by', 'from', 'in', 'into', 'of', 'on', 'onto', 'to', 'with', 'yet', 'so','upon', 'like', 'over', 'plus', 'up', 'down', 'off', 'near'];
+    const title=this.replace(/\p{L}+/gu, (word)=>{
+        const wordLowerCase=word.toLowerCase()
+        return lowerCaseList.includes(wordLowerCase) ? wordLowerCase : word.capitalize()
+    })
+    return title.capitalize()
+})
 
-Array.prototype.findSorted = function(searchElement,minIndex = 0,maxIndex = this.length - 1) {
+defineMethod(String,"toInt",function() {return parseInt(this)})
+if(!String.prototype.toInt) String.prototype.toInteger=String.prototype.toInt
+defineMethod(String,"toTimestamp",function () {
+    return Date.parse(this.substring(0,4)+'/'+this.substring(5,2)+'/'+this.substring(8,11))
+         + parseInt(this.substring(21,3));
+})
+defineMethod(String,"toTime",function () {return  Date.parse(this)})
+defineMethod(String,"CRLF2BR", function(){return  this.replace("\n\r","<br/>").replace("\n","<br/>")})
+
+defineMethod(Array,"findSorted",function(searchElement,minIndex = 0,maxIndex = this.length - 1) {
     let currentIndex, currentElement
     while(minIndex <= maxIndex) {
         currentIndex = (minIndex + maxIndex) / 2 | 0
@@ -77,8 +60,8 @@ Array.prototype.findSorted = function(searchElement,minIndex = 0,maxIndex = this
         } else return currentIndex
     }
     return -minIndex
- }
- Array.prototype.addSorted = function(element) {
+ })
+ defineMethod(Array,"addSorted",function(element) {
    if(this.length){
     const position = -this.findSorted(element)
     if(position<0 ) return -position
@@ -87,15 +70,16 @@ Array.prototype.findSorted = function(searchElement,minIndex = 0,maxIndex = this
    }
    this.push(element)
    return 0
-}
-Object.prototype.addList = function(property,object) {
+})
+
+defineMethod(Object,"addList",function(property,object) {
     try{
         this[property].push(object)
     } catch(ex) {
         this[property]=[object]
     }
-}
-Object.prototype.addErrorFunctions = function(){ 
+})
+defineMethod(Object,"addErrorFunctions",function(){ 
     this.onError=function(call){
         if(this.errorStack) this.errorStack.push(call)
         else this.errorStack=[this.call]
@@ -113,8 +97,9 @@ Object.prototype.addErrorFunctions = function(){
         if(typeof ex == "string") throw Error(ex)
         throw ex
     }
-}
-if(!colourSmallList) var colourSmallList={
+})
+
+const colourSmallList={
     "Red":'#FF0000',
     "Turquoise":'#00FFFF',
     "Grass Green":'#408080',
@@ -132,7 +117,7 @@ if(!colourSmallList) var colourSmallList={
     "Light Purple":'#FF0080',  	 	
     "Dark Grey":'#808080'
 }
-if(!colours) var colours ={
+const colours ={
     AliceBlue: '#F0F8FF',
     AntiqueWhite: '#FAEBD7',
     Aqua: '#00FFFF',
@@ -282,8 +267,7 @@ if(!colours) var colours ={
     Yellow: '#FFFF00',
     YellowGreen: '#9ACD32'
 }
-
-String.prototype.csvLine=function(delimiter=",",quote='"'){
+defineMethod(String,"csvLine",function(delimiter=",",quote='"'){
     let i=this.length,j=i,charInQuote,result=[]
     if(i==0) return result
     delimiter:while(i--){
@@ -317,9 +301,8 @@ String.prototype.csvLine=function(delimiter=",",quote='"'){
     const v=this.substring(i+1,j)
     result.unshift(v.length?isNaN(v)? v : Number(v):null)
     return result
-}
-
-String.prototype.csvFile=function(delimiter=",",quote='"'){
+})
+defineMethod(String,"csvFile",function(delimiter=",",quote='"'){
     let i=this.length,j=i,charInQuote,result=[],line=[]
     if(i==0) return result
     line:while(i--){
@@ -358,4 +341,131 @@ String.prototype.csvFile=function(delimiter=",",quote='"'){
         result.unshift(line)
     }
     return result
+})
+
+defineMethod(Date,"isBetween",function(min, max) {return !(this < toDateType(min) || this > toDateType(max))}) 
+defineMethod(Number,"isBetween",function(min, max) {return !(this < min || this > max)})
+defineMethod(String,"isBetween",function(min, max) {return !(this < min || this > max)})
+defineMethod(Object,"toSimpleArray",function(prefix) {
+	const returnValue=[]
+	for (let property in this) {
+		if(this[property]==null || this[property].enumerable==null || this[property].enumerable)
+		  	returnValue.push([(prefix?prefix:"")+property,this[property],typeof this[property]])
+		}
+	return returnValue
+})
+defineMethod(Object,"toSimpleArrayIgnoreNulls",function(prefix) {
+	const returnValue=[]
+	for (let property in this) {
+		if(this[property]==null ) continue
+		if(this[property].enumerable==null || this[property].enumerable)
+		  	returnValue.push([(prefix?prefix:"")+property,this[property],typeof this[property]])
+		}
+	return returnValue
+})
+
+defineMethod(String,"in",function () {
+	for (let i = 0; i < arguments.length; i++)
+		if(this.toString()===arguments[i]) return true;
+	return false
+})
+defineMethod(String,"startsWithList",function () {
+	for (var i = 0; i < arguments.length; i++)
+		if(this.slice(0, arguments[i].length)===arguments[i]) return true
+	return false
+})
+defineMethod(String,"startsWithListAnyCase",function (...list) {
+	for (var i = 0; i < list.length; i++){
+        const testString=list[i].toLowerCase()
+		if(this.slice(0, testString.length).toLowerCase()==testString) return true
+    }
+	return false
+})
+defineMethod(String,"xmlStringEncode",function() {
+	return this.toString().replace(/([\&"<>])/g, function(str, item) {
+		return {
+			'&': '&amp;',
+			'"': '&quot;',
+			'<': '&lt;',
+			'>': '&gt;'
+		}[item]
+	});
+})
+
+defineMethod(Number,"toAbbreviated",function() {
+    const digits=(v,e)=>{
+        const nv=v/Math.pow(10,e)
+        const anv=Math.abs(nv)
+        if(anv<10)   return nv.toFixed(2).toString()    
+        if(anv<100)   return nv.toFixed(1).toString()
+        return nv.toFixed(0).toString()    
+    }
+    const a=Math.abs(this)
+	if(a>Math.pow(10,15)) return digits(this,15)+'P'
+	if(a>Math.pow(10,12)) return digits(this,12)+'T'
+	if(a>Math.pow(10,9)) return digits(this,9)+'G'
+	if(a>Math.pow(10,6)) return digits(this,6)+'M'
+	if(a>Math.pow(10,3)) return digits(this,3)+'K'
+	return digits(this,0)
+})
+
+defineMethod(BigInt,"toAbbreviated",function() {
+    const digits=(v,e)=>{
+        const nv=v/Math.pow(10,e)
+        const anv=Math.abs(nv)
+        if(anv<10)   return nv.toFixed(2).toString()    
+        if(anv<100)   return nv.toFixed(1).toString()
+        return nv.toFixed(0).toString()    
+    }
+    const a=Math.abs(this)
+	if(a>Math.pow(10,15)) return digits(this,15)+'P'
+	if(a>Math.pow(10,12)) return digits(this,12)+'T'
+	if(a>Math.pow(10,9)) return digits(this,9)+'G'
+	if(a>Math.pow(10,6)) return digits(this,6)+'M'
+	if(a>Math.pow(10,3)) return digits(this,3)+'K'
+	return digits(this,0)
+})
+
+
+defineMethod(String,"getWord",function(wordPosition) {return this.split(/\s+/g,wordPosition+1)[wordPosition-1]??""})
+
+const coalesce=(...args)=>{
+	for (var i=0; i<args.length; ++i)
+ 		if (args[i] !=  null) return args[i]
+	return null; 
 }
+const nullif=(a,b)=>{return a==b?null:a}
+//missing Float16Array,
+[ArrayBuffer,Number,Boolean,BigInt,Date,String,Int8Array,Uint8Array,Uint8ClampedArray,Int16Array,Uint16Array,Int32Array,Uint32Array,BigInt64Array,BigUint64Array,Float32Array,Float64Array].forEach(type=>{
+  defineMethod(type,"deepClone",function(){ return new type(this)})
+})
+
+
+//defineMethod(TypedArray,"deepClone",function(){ return new type(this)})
+defineMethod(Array,"deepClone",function(){
+    const clone=[]
+	for (let i in this)
+		clone[i]=this[i].deepClone()
+    return clone
+})
+defineMethod(Object,"deepClone",function(){
+    const clone={}
+	for (let i in this)
+		clone[i]=this[i].deepClone()
+    return clone
+})
+defineMethod(Number, "rangeLimit",function(min,max) {return (min!=null && this<min) ? min : ((max!=null && this>max) ? max : this)})
+defineMethod(BigInt, "rangeLimit",function(min,max) {return (min!=null && this<min) ? min : ((max!=null && this>max) ? max : this)})
+defineMethod(Date, "rangeLimit",function(min,max) {return (min!=null && this<min) ? min : ((max!=null && this>max) ? max : this)})
+defineMethod(String, "rangeLimit",function(min,max) {return (min!=null && this<min) ? min : ((max!=null && this>max) ? max : this)})
+defineMethod(String,"deunderscore",function(){return this.replace(/_/g," ")})
+defineMethod(String,"deunderscoreCapitilize",function(){return this.replace(/_/g," ").toTitle()})
+defineMethod(String,"dropSquareBracketPrefix",function(bracket="[",endBracket="]"){return (this.substr(0,1)==bracket)? this.split(endBracket+" ")[1] : this})
+module.exports={
+    coalesce:coalesce,
+    colours:colours,
+    colourSmallList:colourSmallList,
+    nullif:nullif,
+    toDateType,
+    toDateTypeZulu,
+}

package/lib/typedInput.js

@@ -0,0 +1,77 @@
+
+const setGetFunction=(RED,node,propertyName)=>node["get"+propertyName[0].toUpperCase() + propertyName.slice(1)]=getFunction(RED,node,propertyName)
+
+const getFunction=(RED,node,propertyName)=>{
+	try{
+		const property=node[propertyName];
+		if(property==null) throw Error("no value for "+propertyName);
+		const propertyType=propertyName+"Type";
+		if(! (propertyType in node)) return eval("()=>node."+property)
+        const type=node[propertyType]
+		switch (type){
+        case "bin": //	a Node.js Buffer
+        case "re": //	a Regular Expression
+        case "jsonata": //	a Jsonata Expression
+        case "cred": //	a secure credential
+        case "bool":
+        case "json":
+        case "num":
+        case "str":
+        case "date": //	the current timestamp
+        case "env":
+        case "global":
+            const value=RED.util.evaluateNodeProperty(property, type, node)
+            return eval("()=>value")
+        case "flow":
+            const flow = node.context().flow;
+			if(flow) throw Error("context store may be memoryonly so flow doesn't work")
+			return eval("()=>flow.get("+property+")");
+        case "msg":
+			return eval("(msg)=>msg."+property);
+        case "node":
+            const nodeContext = node.context();
+            return eval("()=>nodeContext.get("+property+")");
+        default:
+			throw Error("unknown type "+node[propertyType])
+		}
+	} catch(ex) {
+		throw Error(propertyName+" "+ex.message);
+	}
+    
+}
+const setFunction=(RED,node,name)=>{
+    if(!name) 
+    if(!node.hasOwnProperty(name)) throw Error("name is null")
+    if(!node.hasOwnProperty(name+"-type")) {
+        node.set[name]=eval("data=>msg.payload['"+name+"']=data)")
+        return
+    }
+    const type=node[name+"t-type"]
+    switch(type){
+        case "node":
+        node.set[name]=eval("data=>node.context().set("+node[name]+",data)")
+            break
+        case "flow":
+            const flow=node.context().flow
+            if(flow) throw Error("context store may be memory only so flow doesn't work")
+            node.set[name]=eval("data=>flow.set("+node[name]+",data)")
+            break
+        case "global":
+            node.set[name]=eval("data=>nodeContext.global.set("+node[name]+",data)")
+            break
+        case "msg":
+            node.set[name]=eval("(data,msg)=>{msg."+node[name]+"=data;}")
+            break
+        default:
+            throw Error("setData unknown type "+type)
+    }
+}
+
+const getValue=(RED,node,propertyName,defaultValue)=>propertyName in node?getFunction(RED,node,propertyName)():defaultValue
+
+module.exports={
+    getFunction:getFunction,
+    setFunction:setFunction,
+    setGetFunction:setGetFunction,
+    getValue:getValue
+}