n8n-nodes-soar 0.1.21 → 0.1.23

package/dist/credentials/SoarRunner/SoarRunner.credentials.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "SoarRunner", {
+    enumerable: true,
+    get: function() {
+        return SoarRunner;
+    }
+});
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+class SoarRunner {
+    constructor(){
+        _define_property(this, "name", "soarRunnerApi");
+        _define_property(this, "displayName", "Soar Runner");
+        _define_property(this, "documentationUrl", "https://github.com/yoshino-s/n8n-nodes-soar");
+        _define_property(this, "icon", "file:icon.svg");
+        _define_property(this, "properties", [
+            {
+                displayName: "URL",
+                name: "url",
+                type: "string",
+                placeholder: "https://soar.example.com",
+                default: "",
+                required: true
+            },
+            {
+                displayName: "Username",
+                name: "username",
+                type: "string",
+                default: "",
+                required: true
+            },
+            {
+                displayName: "Password",
+                name: "password",
+                type: "string",
+                typeOptions: {
+                    password: true
+                },
+                default: "",
+                required: true
+            }
+        ]);
+        _define_property(this, "authenticate", {
+            type: "generic",
+            properties: {
+                auth: {
+                    username: "={{$credentials.username}}",
+                    password: "={{$credentials.password}}"
+                }
+            }
+        });
+        _define_property(this, "test", {
+            request: {
+                baseURL: "={{$credentials.url}}",
+                url: "/metrics"
+            }
+        });
+    }
+}

package/dist/credentials/SoarRunner/icon.svg

@@ -0,0 +1,8 @@
+<?xml version="1.0" ?>
+<svg xmlns="http://www.w3.org/2000/svg" width="128" height="128" viewBox="-1 -1 130 130">
+	<circle cx="64" cy="32" r="32" fill="none" stroke="#025d02" stroke-width="2" />
+	<circle cx="64" cy="96" r="32" fill="none" stroke="#025d02" stroke-width="2" />
+	<circle cx="32" cy="64" r="32" fill="none" stroke="#025d02" stroke-width="2" />
+	<circle cx="96" cy="64" r="32" fill="none" stroke="#025d02" stroke-width="2" />
+	<path d="M 64,32 L 32,64 L 64,96 L 96,64 Z" fill="#01ae01" fill-rule="nonzero" />
+</svg>

package/dist/credentials/VulboxApi/VulboxApi.credentials.js

