@theotherwillembotha/node-red-whatsapp 0.0.55 → 0.3.0

package/build/index.js

@@ -18,4 +18,5 @@ __exportStar(require("./whatsapp/service/WhatsappService"), exports);
 __exportStar(require("./whatsapp/node/WhatsappAccountConfigNode"), exports);
 __exportStar(require("./whatsapp/node/WhatsappGroupConfigNode"), exports);
 __exportStar(require("./whatsapp/node/WhatsappSendMessageNode"), exports);
+__exportStar(require("./whatsapp/node/WhatsappDynamicSendMessageNode"), exports);
 __exportStar(require("./whatsapp/node/WhatsappReceiveMessageNode"), exports);

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/build/whatsapp/node/WhatsappAccountConfigNode.js

@@ -19,7 +19,12 @@ let WhatsappAccountConfigNode = class WhatsappAccountConfigNode extends node_red
         this.client = WhatsappService_1.WhatsappService.getClient(config.localConnectionId);
     }
     getGroup(groupId) {
-        return this.client ? this.client.getGroupClient(groupId) : undefined;
+        const client = WhatsappService_1.WhatsappService.getClient(this.config().localConnectionId);
+        return client ? client.getGroupClient(groupId) : undefined;
+    }
+    async sendMessage(chatId, message) {
+        const resolvedJid = await this.client.resolveJid(chatId);
+        await this.client.sendMessage(resolvedJid, message);
     }
 };
 exports.WhatsappAccountConfigNode = WhatsappAccountConfigNode;
@@ -29,7 +34,7 @@ exports.WhatsappAccountConfigNode = WhatsappAccountConfigNode = __decorate([
         name: "Whatsapp Config Node",
         group: "config",
         sourceFile: node_red_plugincore_1.SourceUtility.getSourcePath("/build/", "/src/") + "WhatsappAccountConfigNode.html",
-        package: "@theotherwillembotha/nodered_whatsapp",
+        package: "@theotherwillembotha/node-red-whatsapp",
         tags: ["Whatsapp"]
     }),
     __metadata("design:paramtypes", [Object, Object])

package/build/whatsapp/node/WhatsappDynamicSendMessageNode.js

@@ -0,0 +1,112 @@
+"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);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WhatsappDynamicSendMessageNode = void 0;
+const node_red_plugincore_1 = require("@theotherwillembotha/node-red-plugincore");
+const node_red_plugincore_2 = require("@theotherwillembotha/node-red-plugincore");
+const node_red_plugincore_3 = require("@theotherwillembotha/node-red-plugincore");
+const handlebars_1 = __importDefault(require("handlebars"));
+let WhatsappDynamicSendMessageNode = class WhatsappDynamicSendMessageNode extends node_red_plugincore_1.BaseNode {
+    constructor(node, config) {
+        super(node, config);
+        this.accountNode = node_red_plugincore_1.NodeManager.RED.nodes.getNode(config.accountConfig).node();
+    }
+    resolveField(value, valueType, message) {
+        switch (valueType) {
+            case "str": return handlebars_1.default.compile(value)({ msg: message });
+            case "msg": return value.split(".").reduce((obj, key) => obj?.[key], message);
+            case "flow": return this.node().context().flow.get(value);
+            case "global": return this.node().context().global.get(value);
+            default: return undefined;
+        }
+    }
+    async onMessageReceived(message) {
+        this.counter.inc();
+        const chatId = this.resolveField(this.config().recipient, this.config().recipientType, message);
+        if (!chatId) {
+            this.log.log({ error: "recipient resolved to empty value — message not sent" });
+            return;
+        }
+        let actions = [];
+        try {
+            actions = JSON.parse(this.config().payloads || "[]");
+        }
+        catch (e) { }
+        for (const action of actions) {
+            const resolved = this.resolveField(action.value, action.valueType, message);
+            let payload = {};
+            switch (action.type) {
+                case "text":
+                    payload.text = resolved != null ? String(resolved) : undefined;
+                    break;
+                case "image":
+                    payload.image = resolved;
+                    break;
+                case "video":
+                    payload.video = resolved;
+                    break;
+                case "document":
+                    payload.document = resolved;
+                    if (action.documentName) {
+                        payload.documentName = String(this.resolveField(action.documentName, action.documentNameType ?? "str", message) ?? "");
+                    }
+                    if (action.documentMimetype) {
+                        payload.documentMimetype = String(this.resolveField(action.documentMimetype, action.documentMimetypeType ?? "str", message) ?? "");
+                    }
+                    break;
+            }
+            let logPayload = { chatId: String(chatId) };
+            if (payload.text)
+                logPayload.text = payload.text;
+            if (payload.image)
+                logPayload.image = payload.image?.length;
+            if (payload.video)
+                logPayload.video = payload.video?.length;
+            if (payload.document)
+                logPayload.document = payload.document?.length;
+            this.log.log(logPayload);
+            await this.accountNode.sendMessage(String(chatId), payload);
+        }
+    }
+};
+exports.WhatsappDynamicSendMessageNode = WhatsappDynamicSendMessageNode;
+__decorate([
+    (0, node_red_plugincore_3.Logger)(),
+    __metadata("design:type", node_red_plugincore_3.Log)
+], WhatsappDynamicSendMessageNode.prototype, "log", void 0);
+__decorate([
+    (0, node_red_plugincore_2.Metrics)({ name: "counter", type: node_red_plugincore_2.MetricType.Counter, description: "number of messages sent" }),
+    __metadata("design:type", Object)
+], WhatsappDynamicSendMessageNode.prototype, "counter", void 0);
+__decorate([
+    (0, node_red_plugincore_1.onInput)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], WhatsappDynamicSendMessageNode.prototype, "onMessageReceived", null);
+exports.WhatsappDynamicSendMessageNode = WhatsappDynamicSendMessageNode = __decorate([
+    (0, node_red_plugincore_1.NodeDescription)({
+        id: "WhatsappDynamicSendMessageNode",
+        name: "Whatsapp Dynamic Send Message Node",
+        group: "whatsapp",
+        sourceFile: node_red_plugincore_1.SourceUtility.getSourcePath("/build/", "/src/") + "WhatsappDynamicSendMessageNode.html",
+        package: "@theotherwillembotha/node-red-whatsapp",
+        templates: [
+            { template: node_red_plugincore_3.LoggerTemplate, config: {} },
+            { template: node_red_plugincore_2.MetricsTemplate, config: {} },
+        ],
+        tags: ["Whatsapp"]
+    }),
+    __metadata("design:paramtypes", [Object, Object])
+], WhatsappDynamicSendMessageNode);

