@theotherwillembotha/node-red-plugincore 0.0.50

package/src/core/webhook/WebhookDecorator.ts

@@ -0,0 +1,70 @@
+import { RestAuthType } from "../logger/service/LoggerServiceTypes";
+import { BaseNode, createPostConstructDecorator, NodeManager } from "../NodeConstructor";
+import { ProxyManagerClient } from "./service/ReverseProxyTypeService";
+import { ApiKeyAuthenticationConfig, BasicAuthenticationConfig, EndpointConfig, EndpointMethodType, NoAuthenticationConfig, WebhookServer } from "./service/WebhookServerService";
+import { WebhookTemplateConfig } from "./template/WebhookTemplate";
+
+
+type WebhookConfig = {
+    name?:string,
+    methods:EndpointMethodType[],
+}
+
+const Webhook = createPostConstructDecorator<WebhookConfig>('Webhook')
+    .withInitLogic(async (instance, propertyKey, webhookconfig:WebhookConfig) => {
+        //console.log(`Registering webhook callback`,  "PROPERTYKEY", propertyKey, "WEBHOOK CONFIG", webhookconfig, "THIS", this);
+        
+        let node = instance as BaseNode<WebhookTemplateConfig>;
+        let nodeConfig = node.config();
+
+        // create the authentication.
+        let authentication =
+            (nodeConfig.webhookAuth === RestAuthType.basic) ? {type:RestAuthType.basic, username:nodeConfig.webhookAuth_basic_username, password: nodeConfig.webhookAuth_basic_password} as BasicAuthenticationConfig :
+            (nodeConfig.webhookAuth === RestAuthType.apikey) ? {type:RestAuthType.apikey, mechanism:nodeConfig.webhookAuth_apikey_mechanism, key:nodeConfig.webhookAuth_apikey_key, value: nodeConfig.webhookAuth_apikey_value } as ApiKeyAuthenticationConfig :
+            {type:RestAuthType.none} as NoAuthenticationConfig;
+
+        // register a callback listener to the webserver.
+        let endpointConfig:EndpointConfig = {
+            path: nodeConfig.webhookPath,
+            methods: webhookconfig.methods,
+            authentication: authentication
+        }
+
+        let webhookServer:WebhookServer = (NodeManager.RED.nodes.getNode(nodeConfig.webhook) as any).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 = (NodeManager.RED.nodes.getNode(proxy.proxy) as any).node();
+
+                    // TODO: ReverseProxyConfigNodes need to become their own subtype of config nodes so we can enforce the ".client()" method.
+                    let proxyClient = reverseProxyNode.client() as ProxyManagerClient;
+
+                    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();
+
+
+export {
+    Webhook
+}

package/src/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/src/core/webhook/node/WebhookServerConfigNode.ts

@@ -0,0 +1,38 @@
+
+import { Node } from "node-red";
+import { ConfigNode, ConfigNodeConfig } from "../../NodeConstructor"
+import { SourceUtility } from "../../NodeGenerator";
+import { WebhookServer, WebhookServerService } from "../service/WebhookServerService";
+import { NodeDescription } from "../../tagging/NodeDescriptionDecorator";
+
+interface WebhookServerConfigNodeConfig extends ConfigNodeConfig {
+    id: string;
+    port: number;
+    externalHost:string;
+    externalPort:number;
+}
+
+@NodeDescription({
+    id:"WebhookServerConfigNode",
+    name:"Webhook Server Config Node",
+    group:"config",
+    sourceFile:SourceUtility.getSourcePath("/build/", "/src/") + "WebhookServerConfigNode.html",
+    package: "@theotherwillembotha/node-red-plugincore",
+    dependencies:[ WebhookServerService ],
+    tags: [ "Core" ]
+})
+export class WebhookServerConfigNode extends ConfigNode<WebhookServerConfigNodeConfig> {
+    private _server: WebhookServer;
+    
+    constructor(node: Node, config: WebhookServerConfigNodeConfig){
+        super(node, config);
+        let _this = this;
+
+        // instantiate the webhook here.. or get a reference to it atleast.
+        this._server = WebhookServerService.get(config);
+    }
+
+    public server():WebhookServer {
+        return this._server;
+    }
+}

package/src/core/webhook/service/ReverseProxyTypeService.ts

@@ -0,0 +1,46 @@
+import { BaseService, FlowDeployment, ServiceDescriptor } from "../../NodeConstructor";
+import { NodeAPI, NodeAPISettingsWithData } from "node-red";
+
+export abstract class ReverseProxyType {
+
+    private _id: string;
+    private _name: string;
+    
+    constructor(id:string, name:string){
+        this._id = id;
+        this._name = name;
+    }
+
+    public id():string {
+        return this._id;
+    }
+    public name():string {
+        return this._name;
+    }
+}
+
+export interface ProxyManagerClient {
+    updateHost(data: Partial<HostEntry>):Promise<void>;
+    getHosts():Promise<Partial<HostEntry>[]>;
+}
+
+export 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 enum HTTPScheme{
+    HTTP = "http",
+    HTTPS = "https"
+}

package/src/core/webhook/service/WebhookServerService.ts

@@ -0,0 +1,211 @@
+
+import {BaseService, FlowDeployment, ServiceDescriptor } from "../../NodeConstructor";
+import { NodeAPI, NodeAPISettingsWithData } from "node-red";
+import { WebhookServerConfigNode } from "../node/WebhookServerConfigNode";
+import { WebhookTemplate } from "../template/WebhookTemplate";
+import express, {Express, Request, Response} from "express";
+import { Server } from "http";
+import { ApiKeyMechanismType, RestAuthType } from "../../logger/service/LoggerServiceTypes";
+
+var bodyParser = require('body-parser');
+
+export 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 class WebhookServer {
+    
+    private _config: WebhookServerConfig;
+    private _app: Express;
+    private _listener: Server;
+    
+    public constructor(config:WebhookServerConfig){
+        this._config = config;
+
+        this._app = express();
+        this._app.use(bodyParser.json({type: "application/json", limit: '50mb'}));
+        this._listener = this._app.listen(this._config.port, '0.0.0.0');
+    }
+
+    public attach(endpoint:EndpointConfig, callback:(request:Request, response:Response) => any){
+
+        let authenticator:((request:Request, response:Response) => Promise<boolean>);
+        
+        if(endpoint.authentication.type === RestAuthType.none){
+            authenticator = (request, response) => Promise.resolve(true);
+        }
+        
+        if(endpoint.authentication.type === 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 === RestAuthType.apikey){
+            let auth = endpoint.authentication as ApiKeyAuthenticationConfig;
+            authenticator = (request, response) => {
+                if(auth.mechanism === 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:Request, response: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);
+    }
+
+    public detach(configuration:EndpointConfig){
+        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 as any)?.methods.get
+                    }
+                    case EndpointMethodType.POST:{
+                        return !(layer.route as any)?.methods.post
+                    }
+                };
+            })
+        });
+
+        console.log("ROUTES REMOVED!");
+        this._app.router.stack.forEach(route => console.log("KNOWN ROUTE", route, route.route?.path, (route.route as any).methods.post));
+    }
+
+    public config():WebhookServerConfig {
+        return this._config;
+    }
+}
+
+export type  WebhookServerConfig = {
+    id:string
+    port: number;
+    externalHost:string;
+    externalPort:number;
+}
+
+export class WebhookServerService extends BaseService {
+
+    private static webhookServers:{[key:string]:WebhookServer} = {};
+
+    constructor(){
+        super("wehbookserver")
+    }
+
+    public init(red: NodeAPI<NodeAPISettingsWithData>): void | Promise<void> {
+        return Promise.resolve();
+    }
+
+    public deinit(red: NodeAPI<NodeAPISettingsWithData>): void | Promise<void> {
+        return Promise.resolve();
+    }
+
+    public onDeploy(flowDeployment: FlowDeployment): void | Promise<void> {
+        let removedServers:WebhookServerConfig[] = []
+        let addedServers:WebhookServerConfig[] = []
+
+        let webhookServerNodes = flowDeployment.flows.filter(node => node.type === "WebhookServerConfigNode") as any as WebhookServerConfig[];
+
+        // 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);        
+    }
+
+    public static get (config:WebhookServerConfig): WebhookServer{
+        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 override getServiceDescriptor():ServiceDescriptor {
+        return new ServiceDescriptor(
+            "@theotherwillembotha/webhookserverservice",
+            "WebhookServerService",
+            "services-plugin",
+            "@theotherwillembotha/node-red-plugincore",
+            WebhookServerService,
+            [WebhookServerConfigNode, WebhookTemplate]
+        );
+    }
+}