@@ -0,0 +1,157 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "VulboxApi", {
+    enumerable: true,
+    get: function() {
+        return VulboxApi;
+    }
+});
+const _asynclock = /*#__PURE__*/ _interop_require_default(require("async-lock"));
+const _lodash = require("lodash");
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+const vulboxLoginCache = new Map();
+const lock = new _asynclock.default();
+class VulboxApi {
+    async authenticate(credentials, requestOptions) {
+        return await lock.acquire("vulboxLogin", async ()=>{
+            function checkJwtExpired(jwt) {
+                const jwtPayload = JSON.parse(atob(jwt.split(".")[1]));
+                return jwtPayload.exp * 1000 < Date.now();
+            }
+            let jwtToken = "";
+            if (credentials.mode === "jwt") {
+                jwtToken = credentials.jwt;
+            } else {
+                const cachedToken = vulboxLoginCache.get(`${credentials.username} ${credentials.password}`);
+                if (cachedToken && !checkJwtExpired(cachedToken)) {
+                    jwtToken = cachedToken;
+                } else {
+                    const result = await fetch("https://vapi.vulbox.com/openapi/account/login/by", {
+                        method: "POST",
+                        headers: {
+                            uuid: Math.random().toString(36).slice(2),
+                            "Content-Type": "application/json",
+                            origin: "https://www.vulbox.com",
+                            referer: "https://www.vulbox.com"
+                        },
+                        body: JSON.stringify({
+                            login_by: "username",
+                            username: credentials.username.toString(),
+                            password: btoa(credentials.password.toString())
+                        })
+                    }).then((res)=>res.json());
+                    if (result.code !== 200) {
+                        throw new Error(result.msg);
+                    }
+                    jwtToken = result.data.token;
+                    vulboxLoginCache.set(`${credentials.username} ${credentials.password}`, jwtToken);
+                }
+            }
+            const options = (0, _lodash.cloneDeep)(requestOptions);
+            (0, _lodash.set)(options, "headers.Authorization", `Bearer ${jwtToken}`);
+            return options;
+        });
+    }
+    constructor(){
+        _define_property(this, "name", "vulboxApi");
+        _define_property(this, "displayName", "Vulbox API Credentials");
+        _define_property(this, "documentationUrl", "https://www.vulbox.com");
+        _define_property(this, "icon", "file:vulbox.svg");
+        _define_property(this, "properties", [
+            {
+                displayName: "Mode",
+                name: "mode",
+                type: "options",
+                default: "email",
+                options: [
+                    {
+                        name: "Email+Password",
+                        value: "email"
+                    },
+                    {
+                        name: "JWT",
+                        value: "jwt"
+                    }
+                ]
+            },
+            {
+                displayName: "Vulbox Email/Username/Phone",
+                name: "username",
+                type: "string",
+                default: "",
+                displayOptions: {
+                    show: {
+                        mode: [
+                            "email"
+                        ]
+                    }
+                }
+            },
+            {
+                displayName: "Vulbox Password",
+                name: "password",
+                type: "string",
+                typeOptions: {
+                    password: true
+                },
+                default: "",
+                required: true,
+                displayOptions: {
+                    show: {
+                        mode: [
+                            "email"
+                        ]
+                    }
+                }
+            },
+            {
+                displayName: "Vulbox JWT",
+                name: "jwt",
+                type: "string",
+                default: "",
+                displayOptions: {
+                    show: {
+                        mode: [
+                            "jwt"
+                        ]
+                    }
+                }
+            }
+        ]);
+        _define_property(this, "test", {
+            request: {
+                method: "GET",
+                url: "https://user.vulbox.com/api/hacker/user/account/info"
+            },
+            rules: [
+                {
+                    type: "responseSuccessBody",
+                    properties: {
+                        key: "code",
+                        value: 401,
+                        message: "Invalid credentials!"
+                    }
+                }
+            ]
+        });
+    }
+}

package/dist/credentials/VulboxApi/vulbox.svg

@@ -0,0 +1,18 @@
+<svg width="32px" height="32px" viewBox="-2.835 0 29.165 32" version="1.1" xmlns="http://www.w3.org/2000/svg"
+	xmlns:xlink="http://www.w3.org/1999/xlink" style="display:inline-block;vertical-align:middle;" data-v-2f95c8dd="">
+	<polygon id="Fill-1" fill="#2A98CC"
+		points="13.1114323 4.03361345e-05 0.0227870968 8.01671261 13.1114323 15.8635697 26.3147871 7.91573782">
+	</polygon>
+	<polygon id="Fill-2" fill="#1D7EB7"
+		points="0 23.9524437 13.1114839 31.9430319 13.1114839 15.8650487 0.0227096774 8.01671261"></polygon>
+	<polygon id="Fill-3" fill="#1366A3"
+		points="13.1114323 15.863637 13.1114323 31.961116 26.3147871 24.0056202 26.3147871 7.91567059"></polygon>
+	<polygon id="Fill-4" fill="#AFDAEB"
+		points="20.4230194 11.5270588 20.4230194 20.4123025 13.1320516 24.8051765 13.1320516 15.9160336">
+	</polygon>
+	<polyline id="Fill-5" fill="#C4E2F0"
+		points="5.90436129 11.5831261 5.8915871 20.3823193 13.1321032 24.7953613 13.1321032 15.916437"></polyline>
+	<polygon id="Fill-6" fill="#FEFEFE"
+		points="13.1320645 7.15599328 5.90432258 11.5831529 13.1320645 15.9160605 20.4230323 11.5270857">
+	</polygon>
+</svg>

package/dist/nodes/Collector/Collector.node.js

@@ -8,11 +8,10 @@ Object.defineProperty(exports, "Collector", {
         return Collector;
     }
 });
-const _classtransformer = require("class-transformer");
 const _n8nworkflow = require("n8n-workflow");
-const _asset = require("../../common/asset");
 const _collector = require("../../common/collector");
 const _connectionType = require("../../common/connectionType");
