@fsai-flow/core 0.0.5 → 0.1.1

package/dist/lib/UserSettings.js

@@ -0,0 +1,269 @@
+"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.prepareUserSettings = prepareUserSettings;
+exports.getEncryptionKey = getEncryptionKey;
+exports.getInstanceId = getInstanceId;
+exports.addToUserSettings = addToUserSettings;
+exports.writeUserSettings = writeUserSettings;
+exports.getUserSettings = getUserSettings;
+exports.getUserSettingsPath = getUserSettingsPath;
+exports.getUserN8nFolderPath = getUserN8nFolderPath;
+exports.getUserN8nFolderCustomExtensionPath = getUserN8nFolderCustomExtensionPath;
+exports.getUserHome = getUserHome;
+const node_crypto_1 = require("node:crypto");
+/* eslint-disable no-param-reassign */
+/* eslint-disable @typescript-eslint/no-use-before-define */
+/* eslint-disable @typescript-eslint/no-unsafe-call */
+/* eslint-disable @typescript-eslint/no-unsafe-assignment */
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const node_util_1 = require("node:util");
+// eslint-disable-next-line import/no-cycle
+const __1 = require("..");
+const fsAccess = (0, node_util_1.promisify)(fs.access);
+const fsReadFile = (0, node_util_1.promisify)(fs.readFile);
+const fsMkdir = (0, node_util_1.promisify)(fs.mkdir);
+const fsWriteFile = (0, node_util_1.promisify)(fs.writeFile);
+let settingsCache;
+/**
+ * Creates the user settings if they do not exist yet
+ *
+ * @export
+ */
+async function prepareUserSettings() {
+    const settingsPath = getUserSettingsPath();
+    let userSettings = await getUserSettings(settingsPath);
+    if (userSettings !== undefined) {
+        // Settings already exist, check if they contain the encryptionKey
+        if (userSettings.encryptionKey !== undefined) {
+            // Key already exists
+            if (userSettings.instanceId === undefined) {
+                userSettings.instanceId = await generateInstanceId(userSettings.encryptionKey);
+                settingsCache = userSettings;
+            }
+            return userSettings;
+        }
+    }
+    else {
+        userSettings = {};
+    }
+    if (process.env[__1.ENCRYPTION_KEY_ENV_OVERWRITE] !== undefined) {
+        // Use the encryption key which got set via environment
+        userSettings.encryptionKey = process.env[__1.ENCRYPTION_KEY_ENV_OVERWRITE];
+    }
+    else {
+        // Generate a new encryption key
+        userSettings.encryptionKey = (0, node_crypto_1.randomBytes)(24).toString("base64");
+    }
+    userSettings.instanceId = await generateInstanceId(userSettings.encryptionKey);
+    // eslint-disable-next-line no-console
+    console.log(`UserSettings were generated and saved to: ${settingsPath}`);
+    return writeUserSettings(userSettings, settingsPath);
+}
+/**
+ * Returns the encryption key which is used to encrypt
+ * the credentials.
+ *
+ * @export
+ * @returns
+ */
+async function getEncryptionKey() {
+    if (process.env[__1.ENCRYPTION_KEY_ENV_OVERWRITE] !== undefined) {
+        return process.env[__1.ENCRYPTION_KEY_ENV_OVERWRITE];
+    }
+    const userSettings = await getUserSettings();
+    if (userSettings === undefined) {
+        return undefined;
+    }
+    if (userSettings.encryptionKey === undefined) {
+        return undefined;
+    }
+    return userSettings.encryptionKey;
+}
+/**
+ * Returns the instance ID
+ *
+ * @export
+ * @returns
+ */
+async function getInstanceId() {
+    const userSettings = await getUserSettings();
+    if (userSettings === undefined) {
+        return "";
+    }
+    if (userSettings.instanceId === undefined) {
+        return "";
+    }
+    return userSettings.instanceId;
+}
+async function generateInstanceId(key) {
+    const hash = key
+        ? (0, node_crypto_1.createHash)("sha256")
+            .update(key.slice(Math.round(key.length / 2)))
+            .digest("hex")
+        : undefined;
+    return hash;
+}
+/**
+ * Adds/Overwrite the given settings in the currently
+ * saved user settings
+ *
+ * @export
+ * @param {IUserSettings} addSettings  The settings to add/overwrite
+ * @param {string} [settingsPath] Optional settings file path
+ * @returns {Promise<IUserSettings>}
+ */
+async function addToUserSettings(addSettings, settingsPath) {
+    const resolvedSettingsPath = settingsPath ?? getUserSettingsPath();
+    let userSettings = await getUserSettings(resolvedSettingsPath);
+    if (userSettings === undefined) {
+        userSettings = {};
+    }
+    // Add the settings
+    Object.assign(userSettings, addSettings);
+    return writeUserSettings(userSettings, resolvedSettingsPath);
+}
+/**
+ * Writes a user settings file
+ *
+ * @export
+ * @param {IUserSettings} userSettings The settings to write
+ * @param {string} [settingsPath] Optional settings file path
+ * @returns {Promise<IUserSettings>}
+ */
+async function writeUserSettings(userSettings, settingsPath) {
+    const resolvedSettingsPath = settingsPath ?? getUserSettingsPath();
+    const resolvedUserSettings = userSettings ?? {};
+    // Check if parent folder exists if not create it.
+    try {
+        await fsAccess(path.dirname(resolvedSettingsPath));
+    }
+    catch (_error) {
+        // Parent folder does not exist so create
+        await fsMkdir(path.dirname(resolvedSettingsPath));
+    }
+    const settingsToWrite = { ...resolvedUserSettings };
+    if (settingsToWrite.instanceId !== undefined) {
+        settingsToWrite.instanceId = undefined;
+    }
+    await fsWriteFile(resolvedSettingsPath, JSON.stringify(settingsToWrite, null, "\t"));
+    settingsCache = JSON.parse(JSON.stringify(resolvedUserSettings));
+    return resolvedUserSettings;
+}
+/**
+ * Returns the content of the user settings
+ *
+ * @export
+ * @returns {UserSettings}
+ */
+async function getUserSettings(settingsPath, ignoreCache) {
+    if (settingsCache !== undefined && ignoreCache !== true) {
+        return settingsCache;
+    }
+    const resolvedSettingsPath = settingsPath ?? getUserSettingsPath();
+    try {
+        await fsAccess(resolvedSettingsPath);
+    }
+    catch (_error) {
+        // The file does not exist
+        return undefined;
+    }
+    const settingsFile = await fsReadFile(resolvedSettingsPath, "utf8");
+    try {
+        settingsCache = JSON.parse(settingsFile);
+    }
+    catch (_error) {
+        throw new Error(`Error parsing n8n-config file "${resolvedSettingsPath}". It does not seem to be valid JSON.`);
+    }
+    return settingsCache;
+}
+/**
+ * Returns the path to the user settings
+ *
+ * @export
+ * @returns {string}
+ */
+function getUserSettingsPath() {
+    const n8nFolder = getUserN8nFolderPath();
+    return path.join(n8nFolder, __1.USER_SETTINGS_FILE_NAME);
+}
+/**
+ * Retruns the path to the n8n folder in which all n8n
+ * related data gets saved
+ *
+ * @export
+ * @returns {string}
+ */
+function getUserN8nFolderPath() {
+    let userFolder;
+    if (process.env[__1.USER_FOLDER_ENV_OVERWRITE] !== undefined) {
+        userFolder = process.env[__1.USER_FOLDER_ENV_OVERWRITE];
+    }
+    else {
+        userFolder = getUserHome();
+    }
+    return path.join(userFolder, __1.USER_SETTINGS_SUBFOLDER);
+}
+/**
+ * Returns the path to the n8n user folder with the custom
+ * extensions like nodes and credentials
+ *
+ * @export
+ * @returns {string}
+ */
+function getUserN8nFolderCustomExtensionPath() {
+    return path.join(getUserN8nFolderPath(), __1.EXTENSIONS_SUBDIRECTORY);
+}
+/**
+ * Returns the home folder path of the user if
+ * none can be found it falls back to the current
+ * working directory
+ *
+ * @export
+ * @returns {string}
+ */
+function getUserHome() {
+    let variableName = "HOME";
+    if (process.platform === "win32") {
+        variableName = "USERPROFILE";
+    }
+    if (process.env[variableName] === undefined) {
+        // If for some reason the variable does not exist
+        // fall back to current folder
+        return process.cwd();
+    }
+    return process.env[variableName];
+}

