@fsai-flow/core 0.1.1 → 0.2.0

package/dist/index.d.ts

@@ -14,4 +14,4 @@ export * from "./lib/NodesLoader";
 export * from "./lib/RedisLeaderElectionManager";
 export * from "./lib/RequestTypes";
 export * from "./lib/WorkflowExecute";
-export { NodeExecuteFunctions, UserSettings, getInputConnectionDataLegacy };
+export { getInputConnectionDataLegacy, NodeExecuteFunctions, UserSettings };

package/dist/index.js

@@ -36,7 +36,7 @@ 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 });
-exports.getInputConnectionDataLegacy = exports.UserSettings = exports.NodeExecuteFunctions = void 0;
+exports.UserSettings = exports.NodeExecuteFunctions = exports.getInputConnectionDataLegacy = void 0;
 const getInputConnectionDataLegacy = __importStar(require("./lib/InputConnectionDataLegacy"));
 exports.getInputConnectionDataLegacy = getInputConnectionDataLegacy;
 /* eslint-disable import/no-cycle */

package/dist/lib/NodeExecuteFunctions.js

@@ -154,7 +154,7 @@ function searchForHeader(headers, headerName) {
     return headerNames.find((thisHeader) => thisHeader.toLowerCase() === lowerHeaderName);
 }
 async function generateContentLengthHeader(formData, headers) {
-    if (!formData || !formData.getLength) {
+    if (!formData?.getLength) {
         return;
     }
     try {
@@ -880,7 +880,7 @@ async function getCurrentOAuth2AccessToken(credentialsType, node, additionalData
         oauthTokenData["expiresAt"] = expiresAt;
         oauthTokenData["expiresIn"] = expiresIn;
         oauthTokenData["tokenType"] = tokenType;
-        if (!node.credentials || !node.credentials[credentialsType]) {
+        if (!node.credentials?.[credentialsType]) {
             throw new Error(`Node "${node.name}" has no credentials of type "${credentialsType}"`);
         }
         await additionalData.credentialsHelper.updateCredentials(node.credentials[credentialsType], credentialsType, credentials);
@@ -971,7 +971,7 @@ async function requestOAuth2(credentialsType, requestOptions, node, additionalDa
                 tokenType: refreshedToken.token["token_type"],
             };
             // Persist new token
-            if (!node.credentials || !node.credentials[credentialsType]) {
+            if (!node.credentials?.[credentialsType]) {
                 throw new Error(`Node "${node.name}" has no credentials of type "${credentialsType}"`);
             }
             await additionalData.credentialsHelper.updateCredentials(node.credentials[credentialsType], credentialsType, credentials);
@@ -1209,7 +1209,7 @@ async function getCredentials(workflow, node, type, additionalData, mode, runExe
         }
     }
     // Check if node has any credentials defined
-    if (!fullAccess && (!node.credentials || !node.credentials[type])) {
+    if (!fullAccess && !node.credentials?.[type]) {
         // If none are defined check if the credentials are required or not
         if (nodeCredentialDescription?.required === true) {
             // Credentials are required so error
@@ -1225,7 +1225,7 @@ async function getCredentials(workflow, node, type, additionalData, mode, runExe
             return undefined;
         }
     }
-    if (fullAccess && (!node.credentials || !node.credentials[type])) {
+    if (fullAccess && !node.credentials?.[type]) {
         // Make sure that fullAccess nodes still behave like before that if they
         // request access to credentials that are currently not set it returns undefined
         return undefined;
@@ -1732,6 +1732,9 @@ function getExecuteFunctions(workflow, runExecutionData, runIndex, connectionInp
             getExecutionCancelSignal: () => {
                 return undefined;
             },
+            logAiEvent: (_event, _data) => {
+                return;
+            },
         };
     })(workflow, runExecutionData, connectionInputData, inputData, node, nodeTypeData, closeFunctions);
 }
@@ -2353,6 +2356,9 @@ function getSupplyDataFunctions(workflow, runExecutionData, runIndex, connection
                 };
                 return { outputExecutionData };
             },
+            logAiEvent: (_event, _data) => {
+                return;
+            },
             async getInputConnectionData(connectionType, itemIndex) {
                 return await getInputConnectionData.call(this, workflow, runExecutionData, runIndex, connectionInputData, inputData, additionalData, connectionType, mode, itemIndex, nodeTypeData, closeFunctions);
             },

package/dist/src/index.d.ts

@@ -0,0 +1,17 @@
+import * as getInputConnectionDataLegacy from "./lib/InputConnectionDataLegacy";
+import * as NodeExecuteFunctions from "./lib/NodeExecuteFunctions";
+import * as UserSettings from "./lib/UserSettings";
+export * from "./lib/ActiveWebhooks";
+export * from "./lib/ActiveWorkflows";
+export * from "./lib/BinaryDataManager";
+export * from "./lib/ChangeCase";
+export * from "./lib/Constants";
+export * from "./lib/Credentials";
+export * from "./lib/Interfaces";
+export * from "./lib/LoadNodeParameterOptions";
+export * from "./lib/NodeExecuteFunctions";
+export * from "./lib/NodesLoader";
+export * from "./lib/RedisLeaderElectionManager";
+export * from "./lib/RequestTypes";
+export * from "./lib/WorkflowExecute";
+export { getInputConnectionDataLegacy, NodeExecuteFunctions, UserSettings };

package/dist/src/index.js

@@ -0,0 +1,61 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+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 });
+exports.UserSettings = exports.NodeExecuteFunctions = exports.getInputConnectionDataLegacy = void 0;
+const getInputConnectionDataLegacy = __importStar(require("./lib/InputConnectionDataLegacy"));
+exports.getInputConnectionDataLegacy = getInputConnectionDataLegacy;
+/* eslint-disable import/no-cycle */
+const NodeExecuteFunctions = __importStar(require("./lib/NodeExecuteFunctions"));
+exports.NodeExecuteFunctions = NodeExecuteFunctions;
+const UserSettings = __importStar(require("./lib/UserSettings"));
+exports.UserSettings = UserSettings;
+// @ts-expect-error - optional dependency, may not be installed
+Promise.resolve().then(() => __importStar(require("source-map-support"))).then((s) => s.install()).catch(() => { });
+__exportStar(require("./lib/ActiveWebhooks"), exports);
+__exportStar(require("./lib/ActiveWorkflows"), exports);
+__exportStar(require("./lib/BinaryDataManager"), exports);
+__exportStar(require("./lib/ChangeCase"), exports);
+__exportStar(require("./lib/Constants"), exports);
+__exportStar(require("./lib/Credentials"), exports);
+__exportStar(require("./lib/Interfaces"), exports);
+__exportStar(require("./lib/LoadNodeParameterOptions"), exports);
+__exportStar(require("./lib/NodeExecuteFunctions"), exports);
+__exportStar(require("./lib/NodesLoader"), exports);
+__exportStar(require("./lib/RedisLeaderElectionManager"), exports);
+__exportStar(require("./lib/RequestTypes"), exports);
+__exportStar(require("./lib/WorkflowExecute"), exports);

package/dist/src/lib/ActiveWebhooks.d.ts

@@ -0,0 +1,59 @@
+import type { IWebhookData, WebhookHttpMethod, Workflow, WorkflowActivateMode, WorkflowExecuteMode } from "@fsai-flow/workflow";
+export declare class ActiveWebhooks {
+    private workflowWebhooks;
+    private webhookUrls;
+    testWebhooks: boolean;
+    /**
+     * Adds a new webhook
+     *
+     * @param {IWebhookData} webhookData
+     * @param {WorkflowExecuteMode} mode
+     * @returns {Promise<void>}
+     * @memberof ActiveWebhooks
+     */
+    add(workflow: Workflow, webhookData: IWebhookData, mode: WorkflowExecuteMode, activation: WorkflowActivateMode): Promise<void>;
+    /**
+     * Returns webhookData if a webhook with matches is currently registered
+     *
+     * @param {WebhookHttpMethod} httpMethod
+     * @param {string} path
+     * @param {(string | undefined)} webhookId
+     * @returns {(IWebhookData | undefined)}
+     * @memberof ActiveWebhooks
+     */
+    get(httpMethod: WebhookHttpMethod, path: string, webhookId?: string): IWebhookData | undefined;
+    /**
+     * Gets all request methods associated with a single webhook
+     * @param path
+     */
+    getWebhookMethods(path: string): string[];
+    /**
+     * Returns the ids of all the workflows which have active webhooks
+     *
+     * @returns {string[]}
+     * @memberof ActiveWebhooks
+     */
+    getWorkflowIds(): string[];
+    /**
+     * Returns key to uniquely identify a webhook
+     *
+     * @param {WebhookHttpMethod} httpMethod
+     * @param {string} path
+     * @param {(string | undefined)} webhookId
+     * @returns {string}
+     * @memberof ActiveWebhooks
+     */
+    getWebhookKey(httpMethod: WebhookHttpMethod, path: string, webhookId?: string): string;
+    /**
+     * Removes all webhooks of a workflow
+     *
+     * @param {Workflow} workflow
+     * @returns {boolean}
+     * @memberof ActiveWebhooks
+     */
+    removeWorkflow(workflow: Workflow): Promise<boolean>;
+    /**
+     * Removes all the webhooks of the given workflows
+     */
+    removeAll(workflows: Workflow[]): Promise<void>;
+}

package/dist/src/lib/ActiveWebhooks.js

@@ -0,0 +1,177 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ActiveWebhooks = void 0;
+// eslint-disable-next-line import/no-cycle
+const __1 = require("..");
+class ActiveWebhooks {
+    constructor() {
+        this.workflowWebhooks = {};
+        this.webhookUrls = {};
+        this.testWebhooks = false;
+    }
+    /**
+     * Adds a new webhook
+     *
+     * @param {IWebhookData} webhookData
+     * @param {WorkflowExecuteMode} mode
+     * @returns {Promise<void>}
+     * @memberof ActiveWebhooks
+     */
+    async add(workflow, webhookData, mode, activation) {
+        if (workflow.id === undefined) {
+            throw new Error("Webhooks can only be added for saved workflows as an id is needed!");
+        }
+        if (webhookData.path.endsWith("/")) {
+            // eslint-disable-next-line no-param-reassign
+            webhookData.path = webhookData.path.slice(0, -1);
+        }
+        const webhookKey = this.getWebhookKey(webhookData.httpMethod, webhookData.path, webhookData.webhookId);
+        // check that there is not a webhook already registed with that path/method
+        if (this.webhookUrls[webhookKey] && !webhookData.webhookId) {
+            throw new Error(`The URL path that the "${webhookData.node}" node uses is already taken. Please change it to something else.`);
+        }
+        if (this.workflowWebhooks[webhookData.workflowId] === undefined) {
+            this.workflowWebhooks[webhookData.workflowId] = [];
+        }
+        // Make the webhook available directly because sometimes to create it successfully
+        // it gets called
+        if (!this.webhookUrls[webhookKey]) {
+            this.webhookUrls[webhookKey] = [];
+        }
+        this.webhookUrls[webhookKey].push(webhookData);
+        try {
+            const webhookExists = await workflow.runWebhookMethod("checkExists", webhookData, __1.NodeExecuteFunctions, mode, activation, this.testWebhooks);
+            if (webhookExists !== true) {
+                // If webhook does not exist yet create it
+                await workflow.runWebhookMethod("create", webhookData, __1.NodeExecuteFunctions, mode, activation, this.testWebhooks);
+            }
+        }
+        catch (error) {
+            // If there was a problem unregister the webhook again
+            if (this.webhookUrls[webhookKey].length <= 1) {
+                delete this.webhookUrls[webhookKey];
+            }
+            else {
+                this.webhookUrls[webhookKey] = this.webhookUrls[webhookKey].filter((webhook) => webhook.path !== webhookData.path);
+            }
+            throw error;
+        }
+        this.workflowWebhooks[webhookData.workflowId].push(webhookData);
+    }
+    /**
+     * Returns webhookData if a webhook with matches is currently registered
+     *
+     * @param {WebhookHttpMethod} httpMethod
+     * @param {string} path
+     * @param {(string | undefined)} webhookId
+     * @returns {(IWebhookData | undefined)}
+     * @memberof ActiveWebhooks
+     */
+    get(httpMethod, path, webhookId) {
+        const webhookKey = this.getWebhookKey(httpMethod, path, webhookId);
+        if (this.webhookUrls[webhookKey] === undefined) {
+            return undefined;
+        }
+        let webhook;
+        let maxMatches = 0;
+        const pathElementsSet = new Set(path.split("/"));
+        // check if static elements match in path
+        // if more results have been returned choose the one with the most static-route matches
+        for (const dynamicWebhook of this.webhookUrls[webhookKey]) {
+            const staticElements = dynamicWebhook.path
+                .split("/")
+                .filter((ele) => !ele.startsWith(":"));
+            const allStaticExist = staticElements.every((staticEle) => pathElementsSet.has(staticEle));
+            if (allStaticExist && staticElements.length > maxMatches) {
+                maxMatches = staticElements.length;
+                webhook = dynamicWebhook;
+            }
+            // handle routes with no static elements
+            else if (staticElements.length === 0 && !webhook) {
+                webhook = dynamicWebhook;
+            }
+        }
+        return webhook;
+    }
+    /**
+     * Gets all request methods associated with a single webhook
+     * @param path
+     */
+    getWebhookMethods(path) {
+        const methods = [];
+        for (const key of Object.keys(this.webhookUrls)) {
+            if (key.includes(path)) {
+                methods.push(key.split("|")[0]);
+            }
+        }
+        return methods;
+    }
+    /**
+     * Returns the ids of all the workflows which have active webhooks
+     *
+     * @returns {string[]}
+     * @memberof ActiveWebhooks
+     */
+    getWorkflowIds() {
+        return Object.keys(this.workflowWebhooks);
+    }
+    /**
+     * Returns key to uniquely identify a webhook
+     *
+     * @param {WebhookHttpMethod} httpMethod
+     * @param {string} path
+     * @param {(string | undefined)} webhookId
+     * @returns {string}
+     * @memberof ActiveWebhooks
+     */
+    getWebhookKey(httpMethod, path, webhookId) {
+        let webhookPath = path;
+        if (webhookId) {
+            if (webhookPath.startsWith(webhookId)) {
+                const cutFromIndex = webhookPath.indexOf("/") + 1;
+                webhookPath = webhookPath.slice(cutFromIndex);
+            }
+            return `${httpMethod}|${webhookId}|${webhookPath.split("/").length}`;
+        }
+        return `${httpMethod}|${webhookPath}`;
+    }
+    /**
+     * Removes all webhooks of a workflow
+     *
+     * @param {Workflow} workflow
+     * @returns {boolean}
+     * @memberof ActiveWebhooks
+     */
+    async removeWorkflow(workflow) {
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        const workflowId = workflow.id.toString();
+        if (this.workflowWebhooks[workflowId] === undefined) {
+            // If it did not exist then there is nothing to remove
+            return false;
+        }
+        const webhooks = this.workflowWebhooks[workflowId];
+        const mode = "internal";
+        // Go through all the registered webhooks of the workflow and remove them
+        // eslint-disable-next-line no-restricted-syntax
+        for (const webhookData of webhooks) {
+            // eslint-disable-next-line no-await-in-loop
+            await workflow.runWebhookMethod("delete", webhookData, __1.NodeExecuteFunctions, mode, "update", this.testWebhooks);
+            delete this.webhookUrls[this.getWebhookKey(webhookData.httpMethod, webhookData.path, webhookData.webhookId)];
+        }
+        // Remove also the workflow-webhook entry
+        delete this.workflowWebhooks[workflowId];
+        return true;
+    }
+    /**
+     * Removes all the webhooks of the given workflows
+     */
+    async removeAll(workflows) {
+        const removePromises = [];
+        // eslint-disable-next-line no-restricted-syntax
+        for (const workflow of workflows) {
+            removePromises.push(this.removeWorkflow(workflow));
+        }
+        await Promise.all(removePromises);
+    }
+}
+exports.ActiveWebhooks = ActiveWebhooks;

package/dist/src/lib/ActiveWorkflows.d.ts

@@ -0,0 +1,87 @@
+import { type IGetExecutePollFunctions, type IGetExecuteTriggerFunctions, type INode, type IPollResponse, type IWorkflowExecuteAdditionalData, type Workflow, type WorkflowActivateMode, type WorkflowExecuteMode } from "@fsai-flow/workflow";
+import type { RedisOptions } from "ioredis";
+import type { IWorkflowData } from "..";
+export declare class ActiveWorkflows {
+    private workflowData;
+    private redisConfig;
+    private instanceLeaderElection;
+    private pollingWorkflows;
+    private isLeader;
+    private isInitializingLeaderElection;
+    private leaderElectionInitialized;
+    private leaderElectionEnabled;
+    constructor(redisConfig?: string | RedisOptions);
+    /**
+     * Returns if the workflow is active
+     *
+     * @param {string} id The id of the workflow to check
+     * @returns {boolean}
+     * @memberof ActiveWorkflows
+     */
+    isActive(id: string): boolean;
+    /**
+     * Returns the ids of the currently active workflows
+     *
+     * @returns {string[]}
+     * @memberof ActiveWorkflows
+     */
+    allActiveWorkflows(): string[];
+    /**
+     * Returns the Workflow data for the workflow with
+     * the given id if it is currently active
+     *
+     * @param {string} id
+     * @returns {(WorkflowData | undefined)}
+     * @memberof ActiveWorkflows
+     */
+    get(id: string): IWorkflowData | undefined;
+    /**
+     * Makes a workflow active
+     *
+     * @param {string} id The id of the workflow to activate
+     * @param {Workflow} workflow The workflow to activate
+     * @param {IWorkflowExecuteAdditionalData} additionalData The additional data which is needed to run workflows
+     * @returns {Promise<void>}
+     * @memberof ActiveWorkflows
+     */
+    add(id: string, workflow: Workflow, additionalData: IWorkflowExecuteAdditionalData, mode: WorkflowExecuteMode, activation: WorkflowActivateMode, getTriggerFunctions: IGetExecuteTriggerFunctions, getPollFunctions: IGetExecutePollFunctions): Promise<void>;
+    /**
+     * Initialize global leader election (called once per instance)
+     */
+    private initializeLeaderElection;
+    /**
+     * Start all registered polling workflows (called when becoming leader)
+     */
+    private startAllPollingWorkflows;
+    /**
+     * Stop all polling workflows (called when losing leadership)
+     */
+    private stopAllPollingWorkflows;
+    /**
+     * Activates polling for the given node with global Redis leader election
+     *
+     * @param {INode} node
+     * @param {Workflow} workflow
+     * @param {IWorkflowExecuteAdditionalData} additionalData
+     * @param {IGetExecutePollFunctions} getPollFunctions
+     * @returns {Promise<IPollResponse>}
+     * @memberof ActiveWorkflows
+     */
+    activatePolling(node: INode, workflow: Workflow, additionalData: IWorkflowExecuteAdditionalData, getPollFunctions: IGetExecutePollFunctions, mode: WorkflowExecuteMode, activation: WorkflowActivateMode): Promise<IPollResponse>;
+    /**
+     * Extract cron time building logic (same as original)
+     */
+    private buildCronTimes;
+    /**
+     * Validate cron times (same as original)
+     */
+    private validateCronTimes;
+    /**
+     * Makes a workflow inactive
+     *
+     * @param {string} id The id of the workflow to deactivate
+     * @returns {Promise<void>}
+     * @memberof ActiveWorkflows
+     */
+    remove(id: string): Promise<void>;
+}