@theotherwillembotha/node-red-plugincore 0.0.50

package/build/core/other/template/SettingsTemplate.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SettingsTemplate = void 0;
+const NodeConstructor_1 = require("../../NodeConstructor");
+const NodeGenerator_1 = require("../../NodeGenerator");
+class SettingsTemplate extends NodeConstructor_1.Template {
+    static getTemplateDescriptor() {
+        return new NodeConstructor_1.TemplateDescriptor("settings", SettingsTemplate, NodeGenerator_1.SourceUtility.getSourcePath("/build/", "/src/") + "SettingsTemplate.html", []);
+    }
+}
+exports.SettingsTemplate = SettingsTemplate;

package/build/core/tagging/NodeDescriptionDecorator.d.ts

@@ -0,0 +1,17 @@
+import { NodeDependencyType, TemplateConfig } from "../NodeConstructor";
+import { ITemplateClass } from "../NodeGenerator";
+export type NodeDescriptionConfig = {
+    id: string;
+    name: string;
+    group: string;
+    sourceFile: string;
+    package: string;
+    templates?: {
+        template: ITemplateClass;
+        config: TemplateConfig;
+    }[];
+    dependencies?: NodeDependencyType[];
+    tags?: string[];
+};
+export declare function NodeDescription(config: NodeDescriptionConfig): (target: any) => void;
+//# sourceMappingURL=NodeDescriptionDecorator.d.ts.map

package/build/core/tagging/NodeDescriptionDecorator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NodeDescriptionDecorator.d.ts","sourceRoot":"","sources":["../../../src/core/tagging/NodeDescriptionDecorator.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAkB,cAAc,EAAE,MAAM,oBAAoB,CAAC;AACxF,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAElD,MAAM,MAAM,qBAAqB,GAAG;IAChC,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAC,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,CAAC,EAAE;QAAC,QAAQ,EAAC,cAAc,CAAC;QAAC,MAAM,EAAC,cAAc,CAAA;KAAC,EAAE,CAAC;IAC/D,YAAY,CAAC,EAAE,kBAAkB,EAAE,CAAC;IACpC,IAAI,CAAC,EAAC,MAAM,EAAE,CAAC;CAClB,CAAA;AAED,wBAAgB,eAAe,CAAC,MAAM,EAAC,qBAAqB,YAChC,GAAG,UAuB9B"}

package/build/core/tagging/NodeDescriptionDecorator.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NodeDescription = NodeDescription;
+const NodeConstructor_1 = require("../NodeConstructor");
+function NodeDescription(config) {
+    return function (target) {
+        let descriptor = new NodeConstructor_1.NodeDescriptor(config.group, config.id, config.sourceFile, config.package);
+        if (config.templates) {
+            for (let template of config.templates) {
+                descriptor.addTemplate(template.template, template.config);
+            }
+        }
+        if (config.tags) {
+            for (let tag of config.tags) {
+                descriptor.addTag(tag);
+            }
+        }
+        if (config.dependencies) {
+            for (let dependency of config.dependencies) {
+                descriptor.addDependency(dependency);
+            }
+        }
+        target.getNodeDescriptor = () => descriptor;
+    };
+}

package/build/core/tagging/service/NodeTypeService.d.ts

@@ -0,0 +1,15 @@
+import { INodeClass } from "../../NodeGenerator";
+import { BaseService, FlowDeployment, ServiceDescriptor } from "../../NodeConstructor";
+import { NodeAPI, NodeAPISettingsWithData } from "node-red";
+export declare class NodeTypeService extends BaseService {
+    private red;
+    private nodeTypes;
+    constructor();
+    init(red: NodeAPI<NodeAPISettingsWithData>): void | Promise<void>;
+    deinit(red: NodeAPI<NodeAPISettingsWithData>): void | Promise<void>;
+    onDeploy(flowDeployment: FlowDeployment): void | Promise<void>;
+    registerNodeType(tag: string, resource: INodeClass): Promise<void>;
+    getNodeTypesForTag(tag: string): INodeClass[];
+    static getServiceDescriptor(): ServiceDescriptor;
+}
+//# sourceMappingURL=NodeTypeService.d.ts.map

