@theotherwillembotha/node-red-circuitbreaker 0.0.53

package/build/Nodes.js

@@ -0,0 +1,26 @@
+
+/*
+
+    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.
+    
+*/
+"use strict";
+const NodeManager = require("@theotherwillembotha/node-red-plugincore").NodeManager;
+const CircuitBreakerConfigNode = require("@theotherwillembotha/node-red-circuitbreaker").CircuitBreakerConfigNode;
+const CircuitBreakerNode = require("@theotherwillembotha/node-red-circuitbreaker").CircuitBreakerNode;
+const CircuitBreakerFaultDetectorNode = require("@theotherwillembotha/node-red-circuitbreaker").CircuitBreakerFaultDetectorNode;
+const CircuitBreakerEventNode = require("@theotherwillembotha/node-red-circuitbreaker").CircuitBreakerEventNode;
+const CircuitBreakerStateNode = require("@theotherwillembotha/node-red-circuitbreaker").CircuitBreakerStateNode;
+module.exports = (RED) => {
+let manager = new NodeManager(RED);
+    manager.registerNodeType("CircuitBreakerConfigNode", CircuitBreakerConfigNode);
+    manager.registerNodeType("CircuitBreakerNode", CircuitBreakerNode);
+    manager.registerNodeType("CircuitBreakerFaultDetectorNode", CircuitBreakerFaultDetectorNode);
+    manager.registerNodeType("CircuitBreakerEventNode", CircuitBreakerEventNode);
+    manager.registerNodeType("CircuitBreakerStateNode", CircuitBreakerStateNode);
+}        
+        
+        

package/build/Plugins.js

@@ -0,0 +1,70 @@
+
+/*
+
+    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.
+    
+*/
+"use strict";
+const runtime = require("node-red").runtime;
+
+
+module.exports = function (RED) {
+
+    // 1. make a list of all the plugins that need to be installed.
+    let pluginList =  []
+        .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()
+        });
+    })
+};

package/build/circuitbreaker/node/CircuitBreakerConfigNode.js

@@ -0,0 +1,89 @@
+"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.CircuitBreakerEventType = exports.BreakerContext = exports.CircuitBreakerConfigNode = exports.CircuitBreakerDefaultState = void 0;
+const node_red_plugincore_1 = require("@theotherwillembotha/node-red-plugincore");
+var CircuitBreakerDefaultState;
+(function (CircuitBreakerDefaultState) {
+    CircuitBreakerDefaultState["Closed"] = "Closed";
+    CircuitBreakerDefaultState["Open"] = "Open";
+})(CircuitBreakerDefaultState || (exports.CircuitBreakerDefaultState = CircuitBreakerDefaultState = {}));
+let CircuitBreakerConfigNode = class CircuitBreakerConfigNode extends node_red_plugincore_1.ConfigNode {
+    constructor(node, config) {
+        super(node, config);
+        this._eventListeners = [];
+        this._context = new BreakerContext();
+        this._open = config.defaultState === CircuitBreakerDefaultState.Open;
+    }
+    isOpen() {
+        return this._open;
+    }
+    trip() {
+        this._open = true;
+        let event = {
+            state: CircuitBreakerEventType.Trip
+        };
+        this._eventListeners.forEach(listener => listener(event));
+    }
+    reset() {
+        this._open = false;
+        let event = {
+            state: CircuitBreakerEventType.Reset
+        };
+        this._eventListeners.forEach(listener => listener(event));
+    }
+    addEventListener(listener) {
+        this._eventListeners.push(listener);
+        return listener;
+    }
+    removeEventListener(listener) {
+        let index = this._eventListeners.indexOf(listener);
+        if (index >= 0) {
+            this._eventListeners = this._eventListeners.splice(index, 1);
+        }
+    }
+    context() {
+        return this._context;
+    }
+};
+exports.CircuitBreakerConfigNode = CircuitBreakerConfigNode;
+exports.CircuitBreakerConfigNode = CircuitBreakerConfigNode = __decorate([
+    (0, node_red_plugincore_1.NodeDescription)({
+        id: "CircuitBreakerConfigNode",
+        name: "Circuit Breaker Config Node",
+        group: "config",
+        sourceFile: node_red_plugincore_1.SourceUtility.getSourcePath("/build/", "/src/") + "CircuitBreakerConfigNode.html",
+        package: "@theotherwillembotha/node-red-circuitbreaker",
+        tags: ["CircuitBreaker"]
+    }),
+    __metadata("design:paramtypes", [Object, Object])
+], CircuitBreakerConfigNode);
+class BreakerContext {
+    constructor() {
+        this.values = {};
+    }
+    get(id, defaultValue) {
+        let value = this.values[id];
+        if (value === undefined) {
+            value = this.set(id, defaultValue);
+        }
+        return value;
+    }
+    set(id, value) {
+        return this.values[id] = value;
+    }
+}
+exports.BreakerContext = BreakerContext;
+var CircuitBreakerEventType;
+(function (CircuitBreakerEventType) {
+    CircuitBreakerEventType["Trip"] = "Trip";
+    CircuitBreakerEventType["Reset"] = "Reset";
+})(CircuitBreakerEventType || (exports.CircuitBreakerEventType = CircuitBreakerEventType = {}));

