@fsai-flow/core 0.0.1

package/src/lib/ChangeCase.ts

@@ -0,0 +1,45 @@
+export class ChangeCase {
+  private static transformInput(input: string): string[] {
+    return input
+      .split(/[^a-zA-Z0-9]+/) // Split by non-alphanumeric characters
+      .filter((word) => word.length > 0) // Remove empty segments
+      .map((word) => word[0].toUpperCase() + word.slice(1).toLowerCase()); // Capitalize first letter and lowercase the rest
+  }
+
+  static toCamelCase(str: string): string {
+    const words = ChangeCase.transformInput(str);
+    return words[0].toLowerCase() + words.slice(1).join('');
+  }
+
+  static toPascalCase(str: string): string {
+    const words = str
+    .replace(/([a-z0-9])([A-Z])/g, '$1 $2') // insert space before capital letters in camelCase
+    .split(/[^a-zA-Z0-9]+|[\s]+/) // split by non-alphanumerics and added spaces
+    .filter(word => word.length > 0)
+    .map(word => word[0].toUpperCase() + word.slice(1).toLowerCase());
+
+    return words.join('');
+  }
+
+  static toSnakeCase(str: string): string {
+    return str
+      .replace(/([a-z])([A-Z])/g, '$1_$2')
+      .replace(/[\W_]+/g, '_')
+      .toLowerCase();
+  }
+
+  static toCapitalCase(str: string): string {
+    return str.replace(/\b\w/g, (chr) => chr.toUpperCase());
+  }
+
+  static toParamCase(str: string): string {
+    return str
+      .replace(/([a-z])([A-Z])/g, '$1-$2')
+      .replace(/[\W_]+/g, '-')
+      .toLowerCase();
+  }
+
+  static noCase(str: string): string {
+    return str.replace(/[^\w\s]/g, '').toLowerCase();
+  }
+}

package/src/lib/Constants.ts

@@ -0,0 +1,16 @@
+const { NODE_ENV } = process.env;
+export const inProduction = NODE_ENV === 'production';
+export const inDevelopment = !NODE_ENV || NODE_ENV === 'development';
+export const inTest = NODE_ENV === 'test';
+
+export const BINARY_ENCODING = 'base64';
+export const CUSTOM_EXTENSION_ENV = 'N8N_CUSTOM_EXTENSIONS';
+export const ENCRYPTION_KEY_ENV_OVERWRITE = 'FSAI_FLOW_ENCRYPTION_KEY';
+export const EXTENSIONS_SUBDIRECTORY = 'custom';
+export const USER_FOLDER_ENV_OVERWRITE = 'N8N_USER_FOLDER';
+export const USER_SETTINGS_FILE_NAME = 'config';
+export const USER_SETTINGS_SUBFOLDER = '.n8n';
+export const PLACEHOLDER_EMPTY_EXECUTION_ID = '__UNKOWN__';
+export const PLACEHOLDER_EMPTY_WORKFLOW_ID = '__EMPTY__';
+export const TUNNEL_SUBDOMAIN_ENV = 'N8N_TUNNEL_SUBDOMAIN';
+export const WAIT_TIME_UNLIMITED = '3000-01-01T00:00:00.000Z';

package/src/lib/Credentials.ts