package/build/core/tagging/service/NodeTypeService.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NodeTypeService.d.ts","sourceRoot":"","sources":["../../../../src/core/tagging/service/NodeTypeService.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AACjD,OAAO,EAAE,WAAW,EAAc,cAAc,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AACnG,OAAO,EAAE,OAAO,EAAE,uBAAuB,EAAE,MAAM,UAAU,CAAC;AAG5D,qBAAa,eAAgB,SAAQ,WAAW;IAC5C,OAAO,CAAC,GAAG,CAAoC;IAC/C,OAAO,CAAC,SAAS,CAAkC;;IAM5C,IAAI,CAAC,GAAG,EAAE,OAAO,CAAC,uBAAuB,CAAC,GAAG,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC;IAsBjE,MAAM,CAAC,GAAG,EAAE,OAAO,CAAC,uBAAuB,CAAC,GAAG,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC;IAInE,QAAQ,CAAC,cAAc,EAAE,cAAc,GAAG,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC;IAI9D,gBAAgB,CAAC,GAAG,EAAC,MAAM,EAAE,QAAQ,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC;IASjE,kBAAkB,CAAC,GAAG,EAAC,MAAM,GAAE,UAAU,EAAE;WAIlC,oBAAoB,IAAG,iBAAiB;CAU3D"}

package/build/core/tagging/service/NodeTypeService.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NodeTypeService = void 0;
+const NodeConstructor_1 = require("../../NodeConstructor");
+class NodeTypeService extends NodeConstructor_1.BaseService {
+    constructor() {
+        super("nodetypes");
+        this.nodeTypes = {};
+    }
+    init(red) {
+        this.red = red;
+        // update the config/
+        this.red.httpAdmin.get("/nodetypeservice/find", this.red.auth.needsPermission("inject.write"), (request, response) => {
+            let tag = request.query.tag;
+            // serialize the types to a javascript friendly format
+            let types = this.getNodeTypesForTag(tag).map(type => {
+                let description = type.getNodeDescriptor();
+                return {
+                    "id": description.name(),
+                    "name": description.name(),
+                };
+            });
+            response.send(types);
+        });
+        return Promise.resolve();
+    }
+    deinit(red) {
+        return Promise.resolve();
+    }
+    onDeploy(flowDeployment) {
+    }
+    registerNodeType(tag, resource) {
+        let nodes = this.nodeTypes[tag];
+        if (!nodes) {
+            this.nodeTypes[tag] = nodes = [];
+        }
+        nodes.push(resource);
+        return Promise.resolve();
+    }
+    getNodeTypesForTag(tag) {
+        return this.nodeTypes[tag] ? this.nodeTypes[tag] : [];
+    }
+    static getServiceDescriptor() {
+        return new NodeConstructor_1.ServiceDescriptor("@theotherwillembotha/nodetypeservice", "NodeTypeService", "services-plugin", "@theotherwillembotha/node-red-plugincore", NodeTypeService, []);
+    }
+}
+exports.NodeTypeService = NodeTypeService;

package/build/core/webhook/WebhookDecorator.d.ts

@@ -0,0 +1,3 @@
+declare const Webhook: any;
+export { Webhook };
+//# sourceMappingURL=WebhookDecorator.d.ts.map

package/build/core/webhook/WebhookDecorator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"WebhookDecorator.d.ts","sourceRoot":"","sources":["../../../src/core/webhook/WebhookDecorator.ts"],"names":[],"mappings":"AAYA,QAAA,MAAM,OAAO,KAoDD,CAAC;AAGb,OAAO,EACH,OAAO,EACV,CAAA"}

