@theotherwillembotha/node-red-plugincore 0.0.50

package/build/core/NodeGenerator.d.ts

@@ -0,0 +1,37 @@
+import { Template, NodeDescriptor, ServiceDescriptor, TemplateDescriptor } from "./NodeConstructor";
+export interface ITemplateClass {
+    new (): Template;
+    getTemplateDescriptor(): TemplateDescriptor;
+}
+export interface INodeClass {
+    getNodeDescriptor(): NodeDescriptor;
+}
+export interface IServiceClass {
+    getServiceDescriptor(): ServiceDescriptor;
+}
+declare class NodeGenerator {
+    private static headerWidth;
+    private static warning;
+    private _rootFolder;
+    private _nodes;
+    private _services;
+    private _templates;
+    constructor(rootFolder: string);
+    private addDependency;
+    registerTemplate(template: ITemplateClass): NodeGenerator;
+    registerNode(node: INodeClass): NodeGenerator;
+    registerService(service: IServiceClass): NodeGenerator;
+    generate(nodesOutputFile: string, pluginsOutputFile: string): void;
+    private static generateHeader;
+}
+export { NodeGenerator };
+export interface INamedType {
+    name: string;
+}
+export declare class SourceUtility {
+    static getSourcePath(buildPath: string, sourcePath: string): string;
+}
+export type Message = {
+    [key: string]: any;
+};
+//# sourceMappingURL=NodeGenerator.d.ts.map

package/build/core/NodeGenerator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NodeGenerator.d.ts","sourceRoot":"","sources":["../../src/core/NodeGenerator.ts"],"names":[],"mappings":"AAEA,OAAO,EAAa,QAAQ,EAAE,cAAc,EAAe,iBAAiB,EAA4B,kBAAkB,EAAE,MAAM,mBAAmB,CAAA;AAIrJ,MAAM,WAAW,cAAc;IAC3B,QAAQ,QAAQ,CAAC;IACjB,qBAAqB,IAAI,kBAAkB,CAAC;CAC/C;AAED,MAAM,WAAW,UAAU;IACvB,iBAAiB,IAAG,cAAc,CAAC;CACtC;AAED,MAAM,WAAW,aAAa;IAC1B,oBAAoB,IAAG,iBAAiB,CAAC;CAC5C;AAED,cAAM,aAAa;IAEf,OAAO,CAAC,MAAM,CAAC,WAAW,CAAM;IAChC,OAAO,CAAC,MAAM,CAAC,OAAO,CAKpB;IAEF,OAAO,CAAC,WAAW,CAAQ;IAC3B,OAAO,CAAC,MAAM,CAA4E;IAC1F,OAAO,CAAC,SAAS,CAA0B;IAC3C,OAAO,CAAC,UAAU,CAA2B;gBAE1B,UAAU,EAAC,MAAM;IAIpC,OAAO,CAAC,aAAa;IAmBd,gBAAgB,CAAC,QAAQ,EAAE,cAAc,GAAG,aAAa;IAiBzD,YAAY,CAAC,IAAI,EAAC,UAAU,GAAE,aAAa;IAiB3C,eAAe,CAAC,OAAO,EAAE,aAAa,GAAE,aAAa;IAerD,QAAQ,CAAC,eAAe,EAAC,MAAM,EAAE,iBAAiB,EAAC,MAAM;IA0IhE,OAAO,CAAC,MAAM,CAAC,cAAc;CAQhC;AAID,OAAO,EACH,aAAa,EAChB,CAAA;AAED,MAAM,WAAW,UAAU;IACvB,IAAI,EAAC,MAAM,CAAC;CACf;AAmCD,qBAAa,aAAa;WAER,aAAa,CAAC,SAAS,EAAC,MAAM,EAAE,UAAU,EAAC,MAAM,GAAE,MAAM;CA2B1E;AAED,MAAM,MAAM,OAAO,GAAG;IAClB,CAAC,GAAG,EAAC,MAAM,GAAE,GAAG,CAAC;CACpB,CAAA"}

package/build/core/NodeGenerator.js