@@ -0,0 +1,108 @@
+import {
+	CredentialInformation,
+	ICredentialDataDecryptedObject,
+	ICredentials,
+	ICredentialsEncrypted,
+} from '@fsai-flow/workflow';
+
+import { AES, enc } from 'crypto-js';
+
+export class Credentials extends ICredentials {
+	/**
+	 * Returns if the given nodeType has access to data
+	 */
+	hasNodeAccess(nodeType: string): boolean {
+		// eslint-disable-next-line no-restricted-syntax
+		for (const accessData of this.nodesAccess) {
+			if (accessData.nodeType === nodeType) {
+				return true;
+			}
+		}
+
+		return false;
+	}
+
+	/**
+	 * Sets new credential object
+	 */
+	setData(data: ICredentialDataDecryptedObject, encryptionKey: string): void {
+		this.data = AES.encrypt(JSON.stringify(data), encryptionKey).toString();
+	}
+
+	/**
+	 * Sets new credentials for given key
+	 */
+	setDataKey(key: string, data: CredentialInformation, encryptionKey: string): void {
+		let fullData;
+		try {
+			fullData = this.getData(encryptionKey);
+		} catch (e) {
+			fullData = {};
+		}
+
+		fullData[key] = data;
+
+		return this.setData(fullData, encryptionKey);
+	}
+
+	/**
+	 * Returns the decrypted credential object
+	 */
+	getData(encryptionKey: string, nodeType?: string): ICredentialDataDecryptedObject {
+		if (nodeType && !this.hasNodeAccess(nodeType)) {
+			throw new Error(
+				`The node of type "${nodeType}" does not have access to credentials "${this.name}" of type "${this.type}".`,
+			);
+		}
+
+		if (this.data === undefined) {
+			throw new Error('No data is set so nothing can be returned.');
+		}
+
+		const decryptedData = AES.decrypt(this.data, encryptionKey);
+
+		try {
+			// eslint-disable-next-line @typescript-eslint/no-unsafe-return
+			return JSON.parse(decryptedData.toString(enc.Utf8));
+		} catch (e) {
+			throw new Error(
+				'Credentials could not be decrypted. The likely reason is that a different "encryptionKey" was used to encrypt the data.',
+			);
+		}
+	}
+
+	/**
+	 * Returns the decrypted credentials for given key
+	 */
+	getDataKey(key: string, encryptionKey: string, nodeType?: string): CredentialInformation {
+		const fullData = this.getData(encryptionKey, nodeType);
+
+		if (fullData === null) {
+			throw new Error(`No data was set.`);
+		}
+
+		// eslint-disable-next-line no-prototype-builtins
+		if (!fullData.hasOwnProperty(key)) {
+			throw new Error(`No data for key "${key}" exists.`);
+		}
+
+		return fullData[key];
+	}
+
+	/**
+	 * Returns the encrypted credentials to be saved
+	 */
+	getDataToSave(): ICredentialsEncrypted {
+		if (this.data === undefined) {
+			throw new Error(`No credentials were set to save.`);
+		}
+
+		return {
+			id: this.id,
+			name: this.name,
+			type: this.type,
+			data: this.data,
+			nodesAccess: this.nodesAccess,
+		};
+	}
+}

package/src/lib/FileSystem.ts