package/build/whatsapp/node/WhatsappGroupConfigNode.js

@@ -15,20 +15,31 @@ let WhatsappGroupConfigNode = class WhatsappGroupConfigNode extends node_red_plu
     constructor(node, config) {
         super(node, config);
         this.accountconfigNode = node_red_plugincore_1.NodeManager.RED.nodes.getNode(config.accountConfig).node();
-        this.group = this.accountconfigNode.getGroup(config.groupId);
+    }
+    getGroup() {
+        return this.accountconfigNode.getGroup(this.config().groupId);
     }
     send(message) {
-        console.log("Sending message to ", this.group.id());
-        this.group.sendMessage(message);
+        const group = this.getGroup();
+        if (!group) {
+            throw new Error(`WhatsappGroupConfigNode: group client not available — is the account linked and connected?`);
+        }
+        group.sendMessage(message);
     }
     subscribe(subscription) {
-        this.group.subscribe(subscription);
+        const group = this.getGroup();
+        if (!group) {
+            throw new Error(`WhatsappGroupConfigNode: group client not available — is the account linked and connected?`);
+        }
+        group.subscribe(subscription);
         return subscription;
     }
     unsubscribe(subscription) {
-        console.log("unsubscribing from", this.group.id());
-        this.group.unsubscribe(subscription);
-        return;
+        const group = this.getGroup();
+        if (!group)
+            return;
+        console.log("unsubscribing from", group.id());
+        group.unsubscribe(subscription);
     }
 };
 exports.WhatsappGroupConfigNode = WhatsappGroupConfigNode;
@@ -38,7 +49,7 @@ exports.WhatsappGroupConfigNode = WhatsappGroupConfigNode = __decorate([
         name: "Whatsapp Group Config Node",
         group: "config",
         sourceFile: node_red_plugincore_1.SourceUtility.getSourcePath("/build/", "/src/") + "WhatsappGroupConfigNode.html",
-        package: "@theotherwillembotha/nodered_whatsapp",
+        package: "@theotherwillembotha/node-red-whatsapp",
         tags: ["Whatsapp"]
     }),
     __metadata("design:paramtypes", [Object, Object])

package/build/whatsapp/node/WhatsappReceiveMessageNode.js

