@theotherwillembotha/node-red-plugincore 0.1.0 → 0.3.0

package/build/runtime/NodeManagerRuntime.js

@@ -0,0 +1,140 @@
+"use strict";
+/**
+ * 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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NodeManager = exports.POST_CONSTRUCT_KEY = exports.NODEMANAGER_API_VERSION = void 0;
+exports.runPostConstructInitializers = runPostConstructInitializers;
+// ─── 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.
+exports.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.
+exports.POST_CONSTRUCT_KEY = '__plugincore_postConstructInitializers__';
+// ─── Post-construct initializer runner ───────────────────────────────────────
+function runPostConstructInitializers(instance) {
+    const initializers = instance[exports.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[exports.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() {
+    if (!global[_GLOBAL_REGISTERED_NODES_KEY]) {
+        global[_GLOBAL_REGISTERED_NODES_KEY] = new Set();
+    }
+    return global[_GLOBAL_REGISTERED_NODES_KEY];
+}
+class NodeManager {
+    constructor(RED) {
+        this.typeBacklog = [];
+        global[_GLOBAL_RED_KEY] = RED;
+        const nodeTypeServiceId = "@theotherwillembotha/nodetypeservice";
+        const nodeTypeServiceListener = (pluginID) => {
+            if (pluginID === nodeTypeServiceId) {
+                RED.events.off('plugin.instantiated', nodeTypeServiceListener);
+                this.nodeTypeService = RED.plugins.get(nodeTypeServiceId).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)?.instance;
+        if (!this.nodeTypeService) {
+            RED.events.on('plugin.instantiated', nodeTypeServiceListener);
+        }
+    }
+    static get RED() {
+        return global[_GLOBAL_RED_KEY];
+    }
+    registerNodeType(typeName, type) {
+        if (!type) {
+            console.error(`[NodeManager v${exports.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 (config) {
+            try {
+                NodeManager.RED.nodes.createNode(this, config);
+                const node = new type(this, config);
+                runPostConstructInitializers(node);
+                if (node.onInit) {
+                    node.onInit();
+                }
+            }
+            catch (error) {
+                console.error(`[NodeManager v${exports.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${exports.NODEMANAGER_API_VERSION}] Failed to register node type "${typeName}":`, error);
+        }
+        return this;
+    }
+}
+exports.NodeManager = NodeManager;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@theotherwillembotha/node-red-plugincore",
-  "version": "0.1.0",
+  "version": "0.3.0",
   "description": "A core framework for building production-grade Node-RED plugins, with built-in support for structured logging, metrics, and webhook ingestion.",
   "author": "Willem Botha (@theotherwillembotha)",
   "license": "ISC",
@@ -47,27 +47,20 @@
     "nodered": ">=4.0.0"
   },
   "devDependencies": {
-    "@types/deep-equal": "^1.0.4",
     "@types/js-beautify": "^1.14.3",
     "@types/jsdom": "^28.0.3",
     "@types/markdown-it": "^14.1.2",
-    "@types/node": "^22.15.29",
-    "@types/node-red": "~1.3.5",
-    "@types/whatwg-url": "^13.0.0"
+    "@types/node": "^26.1.1",
+    "@types/node-red": "~1.3.5"
   },
   "dependencies": {
     "body-parser": "^2.2.0",
-    "deep-equal": "^2.2.3",
     "express": "^5.1.0",
     "handlebars": "^4.7.8",
     "js-beautify": "^1.15.4",
     "jsdom": "^29.1.1",
     "markdown-it": "^14.1.0",
-    "network": "^0.7.0",
-    "prom-client": "^15.1.3",
-    "reflect-metadata": "^0.2.2",
-    "whatwg-url": "^16.0.1",
-    "winston": "^3.17.0"
+    "reflect-metadata": "^0.2.2"
   },
   "node-red": {
     "version": ">=4.0.0",

package/src/GenerateNodes.ts

@@ -1,46 +1,16 @@
 
-import { DelegatedConfigReferenceNode } from "./core/other/node/DelegatedConfigReferenceNode.js";
+import { NodeGenerator } from "./index.js"
 import { NodeTypeService } from "./core/tagging/service/NodeTypeService.js";
-import { NodeGenerator, SettingsService, BasicTemplate, SettingsTemplate, TimerMetricTemplate, ConsoleLoggerConfigNode, RestLoggerConfigNode, UIHelperTemplate, ScriptEditorTemplate } from "./index.js"
-import { WebhookServerConfigNode, WebhookServerService, WebhookTemplate,  } from "./index.js"
-
-import {LoggerService, LoggerTemplate } from "./index.js";
-
-import { MetricsService, MetricsTemplate, CounterMetricTemplate, GaugeMetricTemplate} from "./index.js";
-import { MetricsConfigNode, GaugeMetricConfigNode, TimerMetricConfigNode, CounterMetricConfigNode } from "./index.js";
 
+// Plugincore is a build framework — it has no leaf nodes of its own.
+// Infrastructure nodes (DelegatedConfigReferenceNode, config nodes, etc.)
+// are pulled in automatically via template dependencies when downstream
+// packages register their nodes.
+//
+// NodeTypeService is the one service that must always be present because
+// it powers the tag registry used by NodeManager at runtime.
 new NodeGenerator("./src/core/")
-    // services.
-    .registerService(LoggerService)
-    .registerService(MetricsService)
-    .registerService(SettingsService)
-    .registerService(WebhookServerService)  
     .registerService(NodeTypeService)
+    .generate("./build/Nodes", "./build/Plugins", "@theotherwillembotha/node-red-plugincore");
 
-    // templates.
-    .registerTemplate(BasicTemplate)
-    .registerTemplate(LoggerTemplate)
-    .registerTemplate(SettingsTemplate)
-    .registerTemplate(MetricsTemplate)
-    .registerTemplate(CounterMetricTemplate)
-    .registerTemplate(GaugeMetricTemplate)
-    .registerTemplate(TimerMetricTemplate)
-    .registerTemplate(WebhookTemplate)
-    .registerTemplate(UIHelperTemplate)
-    .registerTemplate(ScriptEditorTemplate)
-
-    // nodes
-    .registerNode(DelegatedConfigReferenceNode)
-    .registerNode(ConsoleLoggerConfigNode)
-    .registerNode(RestLoggerConfigNode)
-
-    .registerNode(MetricsConfigNode)
-    .registerNode(CounterMetricConfigNode)
-    .registerNode(GaugeMetricConfigNode)
-    .registerNode(TimerMetricConfigNode)
-    .registerNode(WebhookServerConfigNode)
-
-    // done.
-    .generate("./build/Nodes", "./build/Plugins");
-
-process.exit(0);
+process.exit(0);