@@ -0,0 +1,214 @@
+import { promises as fs } from 'fs';
+import * as path from 'path';
+import { v4 as uuid } from 'uuid';
+
+import { IBinaryDataConfig, IBinaryDataManager } from './Interfaces';
+
+const PREFIX_METAFILE = 'binarymeta';
+const PREFIX_PERSISTED_METAFILE = 'persistedmeta';
+
+export class BinaryDataFileSystem implements IBinaryDataManager {
+	private storagePath: string;
+
+	private binaryDataTTL: number;
+
+	private persistedBinaryDataTTL: number;
+
+	constructor(config: IBinaryDataConfig) {
+		this.storagePath = config.localStoragePath;
+		this.binaryDataTTL = config.binaryDataTTL;
+		this.persistedBinaryDataTTL = config.persistedBinaryDataTTL;
+	}
+
+	async init(startPurger = false): Promise<void> {
+		if (startPurger) {
+			setInterval(async () => {
+				await this.deleteMarkedFiles();
+			}, this.binaryDataTTL * 30000);
+
+			setInterval(async () => {
+				await this.deleteMarkedPersistedFiles();
+			}, this.persistedBinaryDataTTL * 30000);
+		}
+
+		return fs
+			.readdir(this.storagePath)
+			.catch(async () => fs.mkdir(this.storagePath, { recursive: true }))
+			.then(async () => fs.readdir(this.getBinaryDataMetaPath()))
+			.catch(async () => fs.mkdir(this.getBinaryDataMetaPath(), { recursive: true }))
+			.then(async () => fs.readdir(this.getBinaryDataPersistMetaPath()))
+			.catch(async () => fs.mkdir(this.getBinaryDataPersistMetaPath(), { recursive: true }))
+			.then(async () => this.deleteMarkedFiles())
+			.then(async () => this.deleteMarkedPersistedFiles())
+			.then(() => {});
+	}
+
+	async storeBinaryData(binaryBuffer: Buffer, executionId: string): Promise<string> {
+		const binaryDataId = this.generateFileName(executionId);
+		return this.addBinaryIdToPersistMeta(executionId, binaryDataId).then(async () =>
+			this.saveToLocalStorage(binaryBuffer, binaryDataId).then(() => binaryDataId),
+		);
+	}
+
+	async retrieveBinaryDataByIdentifier(identifier: string): Promise<Buffer> {
+		return this.retrieveFromLocalStorage(identifier);
+	}
+
+	async markDataForDeletionByExecutionId(executionId: string): Promise<void> {
+		const tt = new Date(new Date().getTime() + this.binaryDataTTL * 60000);
+		return fs.writeFile(
+			path.join(this.getBinaryDataMetaPath(), `${PREFIX_METAFILE}_${executionId}_${tt.valueOf()}`),
+			'',
+		);
+	}
+
+	async deleteMarkedFiles(): Promise<void> {
+		return this.deleteMarkedFilesByMeta(this.getBinaryDataMetaPath(), PREFIX_METAFILE);
+	}
+
+	async deleteMarkedPersistedFiles(): Promise<void> {
+		return this.deleteMarkedFilesByMeta(
+			this.getBinaryDataPersistMetaPath(),
+			PREFIX_PERSISTED_METAFILE,
+		);
+	}
+
+	private async addBinaryIdToPersistMeta(executionId: string, identifier: string): Promise<void> {
+		const currentTime = new Date().getTime();
+		const timeAtNextHour = currentTime + 3600000 - (currentTime % 3600000);
+		const timeoutTime = timeAtNextHour + this.persistedBinaryDataTTL * 60000;
+
+		const filePath = path.join(
+			this.getBinaryDataPersistMetaPath(),
+			`${PREFIX_PERSISTED_METAFILE}_${executionId}_${timeoutTime}`,
+		);
+
+		return fs
+			.readFile(filePath)
+			.catch(async () => fs.writeFile(filePath, identifier))
+			.then(() => {});
+	}
+
+	private async deleteMarkedFilesByMeta(metaPath: string, filePrefix: string): Promise<void> {
+		const currentTimeValue = new Date().valueOf();
+		const metaFileNames = await fs.readdir(metaPath);
+
+		const execsAdded: { [key: string]: number } = {};
+
+		const proms = metaFileNames.reduce(
+			(prev, curr) => {
+				const [prefix, executionId, ts] = curr.split('_');
+
+				if (prefix !== filePrefix) {
+					return prev;
+				}
+
+				const execTimestamp = parseInt(ts, 10);
+
+				if (execTimestamp < currentTimeValue) {
+					if (execsAdded[executionId]) {
+						// do not delete data, only meta file
+						prev.push(this.deleteMetaFileByPath(path.join(metaPath, curr)));
+						return prev;
+					}
+
+					execsAdded[executionId] = 1;
+					prev.push(
+						this.deleteBinaryDataByExecutionId(executionId).then(async () =>
+							this.deleteMetaFileByPath(path.join(metaPath, curr)),
+						),
+					);
+				}
+
+				return prev;
+			},
+			[Promise.resolve()],
+		);
+
+		return Promise.all(proms).then(() => {});
+	}
+
+	async duplicateBinaryDataByIdentifier(binaryDataId: string, prefix: string): Promise<string> {
+		const newBinaryDataId = this.generateFileName(prefix);
+
+		return fs
+			.copyFile(
+				path.join(this.storagePath, binaryDataId),
+				path.join(this.storagePath, newBinaryDataId),
+			)
+			.then(() => newBinaryDataId);
+	}
+
+	async deleteBinaryDataByExecutionId(executionId: string): Promise<void> {
+		const regex = new RegExp(`${executionId}_*`);
+		const filenames = await fs.readdir(path.join(this.storagePath));
+
+		const proms = filenames.reduce(
+			(allProms, filename) => {
+				if (regex.test(filename)) {
+					allProms.push(fs.rm(path.join(this.storagePath, filename)));
+				}
+
+				return allProms;
+			},
+			[Promise.resolve()],
+		);
+
+		return Promise.all(proms).then(async () => Promise.resolve());
+	}
+
+	async deleteBinaryDataByIdentifier(identifier: string): Promise<void> {
+		return this.deleteFromLocalStorage(identifier);
+	}
+
+	async persistBinaryDataForExecutionId(executionId: string): Promise<void> {
+		return fs.readdir(this.getBinaryDataPersistMetaPath()).then(async (metafiles) => {
+			const proms = metafiles.reduce(
+				(prev, curr) => {
+					if (curr.startsWith(`${PREFIX_PERSISTED_METAFILE}_${executionId}_`)) {
+						prev.push(fs.rm(path.join(this.getBinaryDataPersistMetaPath(), curr)));
+						return prev;
+					}
+
+					return prev;
+				},
+				[Promise.resolve()],
+			);
+
+			return Promise.all(proms).then(() => {});
+		});
+	}
+
+	private generateFileName(prefix: string): string {
+		return `${prefix}_${uuid()}`;
+	}
+
+	private getBinaryDataMetaPath() {
+		return path.join(this.storagePath, 'meta');
+	}
+
+	private getBinaryDataPersistMetaPath() {
+		return path.join(this.storagePath, 'persistMeta');
+	}
+
+	private async deleteMetaFileByPath(metafilePath: string): Promise<void> {
+		return fs.rm(metafilePath);
+	}
+
+	private async deleteFromLocalStorage(identifier: string) {
+		return fs.rm(path.join(this.storagePath, identifier));
+	}
+
+	private async saveToLocalStorage(data: Buffer, identifier: string) {
+		await fs.writeFile(path.join(this.storagePath, identifier), data);
+	}
+
+	private async retrieveFromLocalStorage(identifier: string): Promise<Buffer> {
+		const filePath = path.join(this.storagePath, identifier);
+		try {
+			return await fs.readFile(filePath);
+		} catch (e) {
+			throw new Error(`Error finding file: ${filePath}`);
+		}
+	}
+}

