@fsai-flow/core 0.0.5 → 0.1.1

package/dist/lib/BinaryDataManager/index.d.ts

@@ -0,0 +1,21 @@
+import type { IBinaryData, INodeExecutionData } from "@fsai-flow/workflow";
+import type { IBinaryDataConfig } from "../Interfaces";
+export declare class BinaryDataManager {
+    private static instance;
+    private managers;
+    private binaryDataMode;
+    private availableModes;
+    constructor(config: IBinaryDataConfig);
+    static init(config: IBinaryDataConfig, mainManager?: boolean): Promise<void>;
+    static getInstance(): BinaryDataManager;
+    storeBinaryData(binaryData: IBinaryData, binaryBuffer: Buffer, executionId: string): Promise<IBinaryData>;
+    retrieveBinaryData(binaryData: IBinaryData): Promise<Buffer>;
+    retrieveBinaryDataByIdentifier(identifier: string): Promise<Buffer>;
+    markDataForDeletionByExecutionId(executionId: string): Promise<void>;
+    persistBinaryDataForExecutionId(executionId: string): Promise<void>;
+    deleteBinaryDataByExecutionId(executionId: string): Promise<void>;
+    duplicateBinaryData(inputData: Array<INodeExecutionData[] | null> | unknown, executionId: string): Promise<INodeExecutionData[][]>;
+    private generateBinaryId;
+    private splitBinaryModeFileId;
+    private duplicateBinaryDataInExecData;
+}

package/dist/lib/BinaryDataManager/index.js

@@ -0,0 +1,129 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BinaryDataManager = void 0;
+const Constants_1 = require("../Constants");
+const FileSystem_1 = require("./FileSystem");
+class BinaryDataManager {
+    constructor(config) {
+        this.binaryDataMode = config.mode;
+        this.availableModes = config.availableModes.split(",");
+        this.managers = {};
+    }
+    static async init(config, mainManager = false) {
+        if (BinaryDataManager.instance) {
+            throw new Error("Binary Data Manager already initialized");
+        }
+        BinaryDataManager.instance = new BinaryDataManager(config);
+        if (BinaryDataManager.instance.availableModes.includes("filesystem")) {
+            BinaryDataManager.instance.managers["filesystem"] =
+                new FileSystem_1.BinaryDataFileSystem(config);
+            await BinaryDataManager.instance.managers["filesystem"].init(mainManager);
+        }
+        return undefined;
+    }
+    static getInstance() {
+        if (!BinaryDataManager.instance) {
+            throw new Error("Binary Data Manager not initialized");
+        }
+        return BinaryDataManager.instance;
+    }
+    async storeBinaryData(binaryData, binaryBuffer, executionId) {
+        const retBinaryData = binaryData;
+        if (this.managers[this.binaryDataMode]) {
+            return this.managers[this.binaryDataMode]
+                .storeBinaryData(binaryBuffer, executionId)
+                .then((filename) => {
+                retBinaryData.id = this.generateBinaryId(filename);
+                return retBinaryData;
+            });
+        }
+        retBinaryData.data = binaryBuffer.toString(Constants_1.BINARY_ENCODING);
+        return binaryData;
+    }
+    async retrieveBinaryData(binaryData) {
+        if (binaryData.id) {
+            return this.retrieveBinaryDataByIdentifier(binaryData.id);
+        }
+        return Buffer.from(binaryData.data, Constants_1.BINARY_ENCODING);
+    }
+    async retrieveBinaryDataByIdentifier(identifier) {
+        const { mode, id } = this.splitBinaryModeFileId(identifier);
+        if (this.managers[mode]) {
+            return this.managers[mode].retrieveBinaryDataByIdentifier(id);
+        }
+        throw new Error("Storage mode used to store binary data not available");
+    }
+    async markDataForDeletionByExecutionId(executionId) {
+        if (this.managers[this.binaryDataMode]) {
+            return this.managers[this.binaryDataMode].markDataForDeletionByExecutionId(executionId);
+        }
+        return Promise.resolve();
+    }
+    async persistBinaryDataForExecutionId(executionId) {
+        if (this.managers[this.binaryDataMode]) {
+            return this.managers[this.binaryDataMode].persistBinaryDataForExecutionId(executionId);
+        }
+        return Promise.resolve();
+    }
+    async deleteBinaryDataByExecutionId(executionId) {
+        if (this.managers[this.binaryDataMode]) {
+            return this.managers[this.binaryDataMode].deleteBinaryDataByExecutionId(executionId);
+        }
+        return Promise.resolve();
+    }
+    async duplicateBinaryData(inputData, executionId) {
+        if (inputData && this.managers[this.binaryDataMode]) {
+            const returnInputData = inputData.map(async (executionDataArray) => {
+                if (executionDataArray) {
+                    return Promise.all(executionDataArray.map((executionData) => {
+                        if (executionData.binary) {
+                            return this.duplicateBinaryDataInExecData(executionData, executionId);
+                        }
+                        return executionData;
+                    }));
+                }
+                return executionDataArray;
+            });
+            return Promise.all(returnInputData);
+        }
+        return Promise.resolve(inputData);
+    }
+    generateBinaryId(filename) {
+        return `${this.binaryDataMode}:${filename}`;
+    }
+    splitBinaryModeFileId(fileId) {
+        const [mode, id] = fileId.split(":");
+        return { mode, id };
+    }
+    async duplicateBinaryDataInExecData(executionData, executionId) {
+        const binaryManager = this.managers[this.binaryDataMode];
+        if (executionData.binary) {
+            const binaryDataKeys = Object.keys(executionData.binary);
+            const bdPromises = binaryDataKeys.map(async (key) => {
+                if (!executionData.binary) {
+                    return { key, newId: undefined };
+                }
+                const binaryDataId = executionData.binary[key].id;
+                if (!binaryDataId) {
+                    return { key, newId: undefined };
+                }
+                return binaryManager
+                    ?.duplicateBinaryDataByIdentifier(this.splitBinaryModeFileId(binaryDataId).id, executionId)
+                    .then((filename) => ({
+                    newId: this.generateBinaryId(filename),
+                    key,
+                }));
+            });
+            return Promise.all(bdPromises).then((b) => {
+                return b.reduce((acc, curr) => {
+                    if (acc.binary && curr) {
+                        acc.binary[curr.key].id = curr.newId;
+                    }
+                    return acc;
+                }, executionData);
+            });
+        }
+        return executionData;
+    }
+}
+exports.BinaryDataManager = BinaryDataManager;

