@fsai-flow/workflow 0.0.2 → 0.0.3

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

@@ -0,0 +1,198 @@
+import { IContextObject, INode, INodeCredentialDescription, INodeExecutionData, INodeInputConfiguration, INodeIssues, INodeOutputConfiguration, INodeParameters, INodeProperties, INodePropertyCollection, INodeType, INodeTypeDescription, INodeVersionedType, IParameterDependencies, IRunExecutionData, IWebhookData, IWorkflowExecuteAdditionalData, NodeConnectionType, NodeParameterValue } from './Interfaces';
+import { Workflow } from './Workflow';
+export declare function getConnectionTypes(connections: Array<NodeConnectionType | INodeInputConfiguration | INodeOutputConfiguration>): NodeConnectionType[];
+export declare const cronNodeOptions: INodePropertyCollection[];
+export declare function isSubNodeType(typeDescription: Pick<INodeTypeDescription, 'outputs'> | null): boolean;
+/**
+ * Gets special parameters which should be added to nodeTypes depending
+ * on their type or configuration
+ *
+ * @export
+ * @param {INodeType} nodeType
+ * @returns
+ */
+export declare function getSpecialNodeParameters(nodeType: INodeType): INodeProperties[];
+/**
+ * Returns if the parameter should be displayed or not
+ *
+ * @export
+ * @param {INodeParameters} nodeValues The data on the node which decides if the parameter
+ *                                    should be displayed
+ * @param {(INodeProperties | INodeCredentialDescription)} parameter The parameter to check if it should be displayed
+ * @param {INodeParameters} [nodeValuesRoot] The root node-parameter-data
+ * @returns
+ */
+export declare function displayParameter(nodeValues: INodeParameters, parameter: INodeProperties | INodeCredentialDescription, nodeValuesRoot?: INodeParameters): boolean;
+/**
+ * Returns if the given parameter should be displayed or not considering the path
+ * to the properties
+ *
+ * @export
+ * @param {INodeParameters} nodeValues The data on the node which decides if the parameter
+ *                                    should be displayed
+ * @param {(INodeProperties | INodeCredentialDescription)} parameter The parameter to check if it should be displayed
+ * @param {string} path The path to the property
+ * @returns
+ */
+export declare function displayParameterPath(nodeValues: INodeParameters, parameter: INodeProperties | INodeCredentialDescription, path: string): boolean;
+/**
+ * Returns the context data
+ *
+ * @export
+ * @param {IRunExecutionData} runExecutionData The run execution data
+ * @param {string} type The data type. "node"/"flow"
+ * @param {INode} [node] If type "node" is set the node to return the context of has to be supplied
+ * @returns {IContextObject}
+ */
+export declare function getContext(runExecutionData: IRunExecutionData, type: string, node?: INode): IContextObject;
+/**
+ * Returns which parameters are dependent on which
+ *
+ * @export
+ * @param {INodeProperties[]} nodePropertiesArray
+ * @returns {IParameterDependencies}
+ */
+export declare function getParamterDependencies(nodePropertiesArray: INodeProperties[]): IParameterDependencies;
+/**
+ * Returns in which order the parameters should be resolved
+ * to have the parameters available they depend on
+ *
+ * @export
+ * @param {INodeProperties[]} nodePropertiesArray
+ * @param {IParameterDependencies} parameterDependencies
+ * @returns {number[]}
+ */
+export declare function getParamterResolveOrder(nodePropertiesArray: INodeProperties[], parameterDependencies: IParameterDependencies): number[];
+/**
+ * Returns the node parameter values. Depending on the settings it either just returns the none
+ * default values or it applies all the default values.
+ *
+ * @export
+ * @param {INodeProperties[]} nodePropertiesArray The properties which exist and their settings
+ * @param {INodeParameters} nodeValues The node parameter data
+ * @param {boolean} returnDefaults If default values get added or only none default values returned
+ * @param {boolean} returnNoneDisplayed If also values which should not be displayed should be returned
+ * @param {boolean} [onlySimpleTypes=false] If only simple types should be resolved
+ * @param {boolean} [dataIsResolved=false] If nodeValues are already fully resolved (so that all default values got added already)
+ * @param {INodeParameters} [nodeValuesRoot] The root node-parameter-data
+ * @returns {(INodeParameters | null)}
+ */
+export declare function getNodeParameters(nodePropertiesArray: INodeProperties[], nodeValues: INodeParameters, returnDefaults: boolean, returnNoneDisplayed: boolean, onlySimpleTypes?: boolean, dataIsResolved?: boolean, nodeValuesRoot?: INodeParameters, parentType?: string, parameterDependencies?: IParameterDependencies): INodeParameters | null;
+/**
+ * Brings the output data in a format that can be returned from a node
+ *
+ * @export
+ * @param {INodeExecutionData[]} outputData
+ * @param {number} [outputIndex=0]
+ * @returns {Promise<INodeExecutionData[][]>}
+ */
+export declare function prepareOutputData(outputData: INodeExecutionData[], outputIndex?: number): Promise<INodeExecutionData[][]>;
+/**
+ * Returns all the webhooks which should be created for the give node
+ *
+ * @export
+ *
+ * @param {INode} node
+ * @returns {IWebhookData[]}
+ */
+export declare function getNodeWebhooks(workflow: Workflow, node: INode, additionalData: IWorkflowExecuteAdditionalData, ignoreRestartWehbooks?: boolean): IWebhookData[];
+export declare function getNodeWebhooksBasic(workflow: Workflow, node: INode): IWebhookData[];
+/**
+ * Returns the webhook path
+ *
+ * @export
+ * @param {string} workflowId
+ * @param {string} nodeTypeName
+ * @param {string} path
+ * @returns {string}
+ */
+export declare function getNodeWebhookPath(workflowId: string, node: INode, path: string, isFullPath?: boolean, restartWebhook?: boolean): string;
+/**
+ * Returns the webhook URL
+ *
+ * @export
+ * @param {string} baseUrl
+ * @param {string} workflowId
+ * @param {string} nodeTypeName
+ * @param {string} path
+ * @param {boolean} isFullPath
+ * @returns {string}
+ */
+export declare function getNodeWebhookUrl(baseUrl: string, workflowId: string, node: INode, path: string, isFullPath?: boolean): string;
+/**
+ * Returns all the parameter-issues of the node
+ *
+ * @export
+ * @param {INodeProperties[]} nodePropertiesArray The properties of the node
+ * @param {INode} node The data of the node
+ * @returns {(INodeIssues | null)}
+ */
+export declare function getNodeParametersIssues(nodePropertiesArray: INodeProperties[], node: INode): INodeIssues | null;
+/**
+ * Returns the issues of the node as string
+ *
+ * @export
+ * @param {INodeIssues} issues The issues of the node
+ * @param {INode} node The node
+ * @returns {string[]}
+ */
+export declare function nodeIssuesToString(issues: INodeIssues, node?: INode): string[];
+/**
+ * Adds an issue if the parameter is not defined
+ *
+ * @export
+ * @param {INodeIssues} foundIssues The already found issues
+ * @param {INodeProperties} nodeProperties The properties of the node
+ * @param {NodeParameterValue} value The value of the parameter
+ */
+export declare function addToIssuesIfMissing(foundIssues: INodeIssues, nodeProperties: INodeProperties, value: NodeParameterValue): void;
+/**
+ * Returns the parameter value
+ *
+ * @export
+ * @param {INodeParameters} nodeValues The values of the node
+ * @param {string} parameterName The name of the parameter to return the value of
+ * @param {string} path The path to the properties
+ * @returns
+ */
+export declare function getParameterValueByPath(nodeValues: INodeParameters, parameterName: string, path: string): INodeParameters | NodeParameterValue | NodeParameterValue[] | INodeParameters[];
+/**
+ * Returns all the issues with the given node-values
+ *
+ * @export
+ * @param {INodeProperties} nodeProperties The properties of the node
+ * @param {INodeParameters} nodeValues The values of the node
+ * @param {string} path The path to the properties
+ * @returns {INodeIssues}
+ */
+export declare function getParameterIssues(nodeProperties: INodeProperties, nodeValues: INodeParameters, path: string): INodeIssues;
+/**
+ * Merges multiple NodeIssues together
+ *
+ * @export
+ * @param {INodeIssues} destination The issues to merge into
+ * @param {(INodeIssues | null)} source The issues to merge
+ * @returns
+ */
+export declare function mergeIssues(destination: INodeIssues, source: INodeIssues | null): void;
+/**
+ * Merges the given node properties
+ *
+ * @export
+ * @param {INodeProperties[]} mainProperties
+ * @param {INodeProperties[]} addProperties
+ */
+export declare function mergeNodeProperties(mainProperties: INodeProperties[], addProperties: INodeProperties[]): void;
+export declare function getVersionedNodeType(object: INodeVersionedType | INodeType, version?: number): INodeType;
+export declare function getVersionedNodeTypeAll(object: INodeVersionedType | INodeType): INodeType[];
+export declare function isNodeTypeVersioned(object: INodeVersionedType | INodeType): boolean;
+/**
+ * Returns the parameter value from the node parameters
+ *
+ * @export
+ * @param {INodeParameters} nodeParameters The node parameters
+ * @param {string} parameterName The name of the parameter to get
+ * @param {number} [index=0] The index of the parameter value if it's an array
+ * @returns {NodeParameterValue | undefined} The parameter value
+ */
+export declare function getParameterValue(nodeParameters: INodeParameters, parameterName: string, index?: number): NodeParameterValue | undefined;