package/build/core/webhook/WebhookDecorator.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Webhook = void 0;
+const LoggerServiceTypes_1 = require("../logger/service/LoggerServiceTypes");
+const NodeConstructor_1 = require("../NodeConstructor");
+const Webhook = (0, NodeConstructor_1.createPostConstructDecorator)('Webhook')
+    .withInitLogic(async (instance, propertyKey, webhookconfig) => {
+    //console.log(`Registering webhook callback`,  "PROPERTYKEY", propertyKey, "WEBHOOK CONFIG", webhookconfig, "THIS", this);
+    let node = instance;
+    let nodeConfig = node.config();
+    // create the authentication.
+    let authentication = (nodeConfig.webhookAuth === LoggerServiceTypes_1.RestAuthType.basic) ? { type: LoggerServiceTypes_1.RestAuthType.basic, username: nodeConfig.webhookAuth_basic_username, password: nodeConfig.webhookAuth_basic_password } :
+        (nodeConfig.webhookAuth === LoggerServiceTypes_1.RestAuthType.apikey) ? { type: LoggerServiceTypes_1.RestAuthType.apikey, mechanism: nodeConfig.webhookAuth_apikey_mechanism, key: nodeConfig.webhookAuth_apikey_key, value: nodeConfig.webhookAuth_apikey_value } :
+            { type: LoggerServiceTypes_1.RestAuthType.none };
+    // register a callback listener to the webserver.
+    let endpointConfig = {
+        path: nodeConfig.webhookPath,
+        methods: webhookconfig.methods,
+        authentication: authentication
+    };
+    let webhookServer = NodeConstructor_1.NodeManager.RED.nodes.getNode(nodeConfig.webhook).node().server();
+    webhookServer.attach(endpointConfig, (request, respponse) => instance[propertyKey](request, respponse));
+    if (nodeConfig.reverseProxies_enabled) {
+        await Promise.all(nodeConfig.reverseProxies_connections.map(async (proxy) => {
+            try {
+                // get a n instance of reverseProxNode.
+                let reverseProxyNode = NodeConstructor_1.NodeManager.RED.nodes.getNode(proxy.proxy).node();
+                // TODO: ReverseProxyConfigNodes need to become their own subtype of config nodes so we can enforce the ".client()" method.
+                let proxyClient = reverseProxyNode.client();
+                console.log("List of known hosts: ", await proxyClient.getHosts());
+                //console.log("ADD REVERSE PROXY:" + proxy.proxy + " to " + node.id(), proxyClient);
+            }
+            catch (e) {
+                console.log(e);
+            }
+            return Promise.resolve();
+        }));
+    }
+    // register a close listener to the node.
+    node.node().on("close", () => {
+        webhookServer.detach(endpointConfig);
+    });
+})
+    .build();
+exports.Webhook = Webhook;

package/build/core/webhook/node/WebhookServerConfigNode.d.ts

@@ -0,0 +1,16 @@
+import { Node } from "node-red";
+import { ConfigNode, ConfigNodeConfig } from "../../NodeConstructor";
+import { WebhookServer } from "../service/WebhookServerService";
+interface WebhookServerConfigNodeConfig extends ConfigNodeConfig {
+    id: string;
+    port: number;
+    externalHost: string;
+    externalPort: number;
+}
+export declare class WebhookServerConfigNode extends ConfigNode<WebhookServerConfigNodeConfig> {
+    private _server;
+    constructor(node: Node, config: WebhookServerConfigNodeConfig);
+    server(): WebhookServer;
+}
+export {};
+//# sourceMappingURL=WebhookServerConfigNode.d.ts.map

package/build/core/webhook/node/WebhookServerConfigNode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"WebhookServerConfigNode.d.ts","sourceRoot":"","sources":["../../../../src/core/webhook/node/WebhookServerConfigNode.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,MAAM,UAAU,CAAC;AAChC,OAAO,EAAE,UAAU,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAA;AAEpE,OAAO,EAAE,aAAa,EAAwB,MAAM,iCAAiC,CAAC;AAGtF,UAAU,6BAA8B,SAAQ,gBAAgB;IAC5D,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,YAAY,EAAC,MAAM,CAAC;IACpB,YAAY,EAAC,MAAM,CAAC;CACvB;AAED,qBASa,uBAAwB,SAAQ,UAAU,CAAC,6BAA6B,CAAC;IAClF,OAAO,CAAC,OAAO,CAAgB;gBAEnB,IAAI,EAAE,IAAI,EAAE,MAAM,EAAE,6BAA6B;IAQtD,MAAM,IAAG,aAAa;CAGhC"}

package/build/core/webhook/node/WebhookServerConfigNode.html