package/dist/lib/ChangeCase.d.ts

@@ -0,0 +1,9 @@
+export declare class ChangeCase {
+    private static transformInput;
+    static toCamelCase(str: string): string;
+    static toPascalCase(str: string): string;
+    static toSnakeCase(str: string): string;
+    static toCapitalCase(str: string): string;
+    static toParamCase(str: string): string;
+    static noCase(str: string): string;
+}

package/dist/lib/ChangeCase.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChangeCase = void 0;
+// biome-ignore lint/complexity/noStaticOnlyClass: Exported as a utility namespace
+class ChangeCase {
+    static transformInput(input) {
+        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) {
+        const words = ChangeCase.transformInput(str);
+        return words[0].toLowerCase() + words.slice(1).join("");
+    }
+    static toPascalCase(str) {
+        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) {
+        return str
+            .replace(/([a-z])([A-Z])/g, "$1_$2")
+            .replace(/[\W_]+/g, "_")
+            .toLowerCase();
+    }
+    static toCapitalCase(str) {
+        return str.replace(/\b\w/g, (chr) => chr.toUpperCase());
+    }
+    static toParamCase(str) {
+        return str
+            .replace(/([a-z])([A-Z])/g, "$1-$2")
+            .replace(/[\W_]+/g, "-")
+            .toLowerCase();
+    }
+    static noCase(str) {
+        return str.replace(/[^\w\s]/g, "").toLowerCase();
+    }
+}
+exports.ChangeCase = ChangeCase;

package/dist/lib/Constants.d.ts

