@theotherwillembotha/node-red-plugincore 0.0.50

package/src/core/NodeGenerator.ts

@@ -0,0 +1,331 @@
+import * as fs from 'fs';
+
+import { buildNode, Template, NodeDescriptor, BaseService, ServiceDescriptor, BaseNode, DependencyType, TemplateDescriptor } from "./NodeConstructor"
+
+const templatePropertyKeys = ["onIncludeOnce", "onIncludeDefaults", "onIncludeEditPrepare", "onIncludeEditPrepare", "onIncludeEditSave", "onIncludeEditForm"];
+
+export interface ITemplateClass {
+    new (): Template;
+    getTemplateDescriptor(): TemplateDescriptor;
+}
+
+export interface INodeClass {
+    getNodeDescriptor():NodeDescriptor;
+}
+
+export interface IServiceClass {
+    getServiceDescriptor():ServiceDescriptor;
+}
+
+class NodeGenerator {
+
+    private static headerWidth = 50;
+    private static warning:string = `
+    This file was automatically generated using the NODERED Core utility.
+    Any modifications to his file will be overwritten the next time the code is regenerated.
+        
+    You have been warned.
+    `;
+
+    private _rootFolder:string;
+    private _nodes:{[nodeName:string]:{nodeClass:INodeClass, descriptor:NodeDescriptor}} = {};
+    private _services:ServiceDescriptor[] = [];
+    private _templates:TemplateDescriptor[] = [];
+
+    public constructor(rootFolder:string){
+        this._rootFolder = rootFolder;
+    }
+
+    private addDependency(dependency: DependencyType): void {
+        let hierarchy = TypeUtility.getHierrarchy(dependency as INamedType);
+
+        // check if its a node.
+        if(hierarchy.instanceOf(BaseNode)){
+            this.registerNode(dependency as INodeClass);
+        }
+
+        // check if its a service.
+        if(hierarchy.instanceOf(BaseService)){
+            this.registerService(dependency as IServiceClass);
+        }
+
+        // check if its a template.
+        if(hierarchy.instanceOf(Template)){
+            this.registerTemplate(dependency as ITemplateClass);
+        }
+    }
+
+    public registerTemplate(template: ITemplateClass): NodeGenerator {
+        try{
+            // verify that we dont already have this template.
+            let descriptor = template.getTemplateDescriptor();
+            if(!this._templates.map(t => t.name()).includes(descriptor.name())){
+                this._templates.push(descriptor);
+                // FIXME: skip recursive dependency resolution for now.
+                // descriptor.dependencies().forEach(dependency => this.addDependency(dependency));
+            }
+        }
+        catch(error){
+            console.log("ERROR:", error);
+        }
+
+        return this;
+    }
+
+    public registerNode(node:INodeClass):NodeGenerator{
+        try{
+            // verify that we have dont already have this node.
+            let descriptor = node.getNodeDescriptor();
+            if(!this._nodes[descriptor.name()]){
+                this._nodes[descriptor.name()] = {nodeClass:node, descriptor:descriptor};
+                // skip the recursive dependencies for now.
+                //descriptor.dependencies().forEach(dependency => this.addDependency(dependency));
+            }
+
+        }
+        catch(error){
+            console.log("ERROR:", error);
+        }
+        return this;
+    }
+
+    public registerService(service: IServiceClass):NodeGenerator { 
+        try{
+            let descriptor = service.getServiceDescriptor();
+            if(!this._services.map(s => s.name()).includes(descriptor.name())){
+                this._services.push(descriptor);
+                // FIXME: skip recursive dependency resolution for now.
+                //descriptor.dependencies().forEach(dependency => this.addDependency(dependency));
+            }
+        }
+        catch(error){
+            console.log("ERROR:", service, error)
+        }
+        return this;
+    }
+
+    public generate(nodesOutputFile:string, pluginsOutputFile:string){
+        // STEP 1. Compile the templates.
+        // let templateInclude =  this._templates
+        //     .map(template => new (template.clazz()))
+        //     .map(template => {
+        //         return template.onIncludeOnce();
+        //     })
+        //     .join("\n");
+        let templateInclude = ""
+        
+        // STEP 2. compose the HTMLStructure of each of the nodes.
+        let nodeHTMLOutut = Object.values(this._nodes)
+            .map(node => {
+                console.log(`Processing node: ${node.descriptor.name()}`);
+
+                return buildNode(node.nodeClass);
+            })
+            .join("\n")
+
+        fs.writeFileSync(nodesOutputFile + ".html",`
+<!--
+${NodeGenerator.warning}
+-->
+${templateInclude}
+${nodeHTMLOutut}
+
+        `);
+
+        // Step 3. compose the JS structure for each of the nodes.
+        // 1. get a list of the files to import.
+        let importList = [
+            ...Object.values(this._nodes).map(node => {
+                return `const ${node.descriptor.name()} = require("${node.descriptor.package()}").${node.descriptor.name()};`;
+                //let nodeFile = "./" + node.group() + "/" + node.sourceFile();
+                //return `const ${node.name()} = require("${nodeFile}");`;
+            }),
+        ]
+        .join("\n");
+
+        // 2. get the exported modules that have to be regestered by the node manager.
+        let moduleExports = Object.values(this._nodes).map(node => {
+            return `    manager.registerNodeType("${node.descriptor.name()}", ${node.descriptor.name()});`;
+        }).join("\n");
+
+        fs.writeFileSync(nodesOutputFile + ".js", `
+/*
+${NodeGenerator.warning}
+*/
+"use strict";
+const NodeManager = require("@theotherwillembotha/node-red-plugincore").NodeManager;
+${importList}
+module.exports = (RED) => {
+let manager = new NodeManager(RED);
+${moduleExports}
+}        
+        
+        `);
+
+        console.log(`Done building ${Object.keys(this._nodes).length} nodes\n${Object.values(this._nodes).map(node => " - " + node.descriptor.name() + "\n").join("")}\n`);
+
+        let serviceExports = this._services.map(service => {
+            return `    manager.registerService(${service.name()}.${service.name()});`
+        }).join("\n")
+
+        let serviceImports = [...this._services.map(service => {
+            return `const ${service.name()} = require("${service.sourceFile()}").${service.name()};`;
+        })].join("\n")
+
+        let output = `
+/*
+${NodeGenerator.warning}
+*/
+"use strict";
+const runtime = require("node-red").runtime;
+${serviceImports}
+
+module.exports = function (RED) {
+
+    // 1. make a list of all the plugins that need to be installed.
+    let pluginList =  [${this._services.map(service => service.name()).join(", ")}]
+        .map(service => service.getServiceDescriptor())
+        .filter(plugin => !RED.plugins.get(plugin.id()));
+
+    // 2. register a listener if there are any plugins in the pluginList.
+    if(pluginList.length > 0){
+        RED.events.on('registry:plugin-added', async pluginID => {
+
+            let addedPlugin = pluginList.find(plugin => plugin.id() === pluginID);
+            let plugin = RED.plugins.get(pluginID);
+
+            if(addedPlugin && plugin.instantiate && !plugin.instance){
+                console.log("Deploying instance of: " + plugin.id);
+                plugin.instance = new plugin.class();
+                
+                // instantiate the plugin.
+                await plugin.instance.init(RED);
+
+                // publish an event that it has ben deployed.
+                RED.events.emit("plugin.instantiated", pluginID);
+                                
+                pluginList.splice(pluginList.findIndex(current => current.id() === addedPlugin.id()), 1);
+
+                // register a flow deployment listener.
+                let startupDeployment = true;
+                RED.events.on('runtime-event', async (event) => {
+                    // startup deployment.
+                    if ("runtime-deploy" === event?.id && startupDeployment) {
+                        console.log("STARTUP DEPLOYMENT");
+                        startupDeployment = false;
+                        const flows = await runtime.flows.getFlows({});
+                        await plugin.instance.onDeploy(flows);
+                    }
+                    
+                    // stopping flows on redeployment.
+                    if ("runtime-state" === event?.id && event?.payload?.state === "stop" && event?.payload?.deploy) {
+                        console.log("REDEPLOY!");
+                        const flows = await runtime.flows.getFlows({});
+                        await plugin.instance.onDeploy(flows);
+                    }
+                });
+            }
+        });
+    }
+
+    // 3. register the plugins.
+    [...pluginList].forEach(plugin => {
+        RED.plugins.registerPlugin(plugin.id(), {
+            type: plugin.type(),
+            instantiate:true,
+            class: plugin.clazz()
+        });
+    })
+};
+`
+        fs.writeFileSync(pluginsOutputFile + ".js", output);
+        console.log(`Done building ${this._services.length} services\n${this._services.map(service => " - " + service.name() + "\n").join("")}\n`);
+    }
+
+    private static generateHeader(node:NodeDescriptor){
+        let padding = ' '.repeat(Math.max(0, Math.floor(NodeGenerator.headerWidth - node.name().length)/2 ));
+        return `
+<!-- *${'*'.repeat(NodeGenerator.headerWidth)}* -->
+<!-- ${padding} ${node.name()} ${padding}  -->
+<!-- *${'*'.repeat(NodeGenerator.headerWidth)}* -->
+`;
+    }
+}
+
+
+
+export {
+    NodeGenerator
+}
+
+export interface INamedType {
+    name:string;
+}
+
+class TypeUtility {
+    private constructor(){}
+
+    private static getPrototypes(t:INamedType):string[] {
+        if(!t.name){
+            return [];
+        }
+        else{
+            let types = TypeUtility.getPrototypes(Object.getPrototypeOf(t));
+            types.push(t.name);
+            return types;
+        }
+    }
+
+
+    public static getHierrarchy(t:INamedType):Hierarchy {
+        return new Hierarchy(TypeUtility.getPrototypes(t));
+    }
+
+}
+
+class Hierarchy{
+    private types: string[];
+    
+    public constructor(types:string[]){
+        this.types = types;
+    }
+
+    public instanceOf(type:INamedType):boolean {
+        return this.types.includes(type.name);
+    }
+}
+
+export class SourceUtility {
+
+    public static getSourcePath(buildPath:string, sourcePath:string):string {
+        // use the stack to find the caller of this function.
+        
+        let _pst = Error.prepareStackTrace
+        Error.prepareStackTrace = function (err, stack) { return stack; };
+        try {
+            // get the crrent stack.
+            let err = new Error() as any;
+
+            // the first item in the stack is the current file. call and ignore.
+            err.stack.shift().getFileName();
+
+            // the second item in the stack is the actual caller.
+            let callerFile = err.stack.shift().getFileName();
+            // strip away the filename
+            callerFile = callerFile.substring(0, callerFile.lastIndexOf("/")+ 1)
+            // spit on the buildPath indicator
+            let pcs = callerFile.split(buildPath);
+            // extract the last piece.
+            let lastPc = pcs.pop();
+            // recombine with the buildPath indicator and glue on the last piece with the source pathIndicator
+            return pcs.join(buildPath) + sourcePath + lastPc;
+        } 
+        finally {
+            Error.prepareStackTrace = _pst;
+        }
+    }
+}
+
+export type Message = {
+    [key:string]:any;
+}