@@ -0,0 +1,61 @@
+
+<script type="text/javascript" template-section="onCompose">
+    node
+        .addDefault("name", { value:"Webhook Example", required:true})
+        .addDefault("port", { value:6644, required:true})
+        .addDefault("externalHost", { value:"localhost", required:true })
+        .addDefault("externalPort", { value:6644, required:true})
+        .addDefault("name", { value:"Example Test Node", required:true})
+        .setPaletteLabel("Webhook")
+        .setLabelStyle("node_label_white")
+        .setLabel(function() {return this.name })
+        .setColor("#0050E5")
+        .setInput("testInput")
+        .addOutputs("testOutput1","testOutput2","testOutput3")
+</script>
+
+<div template-section="onIncludeOnce">
+</div>
+
+
+<script type="text/html" template-section="onIncludeEditForm">\
+    <div id="WebhookServerConfig">
+        <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-port"><i class="fa fa-tag"></i> Port</label>
+            <input type="number" id="node-config-input-port" />
+        </div>
+
+        <div class="form-row">
+            <label for="node-config-input-externalHost"><i class="fa fa-tag"></i> External Host</label>
+            <input type="text" id="node-config-input-externalHost" />
+        </div>
+
+        <div class="form-row">
+            <label for="node-config-input-externalPort"><i class="fa fa-tag"></i> External Port</label>
+            <input type="number" id="node-config-input-externalPort" />
+        </div>
+        <!-- add a button here to autmatically find an open port --> 
+    </div>
+
+</script>
+
+<script type="text/markdown" template-section="onIncludeDocumentation">
+Configuration node for an Express HTTP server that webhook nodes attach to. A single server instance is shared by all webhook nodes that reference it. The server is started when the flow is first deployed and stopped when it is torn down.
+
+### Inputs
+: *name*          (string) : A descriptive name for this webhook server.
+: *port*          (number) : The local port the HTTP server will listen on. Defaults to `6644`. Each server instance must use a unique port.
+
+### Reverse Proxy
+When this server sits behind a reverse proxy, configure the following fields so that webhook nodes know the externally-visible address. This is used when registering endpoints with a reverse proxy service.
+
+: *external host* (string) : The public hostname or IP of the reverse proxy (e.g. `myserver.example.com`).
+: *external port* (number) : The public port exposed by the reverse proxy.
+</script>
+
+

package/build/core/webhook/node/WebhookServerConfigNode.js

@@ -0,0 +1,40 @@
+"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.WebhookServerConfigNode = void 0;
+const NodeConstructor_1 = require("../../NodeConstructor");
+const NodeGenerator_1 = require("../../NodeGenerator");
+const WebhookServerService_1 = require("../service/WebhookServerService");
+const NodeDescriptionDecorator_1 = require("../../tagging/NodeDescriptionDecorator");
+let WebhookServerConfigNode = class WebhookServerConfigNode extends NodeConstructor_1.ConfigNode {
+    constructor(node, config) {
+        super(node, config);
+        let _this = this;
+        // instantiate the webhook here.. or get a reference to it atleast.
+        this._server = WebhookServerService_1.WebhookServerService.get(config);
+    }
+    server() {
+        return this._server;
+    }
+};
+exports.WebhookServerConfigNode = WebhookServerConfigNode;
+exports.WebhookServerConfigNode = WebhookServerConfigNode = __decorate([
+    (0, NodeDescriptionDecorator_1.NodeDescription)({
+        id: "WebhookServerConfigNode",
+        name: "Webhook Server Config Node",
+        group: "config",
+        sourceFile: NodeGenerator_1.SourceUtility.getSourcePath("/build/", "/src/") + "WebhookServerConfigNode.html",
+        package: "@theotherwillembotha/node-red-plugincore",
+        dependencies: [WebhookServerService_1.WebhookServerService],
+        tags: ["Core"]
+    }),
+    __metadata("design:paramtypes", [Object, Object])
+], WebhookServerConfigNode);

package/build/core/webhook/service/ReverseProxyTypeService.d.ts

@@ -0,0 +1,29 @@
+export declare abstract class ReverseProxyType {
+    private _id;
+    private _name;
+    constructor(id: string, name: string);
+    id(): string;
+    name(): string;
+}
+export interface ProxyManagerClient {
+    updateHost(data: Partial<HostEntry>): Promise<void>;
+    getHosts(): Promise<Partial<HostEntry>[]>;
+}
+export declare abstract class ReverseProxyClient {
+}
+export type HostEntry = {
+    id: number;
+    domainNames: string[];
+    scheme: HTTPScheme;
+    forwardHost: string;
+    forwardPort: number;
+    accessList: string;
+    cacheAssets: boolean;
+    blockCommonExploits: boolean;
+    websocketSupport: boolean;
+};
+export declare enum HTTPScheme {
+    HTTP = "http",
+    HTTPS = "https"
+}
+//# sourceMappingURL=ReverseProxyTypeService.d.ts.map