@@ -0,0 +1,14 @@
+export declare const inProduction: boolean;
+export declare const inDevelopment: boolean;
+export declare const inTest: boolean;
+export declare const BINARY_ENCODING = "base64";
+export declare const CUSTOM_EXTENSION_ENV = "N8N_CUSTOM_EXTENSIONS";
+export declare const ENCRYPTION_KEY_ENV_OVERWRITE = "FSAI_FLOW_ENCRYPTION_KEY";
+export declare const EXTENSIONS_SUBDIRECTORY = "custom";
+export declare const USER_FOLDER_ENV_OVERWRITE = "N8N_USER_FOLDER";
+export declare const USER_SETTINGS_FILE_NAME = "config";
+export declare const USER_SETTINGS_SUBFOLDER = ".n8n";
+export declare const PLACEHOLDER_EMPTY_EXECUTION_ID = "__UNKOWN__";
+export declare const PLACEHOLDER_EMPTY_WORKFLOW_ID = "__EMPTY__";
+export declare const TUNNEL_SUBDOMAIN_ENV = "N8N_TUNNEL_SUBDOMAIN";
+export declare const WAIT_TIME_UNLIMITED = "3000-01-01T00:00:00.000Z";

package/dist/lib/Constants.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WAIT_TIME_UNLIMITED = exports.TUNNEL_SUBDOMAIN_ENV = exports.PLACEHOLDER_EMPTY_WORKFLOW_ID = exports.PLACEHOLDER_EMPTY_EXECUTION_ID = exports.USER_SETTINGS_SUBFOLDER = exports.USER_SETTINGS_FILE_NAME = exports.USER_FOLDER_ENV_OVERWRITE = exports.EXTENSIONS_SUBDIRECTORY = exports.ENCRYPTION_KEY_ENV_OVERWRITE = exports.CUSTOM_EXTENSION_ENV = exports.BINARY_ENCODING = exports.inTest = exports.inDevelopment = exports.inProduction = void 0;
+const { NODE_ENV } = process.env;
+exports.inProduction = NODE_ENV === "production";
+exports.inDevelopment = !NODE_ENV || NODE_ENV === "development";
+exports.inTest = NODE_ENV === "test";
+exports.BINARY_ENCODING = "base64";
+exports.CUSTOM_EXTENSION_ENV = "N8N_CUSTOM_EXTENSIONS";
+exports.ENCRYPTION_KEY_ENV_OVERWRITE = "FSAI_FLOW_ENCRYPTION_KEY";
+exports.EXTENSIONS_SUBDIRECTORY = "custom";
+exports.USER_FOLDER_ENV_OVERWRITE = "N8N_USER_FOLDER";
+exports.USER_SETTINGS_FILE_NAME = "config";
+exports.USER_SETTINGS_SUBFOLDER = ".n8n";
+exports.PLACEHOLDER_EMPTY_EXECUTION_ID = "__UNKOWN__";
+exports.PLACEHOLDER_EMPTY_WORKFLOW_ID = "__EMPTY__";
+exports.TUNNEL_SUBDOMAIN_ENV = "N8N_TUNNEL_SUBDOMAIN";
+exports.WAIT_TIME_UNLIMITED = "3000-01-01T00:00:00.000Z";

package/dist/lib/Credentials.d.ts

@@ -0,0 +1,27 @@
+import { type CredentialInformation, type ICredentialDataDecryptedObject, ICredentials, type ICredentialsEncrypted } from "@fsai-flow/workflow";
+export declare class Credentials extends ICredentials {
+    /**
+     * Returns if the given nodeType has access to data
+     */
+    hasNodeAccess(nodeType: string): boolean;
+    /**
+     * Sets new credential object
+     */
+    setData(data: ICredentialDataDecryptedObject, encryptionKey: string): void;
+    /**
+     * Sets new credentials for given key
+     */
+    setDataKey(key: string, data: CredentialInformation, encryptionKey: string): void;
+    /**
+     * Returns the decrypted credential object
+     */
+    getData(encryptionKey: string, nodeType?: string): ICredentialDataDecryptedObject;
+    /**
+     * Returns the decrypted credentials for given key
+     */
+    getDataKey(key: string, encryptionKey: string, nodeType?: string): CredentialInformation;
+    /**
+     * Returns the encrypted credentials to be saved
+     */
+    getDataToSave(): ICredentialsEncrypted;
+}