@@ -63,7 +63,7 @@ __decorate([
 ], WhatsappReceiveMessageNode.prototype, "log", void 0);
 __decorate([
     (0, node_red_plugincore_2.Metrics)({ name: "counter", type: node_red_plugincore_2.MetricType.Counter, description: "number of messages received" }),
-    __metadata("design:type", node_red_plugincore_2.CounterMetric)
+    __metadata("design:type", Object)
 ], WhatsappReceiveMessageNode.prototype, "counter", void 0);
 exports.WhatsappReceiveMessageNode = WhatsappReceiveMessageNode = __decorate([
     (0, node_red_plugincore_1.NodeDescription)({
@@ -71,7 +71,7 @@ exports.WhatsappReceiveMessageNode = WhatsappReceiveMessageNode = __decorate([
         name: "Whatsapp Receive Message Node",
         group: "whatsapp",
         sourceFile: node_red_plugincore_1.SourceUtility.getSourcePath("/build/", "/src/") + "WhatsappReceiveMessageNode.html",
-        package: "@theotherwillembotha/nodered_whatsapp",
+        package: "@theotherwillembotha/node-red-whatsapp",
         templates: [
             { template: node_red_plugincore_3.LoggerTemplate, config: {} },
             { template: node_red_plugincore_2.MetricsTemplate, config: {} },

package/build/whatsapp/node/WhatsappSendMessageNode.js

@@ -22,45 +22,67 @@ let WhatsappSendMessageNode = class WhatsappSendMessageNode extends node_red_plu
         super(node, config);
         this.groupNode = node_red_plugincore_1.NodeManager.RED.nodes.getNode(config.groupConfig).node();
     }
-    resolveValue(field, message) {
-        switch (field.type) {
-            case "str":
-                return handlebars_1.default.compile(field.value)({ msg: message });
-            case "msg":
-                return field.value.split(".").reduce((obj, key) => obj?.[key], message);
-            case "flow":
-                return this.node().context().flow.get(field.value);
-            case "global":
-                return this.node().context().global.get(field.value);
-            default:
-                return undefined;
+    resolveField(value, valueType, message) {
+        switch (valueType) {
+            case "str": return handlebars_1.default.compile(value)({ msg: message });
+            case "msg": return value.split(".").reduce((obj, key) => obj?.[key], message);
+            case "flow": return this.node().context().flow.get(value);
+            case "global": return this.node().context().global.get(value);
+            default: return undefined;
         }
     }
     onMessageReceived(message) {
         this.counter.inc();
-        let fields = [];
+        if (!this.groupNode) {
+            this.node().error("WhatsappSendMessageNode: no group config node found — check the node configuration.");
+            return;
+        }
+        let actions = [];
         try {
-            fields = JSON.parse(this.config().payloads || "[]");
+            actions = JSON.parse(this.config().payloads || "[]");
         }
         catch (e) { }
-        let payload = {};
-        for (let field of fields) {
-            if (!field.enabled)
-                continue;
-            let resolved = this.resolveValue(field, message);
-            if (field.id === "text")
-                payload.text = resolved != null ? String(resolved) : undefined;
-            if (field.id === "image")
-                payload.image = resolved;
+        for (const action of actions) {
+            const resolved = this.resolveField(action.value, action.valueType, message);
+            let payload = {};
+            switch (action.type) {
+                case "text":
+                    payload.text = resolved != null ? String(resolved) : undefined;
+                    break;
+                case "image":
+                    payload.image = resolved;
+                    break;
+                case "video":
+                    payload.video = resolved;
+                    break;
+                case "document":
+                    payload.document = resolved;
+                    if (action.documentName) {
+                        payload.documentName = String(this.resolveField(action.documentName, action.documentNameType ?? "str", message) ?? "");
+                    }
+                    if (action.documentMimetype) {
+                        payload.documentMimetype = String(this.resolveField(action.documentMimetype, action.documentMimetypeType ?? "str", message) ?? "");
+                    }
+                    break;
+            }
+            let logPayload = {};
+            if (payload.text)
+                logPayload.text = payload.text;
+            if (payload.image)
+                logPayload.image = payload.image?.length;
+            if (payload.video)
+                logPayload.video = payload.video?.length;
+            if (payload.document)
+                logPayload.document = payload.document?.length;
+            this.log.log(logPayload);
+            try {
+                this.groupNode.send(payload);
+            }
+            catch (e) {
+                this.node().error("WhatsappSendMessageNode: failed to send message — " + (e?.message ?? e), message);
+                return;
+            }
         }
-        let logPayload = {};
-        if (payload.text)
-            logPayload.text = payload.text;
-        if (payload.image)
-            logPayload.image = payload.image?.length;
-        this.log.log(logPayload);
-        console.log(payload);
-        this.groupNode.send(payload);
     }
 };
 exports.WhatsappSendMessageNode = WhatsappSendMessageNode;
@@ -70,7 +92,7 @@ __decorate([
 ], WhatsappSendMessageNode.prototype, "log", void 0);
 __decorate([
     (0, node_red_plugincore_2.Metrics)({ name: "counter", type: node_red_plugincore_2.MetricType.Counter, description: "number of messages sent" }),
-    __metadata("design:type", node_red_plugincore_2.CounterMetric)
+    __metadata("design:type", Object)
 ], WhatsappSendMessageNode.prototype, "counter", void 0);
 __decorate([
     (0, node_red_plugincore_1.onInput)(),
@@ -84,7 +106,7 @@ exports.WhatsappSendMessageNode = WhatsappSendMessageNode = __decorate([
         name: "Whatsapp Send Message Node",
         group: "whatsapp",
         sourceFile: node_red_plugincore_1.SourceUtility.getSourcePath("/build/", "/src/") + "WhatsappSendMessageNode.html",
-        package: "@theotherwillembotha/nodered_whatsapp",
+        package: "@theotherwillembotha/node-red-whatsapp",
         templates: [
             { template: node_red_plugincore_3.LoggerTemplate, config: {} },
             { template: node_red_plugincore_2.MetricsTemplate, config: {} },