@theotherwillembotha/node-red-plugincore 0.0.55 → 0.2.0

package/src/core/NodeManagerRuntime.ts

@@ -0,0 +1,179 @@
+/**
+ * NodeManagerRuntime.ts
+ *
+ * STANDALONE - zero imports from the rest of plugincore.
+ *
+ * This file is compiled and copied into every plugin's build output so that
+ * plugins are self-contained and do not require plugincore to be separately
+ * installed in the user's Node-RED environment.
+ *
+ * When multiple plugins are deployed, each ships its own copy of this file.
+ * The first plugin to load registers its NodeManager and nodes; subsequent
+ * copies operate independently on their own node types with no conflict.
+ *
+ * POST_CONSTRUCT_KEY is intentionally a plain string (not a Symbol) so that
+ * the decorators (from plugincore's NodeConstructor, loaded via the plugin's
+ * dependency on plugincore) and this runtime file (a separate module instance)
+ * resolve to the same property key on node instances.
+ */
+
+import type { NodeAPI, NodeAPISettingsWithData } from "node-red";
+
+// ─── API version ────────────────────────────────────────────────────────────
+// Semver of the NodeManager API contract - independent of plugincore's package
+// version. Bump when the contract changes; plugins can read this to warn users
+// that they were built against a different NodeManager version.
+export const NODEMANAGER_API_VERSION = "1.0.0";
+
+// ─── Shared key for post-construct initializer lists ────────────────────────
+// Must be a plain string so it resolves identically across module instances.
+export const POST_CONSTRUCT_KEY = '__plugincore_postConstructInitializers__';
+
+// ─── Minimal types ───────────────────────────────────────────────────────────
+
+export interface BaseNodeConfig {
+    id: string;
+    name: string;
+    type: string;
+}
+
+interface INodeDescriptor {
+    id(): string;
+    tags(): string[];
+}
+
+interface INodeClass {
+    new(node: any, config: any): any;
+    getNodeDescriptor(): INodeDescriptor;
+}
+
+// ─── Post-construct initializer runner ───────────────────────────────────────
+
+export function runPostConstructInitializers(instance: any): void {
+    const initializers: Function[] = instance[POST_CONSTRUCT_KEY];
+    if (!initializers || initializers.length === 0) return;
+
+    const className = instance.constructor.name;
+    initializers.forEach((init, index) => {
+        try {
+            init(instance);
+        } catch (error) {
+            console.error(
+                `Post-construct initialization failed:\n` +
+                `  Class: ${className}\n` +
+                `  Initializer: ${index + 1}/${initializers.length}\n` +
+                `  Error: ${error instanceof Error ? error.message : String(error)}`
+            );
+            throw error;
+        }
+    });
+
+    delete instance[POST_CONSTRUCT_KEY];
+}
+
+// ─── NodeManager ─────────────────────────────────────────────────────────────
+// RED is stored on `global` rather than as a static class field so that all
+// module instances of NodeManagerRuntime (the local copy bundled into Nodes.js
+// and the copy bundled via plugincore's NodeConstructor) share the same value.
+// Without this, esbuild's two separate inline copies would have independent
+// static fields and the one used by decorators would never see RED being set.
+const _GLOBAL_RED_KEY = '__plugincore_NodeManager_RED__';
+
+// ─── Global node-type registration guard ─────────────────────────────────────
+// When multiple self-contained plugins are installed they each bundle plugincore
+// inline and each try to call RED.nodes.registerType for the same shared
+// infrastructure node types (ConsoleLoggerConfigNode, RestLoggerConfigNode, etc.).
+// Node-RED rejects duplicate registrations with a warning and the second
+// plugin's Nodes.js fails to load. This global set tracks which types have
+// already been registered so subsequent plugins silently skip them.
+const _GLOBAL_REGISTERED_NODES_KEY = '__plugincore_registered_nodes__';
+
+function getRegisteredNodes(): Set<string> {
+    if (!(global as any)[_GLOBAL_REGISTERED_NODES_KEY]) {
+        (global as any)[_GLOBAL_REGISTERED_NODES_KEY] = new Set<string>();
+    }
+    return (global as any)[_GLOBAL_REGISTERED_NODES_KEY];
+}
+
+export class NodeManager {
+
+    // nodeTypeService is resolved dynamically via RED.plugins - no static import needed.
+    private nodeTypeService: any;
+    private typeBacklog: INodeClass[] = [];
+
+    public constructor(RED: NodeAPI<NodeAPISettingsWithData>) {
+        (global as any)[_GLOBAL_RED_KEY] = RED;
+
+        const nodeTypeServiceId = "@theotherwillembotha/nodetypeservice";
+
+        const nodeTypeServiceListener = (pluginID: string) => {
+            if (pluginID === nodeTypeServiceId) {
+                RED.events.off('plugin.instantiated', nodeTypeServiceListener);
+                this.nodeTypeService = (RED.plugins.get(nodeTypeServiceId) as any).instance;
+
+                for (const nodeType of this.typeBacklog) {
+                    for (const tag of nodeType.getNodeDescriptor().tags()) {
+                        this.nodeTypeService.registerNodeType(tag, nodeType);
+                    }
+                }
+                this.typeBacklog = [];
+            }
+        };
+
+        this.nodeTypeService = (RED.plugins.get(nodeTypeServiceId) as any)?.instance;
+        if (!this.nodeTypeService) {
+            RED.events.on('plugin.instantiated', nodeTypeServiceListener);
+        }
+    }
+
+    public static get RED(): NodeAPI<NodeAPISettingsWithData> {
+        return (global as any)[_GLOBAL_RED_KEY];
+    }
+
+    public registerNodeType(typeName: string, type: INodeClass): NodeManager {
+        if (!type) {
+            console.error(
+                `[NodeManager v${NODEMANAGER_API_VERSION}] Type "${typeName}" is undefined. ` +
+                `Ensure it is exported and included in GenerateNodes.`
+            );
+            return this;
+        }
+
+        const registeredNodes = getRegisteredNodes();
+        if (registeredNodes.has(typeName)) {
+            // Already registered by another plugin - skip to avoid Node-RED duplicate-registration error.
+            return this;
+        }
+        registeredNodes.add(typeName);
+
+        const nodeConstructor = function(this: any, config: any) {
+            try {
+                NodeManager.RED.nodes.createNode(this, config);
+                const node = new (type as any)(this, config);
+                runPostConstructInitializers(node);
+                if (node.onInit) {
+                    node.onInit();
+                }
+            } catch (error) {
+                console.error(`[NodeManager v${NODEMANAGER_API_VERSION}] Failed to construct node "${typeName}":`, error);
+            }
+        };
+
+        try {
+            NodeManager.RED.nodes.registerType(typeName, nodeConstructor, { settings: {} });
+
+            const nodeDescription = type.getNodeDescriptor();
+            if (this.nodeTypeService) {
+                for (const tag of nodeDescription.tags()) {
+                    this.nodeTypeService.registerNodeType(tag, type);
+                }
+            } else {
+                this.typeBacklog.push(type);
+            }
+        } catch (error) {
+            console.error(`[NodeManager v${NODEMANAGER_API_VERSION}] Failed to register node type "${typeName}":`, error);
+        }
+
+        return this;
+    }
+}