package/build/core/webhook/service/ReverseProxyTypeService.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ReverseProxyTypeService.d.ts","sourceRoot":"","sources":["../../../../src/core/webhook/service/ReverseProxyTypeService.ts"],"names":[],"mappings":"AAGA,8BAAsB,gBAAgB;IAElC,OAAO,CAAC,GAAG,CAAS;IACpB,OAAO,CAAC,KAAK,CAAS;gBAEV,EAAE,EAAC,MAAM,EAAE,IAAI,EAAC,MAAM;IAK3B,EAAE,IAAG,MAAM;IAGX,IAAI,IAAG,MAAM;CAGvB;AAED,MAAM,WAAW,kBAAkB;IAC/B,UAAU,CAAC,IAAI,EAAE,OAAO,CAAC,SAAS,CAAC,GAAE,OAAO,CAAC,IAAI,CAAC,CAAC;IACnD,QAAQ,IAAG,OAAO,CAAC,OAAO,CAAC,SAAS,CAAC,EAAE,CAAC,CAAC;CAC5C;AAED,8BAAsB,kBAAkB;CAEvC;AAED,MAAM,MAAM,SAAS,GAAG;IACpB,EAAE,EAAC,MAAM,CAAC;IACV,WAAW,EAAC,MAAM,EAAE,CAAC;IACrB,MAAM,EAAC,UAAU,CAAC;IAClB,WAAW,EAAC,MAAM,CAAC;IACnB,WAAW,EAAC,MAAM,CAAC;IACnB,UAAU,EAAC,MAAM,CAAC;IAClB,WAAW,EAAC,OAAO,CAAC;IACpB,mBAAmB,EAAC,OAAO,CAAC;IAC5B,gBAAgB,EAAC,OAAO,CAAC;CAC5B,CAAA;AAED,oBAAY,UAAU;IAClB,IAAI,SAAS;IACb,KAAK,UAAU;CAClB"}

package/build/core/webhook/service/ReverseProxyTypeService.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HTTPScheme = exports.ReverseProxyClient = exports.ReverseProxyType = void 0;
+class ReverseProxyType {
+    constructor(id, name) {
+        this._id = id;
+        this._name = name;
+    }
+    id() {
+        return this._id;
+    }
+    name() {
+        return this._name;
+    }
+}
+exports.ReverseProxyType = ReverseProxyType;
+class ReverseProxyClient {
+}
+exports.ReverseProxyClient = ReverseProxyClient;
+var HTTPScheme;
+(function (HTTPScheme) {
+    HTTPScheme["HTTP"] = "http";
+    HTTPScheme["HTTPS"] = "https";
+})(HTTPScheme || (exports.HTTPScheme = HTTPScheme = {}));

package/build/core/webhook/service/WebhookServerService.d.ts

@@ -0,0 +1,52 @@
+import { BaseService, FlowDeployment, ServiceDescriptor } from "../../NodeConstructor";
+import { NodeAPI, NodeAPISettingsWithData } from "node-red";
+import { Request, Response } from "express";
+import { ApiKeyMechanismType, RestAuthType } from "../../logger/service/LoggerServiceTypes";
+export declare enum EndpointMethodType {
+    GET = "GET",
+    POST = "POST"
+}
+export type NoAuthenticationConfig = {
+    type: RestAuthType.none;
+};
+export type BasicAuthenticationConfig = {
+    type: RestAuthType.basic;
+    username: string;
+    password: string;
+};
+export type ApiKeyAuthenticationConfig = {
+    type: RestAuthType.apikey;
+    mechanism: ApiKeyMechanismType;
+    key: string;
+    value: string;
+};
+export type EndpointConfig = {
+    path: string;
+    methods: EndpointMethodType[];
+    authentication: NoAuthenticationConfig | BasicAuthenticationConfig | ApiKeyAuthenticationConfig;
+};
+export declare class WebhookServer {
+    private _config;
+    private _app;
+    private _listener;
+    constructor(config: WebhookServerConfig);
+    attach(endpoint: EndpointConfig, callback: (request: Request, response: Response) => any): void;
+    detach(configuration: EndpointConfig): void;
+    config(): WebhookServerConfig;
+}
+export type WebhookServerConfig = {
+    id: string;
+    port: number;
+    externalHost: string;
+    externalPort: number;
+};
+export declare class WebhookServerService extends BaseService {
+    private static webhookServers;
+    constructor();
+    init(red: NodeAPI<NodeAPISettingsWithData>): void | Promise<void>;
+    deinit(red: NodeAPI<NodeAPISettingsWithData>): void | Promise<void>;
+    onDeploy(flowDeployment: FlowDeployment): void | Promise<void>;
+    static get(config: WebhookServerConfig): WebhookServer;
+    static getServiceDescriptor(): ServiceDescriptor;
+}
+//# sourceMappingURL=WebhookServerService.d.ts.map