package/src/core/Utils.ts

@@ -0,0 +1,19 @@
+class JsonUtil {
+    public static jsonUpdate(source:{[key:string]:any}, location:string, newValue:any):any{
+        let pointer = source;
+        let keys = location.split(".");
+        while(keys.length>1){
+            let key = keys.shift()!;
+            if(!pointer[key]){
+                pointer[key] = {};
+            }
+            pointer = pointer[key];
+        }
+        pointer[keys.shift()!] = newValue;
+        return source;
+    }
+}
+
+export {
+    JsonUtil
+}

package/src/core/logger/LoggerDecorator.ts

@@ -0,0 +1,105 @@
+import { BaseNode, NodeManager } from "../NodeConstructor";
+import { Log, LoggerRegistration } from "./service/LoggerService";
+import { LoggerTemplateConfig } from "./template/LoggerTemplate";
+
+
+export function Logger(debug?:string):Function {
+
+  return function (target: any, propertyKey: string | symbol) {
+
+    // if the type is a string, then its probably defined in the local (core) module.
+    if(typeof propertyKey ===  "string"){
+      const valueSymbol = Symbol(`_${String(propertyKey)}_value`);
+      
+      Object.defineProperty(target, propertyKey, {
+        get: function() {
+          
+          if(!this[valueSymbol]){
+              let node = this as BaseNode<LoggerTemplateConfig>;
+              //console.log("setting logger on node " + node.name() + " (localized)");
+              let config = node.config();
+              let logger;
+
+              if(config.logEnabled){
+                let registration:LoggerRegistration = {
+                  id:config.id,
+                  flow:node.flow(),
+                  type:node.type(),
+                  name:node.name(),
+                  enabled:config.logEnabled,
+                  override:config.logTemplateOverrideEnabled,
+                  template:config.logTemplateOverride
+                };
+              
+                // get a reference to the loggerService.
+                try{
+                  logger = (NodeManager.RED.nodes.getNode(config.logger) as any).node().registerLogger(registration) as Log;
+                }
+                catch(e){
+                  console.log("failed getting logger ", config.logger, e);
+                  logger = { log(){} };
+                }
+              }
+              else{
+                logger = { log(){} };
+              }
+
+              this[valueSymbol] = logger;
+          }
+          return this[valueSymbol];
+        },
+        enumerable: true,
+        configurable: false
+      });
+      return;
+    }
+    else{
+      let property = propertyKey as any;
+      //property.addInitializer(() => {
+      property.addInitializer(function(this:BaseNode<LoggerTemplateConfig>){
+        let node = this as BaseNode<LoggerTemplateConfig>
+        const valueSymbol = Symbol(`_${String(property.name)}_value`);
+        Object.defineProperty(node, property.name, {
+          get: function() {
+            
+            if(!this[valueSymbol]){
+                //console.log("setting logger on node " + node.name()+ " (externalized)");
+                let config = node.config();
+                let logger;
+
+                if(config.logEnabled){
+                  let registration:LoggerRegistration = {
+                    id:config.id,
+                    flow:node.flow(),
+                    type:node.type(),
+                    name:node.name(),
+                    enabled:config.logEnabled,
+                    override:config.logTemplateOverrideEnabled,
+                    template:config.logTemplateOverride
+                  };
+                
+                  // get a reference to the loggerService.
+                  try{
+                    logger = (NodeManager.RED.nodes.getNode(config.logger) as any).node().registerLogger(registration) as Log;
+                  }
+                  catch(e){
+                    console.log("failed getting logger ", config.logger, e);
+                    logger = { log(){} };
+                  }
+                }
+                else{
+                  logger = { log(){} };
+                }
+
+                this[valueSymbol] = logger;
+            }
+            return this[valueSymbol];
+          },
+          enumerable: true,
+          configurable: false
+        });
+      })
+      return;
+    }
+  };
+}