package/src/lib/InputConnectionDataLegacy.ts

@@ -0,0 +1,123 @@
+import {
+    INode,
+    INodeType,
+    IExecuteFunctions,
+    ISupplyDataFunctions,
+    INodeInputConfiguration,
+    INodeTypeDescription,
+    Workflow,
+    SupplyData,
+    NodeConnectionType,
+    NodeOperationError,
+    IWebhookFunctions,
+} from '@fsai-flow/workflow';
+
+export async function getInputConnectionDataLegacy(
+    this:  ISupplyDataFunctions | IWebhookFunctions,
+    workflow: Workflow,
+    connectionType: NodeConnectionType,
+    itemIndex: number,
+    nodeTypeData: INodeType
+): Promise<unknown> {
+    const parentNode = this.getNode();
+
+    const nodeInputs = getNodeInputs(workflow, parentNode, nodeTypeData.description).map(
+        (input) => (typeof input === 'string' ? { type: input } : input),
+    ) as INodeInputConfiguration[];
+    const inputConfiguration = nodeInputs.find((input) => input.type === connectionType);
+    if (inputConfiguration === undefined) {
+        throw new NodeOperationError(
+            parentNode,
+            `Node does not have input of type`,
+            {
+                description: `Node ${parentNode.name} does not have input of type ${connectionType}`,
+            }
+        );
+    }
+
+    const connectedNodes = getConnectedNodes(workflow, parentNode, connectionType);
+    if (connectedNodes.length === 0) {
+        if (inputConfiguration.required) {
+            throw new NodeOperationError(
+                parentNode,
+                `A ${inputConfiguration?.displayName ?? connectionType} sub-node must be connected and enabled`,
+            );
+        }
+        return inputConfiguration.maxConnections === 1 ? undefined : [];
+    }
+
+    if (
+        inputConfiguration.maxConnections !== undefined &&
+        connectedNodes.length > inputConfiguration.maxConnections
+    ) {
+        throw new NodeOperationError(
+            parentNode,
+            `Only ${inputConfiguration.maxConnections} ${connectionType} sub-nodes are/is allowed to be connected`,
+        );
+    }
+
+    const nodes: SupplyData[] = [];
+    for (const connectedNode of connectedNodes) {
+        const connectedNodeType = workflow.nodeTypes.getByNameAndVersion(
+            connectedNode.type,
+            connectedNode.typeVersion,
+        );
+
+        if (!connectedNodeType) {
+            continue;
+        }
+
+        if (connectedNodeType && !connectedNodeType.supplyData) {
+            throw new NodeOperationError(connectedNode, 'Node does not have a `supplyData` method defined', {
+                itemIndex,
+            });
+        } else {
+            try {
+                const supplyData = await connectedNodeType.supplyData?.call(this, itemIndex);
+                if (supplyData) {
+                    nodes.push(supplyData);
+                }
+            } catch (error: any) {
+                throw new NodeOperationError(connectedNode, `Error in sub-node ${connectedNode.name}`, {
+                    itemIndex,
+                    description: error?.message ?? 'Unknown error',
+                });
+            }
+        }
+    }
+
+    return inputConfiguration.maxConnections === 1
+        ? (nodes || [])[0]?.response
+        : nodes.map((node) => node.response);
+}
+
+function getNodeInputs(
+    workflow: Workflow,
+    node: INode,
+    nodeTypeData: INodeTypeDescription,
+): Array<NodeConnectionType | INodeInputConfiguration> {
+    if (Array.isArray(nodeTypeData?.inputs)) {
+        return nodeTypeData.inputs as Array<NodeConnectionType | INodeInputConfiguration>;
+    }
+
+    // Calculate the outputs dynamically
+    try {
+        return (workflow.expression.getSimpleParameterValue(
+            node,
+            nodeTypeData.inputs,
+            'internal',
+            {},
+        ) || []) as NodeConnectionType[];
+    } catch (e) {
+        console.warn('Could not calculate inputs dynamically for node: ', node.name);
+        return [];
+    }
+}
+
+function getConnectedNodes(workflow: Workflow, node: INode, connectionType: NodeConnectionType) {
+    return workflow
+        .getParentNodes(node.name, connectionType, 1)
+        .map((nodeName) => workflow.getNode(nodeName))
+        .filter((node) => !!node)
+        .filter((node) => node.disabled !== true);
+}