package/build/core/webhook/service/WebhookServerService.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"WebhookServerService.d.ts","sourceRoot":"","sources":["../../../../src/core/webhook/service/WebhookServerService.ts"],"names":[],"mappings":"AACA,OAAO,EAAC,WAAW,EAAE,cAAc,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AACtF,OAAO,EAAE,OAAO,EAAE,uBAAuB,EAAE,MAAM,UAAU,CAAC;AAG5D,OAAgB,EAAU,OAAO,EAAE,QAAQ,EAAC,MAAM,SAAS,CAAC;AAE5D,OAAO,EAAE,mBAAmB,EAAE,YAAY,EAAE,MAAM,yCAAyC,CAAC;AAI5F,oBAAY,kBAAkB;IAC1B,GAAG,QAAQ;IACX,IAAI,SAAS;CAChB;AAED,MAAM,MAAM,sBAAsB,GAAG;IACjC,IAAI,EAAC,YAAY,CAAC,IAAI,CAAC;CAC1B,CAAA;AAED,MAAM,MAAM,yBAAyB,GAAG;IACpC,IAAI,EAAC,YAAY,CAAC,KAAK,CAAA;IACvB,QAAQ,EAAC,MAAM,CAAC;IAChB,QAAQ,EAAC,MAAM,CAAC;CACnB,CAAA;AAED,MAAM,MAAM,0BAA0B,GAAG;IACrC,IAAI,EAAC,YAAY,CAAC,MAAM,CAAC;IACzB,SAAS,EAAC,mBAAmB,CAAC;IAC9B,GAAG,EAAC,MAAM,CAAC;IACX,KAAK,EAAC,MAAM,CAAC;CAChB,CAAA;AAED,MAAM,MAAM,cAAc,GAAG;IACzB,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAC,kBAAkB,EAAE,CAAC;IAC7B,cAAc,EAAE,sBAAsB,GAAG,yBAAyB,GAAG,0BAA0B,CAAC;CACnG,CAAA;AAED,qBAAa,aAAa;IAEtB,OAAO,CAAC,OAAO,CAAsB;IACrC,OAAO,CAAC,IAAI,CAAU;IACtB,OAAO,CAAC,SAAS,CAAS;gBAEP,MAAM,EAAC,mBAAmB;IAQtC,MAAM,CAAC,QAAQ,EAAC,cAAc,EAAE,QAAQ,EAAC,CAAC,OAAO,EAAC,OAAO,EAAE,QAAQ,EAAC,QAAQ,KAAK,GAAG;IA+CpF,MAAM,CAAC,aAAa,EAAC,cAAc;IAsBnC,MAAM,IAAG,mBAAmB;CAGtC;AAED,MAAM,MAAO,mBAAmB,GAAG;IAC/B,EAAE,EAAC,MAAM,CAAA;IACT,IAAI,EAAE,MAAM,CAAC;IACb,YAAY,EAAC,MAAM,CAAC;IACpB,YAAY,EAAC,MAAM,CAAC;CACvB,CAAA;AAED,qBAAa,oBAAqB,SAAQ,WAAW;IAEjD,OAAO,CAAC,MAAM,CAAC,cAAc,CAAmC;;IAMzD,IAAI,CAAC,GAAG,EAAE,OAAO,CAAC,uBAAuB,CAAC,GAAG,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC;IAIjE,MAAM,CAAC,GAAG,EAAE,OAAO,CAAC,uBAAuB,CAAC,GAAG,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC;IAInE,QAAQ,CAAC,cAAc,EAAE,cAAc,GAAG,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC;WAyCvD,GAAG,CAAE,MAAM,EAAC,mBAAmB,GAAG,aAAa;WAS7C,oBAAoB,IAAG,iBAAiB;CAU3D"}

package/build/core/webhook/service/WebhookServerService.js