package/build/circuitbreaker/node/CircuitBreakerEventNode.js

@@ -0,0 +1,66 @@
+"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.CircuitBreakerEventNode = 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 CircuitBreakerConfigNode_1 = require("./CircuitBreakerConfigNode");
+let CircuitBreakerEventNode = class CircuitBreakerEventNode extends node_red_plugincore_1.BaseNode {
+    constructor(node, config) {
+        super(node, config);
+        this._circuitBreakerConfigNode = node_red_plugincore_1.NodeManager.RED.nodes.getNode(config.circuitbreakerconfig).node();
+        this._eventListener = this._circuitBreakerConfigNode.addEventListener(event => {
+            if (event.state === CircuitBreakerConfigNode_1.CircuitBreakerEventType.Trip) {
+                this.tripCounter.inc();
+                this.log.log(event);
+                this.node().send([event, null]);
+            }
+            if (event.state === CircuitBreakerConfigNode_1.CircuitBreakerEventType.Reset) {
+                this.resetCounter.inc();
+                this.log.log(event);
+                this.node().send([null, event]);
+            }
+        });
+        this.node().on("close", () => {
+            this._circuitBreakerConfigNode.removeEventListener(this._eventListener);
+        });
+    }
+};
+exports.CircuitBreakerEventNode = CircuitBreakerEventNode;
+__decorate([
+    (0, node_red_plugincore_3.Logger)(),
+    __metadata("design:type", Object)
+], CircuitBreakerEventNode.prototype, "log", void 0);
+__decorate([
+    (0, node_red_plugincore_2.Metrics)({ name: "tripCounter", type: node_red_plugincore_2.MetricType.Counter, description: "number of times the circuit breaker tripped" }),
+    __metadata("design:type", node_red_plugincore_2.CounterMetric)
+], CircuitBreakerEventNode.prototype, "tripCounter", void 0);
+__decorate([
+    (0, node_red_plugincore_2.Metrics)({ name: "resetCounter", type: node_red_plugincore_2.MetricType.Counter, description: "number of times the circuit breaker was reset" }),
+    __metadata("design:type", node_red_plugincore_2.CounterMetric)
+], CircuitBreakerEventNode.prototype, "resetCounter", void 0);
+exports.CircuitBreakerEventNode = CircuitBreakerEventNode = __decorate([
+    (0, node_red_plugincore_1.NodeDescription)({
+        id: "CircuitBreakerEventNode",
+        name: "Circuit Breaker Event Node",
+        group: "circuitbreaker",
+        sourceFile: node_red_plugincore_1.SourceUtility.getSourcePath("/build/", "/src/") + "CircuitBreakerEventNode.html",
+        package: "@theotherwillembotha/node-red-circuitbreaker",
+        dependencies: [CircuitBreakerConfigNode_1.CircuitBreakerConfigNode],
+        templates: [
+            { template: node_red_plugincore_3.LoggerTemplate, config: {} },
+            { template: node_red_plugincore_2.MetricsTemplate, config: {} },
+        ],
+        tags: ["CircuitBreaker"]
+    }),
+    __metadata("design:paramtypes", [Object, Object])
+], CircuitBreakerEventNode);