package/dist/lib/Credentials.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Credentials = void 0;
+const workflow_1 = require("@fsai-flow/workflow");
+const crypto_js_1 = require("crypto-js");
+class Credentials extends workflow_1.ICredentials {
+    /**
+     * Returns if the given nodeType has access to data
+     */
+    hasNodeAccess(nodeType) {
+        // 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, encryptionKey) {
+        this.data = crypto_js_1.AES.encrypt(JSON.stringify(data), encryptionKey).toString();
+    }
+    /**
+     * Sets new credentials for given key
+     */
+    setDataKey(key, data, encryptionKey) {
+        let fullData;
+        try {
+            fullData = this.getData(encryptionKey);
+        }
+        catch (_e) {
+            fullData = {};
+        }
+        fullData[key] = data;
+        this.setData(fullData, encryptionKey);
+    }
+    /**
+     * Returns the decrypted credential object
+     */
+    getData(encryptionKey, nodeType) {
+        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 = crypto_js_1.AES.decrypt(this.data, encryptionKey);
+        try {
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+            return JSON.parse(decryptedData.toString(crypto_js_1.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, encryptionKey, nodeType) {
+        const fullData = this.getData(encryptionKey, nodeType);
+        if (fullData === null) {
+            throw new Error("No data was set.");
+        }
+        // eslint-disable-next-line no-prototype-builtins
+        if (!Object.hasOwn(fullData, key)) {
+            throw new Error(`No data for key "${key}" exists.`);
+        }
+        return fullData[key];
+    }
+    /**
+     * Returns the encrypted credentials to be saved
+     */
+    getDataToSave() {
+        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,
+        };
+    }
+}
+exports.Credentials = Credentials;

package/dist/lib/FileSystem.d.ts

@@ -0,0 +1,26 @@
+import type { IBinaryDataConfig, IBinaryDataManager } from "./Interfaces";
+export declare class BinaryDataFileSystem implements IBinaryDataManager {
+    private storagePath;
+    private binaryDataTTL;
+    private persistedBinaryDataTTL;
+    constructor(config: IBinaryDataConfig);
+    init(startPurger?: boolean): Promise<void>;
+    storeBinaryData(binaryBuffer: Buffer, executionId: string): Promise<string>;
+    retrieveBinaryDataByIdentifier(identifier: string): Promise<Buffer>;
+    markDataForDeletionByExecutionId(executionId: string): Promise<void>;
+    deleteMarkedFiles(): Promise<void>;
+    deleteMarkedPersistedFiles(): Promise<void>;
+    private addBinaryIdToPersistMeta;
+    private deleteMarkedFilesByMeta;
+    duplicateBinaryDataByIdentifier(binaryDataId: string, prefix: string): Promise<string>;
+    deleteBinaryDataByExecutionId(executionId: string): Promise<void>;
+    deleteBinaryDataByIdentifier(identifier: string): Promise<void>;
+    persistBinaryDataForExecutionId(executionId: string): Promise<void>;
+    private generateFileName;
+    private getBinaryDataMetaPath;
+    private getBinaryDataPersistMetaPath;
+    private deleteMetaFileByPath;
+    private deleteFromLocalStorage;
+    private saveToLocalStorage;
+    private retrieveFromLocalStorage;
+}

package/dist/lib/FileSystem.js

@@ -0,0 +1,180 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BinaryDataFileSystem = void 0;
+const node_fs_1 = require("node:fs");
+const path = __importStar(require("node:path"));
+const uuid_1 = require("uuid");
+const PREFIX_METAFILE = "binarymeta";
+const PREFIX_PERSISTED_METAFILE = "persistedmeta";
+class BinaryDataFileSystem {
+    constructor(config) {
+        this.storagePath = config.localStoragePath;
+        this.binaryDataTTL = config.binaryDataTTL;
+        this.persistedBinaryDataTTL = config.persistedBinaryDataTTL;
+    }
+    async init(startPurger = false) {
+        if (startPurger) {
+            setInterval(async () => {
+                await this.deleteMarkedFiles();
+            }, this.binaryDataTTL * 30000);
+            setInterval(async () => {
+                await this.deleteMarkedPersistedFiles();
+            }, this.persistedBinaryDataTTL * 30000);
+        }
+        return node_fs_1.promises
+            .readdir(this.storagePath)
+            .catch(async () => node_fs_1.promises.mkdir(this.storagePath, { recursive: true }))
+            .then(async () => node_fs_1.promises.readdir(this.getBinaryDataMetaPath()))
+            .catch(async () => node_fs_1.promises.mkdir(this.getBinaryDataMetaPath(), { recursive: true }))
+            .then(async () => node_fs_1.promises.readdir(this.getBinaryDataPersistMetaPath()))
+            .catch(async () => node_fs_1.promises.mkdir(this.getBinaryDataPersistMetaPath(), { recursive: true }))
+            .then(async () => this.deleteMarkedFiles())
+            .then(async () => this.deleteMarkedPersistedFiles())
+            .then(() => { });
+    }
+    async storeBinaryData(binaryBuffer, executionId) {
+        const binaryDataId = this.generateFileName(executionId);
+        return this.addBinaryIdToPersistMeta(executionId, binaryDataId).then(async () => this.saveToLocalStorage(binaryBuffer, binaryDataId).then(() => binaryDataId));
+    }
+    async retrieveBinaryDataByIdentifier(identifier) {
+        return this.retrieveFromLocalStorage(identifier);
+    }
+    async markDataForDeletionByExecutionId(executionId) {
+        const tt = new Date(Date.now() + this.binaryDataTTL * 60000);
+        return node_fs_1.promises.writeFile(path.join(this.getBinaryDataMetaPath(), `${PREFIX_METAFILE}_${executionId}_${tt.valueOf()}`), "");
+    }
+    async deleteMarkedFiles() {
+        return this.deleteMarkedFilesByMeta(this.getBinaryDataMetaPath(), PREFIX_METAFILE);
+    }
+    async deleteMarkedPersistedFiles() {
+        return this.deleteMarkedFilesByMeta(this.getBinaryDataPersistMetaPath(), PREFIX_PERSISTED_METAFILE);
+    }
+    async addBinaryIdToPersistMeta(executionId, identifier) {
+        const currentTime = Date.now();
+        const timeAtNextHour = currentTime + 3600000 - (currentTime % 3600000);
+        const timeoutTime = timeAtNextHour + this.persistedBinaryDataTTL * 60000;
+        const filePath = path.join(this.getBinaryDataPersistMetaPath(), `${PREFIX_PERSISTED_METAFILE}_${executionId}_${timeoutTime}`);
+        return node_fs_1.promises
+            .readFile(filePath)
+            .catch(async () => node_fs_1.promises.writeFile(filePath, identifier))
+            .then(() => { });
+    }
+    async deleteMarkedFilesByMeta(metaPath, filePrefix) {
+        const currentTimeValue = Date.now();
+        const metaFileNames = await node_fs_1.promises.readdir(metaPath);
+        const execsAdded = {};
+        const proms = metaFileNames.reduce((prev, curr) => {
+            const [prefix, executionId, ts] = curr.split("_");
+            if (prefix !== filePrefix) {
+                return prev;
+            }
+            const execTimestamp = Number.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, prefix) {
+        const newBinaryDataId = this.generateFileName(prefix);
+        return node_fs_1.promises
+            .copyFile(path.join(this.storagePath, binaryDataId), path.join(this.storagePath, newBinaryDataId))
+            .then(() => newBinaryDataId);
+    }
+    async deleteBinaryDataByExecutionId(executionId) {
+        const regex = new RegExp(`${executionId}_*`);
+        const filenames = await node_fs_1.promises.readdir(path.join(this.storagePath));
+        const proms = filenames.reduce((allProms, filename) => {
+            if (regex.test(filename)) {
+                allProms.push(node_fs_1.promises.rm(path.join(this.storagePath, filename)));
+            }
+            return allProms;
+        }, [Promise.resolve()]);
+        return Promise.all(proms).then(async () => Promise.resolve());
+    }
+    async deleteBinaryDataByIdentifier(identifier) {
+        return this.deleteFromLocalStorage(identifier);
+    }
+    async persistBinaryDataForExecutionId(executionId) {
+        return node_fs_1.promises
+            .readdir(this.getBinaryDataPersistMetaPath())
+            .then(async (metafiles) => {
+            const proms = metafiles.reduce((prev, curr) => {
+                if (curr.startsWith(`${PREFIX_PERSISTED_METAFILE}_${executionId}_`)) {
+                    prev.push(node_fs_1.promises.rm(path.join(this.getBinaryDataPersistMetaPath(), curr)));
+                    return prev;
+                }
+                return prev;
+            }, [Promise.resolve()]);
+            return Promise.all(proms).then(() => { });
+        });
+    }
+    generateFileName(prefix) {
+        return `${prefix}_${(0, uuid_1.v4)()}`;
+    }
+    getBinaryDataMetaPath() {
+        return path.join(this.storagePath, "meta");
+    }
+    getBinaryDataPersistMetaPath() {
+        return path.join(this.storagePath, "persistMeta");
+    }
+    async deleteMetaFileByPath(metafilePath) {
+        return node_fs_1.promises.rm(metafilePath);
+    }
+    async deleteFromLocalStorage(identifier) {
+        return node_fs_1.promises.rm(path.join(this.storagePath, identifier));
+    }
+    async saveToLocalStorage(data, identifier) {
+        await node_fs_1.promises.writeFile(path.join(this.storagePath, identifier), data);
+    }
+    async retrieveFromLocalStorage(identifier) {
+        const filePath = path.join(this.storagePath, identifier);
+        try {
+            return await node_fs_1.promises.readFile(filePath);
+        }
+        catch (_e) {
+            throw new Error(`Error finding file: ${filePath}`);
+        }
+    }
+}
+exports.BinaryDataFileSystem = BinaryDataFileSystem;

package/dist/lib/InputConnectionDataLegacy.d.ts

@@ -0,0 +1,2 @@
+import { type INodeType, type ISupplyDataFunctions, type IWebhookFunctions, type NodeConnectionType, type Workflow } from "@fsai-flow/workflow";
+export declare function getInputConnectionDataLegacy(this: ISupplyDataFunctions | IWebhookFunctions, workflow: Workflow, connectionType: NodeConnectionType, itemIndex: number, nodeTypeData: INodeType): Promise<unknown>;

package/dist/lib/InputConnectionDataLegacy.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getInputConnectionDataLegacy = getInputConnectionDataLegacy;
+const workflow_1 = require("@fsai-flow/workflow");
+async function getInputConnectionDataLegacy(workflow, connectionType, itemIndex, nodeTypeData) {
+    const parentNode = this.getNode();
+    const nodeInputs = getNodeInputs(workflow, parentNode, nodeTypeData.description).map((input) => typeof input === "string" ? { type: input } : input);
+    const inputConfiguration = nodeInputs.find((input) => input.type === connectionType);
+    if (inputConfiguration === undefined) {
+        throw new workflow_1.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 workflow_1.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 workflow_1.NodeOperationError(parentNode, `Only ${inputConfiguration.maxConnections} ${connectionType} sub-nodes are/is allowed to be connected`);
+    }
+    const nodes = [];
+    for (const connectedNode of connectedNodes) {
+        const connectedNodeType = workflow.nodeTypes.getByNameAndVersion(connectedNode.type, connectedNode.typeVersion);
+        if (!connectedNodeType) {
+            continue;
+        }
+        if (connectedNodeType && !connectedNodeType.supplyData) {
+            throw new workflow_1.NodeOperationError(connectedNode, "Node does not have a `supplyData` method defined", {
+                itemIndex,
+            });
+        }
+        try {
+            const supplyData = await connectedNodeType.supplyData?.call(this, itemIndex);
+            if (supplyData) {
+                nodes.push(supplyData);
+            }
+        }
+        catch (error) {
+            throw new workflow_1.NodeOperationError(connectedNode, `Error in sub-node ${connectedNode.name}`, {
+                itemIndex,
+                description: error instanceof Error ? error.message : "Unknown error",
+            });
+        }
+    }
+    return inputConfiguration.maxConnections === 1
+        ? (nodes || [])[0]?.response
+        : nodes.map((node) => node.response);
+}
+function getNodeInputs(workflow, node, nodeTypeData) {
+    if (Array.isArray(nodeTypeData?.inputs)) {
+        return nodeTypeData.inputs;
+    }
+    // Calculate the outputs dynamically
+    try {
+        return (workflow.expression.getSimpleParameterValue(node, nodeTypeData.inputs, "internal", {}) || []);
+    }
+    catch (_e) {
+        console.warn("Could not calculate inputs dynamically for node: ", node.name);
+        return [];
+    }
+}
+function getConnectedNodes(workflow, node, connectionType) {
+    return workflow
+        .getParentNodes(node.name, connectionType, 1)
+        .map((nodeName) => workflow.getNode(nodeName))
+        .filter((node) => !!node)
+        .filter((node) => node !== null && node.disabled !== true);
+}