@@ -0,0 +1,146 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebhookServerService = exports.WebhookServer = exports.EndpointMethodType = void 0;
+const NodeConstructor_1 = require("../../NodeConstructor");
+const WebhookServerConfigNode_1 = require("../node/WebhookServerConfigNode");
+const WebhookTemplate_1 = require("../template/WebhookTemplate");
+const express_1 = __importDefault(require("express"));
+const LoggerServiceTypes_1 = require("../../logger/service/LoggerServiceTypes");
+var bodyParser = require('body-parser');
+var EndpointMethodType;
+(function (EndpointMethodType) {
+    EndpointMethodType["GET"] = "GET";
+    EndpointMethodType["POST"] = "POST";
+})(EndpointMethodType || (exports.EndpointMethodType = EndpointMethodType = {}));
+class WebhookServer {
+    constructor(config) {
+        this._config = config;
+        this._app = (0, express_1.default)();
+        this._app.use(bodyParser.json({ type: "application/json", limit: '50mb' }));
+        this._listener = this._app.listen(this._config.port, '0.0.0.0');
+    }
+    attach(endpoint, callback) {
+        let authenticator;
+        if (endpoint.authentication.type === LoggerServiceTypes_1.RestAuthType.none) {
+            authenticator = (request, response) => Promise.resolve(true);
+        }
+        if (endpoint.authentication.type === LoggerServiceTypes_1.RestAuthType.basic) {
+            let header = "Basic " + Buffer.from(`${endpoint.authentication.username}:${endpoint.authentication.password}`).toString("base64");
+            authenticator = (request, response) => {
+                return Promise.resolve(header === request.headers.authorization);
+            };
+        }
+        if (endpoint.authentication.type === LoggerServiceTypes_1.RestAuthType.apikey) {
+            let auth = endpoint.authentication;
+            authenticator = (request, response) => {
+                if (auth.mechanism === LoggerServiceTypes_1.ApiKeyMechanismType.header) {
+                    return Promise.resolve(request.headers[auth.key] === auth.value);
+                }
+                console.log("No APIKEY Authentication Handler Implementation for Type: " + auth.mechanism);
+                return Promise.resolve(false);
+            };
+        }
+        let handlerChain = (request, response) => authenticator(request, response)
+            .then(result => {
+            if (result) {
+                callback(request, response);
+            }
+            else {
+                response.status(401).send();
+            }
+        });
+        if (endpoint.methods.includes(EndpointMethodType.GET)) {
+            this._app.get(endpoint.path, handlerChain);
+        }
+        if (endpoint.methods.includes(EndpointMethodType.POST)) {
+            this._app.post(endpoint.path, handlerChain);
+        }
+        console.log("added endpoint to " + endpoint.path);
+    }
+    detach(configuration) {
+        configuration.methods.forEach(method => {
+            this._app.router.stack = this._app.router.stack.filter(layer => {
+                // if the path doesnt match, keep it.
+                if (layer.route?.path !== configuration.path) {
+                    return true;
+                }
+                switch (method) {
+                    case EndpointMethodType.GET: {
+                        return !layer.route?.methods.get;
+                    }
+                    case EndpointMethodType.POST: {
+                        return !layer.route?.methods.post;
+                    }
+                }
+                ;
+            });
+        });
+        console.log("ROUTES REMOVED!");
+        this._app.router.stack.forEach(route => console.log("KNOWN ROUTE", route, route.route?.path, route.route.methods.post));
+    }
+    config() {
+        return this._config;
+    }
+}
+exports.WebhookServer = WebhookServer;
+class WebhookServerService extends NodeConstructor_1.BaseService {
+    constructor() {
+        super("wehbookserver");
+    }
+    init(red) {
+        return Promise.resolve();
+    }
+    deinit(red) {
+        return Promise.resolve();
+    }
+    onDeploy(flowDeployment) {
+        let removedServers = [];
+        let addedServers = [];
+        let webhookServerNodes = flowDeployment.flows.filter(node => node.type === "WebhookServerConfigNode");
+        // find all the nodes that have been removed or changed.
+        Object.entries(WebhookServerService.webhookServers).forEach(([key, serverService]) => {
+            let webhookServerNode = webhookServerNodes.find(node => node.id === key);
+            let serverServiceConfig = serverService.config();
+            // compare the properties.
+            if (!webhookServerNode) {
+                // the node has been removed: TODO: alert the listeners that it has been removed.
+                console.log("Webhook Service Removed", serverServiceConfig);
+                removedServers.push(serverServiceConfig);
+            }
+            else {
+                // check if the node has changed at all.
+                let serviceChanged = webhookServerNode.port !== serverServiceConfig.port ||
+                    webhookServerNode.externalHost !== serverServiceConfig.externalHost ||
+                    webhookServerNode.externalPort !== serverServiceConfig.externalPort;
+                if (serviceChanged) {
+                    // TODO: notify the subscribers that the server has chaned.
+                    console.log("Notify the subscribers WebhookServer has changed.", serverServiceConfig, webhookServerNode);
+                    removedServers.push(serverServiceConfig);
+                    addedServers.push(webhookServerNode);
+                }
+            }
+        });
+        // find all the servers that have been added.
+        webhookServerNodes
+            .filter(node => !WebhookServerService.webhookServers[node.id])
+            .forEach(node => addedServers.push(node));
+        //console.log("REMOVED SERVERS:", removedServers);
+        //console.log("ADDED SERVERS:", addedServers);        
+    }
+    static get(config) {
+        let server = (this.webhookServers[config.id]);
+        if (!server) {
+            this.webhookServers[config.id] = server = new WebhookServer(config);
+            console.log(`Creating webhook server on port ${config.port}`);
+        }
+        return server;
+    }
+    static getServiceDescriptor() {
+        return new NodeConstructor_1.ServiceDescriptor("@theotherwillembotha/webhookserverservice", "WebhookServerService", "services-plugin", "@theotherwillembotha/node-red-plugincore", WebhookServerService, [WebhookServerConfigNode_1.WebhookServerConfigNode, WebhookTemplate_1.WebhookTemplate]);
+    }
+}
+exports.WebhookServerService = WebhookServerService;
+WebhookServerService.webhookServers = {};