package/src/core/logger/service/LoggerService.ts

@@ -1,15 +1,23 @@
 
-import {BaseService, ServiceDescriptor, ConfigNodeConfig, ConfigNode } from "../../NodeConstructor";
+import {BaseService, ConfigNodeConfig, ConfigNode } from "../../NodeConstructor";
+import { ServiceDescription } from "../../tagging/ServiceDescriptionDecorator";
 import { NodeAPI, NodeAPISettingsWithData, Node } from "node-red";
-import Handlebars from "handlebars";
 import { LoggerTemplate, LoggerTemplateConfig } from "../template/LoggerTemplate";
-var network = require('network');
 
-// helper for serializing json objects inside handlebars tags.
-// you can then convert it like this: {{{json myobject}}}
-Handlebars.registerHelper('json', function(context) {
-    return JSON.stringify(context);
-});
+// Build-time / optional runtime deps - lazy so they are never required at bundle load time.
+function getHandlebars(): any { return require('handlebars'); }
+function getNetwork(): any { return require('network'); }
+
+let _helpersRegistered = false;
+function ensureHelpersRegistered(): void {
+    if (_helpersRegistered) return;
+    _helpersRegistered = true;
+    // helper for serializing json objects inside handlebars tags.
+    // you can then convert it like this: {{{json myobject}}}
+    getHandlebars().registerHelper('json', function(context: any) {
+        return JSON.stringify(context);
+    });
+}
 
 export enum Level{
     DEBUG = "DEBUG",
@@ -40,12 +48,13 @@ export type TagMap = {
 
 export abstract class Log  {
     private _config: LoggerTemplateConfig;
-    private template: HandlebarsTemplateDelegate<any>;
+    private _templateStr: string;
+    private _compiledTemplate: any = null;
     private tags:TagMap;
 
     protected constructor(config:LoggerTemplateConfig){
         this._config = config;
-        this.template = Handlebars.compile(config.template);
+        this._templateStr = config.template;
         this.tags = {
             id: config.id,
             node: config.name,
@@ -55,6 +64,14 @@ export abstract class Log  {
         }
     }
 
+    private getTemplate(): any {
+        if (!this._compiledTemplate) {
+            ensureHelpersRegistered();
+            this._compiledTemplate = getHandlebars().compile(this._templateStr);
+        }
+        return this._compiledTemplate;
+    }
+
     protected config():LoggerTemplateConfig{
         return this._config;
     }
@@ -62,7 +79,7 @@ export abstract class Log  {
     public log(payload:{[key:string]:any}|string):void{
         try{
             // step 1. serialize the payload using the template engine.
-            let message = (payload instanceof String) ? payload as string : this.template({msg:payload});
+            let message = (payload instanceof String) ? payload as string : this.getTemplate()({msg:payload});
 
             // step 2. write to the log appender.
             this.writeToLog(this.config().level, message, this.tags);
@@ -71,7 +88,7 @@ export abstract class Log  {
             console.log(e);
         }
     }
-    
+
     protected abstract writeToLog(level:string, message:string, tags:{[key:string]:string|boolean|number}):void;
 }
 
@@ -110,6 +127,11 @@ export abstract class AbstractLogger<BaseLoggerConfig>{
     protected abstract createLogger(config: LoggerTemplateConfig):Log;
 }
 
+@ServiceDescription({
+    id: "@theotherwillembotha/loggerservice",
+    sourceFile: "@theotherwillembotha/node-red-plugincore",
+    dependencies: [LoggerTemplate]
+})
 export class LoggerService extends BaseService {
 
     public static instanceID:string;
@@ -123,7 +145,7 @@ export class LoggerService extends BaseService {
         this.red = red;
 
         return new Promise<void>((resolve) => {
-            network.get_active_interface((err:any, obj:any) => {
+            getNetwork().get_active_interface((_err:any, obj:any) => {
                 LoggerService.instanceID = obj.ip_address;
             });
         });
@@ -131,16 +153,6 @@ export class LoggerService extends BaseService {
 
     public deinit(red: NodeAPI<NodeAPISettingsWithData>): void | Promise<void> {}
 
-    static override getServiceDescriptor():ServiceDescriptor {
-        return new ServiceDescriptor(
-            "@theotherwillembotha/loggerservice",
-            "LoggerService",
-            "services-plugin",
-            "@theotherwillembotha/node-red-plugincore",
-            LoggerService,
-            [LoggerTemplate]
-        );
-    }
 }
 
 export type LoggerConfigNodeConfig = ConfigNodeConfig & BaseLoggerConfig & {}
@@ -160,10 +172,11 @@ export abstract class LoggerConfigNode<CNC extends LoggerConfigNodeConfig, Logge
 
 export class DoNothingAppender extends Log{
 
-    private static instance:DoNothingAppender = new DoNothingAppender();
+    private static _instance: DoNothingAppender | null = null;
 
-    static get(): any {
-      return DoNothingAppender.instance;
+    static get(): DoNothingAppender {
+        if (!DoNothingAppender._instance) DoNothingAppender._instance = new DoNothingAppender();
+        return DoNothingAppender._instance;
     }
 
     private constructor(){

package/src/core/logger/template/LoggerTemplate.html

@@ -59,10 +59,10 @@
     .towb_editorlabel {
         width: 120px !important;
     }
-    .towb_editorfield {
+    input.towb_editorfield, select.towb_editorfield, textarea.towb_editorfield {
         width: 70% !important;
     }
-    .towb_editorfield_short {
+    input.towb_editorfield_short, select.towb_editorfield_short {
         width: 30% !important;
     }
 
@@ -108,13 +108,13 @@
 </script>
 
 <script type="text/javascript" template-section="onIncludeEditPrepare">
-    let node = this;
-
     // controls.
     let logEnabled = $("#{{defaults.logEnabled}}");
     let logTemplateEnabled = $("#{{defaults.logTemplateOverrideEnabled}}");
     let logTemplateEnabledSection = $("#section_logTemplateOverrideEnabled");
     let logEnabledSection = $("#section_logEnabled");
+    let loggerSection = $("#section_loggerconfig");
+    loggerSection.hide();
 
     // functions.
     let getLoggerTypes = async function(){
@@ -262,10 +262,15 @@
         }
     });
     
-    // lastly, make sure that we set the correct value on the logger selector.
-    updateLoggerSelectorList().then(() => {
-        loggerSelector.val(node.logger);
-        loggerSelector.trigger('change');
+    // Show the logger section only if at least one logger type is registered.
+    // If nodered_logging (or any other logger provider) is not installed, the section stays hidden.
+    getLoggerTypes().then(loggerTypes => {
+        if (loggerTypes.length === 0) return;
+        loggerSection.show();
+        updateLoggerSelectorList().then(() => {
+            loggerSelector.val(node.logger);
+            loggerSelector.trigger('change');
+        });
     });
 
 </script>