package/src/core/logger/node/ConsoleLoggerConfigNode.html

@@ -0,0 +1,131 @@
+
+<script type="text/javascript" template-section="onCompose">
+    node
+        .addDefault("name", {value:"Logger Example", required:true})
+        .addDefault("platform", {value:"rest", required:true})
+        .addDefault("template", {value:`message:{{msg}}`, required:true})
+        .addDefault("level", {value:"info", required:true})
+        .setPaletteLabel("Console Logger Config Node")
+        .setLabel(function() {return this.name })
+</script>
+
+<script type="text/javascript" template-section="onIncludeEditPrepare">
+{
+    let node = this;
+
+    let levelSelection = $("#node-config-input-level");
+    levelSelection.typedInput({type:"level", types:[{
+        value: "level",
+        options: [
+            { value: "DEBUG", label: "debug"},
+            { value: "INFO", label: "info"},
+            { value: "WARNING", label: "warning"},
+            { value: "ERROR", label: "error"},
+        ]
+    }]});
+
+    this.editor = RED.editor.createEditor({
+        id: 'node-config-input-templateEditor',
+        mode: 'ace/mode/handlebars',
+        value: this.template
+    });
+}
+</script>
+
+<script type="text/javascript" template-section="onIncludeEditSave">
+{
+    let node = this;
+
+    this.template = this.editor.getValue();
+    this.editor.destroy();
+    delete this.editor;
+}
+
+</script>
+
+<script type="text/html" template-section="onIncludeEditForm">
+<div id="LoggerConfig">
+    <div class="form-row">
+        <label for="node-config-input-name"><i class="fa fa-tag"></i> Name</label>
+        <input type="text" id="node-config-input-name" />
+    </div>
+
+    <div class="form-row">
+        <label for="node-config-input-level"><i class="fa fa-tag"></i> Level</label>
+        <input type="text" id="node-config-input-level" />
+    </div>
+
+    <div class="form-row">
+        <label for="node-config-input-templateEditor"><i class="fa fa-tag"></i> Template</label>
+        <div style="height: 250px; min-height:150px;" class="node-text-editor" id="node-config-input-templateEditor"></div>
+    </div>
+</div>
+</script>
+
+<script type="text/markdown" template-section="onIncludeDocumentation">
+Configuration node for the Logger Integration
+
+## Inputs
+: *name*    (string)    : The common name for the logger Configuration
+: *level*   (level)     : The logging level - debug, info, warning, error
+: *platform*(string)    : The common name for the logger Configuration
+: *template*(mustache)  : A template for the log messages.
+
+## Logger platform
+Currently supported logging platforms
+
+### Console
+The log message will be printed out to stdio
+
+### Http / Https
+Publish the message to an http endpoint using a http / https POST command.
+
+: *url*                 (url)           : The endpoint for the url where requests are to be posted to.
+: *ignore ssl errors*   (boolean)       : If enabled, the invalid ssl certificates will be ignored.
+: *authentication*      (auth method)   : what auth method should be used for the http request. (none, basic, api key)
+
+#### Authentication
+##### Basic
+Provides basic authentication using the Authorization header 
+
+: *username*    (string) : the username used for basic authentication
+: *password*    (string) : the password used for basic authentication
+
+##### APIKey
+Provides authentication using a matrix parameter, header or query parameter and an apikey
+
+: *mechanism*   (mechanism) : the mechanism that will be used for transmitting the key (header, queryparam, matrixparam)
+: *apikey name* (string)    : the name of the key used for api authentication. (path variable or query param name)
+: *apikey value*(string)    : the value of the api key that will be transmitted. (beware of special characters)
+
+### Loki
+Publish the message to a loki endpoint.
+
+: *host*        (string) : the host and port\ of the loki instance that it being logged to
+: *tenant*      (string) : the tenant id that will be used to log to
+: *username*    (string) : the username for the loki instance.
+: *authtoken*   (string) : the authtoken for the loki instance.
+
+# Mustache Templating
+Mustache / Handlebars are used for building up the logged message payloads that are sent to the logging backend.
+The resultant message will be interpreted as a string, meaning care should be taken in the event that a string representation of a json object is built.
+
+### Provided Properties
+A couple of values are provided to the logging context by default.
+
+: *msg*         (object)    : an object containing the payload or message that should be parsed through the template.
+: *currentTime* (object)    : a string containing the current time in ISO8601 format
+
+### Mustache Helpers
+In addition to the provided properties, some "helpers" have also been provided to assist in serialization.
+
+: *json*        (helper)    : converts a json object to a string using the JSON.stringify method.
+
+## Examples
+- {{{json msg}}} - serializes the the msg object to json format.
+
+# References
+- [Mustache - Wikipedia](https://en.wikipedia.org/wiki/Mustache_(template_system))
+- [Mustache - Playground](https://jgonggrijp.gitlab.io/wontache/playground.html)
+</script>
+

package/src/core/logger/node/ConsoleLoggerConfigNode.ts

@@ -0,0 +1,46 @@
+
+import { Node } from "node-red";
+import { ConfigNode, ConfigNodeConfig } from "../../NodeConstructor"
+import { NewLogger, Log, LoggerRegistration, LoggerService } from "../service/LoggerService"
+import { SourceUtility } from "../../NodeGenerator";
+import { Level, PlatformType } from "../service/LoggerServiceTypes";
+import { NodeDescription } from "../../tagging/NodeDescriptionDecorator";
+
+interface ConsoleLoggerConfigNodeConfig extends ConfigNodeConfig {
+    id: string;
+    level:Level;
+    template:string;
+}
+
+@NodeDescription({
+    id:"ConsoleLoggerConfigNode",
+    name:"Console Logger",
+    group:"config",
+    sourceFile:SourceUtility.getSourcePath("/build/", "/src/") + "ConsoleLoggerConfigNode.html",
+    package: "@theotherwillembotha/node-red-plugincore",
+    dependencies:[ LoggerService ],
+    tags: [ "LoggerType" ]
+})
+export class ConsoleLoggerConfigNode extends ConfigNode<ConsoleLoggerConfigNodeConfig> {
+    
+    private _logger!: NewLogger<any>;
+    
+    constructor(node: Node, config: ConsoleLoggerConfigNodeConfig){
+        super(node, config);
+        let _this = this;
+
+        // instantiate the logger.
+        let loggerConfig = {
+            id:this.id(),
+            type:PlatformType.console,
+            template:config.template,
+            level:config.level,
+        }
+
+        this._logger = LoggerService.get(loggerConfig);
+    }
+
+    public registerLogger(registration:LoggerRegistration):Log {
+        return this._logger.register(registration)
+    }
+}