package/build/core/webhook/template/WebhookTemplate.d.ts

@@ -0,0 +1,22 @@
+import { BaseNodeConfig, Template, TemplateDescriptor } from "../../NodeConstructor";
+import { ApiKeyMechanismType, RestAuthType } from "../../logger/service/LoggerServiceTypes";
+export interface WebhookTemplateConfig extends BaseNodeConfig {
+    webhook: string;
+    webhookPath: string;
+    webhookAuth: RestAuthType;
+    webhookAuth_basic_username: string;
+    webhookAuth_basic_password: string;
+    webhookAuth_apikey_mechanism: ApiKeyMechanismType;
+    webhookAuth_apikey_key: string;
+    webhookAuth_apikey_value: string;
+    reverseProxies_enabled: boolean;
+    reverseProxies_connections: ReverseproxyConnection[];
+}
+export type ReverseproxyConnection = {
+    proxy: string;
+    domainname: string;
+};
+export declare class WebhookTemplate extends Template {
+    static getTemplateDescriptor(): TemplateDescriptor;
+}
+//# sourceMappingURL=WebhookTemplate.d.ts.map

package/build/core/webhook/template/WebhookTemplate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"WebhookTemplate.d.ts","sourceRoot":"","sources":["../../../../src/core/webhook/template/WebhookTemplate.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,QAAQ,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAA;AAGpF,OAAO,EAAE,mBAAmB,EAAE,YAAY,EAAE,MAAM,yCAAyC,CAAC;AAE5F,MAAM,WAAW,qBAAsB,SAAQ,cAAc;IACzD,OAAO,EAAC,MAAM,CAAC;IACf,WAAW,EAAC,MAAM,CAAC;IACnB,WAAW,EAAC,YAAY,CAAC;IACzB,0BAA0B,EAAC,MAAM,CAAC;IAClC,0BAA0B,EAAC,MAAM,CAAC;IAClC,4BAA4B,EAAC,mBAAmB,CAAC;IACjD,sBAAsB,EAAC,MAAM,CAAC;IAC9B,wBAAwB,EAAC,MAAM,CAAC;IAEhC,sBAAsB,EAAC,OAAO,CAAC;IAC/B,0BAA0B,EAAC,sBAAsB,EAAE,CAAC;CACvD;AAED,MAAM,MAAM,sBAAsB,GAAG;IACjC,KAAK,EAAC,MAAM,CAAC;IACb,UAAU,EAAC,MAAM,CAAA;CACpB,CAAA;AAED,qBAAa,eAAgB,SAAQ,QAAQ;IAEzC,MAAM,CAAC,qBAAqB,IAAI,kBAAkB;CAMrD"}