@fsai-flow/core 0.0.1

package/src/lib/Interfaces.ts

@@ -0,0 +1,338 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import {
+	IAdditionalCredentialOptions,
+	IAllExecuteFunctions,
+	IBinaryData,
+	ICredentialTestFunctions as ICredentialTestFunctionsBase,
+	ICredentialType,
+	IDataObject,
+	IExecuteFunctions as IExecuteFunctionsBase,
+	IExecuteSingleFunctions as IExecuteSingleFunctionsBase,
+	IHookFunctions as IHookFunctionsBase,
+	IHttpRequestOptions,
+	ILoadOptionsFunctions as ILoadOptionsFunctionsBase,
+	INodeExecutionData,
+	INodeType,
+	IOAuth2Options,
+	IPollFunctions as IPollFunctionsBase,
+	IPollResponse,
+	ITriggerFunctions as ITriggerFunctionsBase,
+	ITriggerResponse,
+	IWebhookFunctions as IWebhookFunctionsBase,
+	IWorkflowSettings as IWorkflowSettingsWorkflow,
+} from '@fsai-flow/workflow';
+
+import { OptionsWithUri, OptionsWithUrl } from 'request';
+import * as requestPromise from 'request-promise-native';
+
+interface Constructable<T> {
+	new (): T;
+}
+
+export interface IProcessMessage {
+	data?: any;
+	type: string;
+}
+
+export type Class<T = object, A extends unknown[] = unknown[]> = new (...args: A) => T;
+
+export interface IExecuteFunctions extends IExecuteFunctionsBase {
+	helpers: {
+		httpRequest(requestOptions: IHttpRequestOptions): Promise<any>; // tslint:disable-line:no-any
+		prepareBinaryData(
+			binaryData: Buffer,
+			filePath?: string,
+			mimeType?: string,
+		): Promise<IBinaryData>;
+		assertBinaryData(itemIndex: number, propertyName: string, inputIndex?:number): IBinaryData;
+		getBinaryDataBuffer(itemIndex: number, propertyName: string, inputIndex?:number): Promise<Buffer>;
+		request: (uriOrObject: string | IDataObject | any, options?: IDataObject) => Promise<any>; // tslint:disable-line:no-any
+		requestWithAuthentication(
+			this: IAllExecuteFunctions,
+			credentialsType: string,
+			requestOptions: OptionsWithUri | requestPromise.RequestPromiseOptions,
+			additionalCredentialOptions?: IAdditionalCredentialOptions,
+		): Promise<any>;
+		requestOAuth2(
+			this: IAllExecuteFunctions,
+			credentialsType: string,
+			requestOptions: OptionsWithUri | requestPromise.RequestPromiseOptions,
+			oAuth2Options?: IOAuth2Options,
+		): Promise<any>; // tslint:disable-line:no-any
+		requestOAuth1(
+			this: IAllExecuteFunctions,
+			credentialsType: string,
+			requestOptions: OptionsWithUrl | requestPromise.RequestPromiseOptions,
+		): Promise<any>; // tslint:disable-line:no-any
+		returnJsonArray(jsonData: IDataObject | IDataObject[]): INodeExecutionData[];
+		normalizeItems(items: INodeExecutionData | INodeExecutionData[]): INodeExecutionData[];
+		httpRequestWithAuthentication(
+			this: IAllExecuteFunctions,
+			credentialsType: string,
+			requestOptions: IHttpRequestOptions,
+		): Promise<any>;
+	};
+}
+
+export interface IExecuteSingleFunctions extends IExecuteSingleFunctionsBase {
+	helpers: {
+		httpRequest(requestOptions: IHttpRequestOptions): Promise<any>; // tslint:disable-line:no-any
+		prepareBinaryData(
+			binaryData: Buffer,
+			filePath?: string,
+			mimeType?: string,
+		): Promise<IBinaryData>;
+		request: (uriOrObject: string | IDataObject | any, options?: IDataObject) => Promise<any>; // tslint:disable-line:no-any
+		requestWithAuthentication(
+			this: IAllExecuteFunctions,
+			credentialsType: string,
+			requestOptions: OptionsWithUri | requestPromise.RequestPromiseOptions,
+			additionalCredentialOptions?: IAdditionalCredentialOptions,
+		): Promise<any>;
+		requestOAuth2(
+			this: IAllExecuteFunctions,
+			credentialsType: string,
+			requestOptions: OptionsWithUri | requestPromise.RequestPromiseOptions,
+			oAuth2Options?: IOAuth2Options,
+		): Promise<any>; // tslint:disable-line:no-any
+		requestOAuth1(
+			this: IAllExecuteFunctions,
+			credentialsType: string,
+			requestOptions: OptionsWithUrl | requestPromise.RequestPromiseOptions,
+		): Promise<any>; // tslint:disable-line:no-any
+		httpRequestWithAuthentication(
+			this: IAllExecuteFunctions,
+			credentialsType: string,
+			requestOptions: IHttpRequestOptions,
+		): Promise<any>;
+	};
+}
+
+export interface IPollFunctions extends IPollFunctionsBase {
+	helpers: {
+		httpRequest(requestOptions: IHttpRequestOptions): Promise<any>; // tslint:disable-line:no-any
+		prepareBinaryData(
+			binaryData: Buffer,
+			filePath?: string,
+			mimeType?: string,
+		): Promise<IBinaryData>;
+		request: (uriOrObject: string | IDataObject | any, options?: IDataObject) => Promise<any>; // tslint:disable-line:no-any
+		requestWithAuthentication(
+			this: IAllExecuteFunctions,
+			credentialsType: string,
+			requestOptions: OptionsWithUri | requestPromise.RequestPromiseOptions,
+			additionalCredentialOptions?: IAdditionalCredentialOptions,
+		): Promise<any>;
+		requestOAuth2(
+			this: IAllExecuteFunctions,
+			credentialsType: string,
+			requestOptions: OptionsWithUri | requestPromise.RequestPromiseOptions,
+			oAuth2Options?: IOAuth2Options,
+		): Promise<any>; // tslint:disable-line:no-any
+		requestOAuth1(
+			this: IAllExecuteFunctions,
+			credentialsType: string,
+			requestOptions: OptionsWithUrl | requestPromise.RequestPromiseOptions,
+		): Promise<any>; // tslint:disable-line:no-any
+		returnJsonArray(jsonData: IDataObject | IDataObject[]): INodeExecutionData[];
+		httpRequestWithAuthentication(
+			this: IAllExecuteFunctions,
+			credentialsType: string,
+			requestOptions: IHttpRequestOptions,
+		): Promise<any>;
+	};
+}
+
+export interface IResponseError extends Error {
+	statusCode?: number;
+}
+
+export interface ITriggerFunctions extends ITriggerFunctionsBase {
+	helpers: {
+		httpRequest(requestOptions: IHttpRequestOptions): Promise<any>; // tslint:disable-line:no-any
+		prepareBinaryData(
+			binaryData: Buffer,
+			filePath?: string,
+			mimeType?: string,
+		): Promise<IBinaryData>;
+		request: (uriOrObject: string | IDataObject | any, options?: IDataObject) => Promise<any>; // tslint:disable-line:no-any
+		requestWithAuthentication(
+			this: IAllExecuteFunctions,
+			credentialsType: string,
+			requestOptions: OptionsWithUri | requestPromise.RequestPromiseOptions,
+			additionalCredentialOptions?: IAdditionalCredentialOptions,
+		): Promise<any>;
+		requestOAuth2(
+			this: IAllExecuteFunctions,
+			credentialsType: string,
+			requestOptions: OptionsWithUri | requestPromise.RequestPromiseOptions,
+			oAuth2Options?: IOAuth2Options,
+		): Promise<any>; // tslint:disable-line:no-any
+		requestOAuth1(
+			this: IAllExecuteFunctions,
+			credentialsType: string,
+			requestOptions: OptionsWithUrl | requestPromise.RequestPromiseOptions,
+		): Promise<any>; // tslint:disable-line:no-any
+		returnJsonArray(jsonData: IDataObject | IDataObject[]): INodeExecutionData[];
+		httpRequestWithAuthentication(
+			this: IAllExecuteFunctions,
+			credentialsType: string,
+			requestOptions: IHttpRequestOptions,
+		): Promise<any>;
+	};
+}
+
+export interface ITriggerTime {
+	mode: string;
+	hour: number;
+	minute: number;
+	dayOfMonth: number;
+	weekeday: number;
+	[key: string]: string | number;
+}
+
+export interface IUserSettings {
+	encryptionKey?: string;
+	tunnelSubdomain?: string;
+	instanceId?: string;
+}
+
+export interface ILoadOptionsFunctions extends ILoadOptionsFunctionsBase {
+	helpers: {
+		httpRequest(requestOptions: IHttpRequestOptions): Promise<any>; // tslint:disable-line:no-any
+		request?: (uriOrObject: string | IDataObject | any, options?: IDataObject) => Promise<any>; // tslint:disable-line:no-any
+		requestWithAuthentication(
+			this: IAllExecuteFunctions,
+			credentialsType: string,
+			requestOptions: OptionsWithUri | requestPromise.RequestPromiseOptions,
+			additionalCredentialOptions?: IAdditionalCredentialOptions,
+		): Promise<any>;
+		requestOAuth2?: (
+			this: IAllExecuteFunctions,
+			credentialsType: string,
+			requestOptions: OptionsWithUri | requestPromise.RequestPromiseOptions,
+			oAuth2Options?: IOAuth2Options,
+		) => Promise<any>; // tslint:disable-line:no-any
+		requestOAuth1?(
+			this: IAllExecuteFunctions,
+			credentialsType: string,
+			requestOptions: OptionsWithUrl | requestPromise.RequestPromiseOptions,
+		): Promise<any>; // tslint:disable-line:no-any
+		httpRequestWithAuthentication(
+			this: IAllExecuteFunctions,
+			credentialsType: string,
+			requestOptions: IHttpRequestOptions,
+		): Promise<any>;
+	};
+}
+
+export interface ICredentialTestFunctions extends ICredentialTestFunctionsBase {
+	helpers: {
+		request?: (uriOrObject: string | IDataObject | any, options?: IDataObject) => Promise<any>; // tslint:disable-line:no-any
+	};
+}
+
+export interface IHookFunctions extends IHookFunctionsBase {
+	helpers: {
+		httpRequest(requestOptions: IHttpRequestOptions): Promise<any>; // tslint:disable-line:no-any
+		request: (uriOrObject: string | IDataObject | any, options?: IDataObject) => Promise<any>; // tslint:disable-line:no-any
+		requestWithAuthentication(
+			this: IAllExecuteFunctions,
+			credentialsType: string,
+			requestOptions: OptionsWithUri | requestPromise.RequestPromiseOptions,
+			additionalCredentialOptions?: IAdditionalCredentialOptions,
+		): Promise<any>;
+		requestOAuth2(
+			this: IAllExecuteFunctions,
+			credentialsType: string,
+			requestOptions: OptionsWithUri | requestPromise.RequestPromiseOptions,
+			oAuth2Options?: IOAuth2Options,
+		): Promise<any>; // tslint:disable-line:no-any
+		requestOAuth1(
+			this: IAllExecuteFunctions,
+			credentialsType: string,
+			requestOptions: OptionsWithUrl | requestPromise.RequestPromiseOptions,
+		): Promise<any>; // tslint:disable-line:no-any
+		httpRequestWithAuthentication(
+			this: IAllExecuteFunctions,
+			credentialsType: string,
+			requestOptions: IHttpRequestOptions,
+		): Promise<any>;
+	};
+}
+
+export interface IWebhookFunctions extends IWebhookFunctionsBase {
+	helpers: {
+		httpRequest(requestOptions: IHttpRequestOptions): Promise<any>; // tslint:disable-line:no-any
+		prepareBinaryData(
+			binaryData: Buffer,
+			filePath?: string,
+			mimeType?: string,
+		): Promise<IBinaryData>;
+		request: (uriOrObject: string | IDataObject | any, options?: IDataObject) => Promise<any>; // tslint:disable-line:no-any
+		requestWithAuthentication(
+			this: IAllExecuteFunctions,
+			credentialsType: string,
+			requestOptions: OptionsWithUri | requestPromise.RequestPromiseOptions,
+			additionalCredentialOptions?: IAdditionalCredentialOptions,
+		): Promise<any>;
+		requestOAuth2(
+			this: IAllExecuteFunctions,
+			credentialsType: string,
+			requestOptions: OptionsWithUri | requestPromise.RequestPromiseOptions,
+			oAuth2Options?: IOAuth2Options,
+		): Promise<any>; // tslint:disable-line:no-any
+		requestOAuth1(
+			this: IAllExecuteFunctions,
+			credentialsType: string,
+			requestOptions: OptionsWithUrl | requestPromise.RequestPromiseOptions,
+		): Promise<any>; // tslint:disable-line:no-any
+		returnJsonArray(jsonData: IDataObject | IDataObject[]): INodeExecutionData[];
+		httpRequestWithAuthentication(
+			this: IAllExecuteFunctions,
+			credentialsType: string,
+			requestOptions: IHttpRequestOptions,
+		): Promise<any>;
+	};
+}
+
+export interface IWorkflowSettings extends IWorkflowSettingsWorkflow {
+	errorWorkflow?: string;
+	timezone?: string;
+	saveManualRuns?: boolean;
+}
+
+// New node definition in file
+export interface INodeDefinitionFile {
+	[key: string]: Constructable<INodeType | ICredentialType>;
+}
+
+// Is identical to TaskDataConnections but does not allow null value to be used as input for nodes
+export interface INodeInputDataConnections {
+	[key: string]: INodeExecutionData[][];
+}
+
+export interface IWorkflowData {
+	pollResponses?: IPollResponse[];
+	triggerResponses?: ITriggerResponse[];
+}
+
+export interface IBinaryDataConfig {
+	mode: 'default' | 'filesystem';
+	availableModes: string;
+	localStoragePath: string;
+	binaryDataTTL: number;
+	persistedBinaryDataTTL: number;
+}
+
+export interface IBinaryDataManager {
+	init(startPurger: boolean): Promise<void>;
+	storeBinaryData(binaryBuffer: Buffer, executionId: string): Promise<string>;
+	retrieveBinaryDataByIdentifier(identifier: string): Promise<Buffer>;
+	markDataForDeletionByExecutionId(executionId: string): Promise<void>;
+	deleteMarkedFiles(): Promise<unknown>;
+	deleteBinaryDataByIdentifier(identifier: string): Promise<void>;
+	duplicateBinaryDataByIdentifier(binaryDataId: string, prefix: string): Promise<string>;
+	deleteBinaryDataByExecutionId(executionId: string): Promise<void>;
+	persistBinaryDataForExecutionId(executionId: string): Promise<void>;
+}