package/build/circuitbreaker/node/CircuitBreakerFaultDetectorNode.js

@@ -0,0 +1,75 @@
+"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.CircuitBreakerFaultDetectorNode = 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 node_red_plugincore_4 = require("@theotherwillembotha/node-red-plugincore");
+const CircuitBreakerConfigNode_1 = require("./CircuitBreakerConfigNode");
+let CircuitBreakerFaultDetectorNode = class CircuitBreakerFaultDetectorNode extends node_red_plugincore_1.BaseNode {
+    constructor(node, config) {
+        super(node, config);
+        let _this = this;
+        // get a reference to the reolink clients.
+        this._configNode = node_red_plugincore_1.NodeManager.RED.nodes.getNode(config.circuitbreakerconfig).node();
+        this._breakerFaultFunction = new Function('msg', config.faultFunction);
+        this._breakerTripFunction = new Function('breaker', config.tripFunction);
+    }
+    async messageReceived(message) {
+        this.log.log(message);
+        this.counter.inc();
+        // perform the fault check
+        if (this._breakerFaultFunction(message)) {
+            // perform the trip function. if it passes, notify the circuitbreakerconfig.
+            if (this._breakerTripFunction(this._configNode)) {
+                this._configNode.trip();
+            }
+            this.node().send([null, message]);
+        }
+        else {
+            // perform the resetFunction. if it passes, notify the circuritbreakerconfig.
+            this.node().send([message, null]);
+        }
+    }
+};
+exports.CircuitBreakerFaultDetectorNode = CircuitBreakerFaultDetectorNode;
+__decorate([
+    (0, node_red_plugincore_3.Logger)(),
+    __metadata("design:type", Object)
+], CircuitBreakerFaultDetectorNode.prototype, "log", void 0);
+__decorate([
+    (0, node_red_plugincore_2.Metrics)({ name: "counter", type: node_red_plugincore_2.MetricType.Counter, description: "number of requests received" }),
+    __metadata("design:type", node_red_plugincore_2.CounterMetric)
+], CircuitBreakerFaultDetectorNode.prototype, "counter", void 0);
+__decorate([
+    (0, node_red_plugincore_1.onInput)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], CircuitBreakerFaultDetectorNode.prototype, "messageReceived", null);
+exports.CircuitBreakerFaultDetectorNode = CircuitBreakerFaultDetectorNode = __decorate([
+    (0, node_red_plugincore_1.NodeDescription)({
+        id: "CircuitBreakerFaultDetectorNode",
+        name: "Circuit Breaker Fault Detector Node",
+        group: "circuitbreaker",
+        sourceFile: node_red_plugincore_1.SourceUtility.getSourcePath("/build/", "/src/") + "CircuitBreakerFaultDetectorNode.html",
+        package: "@theotherwillembotha/node-red-circuitbreaker",
+        dependencies: [CircuitBreakerConfigNode_1.CircuitBreakerConfigNode],
+        templates: [
+            { template: node_red_plugincore_3.LoggerTemplate, config: {} },
+            { template: node_red_plugincore_2.MetricsTemplate, config: {} },
+            { template: node_red_plugincore_4.ScriptEditorTemplate, config: {} },
+        ],
+        tags: ["CircuitBreaker"]
+    }),
+    __metadata("design:paramtypes", [Object, Object])
+], CircuitBreakerFaultDetectorNode);

package/build/circuitbreaker/node/CircuitBreakerNode.js

