@fsai-flow/workflow 0.0.2 → 0.0.3

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

@@ -0,0 +1,248 @@
+import { Expression, IConnections, IGetExecuteTriggerFunctions, INode, INodeExecuteFunctions, INodeExecutionData, INodeParameters, INodes, INodeType, INodeTypes, IPollFunctions, IRunExecutionData, ITaskDataConnections, ITriggerResponse, IWebhookData, IWebhookResponseData, IWorfklowIssues, IWorkflowExecuteAdditionalData, IWorkflowSettings, NodeParameterValue, WebhookSetupMethodNames, WorkflowActivateMode, WorkflowExecuteMode } from '..';
+import { IDataObject } from './Interfaces';
+export declare class Workflow {
+    id: string | undefined;
+    name: string | undefined;
+    nodes: INodes;
+    connectionsBySourceNode: IConnections;
+    connectionsByDestinationNode: IConnections;
+    nodeTypes: INodeTypes;
+    expression: Expression;
+    active: boolean;
+    settings: IWorkflowSettings;
+    staticData: IDataObject;
+    constructor(parameters: {
+        id?: string;
+        name?: string;
+        nodes: INode[];
+        connections: IConnections;
+        active: boolean;
+        nodeTypes: INodeTypes;
+        staticData?: IDataObject;
+        settings?: IWorkflowSettings;
+    });
+    /**
+     * The default connections are by source node. This function rewrites them by destination nodes
+     * to easily find parent nodes.
+     *
+     * @param {IConnections} connections
+     * @returns {IConnections}
+     * @memberof Workflow
+     */
+    __getConnectionsByDestination(connections: IConnections): IConnections;
+    /**
+     * A workflow can only be activated if it has a node which has either triggers
+     * or webhooks defined.
+     *
+     * @param {string[]} [ignoreNodeTypes] Node-types to ignore in the check
+     * @returns {boolean}
+     * @memberof Workflow
+     */
+    checkIfWorkflowCanBeActivated(ignoreNodeTypes?: string[]): boolean;
+    /**
+     * Checks if everything in the workflow is complete
+     * and ready to be executed. If it returns null everything
+     * is fine. If there are issues it returns the issues
+     * which have been found for the different nodes.
+     * TODO: Does currently not check for credential issues!
+     *
+     * @returns {(IWorfklowIssues | null)}
+     * @memberof Workflow
+     */
+    checkReadyForExecution(inputData: {
+        startNode?: string;
+        destinationNode?: string;
+    }): IWorfklowIssues | null;
+    /**
+     * Returns the static data of the workflow.
+     * It gets saved with the workflow and will be the same for
+     * all workflow-executions.
+     *
+     * @param {string} type The type of data to return ("global"|"node")
+     * @param {INode} [node] If type is set to "node" then the node has to be provided
+     * @returns {IDataObject}
+     * @memberof Workflow
+     */
+    getStaticData(type: string, node?: INode): IDataObject;
+    /**
+     * Returns all the trigger nodes in the workflow.
+     *
+     * @returns {INode[]}
+     * @memberof Workflow
+     */
+    getTriggerNodes(): INode[];
+    /**
+     * Returns all the poll nodes in the workflow
+     *
+     * @returns {INode[]}
+     * @memberof Workflow
+     */
+    getPollNodes(): INode[];
+    /**
+     * Returns all the nodes in the workflow for which the given
+     * checkFunction return true
+     *
+     * @param {(nodeType: INodeType) => boolean} checkFunction
+     * @returns {INode[]}
+     * @memberof Workflow
+     */
+    queryNodes(checkFunction: (nodeType: INodeType) => boolean): INode[];
+    /**
+     * Returns the node with the given name if it exists else null
+     *
+     * @param {string} nodeName Name of the node to return
+     * @returns {(INode | null)}
+     * @memberof Workflow
+     */
+    getNode(nodeName: string): INode | null;
+    /**
+     * Renames nodes in expressions
+     *
+     * @param {(NodeParameterValue | INodeParameters | NodeParameterValue[] | INodeParameters[])} parameterValue The parameters to check for expressions
+     * @param {string} currentName The current name of the node
+     * @param {string} newName The new name
+     * @returns {(NodeParameterValue | INodeParameters | NodeParameterValue[] | INodeParameters[])}
+     * @memberof Workflow
+     */
+    renameNodeInExpressions(parameterValue: NodeParameterValue | INodeParameters | NodeParameterValue[] | INodeParameters[], currentName: string, newName: string): NodeParameterValue | INodeParameters | NodeParameterValue[] | INodeParameters[];
+    /**
+     * Rename a node in the workflow
+     *
+     * @param {string} currentName The current name of the node
+     * @param {string} newName The new name
+     * @memberof Workflow
+     */
+    renameNode(currentName: string, newName: string): void;
+    /**
+     * Finds the highest parent nodes of the node with the given name
+     *
+     * @param {string} nodeName
+     * @param {string} [type='main']
+     * @param {number} [nodeConnectionIndex]
+     * @returns {string[]}
+     * @memberof Workflow
+     */
+    getHighestNode(nodeName: string, type?: string, nodeConnectionIndex?: number, checkedNodes?: string[]): string[];
+    /**
+     * Returns all the after the given one
+     *
+     * @param {string} nodeName
+     * @param {string} [type='main']
+     * @param {*} [depth=-1]
+     * @returns {string[]}
+     * @memberof Workflow
+     */
+    getChildNodes(nodeName: string, type?: string, depth?: number): string[];
+    /**
+     * Returns all the nodes before the given one
+     *
+     * @param {string} nodeName
+     * @param {string} [type='main']
+     * @param {*} [depth=-1]
+     * @returns {string[]}
+     * @memberof Workflow
+     */
+    getParentNodes(nodeName: string, type?: string, depth?: number): string[];
+    /**
+     * Gets all the nodes which are connected nodes starting from
+     * the given one
+     *
+     * @param {IConnections} connections
+     * @param {string} nodeName
+     * @param {string} [type='main']
+     * @param {*} [depth=-1]
+     * @param {string[]} [checkedNodes]
+     * @returns {string[]}
+     * @memberof Workflow
+     */
+    getConnectedNodes(connections: IConnections, nodeName: string, type?: string, depth?: number, checkedNodes?: string[]): string[];
+    /**
+     * Returns via which output of the parent-node the node
+     * is connected to.
+     *
+     * @param {string} nodeName The node to check how it is connected with parent node
+     * @param {string} parentNodeName The parent node to get the output index of
+     * @param {string} [type='main']
+     * @param {*} [depth=-1]
+     * @param {string[]} [checkedNodes]
+     * @returns {(number | undefined)}
+     * @memberof Workflow
+     */
+    getNodeConnectionOutputIndex(nodeName: string, parentNodeName: string, type?: string, depth?: number, checkedNodes?: string[]): number | undefined;
+    /**
+     * Returns from which of the given nodes the workflow should get started from
+     *
+     * @param {string[]} nodeNames The potential start nodes
+     * @returns {(INode | undefined)}
+     * @memberof Workflow
+     */
+    __getStartNode(nodeNames: string[]): INode | undefined;
+    /**
+     * Returns the start node to start the worfklow from
+     *
+     * @param {string} [destinationNode]
+     * @returns {(INode | undefined)}
+     * @memberof Workflow
+     */
+    getStartNode(destinationNode?: string): INode | undefined;
+    /**
+     * Executes the Webhooks method of the node
+     *
+     * @param {WebhookSetupMethodNames} method The name of the method to execute
+     * @param {IWebhookData} webhookData
+     * @param {INodeExecuteFunctions} nodeExecuteFunctions
+     * @param {WorkflowExecuteMode} mode
+     * @returns {(Promise<boolean | undefined>)}
+     * @memberof Workflow
+     */
+    runWebhookMethod(method: WebhookSetupMethodNames, webhookData: IWebhookData, nodeExecuteFunctions: INodeExecuteFunctions, mode: WorkflowExecuteMode, activation: WorkflowActivateMode, isTest?: boolean): Promise<boolean | undefined>;
+    /**
+     * Runs the given trigger node so that it can trigger the workflow
+     * when the node has data.
+     *
+     * @param {INode} node
+     * @param {IGetExecuteTriggerFunctions} getTriggerFunctions
+     * @param {IWorkflowExecuteAdditionalData} additionalData
+     * @param {WorkflowExecuteMode} mode
+     * @returns {(Promise<ITriggerResponse | undefined>)}
+     * @memberof Workflow
+     */
+    runTrigger(node: INode, getTriggerFunctions: IGetExecuteTriggerFunctions, additionalData: IWorkflowExecuteAdditionalData, mode: WorkflowExecuteMode, activation: WorkflowActivateMode): Promise<ITriggerResponse | undefined>;
+    /**
+     * Runs the given trigger node so that it can trigger the workflow
+     * when the node has data.
+     *
+     * @param {INode} node
+     * @param {IPollFunctions} pollFunctions
+     * @returns
+     * @memberof Workflow
+     */
+    runPoll(node: INode, pollFunctions: IPollFunctions): Promise<INodeExecutionData[][] | null>;
+    /**
+     * Executes the webhook data to see what it should return and if the
+     * workflow should be started or not
+     *
+     * @param {INode} node
+     * @param {IWorkflowExecuteAdditionalData} additionalData
+     * @param {INodeExecuteFunctions} nodeExecuteFunctions
+     * @param {WorkflowExecuteMode} mode
+     * @param {IRunExecutionData | undefined} runExecutionData
+     * @returns {Promise<IWebhookResponseData>}
+     * @memberof Workflow
+     */
+    runWebhook(webhookData: IWebhookData, node: INode, additionalData: IWorkflowExecuteAdditionalData, nodeExecuteFunctions: INodeExecuteFunctions, mode: WorkflowExecuteMode, runExecutionData: IRunExecutionData | undefined, workflow?: Workflow): Promise<IWebhookResponseData>;
+    /**
+     * Executes the given node.
+     *
+     * @param {INode} node
+     * @param {ITaskDataConnections} inputData
+     * @param {IRunExecutionData} runExecutionData
+     * @param {number} runIndex
+     * @param {IWorkflowExecuteAdditionalData} additionalData
+     * @param {INodeExecuteFunctions} nodeExecuteFunctions
+     * @param {WorkflowExecuteMode} mode
+     * @returns {(Promise<INodeExecutionData[][] | null>)}
+     * @memberof Workflow
+     */
+    runNode(node: INode, inputData: ITaskDataConnections, runExecutionData: IRunExecutionData, runIndex: number, additionalData: IWorkflowExecuteAdditionalData, nodeExecuteFunctions: INodeExecuteFunctions, mode: WorkflowExecuteMode): Promise<INodeExecutionData[][] | null | undefined>;
+}