@fsai-flow/core 0.0.4 → 0.1.0

package/dist/{src/lib → lib}/Interfaces.d.ts

@@ -1,50 +1,49 @@
-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';
+import type { IAdditionalCredentialOptions, IAllExecuteFunctions, IBinaryData, ICredentialTestFunctions as ICredentialTestFunctionsBase, ICredentialType, IDataObject, IExecuteFunctions as IExecuteFunctionsBase, IExecuteSingleFunctions as IExecuteSingleFunctionsBase, IHookFunctions as IHookFunctionsBase, IHttpRequestOptions, ILoadOptionsFunctions as ILoadOptionsFunctionsBase, IN8nHttpFullResponse, IN8nHttpResponse, INodeExecutionData, INodeType, IOAuth2Options, IPollFunctions as IPollFunctionsBase, IPollResponse, ITriggerFunctions as ITriggerFunctionsBase, ITriggerResponse, IWebhookFunctions as IWebhookFunctionsBase, IWorkflowSettings as IWorkflowSettingsWorkflow } from "@fsai-flow/workflow";
+import type { OptionsWithUri, OptionsWithUrl, RequestPromiseOptions } from "./RequestTypes";
 interface Constructable<T> {
     new (): T;
 }
 export interface IProcessMessage {
-    data?: any;
+    data?: unknown;
     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>;
+        httpRequest(requestOptions: IHttpRequestOptions): Promise<IN8nHttpFullResponse | IN8nHttpResponse>;
         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>;
-        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>;
-        requestOAuth1(this: IAllExecuteFunctions, credentialsType: string, requestOptions: OptionsWithUrl | requestPromise.RequestPromiseOptions): Promise<any>;
+        request: (uriOrObject: string | IDataObject | unknown, options?: IDataObject) => Promise<unknown>;
+        requestWithAuthentication(this: IAllExecuteFunctions, credentialsType: string, requestOptions: OptionsWithUri | RequestPromiseOptions, additionalCredentialOptions?: IAdditionalCredentialOptions): Promise<unknown>;
+        requestOAuth2(this: IAllExecuteFunctions, credentialsType: string, requestOptions: OptionsWithUri | RequestPromiseOptions, oAuth2Options?: IOAuth2Options): Promise<unknown>;
+        requestOAuth1(this: IAllExecuteFunctions, credentialsType: string, requestOptions: OptionsWithUrl | RequestPromiseOptions): Promise<unknown>;
         returnJsonArray(jsonData: IDataObject | IDataObject[]): INodeExecutionData[];
         normalizeItems(items: INodeExecutionData | INodeExecutionData[]): INodeExecutionData[];
-        httpRequestWithAuthentication(this: IAllExecuteFunctions, credentialsType: string, requestOptions: IHttpRequestOptions): Promise<any>;
+        httpRequestWithAuthentication(this: IAllExecuteFunctions, credentialsType: string, requestOptions: IHttpRequestOptions): Promise<IN8nHttpFullResponse | IN8nHttpResponse>;
     };
 }
 export interface IExecuteSingleFunctions extends IExecuteSingleFunctionsBase {
     helpers: {
-        httpRequest(requestOptions: IHttpRequestOptions): Promise<any>;
+        httpRequest(requestOptions: IHttpRequestOptions): Promise<IN8nHttpFullResponse | IN8nHttpResponse>;
         prepareBinaryData(binaryData: Buffer, filePath?: string, mimeType?: string): Promise<IBinaryData>;
-        request: (uriOrObject: string | IDataObject | any, options?: IDataObject) => Promise<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>;
-        requestOAuth1(this: IAllExecuteFunctions, credentialsType: string, requestOptions: OptionsWithUrl | requestPromise.RequestPromiseOptions): Promise<any>;
-        httpRequestWithAuthentication(this: IAllExecuteFunctions, credentialsType: string, requestOptions: IHttpRequestOptions): Promise<any>;
+        request: (uriOrObject: string | IDataObject | unknown, options?: IDataObject) => Promise<unknown>;
+        requestWithAuthentication(this: IAllExecuteFunctions, credentialsType: string, requestOptions: OptionsWithUri | RequestPromiseOptions, additionalCredentialOptions?: IAdditionalCredentialOptions): Promise<unknown>;
+        requestOAuth2(this: IAllExecuteFunctions, credentialsType: string, requestOptions: OptionsWithUri | RequestPromiseOptions, oAuth2Options?: IOAuth2Options): Promise<unknown>;
+        requestOAuth1(this: IAllExecuteFunctions, credentialsType: string, requestOptions: OptionsWithUrl | RequestPromiseOptions): Promise<unknown>;
+        httpRequestWithAuthentication(this: IAllExecuteFunctions, credentialsType: string, requestOptions: IHttpRequestOptions): Promise<IN8nHttpFullResponse | IN8nHttpResponse>;
     };
 }
 export interface IPollFunctions extends IPollFunctionsBase {
     helpers: {
-        httpRequest(requestOptions: IHttpRequestOptions): Promise<any>;
+        httpRequest(requestOptions: IHttpRequestOptions): Promise<IN8nHttpFullResponse | IN8nHttpResponse>;
         prepareBinaryData(binaryData: Buffer, filePath?: string, mimeType?: string): Promise<IBinaryData>;
-        request: (uriOrObject: string | IDataObject | any, options?: IDataObject) => Promise<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>;
-        requestOAuth1(this: IAllExecuteFunctions, credentialsType: string, requestOptions: OptionsWithUrl | requestPromise.RequestPromiseOptions): Promise<any>;
+        request: (uriOrObject: string | IDataObject | unknown, options?: IDataObject) => Promise<unknown>;
+        requestWithAuthentication(this: IAllExecuteFunctions, credentialsType: string, requestOptions: OptionsWithUri | RequestPromiseOptions, additionalCredentialOptions?: IAdditionalCredentialOptions): Promise<unknown>;
+        requestOAuth2(this: IAllExecuteFunctions, credentialsType: string, requestOptions: OptionsWithUri | RequestPromiseOptions, oAuth2Options?: IOAuth2Options): Promise<unknown>;
+        requestOAuth1(this: IAllExecuteFunctions, credentialsType: string, requestOptions: OptionsWithUrl | RequestPromiseOptions): Promise<unknown>;
         returnJsonArray(jsonData: IDataObject | IDataObject[]): INodeExecutionData[];
-        httpRequestWithAuthentication(this: IAllExecuteFunctions, credentialsType: string, requestOptions: IHttpRequestOptions): Promise<any>;
+        httpRequestWithAuthentication(this: IAllExecuteFunctions, credentialsType: string, requestOptions: IHttpRequestOptions): Promise<IN8nHttpFullResponse | IN8nHttpResponse>;
     };
 }
 export interface IResponseError extends Error {
@@ -52,14 +51,14 @@ export interface IResponseError extends Error {
 }
 export interface ITriggerFunctions extends ITriggerFunctionsBase {
     helpers: {
-        httpRequest(requestOptions: IHttpRequestOptions): Promise<any>;
+        httpRequest(requestOptions: IHttpRequestOptions): Promise<IN8nHttpFullResponse | IN8nHttpResponse>;
         prepareBinaryData(binaryData: Buffer, filePath?: string, mimeType?: string): Promise<IBinaryData>;
-        request: (uriOrObject: string | IDataObject | any, options?: IDataObject) => Promise<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>;
-        requestOAuth1(this: IAllExecuteFunctions, credentialsType: string, requestOptions: OptionsWithUrl | requestPromise.RequestPromiseOptions): Promise<any>;
+        request: (uriOrObject: string | IDataObject | unknown, options?: IDataObject) => Promise<unknown>;
+        requestWithAuthentication(this: IAllExecuteFunctions, credentialsType: string, requestOptions: OptionsWithUri | RequestPromiseOptions, additionalCredentialOptions?: IAdditionalCredentialOptions): Promise<unknown>;
+        requestOAuth2(this: IAllExecuteFunctions, credentialsType: string, requestOptions: OptionsWithUri | RequestPromiseOptions, oAuth2Options?: IOAuth2Options): Promise<unknown>;
+        requestOAuth1(this: IAllExecuteFunctions, credentialsType: string, requestOptions: OptionsWithUrl | RequestPromiseOptions): Promise<unknown>;
         returnJsonArray(jsonData: IDataObject | IDataObject[]): INodeExecutionData[];
-        httpRequestWithAuthentication(this: IAllExecuteFunctions, credentialsType: string, requestOptions: IHttpRequestOptions): Promise<any>;
+        httpRequestWithAuthentication(this: IAllExecuteFunctions, credentialsType: string, requestOptions: IHttpRequestOptions): Promise<IN8nHttpFullResponse | IN8nHttpResponse>;
     };
 }
 export interface ITriggerTime {
@@ -77,39 +76,39 @@ export interface IUserSettings {
 }
 export interface ILoadOptionsFunctions extends ILoadOptionsFunctionsBase {
     helpers: {
-        httpRequest(requestOptions: IHttpRequestOptions): Promise<any>;
-        request?: (uriOrObject: string | IDataObject | any, options?: IDataObject) => Promise<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>;
-        requestOAuth1?(this: IAllExecuteFunctions, credentialsType: string, requestOptions: OptionsWithUrl | requestPromise.RequestPromiseOptions): Promise<any>;
-        httpRequestWithAuthentication(this: IAllExecuteFunctions, credentialsType: string, requestOptions: IHttpRequestOptions): Promise<any>;
+        httpRequest(requestOptions: IHttpRequestOptions): Promise<IN8nHttpFullResponse | IN8nHttpResponse>;
+        request?: (uriOrObject: string | IDataObject | unknown, options?: IDataObject) => Promise<unknown>;
+        requestWithAuthentication(this: IAllExecuteFunctions, credentialsType: string, requestOptions: OptionsWithUri | RequestPromiseOptions, additionalCredentialOptions?: IAdditionalCredentialOptions): Promise<unknown>;
+        requestOAuth2?: (this: IAllExecuteFunctions, credentialsType: string, requestOptions: OptionsWithUri | RequestPromiseOptions, oAuth2Options?: IOAuth2Options) => Promise<unknown>;
+        requestOAuth1?(this: IAllExecuteFunctions, credentialsType: string, requestOptions: OptionsWithUrl | RequestPromiseOptions): Promise<unknown>;
+        httpRequestWithAuthentication(this: IAllExecuteFunctions, credentialsType: string, requestOptions: IHttpRequestOptions): Promise<IN8nHttpFullResponse | IN8nHttpResponse>;
     };
 }
 export interface ICredentialTestFunctions extends ICredentialTestFunctionsBase {
     helpers: {
-        request?: (uriOrObject: string | IDataObject | any, options?: IDataObject) => Promise<any>;
+        request?: (uriOrObject: string | IDataObject | unknown, options?: IDataObject) => Promise<unknown>;
     };
 }
 export interface IHookFunctions extends IHookFunctionsBase {
     helpers: {
-        httpRequest(requestOptions: IHttpRequestOptions): Promise<any>;
-        request: (uriOrObject: string | IDataObject | any, options?: IDataObject) => Promise<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>;
-        requestOAuth1(this: IAllExecuteFunctions, credentialsType: string, requestOptions: OptionsWithUrl | requestPromise.RequestPromiseOptions): Promise<any>;
-        httpRequestWithAuthentication(this: IAllExecuteFunctions, credentialsType: string, requestOptions: IHttpRequestOptions): Promise<any>;
+        httpRequest(requestOptions: IHttpRequestOptions): Promise<IN8nHttpFullResponse | IN8nHttpResponse>;
+        request: (uriOrObject: string | IDataObject | unknown, options?: IDataObject) => Promise<unknown>;
+        requestWithAuthentication(this: IAllExecuteFunctions, credentialsType: string, requestOptions: OptionsWithUri | RequestPromiseOptions, additionalCredentialOptions?: IAdditionalCredentialOptions): Promise<unknown>;
+        requestOAuth2(this: IAllExecuteFunctions, credentialsType: string, requestOptions: OptionsWithUri | RequestPromiseOptions, oAuth2Options?: IOAuth2Options): Promise<unknown>;
+        requestOAuth1(this: IAllExecuteFunctions, credentialsType: string, requestOptions: OptionsWithUrl | RequestPromiseOptions): Promise<unknown>;
+        httpRequestWithAuthentication(this: IAllExecuteFunctions, credentialsType: string, requestOptions: IHttpRequestOptions): Promise<IN8nHttpFullResponse | IN8nHttpResponse>;
     };
 }
 export interface IWebhookFunctions extends IWebhookFunctionsBase {
     helpers: {
-        httpRequest(requestOptions: IHttpRequestOptions): Promise<any>;
+        httpRequest(requestOptions: IHttpRequestOptions): Promise<IN8nHttpFullResponse | IN8nHttpResponse>;
         prepareBinaryData(binaryData: Buffer, filePath?: string, mimeType?: string): Promise<IBinaryData>;
-        request: (uriOrObject: string | IDataObject | any, options?: IDataObject) => Promise<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>;
-        requestOAuth1(this: IAllExecuteFunctions, credentialsType: string, requestOptions: OptionsWithUrl | requestPromise.RequestPromiseOptions): Promise<any>;
+        request: (uriOrObject: string | IDataObject | unknown, options?: IDataObject) => Promise<unknown>;
+        requestWithAuthentication(this: IAllExecuteFunctions, credentialsType: string, requestOptions: OptionsWithUri | RequestPromiseOptions, additionalCredentialOptions?: IAdditionalCredentialOptions): Promise<unknown>;
+        requestOAuth2(this: IAllExecuteFunctions, credentialsType: string, requestOptions: OptionsWithUri | RequestPromiseOptions, oAuth2Options?: IOAuth2Options): Promise<unknown>;
+        requestOAuth1(this: IAllExecuteFunctions, credentialsType: string, requestOptions: OptionsWithUrl | RequestPromiseOptions): Promise<unknown>;
         returnJsonArray(jsonData: IDataObject | IDataObject[]): INodeExecutionData[];
-        httpRequestWithAuthentication(this: IAllExecuteFunctions, credentialsType: string, requestOptions: IHttpRequestOptions): Promise<any>;
+        httpRequestWithAuthentication(this: IAllExecuteFunctions, credentialsType: string, requestOptions: IHttpRequestOptions): Promise<IN8nHttpFullResponse | IN8nHttpResponse>;
     };
 }
 export interface IWorkflowSettings extends IWorkflowSettingsWorkflow {
@@ -128,7 +127,7 @@ export interface IWorkflowData {
     triggerResponses?: ITriggerResponse[];
 }
 export interface IBinaryDataConfig {
-    mode: 'default' | 'filesystem';
+    mode: "default" | "filesystem";
     availableModes: string;
     localStoragePath: string;
     binaryDataTTL: number;

package/dist/{src/lib → lib}/Interfaces.js

@@ -1,3 +1,2 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=Interfaces.js.map

package/dist/{src/lib → lib}/LoadNodeParameterOptions.d.ts

@@ -1,4 +1,4 @@
-import { ILoadOptions, INode, INodeCredentials, INodeParameters, INodePropertyOptions, INodeTypeNameVersion, INodeTypes, IWorkflowExecuteAdditionalData, Workflow } from '@fsai-flow/workflow';
+import { type ILoadOptions, type INode, type INodeCredentials, type INodeParameters, type INodePropertyOptions, type INodeTypeNameVersion, type INodeTypes, type IWorkflowExecuteAdditionalData, Workflow } from "@fsai-flow/workflow";
 export declare class LoadNodeParameterOptions {
     currentNodeParameters: INodeParameters;
     path: string;

package/dist/lib/LoadNodeParameterOptions.js

@@ -0,0 +1,152 @@
+"use strict";
+/* 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 */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LoadNodeParameterOptions = void 0;
+const workflow_1 = require("@fsai-flow/workflow");
+// eslint-disable-next-line import/no-cycle
+const __1 = require("..");
+const TEMP_NODE_NAME = "Temp-Node";
+const TEMP_WORKFLOW_NAME = "Temp-Workflow";
+class LoadNodeParameterOptions {
+    constructor(nodeTypeNameAndVersion, nodeTypes, path, currentNodeParameters, credentials) {
+        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 = {
+            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_1.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, additionalData) {
+        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 = __1.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.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, additionalData) {
+        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 = [];
+        const runExecutionData = { resultData: { runData: {} } };
+        const routingNode = new workflow_1.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 = {
+            ...nodeType,
+            ...{
+                description: {
+                    ...nodeType.description,
+                    properties: [
+                        {
+                            displayName: "",
+                            type: "string",
+                            name: "",
+                            default: "",
+                            routing: loadOptions.routing,
+                        },
+                    ],
+                },
+            },
+        };
+        const inputData = {
+            main: [[{ json: {} }]],
+        };
+        const optionsData = await routingNode.runNode(inputData, runIndex, tempNode, __1.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);
+    }
+}
+exports.LoadNodeParameterOptions = LoadNodeParameterOptions;

package/dist/{src/lib → lib}/NodeExecuteFunctions.d.ts

@@ -1,7 +1,6 @@
-import { IAdditionalCredentialOptions, IAllExecuteFunctions, IBinaryData, ICredentialDataDecryptedObject, IDataObject, IExecuteFunctions, IExecuteSingleFunctions, IHttpRequestOptions, INode, INodeExecutionData, INodeParameters, INodeType, IOAuth2Options, IPollFunctions, IRunExecutionData, ITaskDataConnections, ITriggerFunctions, IWebhookData, IWebhookDescription, IWebhookFunctions, IWorkflowDataProxyAdditionalKeys, IWorkflowExecuteAdditionalData, IWorkflowMetadata, NodeParameterValue, Workflow, WorkflowActivateMode, WorkflowExecuteMode, ISupplyDataFunctions, NodeConnectionType, CloseFunction } from '@fsai-flow/workflow';
-import { OptionsWithUri, OptionsWithUrl } from 'request';
-import * as requestPromise from 'request-promise-native';
-import { ICredentialTestFunctions, IHookFunctions, ILoadOptionsFunctions } from '..';
+import { type CloseFunction, type IAdditionalCredentialOptions, type IAllExecuteFunctions, type IBinaryData, type ICredentialDataDecryptedObject, type IDataObject, type IExecuteFunctions, type IExecuteSingleFunctions, type IHttpRequestOptions, type INode, type INodeExecutionData, type INodeParameters, type INodeType, type IOAuth2Options, type IPollFunctions, type IRunExecutionData, type ISupplyDataFunctions, type ITaskDataConnections, type ITriggerFunctions, type IWebhookData, type IWebhookDescription, type IWebhookFunctions, type IWorkflowDataProxyAdditionalKeys, type IWorkflowExecuteAdditionalData, type IWorkflowMetadata, type NodeConnectionType, type NodeParameterValue, type Workflow, type WorkflowActivateMode, type WorkflowExecuteMode } from "@fsai-flow/workflow";
+import { type ICredentialTestFunctions, type IHookFunctions, type ILoadOptionsFunctions } from "..";
+import type { OptionsWithUri, OptionsWithUrl, RequestPromiseOptions } from "./RequestTypes";
 /**
  * Returns binary data buffer for given item index and property name.
  *
@@ -25,9 +24,9 @@ export declare function getBinaryDataBuffer(inputData: ITaskDataConnections, ite
  */
 export declare function prepareBinaryData(binaryData: Buffer, executionId: string, filePath?: string, mimeType?: string): Promise<IBinaryData>;
 export declare function getCurrentOAuth2AccessToken(this: IAllExecuteFunctions, credentialsType: string, node: INode, additionalData: IWorkflowExecuteAdditionalData, oAuth2Options?: IOAuth2Options): Promise<string>;
-export declare function requestOAuth2(this: IAllExecuteFunctions, credentialsType: string, requestOptions: OptionsWithUri | requestPromise.RequestPromiseOptions | IHttpRequestOptions, node: INode, additionalData: IWorkflowExecuteAdditionalData, oAuth2Options?: IOAuth2Options, isN8nRequest?: boolean): Promise<any>;
-export declare function requestOAuth1(this: IAllExecuteFunctions, credentialsType: string, requestOptions: OptionsWithUrl | OptionsWithUri | requestPromise.RequestPromiseOptions | IHttpRequestOptions, isN8nRequest?: boolean): Promise<any>;
-export declare function httpRequestWithAuthentication(this: IAllExecuteFunctions, credentialsType: string, requestOptions: IHttpRequestOptions, workflow: Workflow, node: INode, additionalData: IWorkflowExecuteAdditionalData, additionalCredentialOptions?: IAdditionalCredentialOptions): Promise<any>;
+export declare function requestOAuth2(this: IAllExecuteFunctions, credentialsType: string, requestOptions: OptionsWithUri | RequestPromiseOptions | IHttpRequestOptions, node: INode, additionalData: IWorkflowExecuteAdditionalData, oAuth2Options?: IOAuth2Options, isN8nRequest?: boolean): Promise<unknown>;
+export declare function requestOAuth1(this: IAllExecuteFunctions, credentialsType: string, requestOptions: OptionsWithUrl | OptionsWithUri | RequestPromiseOptions | IHttpRequestOptions, isN8nRequest?: boolean): Promise<unknown>;
+export declare function httpRequestWithAuthentication(this: IAllExecuteFunctions, credentialsType: string, requestOptions: IHttpRequestOptions, workflow: Workflow, node: INode, additionalData: IWorkflowExecuteAdditionalData, additionalCredentialOptions?: IAdditionalCredentialOptions): Promise<unknown>;
 /**
  * Takes generic input data and brings it into the json format n8n uses.
  *
@@ -45,7 +44,7 @@ export declare function returnJsonArray(jsonData: IDataObject | IDataObject[]):
  * @returns {INodeExecutionData[]}
  */
 export declare function normalizeItems(executionData: INodeExecutionData | INodeExecutionData[]): INodeExecutionData[];
-export declare function requestWithAuthentication(this: IAllExecuteFunctions, credentialsType: string, requestOptions: OptionsWithUri | requestPromise.RequestPromiseOptions, workflow: Workflow, node: INode, additionalData: IWorkflowExecuteAdditionalData, additionalCredentialOptions?: IAdditionalCredentialOptions): Promise<any>;
+export declare function requestWithAuthentication(this: IAllExecuteFunctions, credentialsType: string, requestOptions: OptionsWithUri | RequestPromiseOptions, workflow: Workflow, node: INode, additionalData: IWorkflowExecuteAdditionalData, additionalCredentialOptions?: IAdditionalCredentialOptions): Promise<unknown>;
 /**
  * Returns the additional keys for Expressions and Function-Nodes
  *
@@ -87,7 +86,7 @@ export declare function getNode(node: INode): INode;
  * @param {*} [fallbackValue]
  * @returns {(NodeParameterValue | INodeParameters | NodeParameterValue[] | INodeParameters[] | object)}
  */
-export declare function getNodeParameter(workflow: Workflow, runExecutionData: IRunExecutionData | null, runIndex: number, connectionInputData: INodeExecutionData[], node: INode, parameterName: string, itemIndex: number, mode: WorkflowExecuteMode, additionalKeys: IWorkflowDataProxyAdditionalKeys, fallbackValue?: any): NodeParameterValue | INodeParameters | NodeParameterValue[] | INodeParameters[] | object;
+export declare function getNodeParameter(workflow: Workflow, runExecutionData: IRunExecutionData | null, runIndex: number, connectionInputData: INodeExecutionData[], node: INode, parameterName: string, itemIndex: number, mode: WorkflowExecuteMode, additionalKeys: IWorkflowDataProxyAdditionalKeys, fallbackValue?: unknown): NodeParameterValue | INodeParameters | NodeParameterValue[] | INodeParameters[] | object;
 /**
  * Returns if execution should be continued even if there was an error.
  *
@@ -221,6 +220,6 @@ export declare function getExecuteHookFunctions(workflow: Workflow, node: INode,
  * @param {WorkflowExecuteMode} mode
  * @returns {IWebhookFunctions}
  */
-export declare function getExecuteWebhookFunctions(workflow: Workflow, node: INode, additionalData: IWorkflowExecuteAdditionalData, mode: WorkflowExecuteMode, webhookData: IWebhookData, runExecutionData: IRunExecutionData | undefined): IWebhookFunctions;
+export declare function getExecuteWebhookFunctions(workflow: Workflow, node: INode, additionalData: IWorkflowExecuteAdditionalData, mode: WorkflowExecuteMode, webhookData: IWebhookData, initialRunExecutionData: IRunExecutionData | undefined): IWebhookFunctions;
 export declare function getSupplyDataFunctions(workflow: Workflow, runExecutionData: IRunExecutionData, runIndex: number, connectionInputData: INodeExecutionData[], inputData: ITaskDataConnections, node: INode, additionalData: IWorkflowExecuteAdditionalData, mode: WorkflowExecuteMode, nodeTypeData: INodeType, closeFunctions: CloseFunction[]): ISupplyDataFunctions;
 export declare function getInputConnectionData(this: IExecuteFunctions | ISupplyDataFunctions, workflow: Workflow, runExecutionData: IRunExecutionData, runIndex: number, connectionInputData: INodeExecutionData[], inputData: ITaskDataConnections, additionalData: IWorkflowExecuteAdditionalData, connectionType: NodeConnectionType, mode: WorkflowExecuteMode, itemIndex: number, nodeTypeData: INodeType, closeFunctions: CloseFunction[]): Promise<unknown>;