@@ -0,0 +1,78 @@
+"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.CircuitBreakerNode = 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 CircuitBreakerConfigNode_1 = require("./CircuitBreakerConfigNode");
+const openStatus = { fill: "red", shape: "dot", text: "open" };
+const closedStatus = { fill: "green", shape: "dot", text: "closed" };
+let CircuitBreakerNode = class CircuitBreakerNode extends node_red_plugincore_1.BaseNode {
+    constructor(node, config) {
+        super(node, config);
+        this._configNode = node_red_plugincore_1.NodeManager.RED.nodes.getNode(config.circuitbreakerconfig).node();
+        // register a status listener
+        this._configNode.addEventListener(event => {
+            this.node().status(event.state === CircuitBreakerConfigNode_1.CircuitBreakerEventType.Trip ? openStatus : closedStatus);
+        });
+        // set the initial status
+        this.node().status(this._configNode.isOpen() ? openStatus : closedStatus);
+    }
+    async messageReceived(message) {
+        // check the current state of the node.
+        if (this._configNode.isOpen()) {
+            this.openCounter.inc();
+            this.log.log({ state: "open", data: message });
+            this.node().send([null, message]);
+        }
+        else {
+            this.closedCounter.inc();
+            this.log.log({ state: "closed", data: message });
+            this.node().send([message, null]);
+        }
+    }
+};
+exports.CircuitBreakerNode = CircuitBreakerNode;
+__decorate([
+    (0, node_red_plugincore_3.Logger)(),
+    __metadata("design:type", Object)
+], CircuitBreakerNode.prototype, "log", void 0);
+__decorate([
+    (0, node_red_plugincore_2.Metrics)({ name: "closeCounter", type: node_red_plugincore_2.MetricType.Counter, description: "number of requests processed while circuit breaker closed" }),
+    __metadata("design:type", node_red_plugincore_2.CounterMetric)
+], CircuitBreakerNode.prototype, "closedCounter", void 0);
+__decorate([
+    (0, node_red_plugincore_2.Metrics)({ name: "openCounter", type: node_red_plugincore_2.MetricType.Counter, description: "number of requests processed while circuit breaker open" }),
+    __metadata("design:type", node_red_plugincore_2.CounterMetric)
+], CircuitBreakerNode.prototype, "openCounter", void 0);
+__decorate([
+    (0, node_red_plugincore_1.onInput)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], CircuitBreakerNode.prototype, "messageReceived", null);
+exports.CircuitBreakerNode = CircuitBreakerNode = __decorate([
+    (0, node_red_plugincore_1.NodeDescription)({
+        id: "CircuitBreakerNode",
+        name: "Circuit Breaker Node",
+        group: "circuitbreaker",
+        sourceFile: node_red_plugincore_1.SourceUtility.getSourcePath("/build/", "/src/") + "CircuitBreakerNode.html",
+        package: "@theotherwillembotha/node-red-circuitbreaker",
+        dependencies: [CircuitBreakerConfigNode_1.CircuitBreakerConfigNode],
+        templates: [
+            { template: node_red_plugincore_3.LoggerTemplate, config: {} },
+            { template: node_red_plugincore_2.MetricsTemplate, config: {} },
+        ],
+        tags: ["CircuitBreaker"]
+    }),
+    __metadata("design:paramtypes", [Object, Object])
+], CircuitBreakerNode);

package/build/circuitbreaker/node/CircuitBreakerStateNode.js