+const _decorator = require("../../common/runner/decorator");
 function _define_property(obj, key, value) {
     if (key in obj) {
         Object.defineProperty(obj, key, {
@@ -28,47 +27,52 @@ function _define_property(obj, key, value) {
 }
 class Collector {
     async execute() {
-        let assets = this.getInputData().map((n)=>(0, _classtransformer.plainToInstance)(_asset.Asset, n.json));
-        const batch = this.getNodeParameter("batch", 0);
-        if (batch) {
-            const executor = await this.getInputConnectionData(_connectionType.NodeConnectionType.Executor, 0);
-            const collector = new _collector.Collector();
+        const inputs = this.getInputData();
+        const collector = new _collector.Collector();
+        const run = async (inputs, idx)=>{
+            const outputs = [];
+            const executor = await this.getInputConnectionData(_connectionType.NodeConnectionType.Executor, idx);
             collector.setExecutor(executor);
-            let runners = (await this.getInputConnectionData(_connectionType.NodeConnectionType.Runner, 0)).flat();
-            runners = runners.sort((a, b)=>a.priority - b.priority);
-            for (const runner of runners){
-                assets = await runner.run(collector, assets);
+            const memorizer = await this.getInputConnectionData(_connectionType.NodeConnectionType.Memorizer, idx);
+            const ignoreMemorizedData = this.getNodeParameter("ignoreMemorizedData", idx);
+            if (memorizer) {
+                const cachedOutput = await memorizer.batchLoad(inputs);
+                inputs = inputs.filter((i, idx)=>!cachedOutput[idx]);
+                if (!ignoreMemorizedData) {
+                    outputs.push(...cachedOutput.filter((o)=>o !== null).flat());
+                }
+                inputs.forEach((i, idx)=>{
+                    i.sourceInputIndex = idx;
+                });
             }
-            return [
-                assets.flatMap((n)=>{
-                    return this.helpers.returnJsonArray((0, _classtransformer.instanceToPlain)(n));
-                })
-            ];
-        } else {
-            const results = [];
-            for(let idx = 0; idx < assets.length; idx++){
-                const asset = assets[idx];
-                let currentAssets = [
-                    asset
-                ];
-                const executor = await this.getInputConnectionData(_connectionType.NodeConnectionType.Executor, idx);
-                const collector = new _collector.Collector();
-                collector.setExecutor(executor);
-                let runners = (await this.getInputConnectionData(_connectionType.NodeConnectionType.Runner, 0)).flat();
-                runners = runners.sort((a, b)=>a.priority - b.priority);
+            if (inputs.length !== 0) {
+                let runners = (await this.getInputConnectionData(_connectionType.NodeConnectionType.Runner, idx)).flat();
+                runners = runners.sort((a, b)=>(0, _decorator.getPriority)(b) - (0, _decorator.getPriority)(a));
+                let runOutputs = inputs;
                 for (const runner of runners){
-                    currentAssets = await runner.run(collector, currentAssets);
+                    runOutputs = await runner.run(collector, runOutputs);
                 }
-                results.push(...this.helpers.constructExecutionMetaData(this.helpers.returnJsonArray(currentAssets.map((n)=>(0, _classtransformer.instanceToPlain)(n))), {
-                    itemData: {
-                        item: idx
+                if (memorizer) {
+                    const paired = inputs.map(()=>[]);
+                    for (const output of runOutputs){
+                        if (output.sourceInputIndex !== -1) {
+                            console.log(output);
+                            paired[output.sourceInputIndex].push(output);
+                        }
                     }
-                }));
+                    await memorizer.batchSave(inputs, paired);
+                }
+                outputs.push(...runOutputs);
             }
-            return [
-                results
-            ];
-        }
+            return outputs;
+        };
+        return [
+            this.helpers.returnJsonArray(await run(inputs.map((n, idx)=>({
+                    json: n.json,
+                    binary: n.binary,
+                    sourceInputIndex: idx
+                })), 0))
+        ];
     }
     constructor(){
         _define_property(this, "description", {
@@ -79,7 +83,7 @@ class Collector {
                 "transform"
             ],
             version: 1,
-            description: "A collector to collect all info about site",
+            description: "A collector to collect all info about assets",
             defaults: {
                 name: "Collector",
                 color: "#D8EF40"
@@ -89,9 +93,15 @@ class Collector {
                 _n8nworkflow.NodeConnectionType.Main,
                 {
                     displayName: "Executor",
-                    maxConnections: 1,
                     type: _connectionType.NodeConnectionType.Executor,
-                    required: true
+                    required: true,
+                    maxConnections: 1
+                },
+                {
+                    displayName: "Memorizer",
+                    type: _connectionType.NodeConnectionType.Memorizer,
+                    required: false,
+                    maxConnections: 1
                 },
                 {
                     displayName: "Collector",
@@ -103,19 +113,18 @@ class Collector {
             outputs: [
                 _n8nworkflow.NodeConnectionType.Main
             ],
-            credentials: [],
             properties: [
-                {
-                    displayName: "Batch",
-                    name: "batch",
-                    type: "boolean",
-                    default: true
-                },
                 {
                     displayName: "Asset",
                     name: "asset",
                     type: "json",
                     default: "={{ $json }}"
+                },
+                {
+                    displayName: "Ignore Memorized Data",
+                    name: "ignoreMemorizedData",
+                    type: "boolean",
+                    default: false
                 }
             ]
         });

package/dist/nodes/EmptyCheck/EmptyCheck.node.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "EmptyCheck", {
+    enumerable: true,
+    get: function() {
+        return EmptyCheck;
+    }
+});
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+class EmptyCheck {
+    async execute() {
+        const all = this.getInputData();
+        if (all.length === 1 && JSON.stringify(all[0].json) === "{}" && all[0].binary === undefined) {
+            return [
+                [],
+                all
+            ];
+        } else {
+            return [
+                all,
+                []
+            ];
+        }
+    }
+    constructor(){
+        _define_property(this, "description", {
+            displayName: "Empty Check",
+            name: "emptyCheck",
+            group: [
+                "transform"
+            ],
+            version: 1,
+            icon: "fa:dot-circle",
+            description: "Check if previous node returned empty result",
+            defaults: {
+                name: "Empty Check",
+                color: "#FF0000"
+            },
+            inputs: [
+                "main"
+            ],
+            // eslint-disable-next-line n8n-nodes-base/node-class-description-outputs-wrong
+            outputs: [
+                "main",
+                "main"
+            ],
+            outputNames: [
+                "Result",
+                "IsEmpty"
+            ],
+            credentials: [],
+            properties: []
+        });
+    }
+}

package/dist/nodes/Executor/DockerExecutor/DockerExecutor.node.js

@@ -10,6 +10,8 @@ Object.defineProperty(exports, "DockerExecutor", {
 });
 const _connectionType = require("../../../common/connectionType");
 const _dockerexecutor = require("../../../common/executor/docker.executor");
+const _executorproxy = require("../../../common/proxy/executor.proxy");
+const _image = require("../../../constants/image");
 function _define_property(obj, key, value) {
     if (key in obj) {
         Object.defineProperty(obj, key, {
@@ -25,8 +27,17 @@ function _define_property(obj, key, value) {
 }
 class DockerExecutor {
     async supplyData(itemIndex) {
+        const stateless = this.getNodeParameter("stateless", itemIndex);
+        const executor = new _dockerexecutor.DockerExecutor(this.getNodeParameter("image", itemIndex), await this.getCredentials("dockerApi", itemIndex), this);
+        if (stateless) {
+            executor.setContainer(await executor.prepareContainer());
+        } else {
+            const { value } = this.getNodeParameter("container", itemIndex);
+            const container = await executor.findContainerByID(value);
+            executor.setContainer(container);
+        }
         return {
-            response: new _dockerexecutor.DockerExecutor(await this.getCredentials("dockerApi", itemIndex), this)
+            response: (0, _executorproxy.proxyExecutor)(executor)
         };
     }
     constructor(){
@@ -50,10 +61,76 @@ class DockerExecutor {
             ],
             credentials: [
                 {
-                    name: "dockerApi"
+                    name: "dockerApi",
+                    required: true
                 }
             ],
-            properties: []
+            properties: [
+                {
+                    displayName: "Image",
+                    name: "image",
+                    type: "string",
+                    default: _image.IMAGE,
+                    required: true,
+                    description: "Docker image to use"
+                },
+                {
+                    displayName: "Stateless",
+                    name: "stateless",
+                    type: "boolean",
+                    default: true,
+                    description: "Whether to use a stateless container, which mean we will use any container that is available. If false, we will use the same container for all executions."
+                },
+                {
+                    displayName: "Container",
+                    name: "container",
+                    type: "resourceLocator",
+                    default: {
+                        mode: "list",
+                        value: ""
+                    },
+                    required: true,
+                    modes: [
+                        {
+                            displayName: "Container",
+                            name: "list",
+                            type: "list",
+                            placeholder: "Select a container...",
+                            typeOptions: {
+                                searchListMethod: "containerSearch"
+                            }
+                        }
+                    ],
+                    displayOptions: {
+                        show: {
+                            stateless: [
+                                false
+                            ]
+                        }
+                    }
+                },
+                {
+                    displayName: "Debug Mode",
+                    name: "debug",
+                    type: "boolean",
+                    default: false,
+                    description: "Whether open to see more information in node input & output"
+                }
+            ]
+        });
+        _define_property(this, "methods", {
+            listSearch: {
+                async containerSearch (_filter) {
+                    const executor = new _dockerexecutor.DockerExecutor(this.getNodeParameter("image"), await this.getCredentials("dockerApi"), this);
+                    const containers = await executor.listContainers();
+                    return {
+                        results: containers.map((c)=>({
+                                name: c.Names.join(","),
+                                value: c.Id
+                            }))
+                    };
+                }
+            }
         });
     }
 }

package/dist/nodes/Executor/JsonRpcExecutor/JsonRpcExecutor.node.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "JsonRpcExecutor", {
+    enumerable: true,
+    get: function() {
+        return JsonRpcExecutor;
+    }
+});
+const _connectionType = require("../../../common/connectionType");
+const _jsonrpcexecutor = require("../../../common/executor/jsonrpc.executor");
+const _executorproxy = require("../../../common/proxy/executor.proxy");
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+class JsonRpcExecutor {
+    async supplyData(itemIndex) {
+        return {
+            response: (0, _executorproxy.proxyExecutor)(new _jsonrpcexecutor.JSONRPCExecutor(await this.getCredentials("soarRunnerApi", itemIndex), this))
+        };
+    }
+    constructor(){
+        _define_property(this, "description", {
+            displayName: "JSONRPC Executor",
+            name: "jsonRpcExecutor",
+            icon: "file:icon.svg",
+            group: [
+                "transform"
+            ],
+            version: 1,
+            description: "Execute with JSONRPC",
+            defaults: {
+                name: "JSONRPC"
+            },
+            // eslint-disable-next-line n8n-nodes-base/node-class-description-inputs-wrong-regular-node
+            inputs: [],
+            // eslint-disable-next-line n8n-nodes-base/node-class-description-outputs-wrong
+            outputs: [
+                _connectionType.NodeConnectionType.Executor
+            ],
+            credentials: [
+                {
+                    name: "soarRunnerApi",
+                    required: true
+                }
+            ],
+            properties: [
+                {
+                    displayName: "Debug Mode",
+                    name: "debug",
+                    type: "boolean",
+                    default: false,
+                    description: "Whether open to see more information in node input & output"
+                }
+            ]
+        });
+    }
+}

package/dist/nodes/Executor/JsonRpcExecutor/icon.svg

@@ -0,0 +1,8 @@
+<?xml version="1.0" ?>
+<svg xmlns="http://www.w3.org/2000/svg" width="128" height="128" viewBox="-1 -1 130 130">
+	<circle cx="64" cy="32" r="32" fill="none" stroke="#025d02" stroke-width="2" />
+	<circle cx="64" cy="96" r="32" fill="none" stroke="#025d02" stroke-width="2" />
+	<circle cx="32" cy="64" r="32" fill="none" stroke="#025d02" stroke-width="2" />
+	<circle cx="96" cy="64" r="32" fill="none" stroke="#025d02" stroke-width="2" />
+	<path d="M 64,32 L 32,64 L 64,96 L 96,64 Z" fill="#01ae01" fill-rule="nonzero" />
+</svg>