package/src/lib/LoadNodeParameterOptions.ts

@@ -0,0 +1,235 @@
+/* eslint-disable no-restricted-syntax */
+/* eslint-disable @typescript-eslint/no-unsafe-return */
+/* eslint-disable @typescript-eslint/no-unsafe-member-access */
+/* eslint-disable @typescript-eslint/restrict-template-expressions */
+/* eslint-disable @typescript-eslint/no-unsafe-call */
+/* eslint-disable @typescript-eslint/no-unsafe-assignment */
+/* eslint-disable @typescript-eslint/no-non-null-assertion */
+
+import {
+	ILoadOptions,
+	INode,
+	INodeCredentials,
+	INodeExecutionData,
+	INodeParameters,
+	INodeProperties,
+	INodePropertyOptions,
+	INodeType,
+	INodeTypeNameVersion,
+	INodeTypes,
+	IRunExecutionData,
+	ITaskDataConnections,
+	IWorkflowExecuteAdditionalData,
+	RoutingNode,
+	Workflow,
+} from '@fsai-flow/workflow';
+
+// eslint-disable-next-line import/no-cycle
+import { NodeExecuteFunctions } from '../../src';
+
+const TEMP_NODE_NAME = 'Temp-Node';
+const TEMP_WORKFLOW_NAME = 'Temp-Workflow';
+
+export class LoadNodeParameterOptions {
+	currentNodeParameters: INodeParameters;
+
+	path: string;
+
+	workflow: Workflow;
+
+	constructor(
+		nodeTypeNameAndVersion: INodeTypeNameVersion,
+		nodeTypes: INodeTypes,
+		path: string,
+		currentNodeParameters: INodeParameters,
+		credentials?: INodeCredentials,
+	) {
+		const nodeType = nodeTypes.getByNameAndVersion(
+			nodeTypeNameAndVersion.name,
+			nodeTypeNameAndVersion.version,
+		);
+		this.currentNodeParameters = currentNodeParameters;
+		this.path = path;
+		if (nodeType === undefined) {
+			throw new Error(
+				`The node-type "${nodeTypeNameAndVersion.name} v${nodeTypeNameAndVersion.version}"  is not known!`,
+			);
+		}
+
+		const nodeData: INode = {
+			parameters: currentNodeParameters,
+			name: TEMP_NODE_NAME,
+			type: nodeTypeNameAndVersion.name,
+			typeVersion: nodeTypeNameAndVersion.version,
+			position: [0, 0],
+			id: '',
+		};
+		if (credentials) {
+			nodeData.credentials = credentials;
+		}
+
+		const workflowData = {
+			nodes: [nodeData],
+			connections: {},
+		};
+
+		this.workflow = new Workflow({
+			nodes: workflowData.nodes,
+			connections: workflowData.connections,
+			active: false,
+			nodeTypes,
+		});
+	}
+
+	/**
+	 * Returns data of a fake workflow
+	 *
+	 * @returns
+	 * @memberof LoadNodeParameterOptions
+	 */
+	// eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
+	getWorkflowData() {
+		return {
+			name: TEMP_WORKFLOW_NAME,
+			active: false,
+			connections: {},
+			nodes: Object.values(this.workflow.nodes),
+			createdAt: new Date(),
+			updatedAt: new Date(),
+		};
+	}
+
+	/**
+	 * Returns the available options via a predefined method
+	 *
+	 * @param {string} methodName The name of the method of which to get the data from
+	 * @param {IWorkflowExecuteAdditionalData} additionalData
+	 * @returns {Promise<INodePropertyOptions[]>}
+	 * @memberof LoadNodeParameterOptions
+	 */
+	async getOptionsViaMethodName(
+		methodName: string,
+		additionalData: IWorkflowExecuteAdditionalData,
+	): Promise<INodePropertyOptions[]> {
+		const node = this.workflow.getNode(TEMP_NODE_NAME);
+
+		const nodeType = this.workflow.nodeTypes.getByNameAndVersion(node!.type, node?.typeVersion);
+
+		if (
+			!nodeType ||
+			nodeType.methods === undefined ||
+			nodeType.methods.loadOptions === undefined ||
+			nodeType.methods.loadOptions[methodName] === undefined
+		) {
+			throw new Error(
+				`The node-type "${node!.type}" does not have the method "${methodName}" defined!`,
+			);
+		}
+
+		const thisArgs = NodeExecuteFunctions.getLoadOptionsFunctions(
+			this.workflow,
+			node!,
+			this.path,
+			additionalData,
+		);
+
+		try {
+			return await nodeType.methods.loadOptions[methodName].call(thisArgs);
+		} catch (error) {
+			return [{
+				name: 'Error trying to load options',
+				value: '',
+				description: (error as Error).message || 'Error trying to load options.'
+			}];
+		}
+	}
+
+	/**
+	 * Returns the available options via a load request informatoin
+	 *
+	 * @param {ILoadOptions} loadOptions The load options which also contain the request information
+	 * @param {IWorkflowExecuteAdditionalData} additionalData
+	 * @returns {Promise<INodePropertyOptions[]>}
+	 * @memberof LoadNodeParameterOptions
+	 */
+	async getOptionsViaRequestProperty(
+		loadOptions: ILoadOptions,
+		additionalData: IWorkflowExecuteAdditionalData,
+	): Promise<INodePropertyOptions[]> {
+		const node = this.workflow.getNode(TEMP_NODE_NAME);
+
+		const nodeType = this.workflow.nodeTypes.getByNameAndVersion(node!.type, node?.typeVersion);
+
+		if (
+			nodeType === undefined ||
+			!nodeType.description.requestDefaults ||
+			!nodeType.description.requestDefaults.baseURL
+		) {
+			// This in in here for now for security reasons.
+			// Background: As the full data for the request to make does get send, and the auth data
+			// will then be applied, would it be possible to retrieve that data like that. By at least
+			// requiring a baseURL to be defined can at least not a random server be called.
+			// In the future this code has to get improved that it does not use the request information from
+			// the request rather resolves it via the parameter-path and nodeType data.
+			throw new Error(
+				`The node-type "${
+					node!.type
+				}" does not exist or does not have "requestDefaults.baseURL" defined!`,
+			);
+		}
+
+		const mode = 'internal';
+		const runIndex = 0;
+		const connectionInputData: INodeExecutionData[] = [];
+		const runExecutionData: IRunExecutionData = { resultData: { runData: {} } };
+
+		const routingNode = new RoutingNode(
+			this.workflow,
+			node!,
+			connectionInputData,
+			runExecutionData ?? null,
+			additionalData,
+			mode,
+		);
+
+		// Create copy of node-type with the single property we want to get the data off
+		const tempNode: INodeType = {
+			...nodeType,
+			...{
+				description: {
+					...nodeType.description,
+					properties: [
+						{
+							displayName: '',
+							type: 'string',
+							name: '',
+							default: '',
+							routing: loadOptions.routing,
+						} as INodeProperties,
+					],
+				},
+			},
+		};
+
+		const inputData: ITaskDataConnections = {
+			main: [[{ json: {} }]],
+		};
+
+		const optionsData = await routingNode.runNode(
+			inputData,
+			runIndex,
+			tempNode,
+			NodeExecuteFunctions,
+		);
+
+		if (optionsData?.length === 0) {
+			return [];
+		}
+
+		if (!Array.isArray(optionsData)) {
+			throw new Error('The returned data is not an array!');
+		}
+
+		return optionsData[0].map((item) => item.json) as unknown as INodePropertyOptions[];
+	}
+}