@@ -0,0 +1,79 @@
+"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.CircuitBreakerStateNode = 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 node_red_plugincore_4 = require("@theotherwillembotha/node-red-plugincore");
+const CircuitBreakerConfigNode_1 = require("./CircuitBreakerConfigNode");
+let CircuitBreakerStateNode = class CircuitBreakerStateNode extends node_red_plugincore_1.BaseNode {
+    constructor(node, config) {
+        super(node, config);
+        this._circuitBreakerConfigNode = node_red_plugincore_1.NodeManager.RED.nodes.getNode(config.circuitbreakerconfig).node();
+        if (config.action === CircuitBreakerStateAction.Script) {
+            this._breakerScript = new Function('breaker', 'message', config.script);
+        }
+    }
+    onMessageReceived(message) {
+        this.log.log(message);
+        this.counter.inc();
+        // handle the message and change the state based on the mesage.
+        if (this.config().action === CircuitBreakerStateAction.Reset) {
+            this._circuitBreakerConfigNode.reset();
+        }
+        if (this.config().action === CircuitBreakerStateAction.Trip) {
+            this._circuitBreakerConfigNode.trip();
+        }
+        if (this.config().action === CircuitBreakerStateAction.Script) {
+            this._breakerScript(this._circuitBreakerConfigNode, message);
+        }
+        this.node().send(message);
+    }
+};
+exports.CircuitBreakerStateNode = CircuitBreakerStateNode;
+__decorate([
+    (0, node_red_plugincore_3.Logger)(),
+    __metadata("design:type", Object)
+], CircuitBreakerStateNode.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)
+], CircuitBreakerStateNode.prototype, "counter", void 0);
+__decorate([
+    (0, node_red_plugincore_1.onInput)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", void 0)
+], CircuitBreakerStateNode.prototype, "onMessageReceived", null);
+exports.CircuitBreakerStateNode = CircuitBreakerStateNode = __decorate([
+    (0, node_red_plugincore_1.NodeDescription)({
+        id: "CircuitBreakerStateNode",
+        name: "Circuit Breaker State Node",
+        group: "circuitbreaker",
+        sourceFile: node_red_plugincore_1.SourceUtility.getSourcePath("/build/", "/src/") + "CircuitBreakerStateNode.html",
+        package: "@theotherwillembotha/node-red-circuitbreaker",
+        dependencies: [CircuitBreakerConfigNode_1.CircuitBreakerConfigNode],
+        templates: [
+            { template: node_red_plugincore_3.LoggerTemplate, config: {} },
+            { template: node_red_plugincore_2.MetricsTemplate, config: {} },
+            { template: node_red_plugincore_4.ScriptEditorTemplate, config: {} },
+        ],
+        tags: ["CircuitBreaker"]
+    }),
+    __metadata("design:paramtypes", [Object, Object])
+], CircuitBreakerStateNode);
+var CircuitBreakerStateAction;
+(function (CircuitBreakerStateAction) {
+    CircuitBreakerStateAction["Reset"] = "Reset";
+    CircuitBreakerStateAction["Trip"] = "Trip";
+    CircuitBreakerStateAction["Script"] = "Script";
+})(CircuitBreakerStateAction || (CircuitBreakerStateAction = {}));

package/build/index.js

@@ -0,0 +1,21 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./circuitbreaker/node/CircuitBreakerConfigNode"), exports);
+__exportStar(require("./circuitbreaker/node/CircuitBreakerNode"), exports);
+__exportStar(require("./circuitbreaker/node/CircuitBreakerFaultDetectorNode"), exports);
+__exportStar(require("./circuitbreaker/node/CircuitBreakerEventNode"), exports);
+__exportStar(require("./circuitbreaker/node/CircuitBreakerStateNode"), exports);

package/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "@theotherwillembotha/node-red-circuitbreaker",
+  "version": "0.0.53",
+  "description": "Circuit Breaker nodes for Node-RED with configurable fault detection, trip conditions, and state management.",
+  "main": "./build/index.js",
+  "exports": "./build/index.js",
+  "author": "Willem Botha (@theotherwillembotha)",
+  "license": "ISC",
+  "keywords": [
+    "node-red",
+    "circuit-breaker",
+    "fault-tolerance",
+    "resilience",
+    "reliability"
+  ],
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "build": "npm run clean && tsc && npm run generate-nodes && npm run copy-files",
+    "clean": "rm -rf ./build",
+    "generate-nodes": "node build/GenerateNodes.js",
+    "copy-files": "cp -r ./icons ./build/"
+  },
+  "files": [
+    "build/",
+    "icons/",
+    "documentation/",
+    "LICENSE",
+    "README.md"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/theotherwillembotha/nodered_circuitbreaker.git"
+  },
+  "bugs": {
+    "url": "https://github.com/theotherwillembotha/nodered_circuitbreaker/issues"
+  },
+  "homepage": "https://github.com/theotherwillembotha/nodered_circuitbreaker#readme",
+  "engines": {
+    "node": ">=18",
+    "nodered": ">=4.0.0"
+  },
+  "dependencies": {
+    "@theotherwillembotha/node-red-plugincore": "^0.0.53"
+  },
+  "devDependencies": {
+    "@theotherwillembotha/node-red-plugincore": "../nodered_plugincore",
+    "@types/node": "^22.15.16",
+    "@types/node-red": "~1.3.5"
+  },
+  "node-red": {
+    "version": ">=4.0.0",
+    "nodes": {
+      "circuitbreaker": "./build/Nodes.js"
+    },
+    "plugins": {
+      "circuitbreaker": "./build/Plugins.js"
+    }
+  }
+}