package/dist/lib/WorkflowExecute.d.ts

@@ -0,0 +1,53 @@
+import { type ExecutionError, type IConnection, type INode, type INodeExecutionData, type IRun, type IRunData, type IRunExecutionData, type IWorkflowExecuteAdditionalData, type Workflow, type WorkflowExecuteMode } from "@fsai-flow/workflow";
+import PCancelable from "p-cancelable";
+export declare class WorkflowExecute {
+    runExecutionData: IRunExecutionData;
+    private additionalData;
+    private mode;
+    constructor(additionalData: IWorkflowExecuteAdditionalData, mode: WorkflowExecuteMode, runExecutionData?: IRunExecutionData);
+    /**
+     * Executes the given workflow.
+     *
+     * @param {Workflow} workflow The workflow to execute
+     * @param {INode[]} [startNodes] Node to start execution from
+     * @param {string} [destinationNode] Node to stop execution at
+     * @returns {(Promise<string>)}
+     * @memberof WorkflowExecute
+     */
+    run(workflow: Workflow, startNode?: INode, destinationNode?: string): PCancelable<IRun>;
+    /**
+     * Executes the given workflow but only
+     *
+     * @param {Workflow} workflow The workflow to execute
+     * @param {IRunData} runData
+     * @param {string[]} startNodes Nodes to start execution from
+     * @param {string} destinationNode Node to stop execution at
+     * @returns {(Promise<string>)}
+     * @memberof WorkflowExecute
+     */
+    runPartialWorkflow(workflow: Workflow, runData: IRunData, startNodes: string[], destinationNode: string): PCancelable<IRun>;
+    /**
+     * Executes the hook with the given name
+     *
+     * @param {string} hookName
+     * @param {unknown[]} parameters
+     * @returns {Promise<IRun>}
+     * @memberof WorkflowExecute
+     */
+    executeHook(hookName: string, parameters: unknown[]): Promise<void>;
+    /**
+     * Checks the incoming connection does not receive any data
+     */
+    incomingConnectionIsEmpty(runData: IRunData, inputConnections: IConnection[], runIndex: number): boolean;
+    addNodeToBeExecuted(workflow: Workflow, connectionData: IConnection, outputIndex: number, parentNodeName: string, nodeSuccessData: INodeExecutionData[][], runIndex: number): void;
+    /**
+     * Runs the given execution data.
+     *
+     * @param {Workflow} workflow
+     * @returns {Promise<string>}
+     * @memberof WorkflowExecute
+     */
+    processRunExecutionData(workflow: Workflow): PCancelable<IRun>;
+    processSuccessExecution(startedAt: Date, workflow: Workflow, executionError?: ExecutionError): Promise<IRun>;
+    getFullRunData(startedAt: Date): IRun;
+}