@@ -0,0 +1,300 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SourceUtility = exports.NodeGenerator = void 0;
+const fs = __importStar(require("fs"));
+const NodeConstructor_1 = require("./NodeConstructor");
+const templatePropertyKeys = ["onIncludeOnce", "onIncludeDefaults", "onIncludeEditPrepare", "onIncludeEditPrepare", "onIncludeEditSave", "onIncludeEditForm"];
+class NodeGenerator {
+    constructor(rootFolder) {
+        this._nodes = {};
+        this._services = [];
+        this._templates = [];
+        this._rootFolder = rootFolder;
+    }
+    addDependency(dependency) {
+        let hierarchy = TypeUtility.getHierrarchy(dependency);
+        // check if its a node.
+        if (hierarchy.instanceOf(NodeConstructor_1.BaseNode)) {
+            this.registerNode(dependency);
+        }
+        // check if its a service.
+        if (hierarchy.instanceOf(NodeConstructor_1.BaseService)) {
+            this.registerService(dependency);
+        }
+        // check if its a template.
+        if (hierarchy.instanceOf(NodeConstructor_1.Template)) {
+            this.registerTemplate(dependency);
+        }
+    }
+    registerTemplate(template) {
+        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;
+    }
+    registerNode(node) {
+        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;
+    }
+    registerService(service) {
+        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;
+    }
+    generate(nodesOutputFile, pluginsOutputFile) {
+        // 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 (0, NodeConstructor_1.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`);
+    }
+    static generateHeader(node) {
+        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)}* -->
+`;
+    }
+}
+exports.NodeGenerator = NodeGenerator;
+NodeGenerator.headerWidth = 50;
+NodeGenerator.warning = `
+    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.
+    `;
+class TypeUtility {
+    constructor() { }
+    static getPrototypes(t) {
+        if (!t.name) {
+            return [];
+        }
+        else {
+            let types = TypeUtility.getPrototypes(Object.getPrototypeOf(t));
+            types.push(t.name);
+            return types;
+        }
+    }
+    static getHierrarchy(t) {
+        return new Hierarchy(TypeUtility.getPrototypes(t));
+    }
+}
+class Hierarchy {
+    constructor(types) {
+        this.types = types;
+    }
+    instanceOf(type) {
+        return this.types.includes(type.name);
+    }
+}
+class SourceUtility {
+    static getSourcePath(buildPath, sourcePath) {
+        // 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();
+            // 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;
+        }
+    }
+}
+exports.SourceUtility = SourceUtility;

package/build/core/Utils.d.ts

@@ -0,0 +1,7 @@
+declare class JsonUtil {
+    static jsonUpdate(source: {
+        [key: string]: any;
+    }, location: string, newValue: any): any;
+}
+export { JsonUtil };
+//# sourceMappingURL=Utils.d.ts.map

package/build/core/Utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Utils.d.ts","sourceRoot":"","sources":["../../src/core/Utils.ts"],"names":[],"mappings":"AAAA,cAAM,QAAQ;WACI,UAAU,CAAC,MAAM,EAAC;QAAC,CAAC,GAAG,EAAC,MAAM,GAAE,GAAG,CAAA;KAAC,EAAE,QAAQ,EAAC,MAAM,EAAE,QAAQ,EAAC,GAAG,GAAE,GAAG;CAazF;AAED,OAAO,EACH,QAAQ,EACX,CAAA"}

package/build/core/Utils.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JsonUtil = void 0;
+class JsonUtil {
+    static jsonUpdate(source, location, newValue) {
+        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;
+    }
+}
+exports.JsonUtil = JsonUtil;

package/build/core/logger/LoggerDecorator.d.ts

@@ -0,0 +1,2 @@
+export declare function Logger(debug?: string): Function;
+//# sourceMappingURL=LoggerDecorator.d.ts.map

package/build/core/logger/LoggerDecorator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LoggerDecorator.d.ts","sourceRoot":"","sources":["../../../src/core/logger/LoggerDecorator.ts"],"names":[],"mappings":"AAKA,wBAAgB,MAAM,CAAC,KAAK,CAAC,EAAC,MAAM,GAAE,QAAQ,CAmG7C"}

package/build/core/logger/LoggerDecorator.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Logger = Logger;
+const NodeConstructor_1 = require("../NodeConstructor");
+function Logger(debug) {
+    return function (target, propertyKey) {
+        // 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;
+                        //console.log("setting logger on node " + node.name() + " (localized)");
+                        let config = node.config();
+                        let logger;
+                        if (config.logEnabled) {
+                            let registration = {
+                                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 = NodeConstructor_1.NodeManager.RED.nodes.getNode(config.logger).node().registerLogger(registration);
+                            }
+                            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;
+            //property.addInitializer(() => {
+            property.addInitializer(function () {
+                let node = this;
+                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 = {
+                                    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 = NodeConstructor_1.NodeManager.RED.nodes.getNode(config.logger).node().registerLogger(registration);
+                                }
+                                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/build/core/logger/node/ConsoleLoggerConfigNode.d.ts

@@ -0,0 +1,16 @@
+import { Node } from "node-red";
+import { ConfigNode, ConfigNodeConfig } from "../../NodeConstructor";
+import { Log, LoggerRegistration } from "../service/LoggerService";
+import { Level } from "../service/LoggerServiceTypes";
+interface ConsoleLoggerConfigNodeConfig extends ConfigNodeConfig {
+    id: string;
+    level: Level;
+    template: string;
+}
+export declare class ConsoleLoggerConfigNode extends ConfigNode<ConsoleLoggerConfigNodeConfig> {
+    private _logger;
+    constructor(node: Node, config: ConsoleLoggerConfigNodeConfig);
+    registerLogger(registration: LoggerRegistration): Log;
+}
+export {};
+//# sourceMappingURL=ConsoleLoggerConfigNode.d.ts.map

package/build/core/logger/node/ConsoleLoggerConfigNode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ConsoleLoggerConfigNode.d.ts","sourceRoot":"","sources":["../../../../src/core/logger/node/ConsoleLoggerConfigNode.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,MAAM,UAAU,CAAC;AAChC,OAAO,EAAE,UAAU,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAA;AACpE,OAAO,EAAa,GAAG,EAAE,kBAAkB,EAAiB,MAAM,0BAA0B,CAAA;AAE5F,OAAO,EAAE,KAAK,EAAgB,MAAM,+BAA+B,CAAC;AAGpE,UAAU,6BAA8B,SAAQ,gBAAgB;IAC5D,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAC,KAAK,CAAC;IACZ,QAAQ,EAAC,MAAM,CAAC;CACnB;AAED,qBASa,uBAAwB,SAAQ,UAAU,CAAC,6BAA6B,CAAC;IAElF,OAAO,CAAC,OAAO,CAAkB;gBAErB,IAAI,EAAE,IAAI,EAAE,MAAM,EAAE,6BAA6B;IAetD,cAAc,CAAC,YAAY,EAAC,kBAAkB,GAAE,GAAG;CAG7D"}

package/build/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/build/core/logger/node/ConsoleLoggerConfigNode.js

@@ -0,0 +1,47 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConsoleLoggerConfigNode = void 0;
+const NodeConstructor_1 = require("../../NodeConstructor");
+const LoggerService_1 = require("../service/LoggerService");
+const NodeGenerator_1 = require("../../NodeGenerator");
+const LoggerServiceTypes_1 = require("../service/LoggerServiceTypes");
+const NodeDescriptionDecorator_1 = require("../../tagging/NodeDescriptionDecorator");
+let ConsoleLoggerConfigNode = class ConsoleLoggerConfigNode extends NodeConstructor_1.ConfigNode {
+    constructor(node, config) {
+        super(node, config);
+        let _this = this;
+        // instantiate the logger.
+        let loggerConfig = {
+            id: this.id(),
+            type: LoggerServiceTypes_1.PlatformType.console,
+            template: config.template,
+            level: config.level,
+        };
+        this._logger = LoggerService_1.LoggerService.get(loggerConfig);
+    }
+    registerLogger(registration) {
+        return this._logger.register(registration);
+    }
+};
+exports.ConsoleLoggerConfigNode = ConsoleLoggerConfigNode;
+exports.ConsoleLoggerConfigNode = ConsoleLoggerConfigNode = __decorate([
+    (0, NodeDescriptionDecorator_1.NodeDescription)({
+        id: "ConsoleLoggerConfigNode",
+        name: "Console Logger",
+        group: "config",
+        sourceFile: NodeGenerator_1.SourceUtility.getSourcePath("/build/", "/src/") + "ConsoleLoggerConfigNode.html",
+        package: "@theotherwillembotha/node-red-plugincore",
+        dependencies: [LoggerService_1.LoggerService],
+        tags: ["LoggerType"]
+    }),
+    __metadata("design:paramtypes", [Object, Object])
+], ConsoleLoggerConfigNode);