@fsai-flow/core 0.0.5 → 0.1.1

package/dist/lib/NodesLoader/load-class-in-isolation.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadClassInIsolation = void 0;
+const node_vm_1 = require("node:vm");
+const Constants_1 = require("../Constants");
+const context = (0, node_vm_1.createContext)({ require });
+const loadClassInIsolation = (filePath, className) => {
+    const normalizedPath = process.platform === "win32" ? filePath.replace(/\\/g, "/") : filePath;
+    // Note: Skip the isolation because it breaks nock mocks in tests
+    if (Constants_1.inTest) {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-call, @typescript-eslint/no-var-requires, @typescript-eslint/no-unsafe-member-access
+        return new (require(normalizedPath)[className])();
+    }
+    const script = new node_vm_1.Script(`new (require('${normalizedPath}').${className})()`);
+    return script.runInContext(context);
+};
+exports.loadClassInIsolation = loadClassInIsolation;

package/dist/lib/NodesLoader/package-directory-loader.d.ts

@@ -0,0 +1,17 @@
+import { DirectoryLoader } from "./directory-loader";
+import type { n8n } from "./types";
+/**
+ * Loader for source files of nodes and credentials located in a package dir,
+ * e.g. /nodes-base or community packages.
+ */
+export declare class PackageDirectoryLoader extends DirectoryLoader {
+    packageJson: n8n.PackageJson;
+    packageName: string;
+    constructor(directory: string, excludeNodes?: string[], includeNodes?: string[]);
+    private extractNodeTypes;
+    loadAll(): Promise<void>;
+    private inferSupportedNodes;
+    private parseJSON;
+    protected readJSONSync<T>(file: string): T;
+    protected readJSON<T>(file: string): Promise<T>;
+}

package/dist/lib/NodesLoader/package-directory-loader.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PackageDirectoryLoader = void 0;
+const node_fs_1 = require("node:fs");
+const promises_1 = require("node:fs/promises");
+const workflow_1 = require("@fsai-flow/workflow");
+const directory_loader_1 = require("./directory-loader");
+/**
+ * Loader for source files of nodes and credentials located in a package dir,
+ * e.g. /nodes-base or community packages.
+ */
+class PackageDirectoryLoader extends directory_loader_1.DirectoryLoader {
+    constructor(directory, excludeNodes = [], includeNodes = []) {
+        super(directory, excludeNodes, includeNodes);
+        this.packageJson = this.readJSONSync("package.json");
+        this.packageName = this.packageJson.name;
+        this.excludeNodes = this.extractNodeTypes(excludeNodes);
+        this.includeNodes = this.extractNodeTypes(includeNodes);
+    }
+    extractNodeTypes(fullNodeTypes) {
+        return fullNodeTypes
+            .map((fullNodeType) => fullNodeType.split("."))
+            .filter(([packageName]) => packageName === this.packageName)
+            .map(([_, nodeType]) => nodeType);
+    }
+    async loadAll() {
+        const { n8n } = this.packageJson;
+        if (!n8n)
+            return;
+        const { nodes, credentials } = n8n;
+        if (Array.isArray(nodes)) {
+            for (const nodePath of nodes) {
+                this.loadNodeFromFile(nodePath);
+            }
+        }
+        if (Array.isArray(credentials)) {
+            for (const credentialPath of credentials) {
+                this.loadCredentialFromFile(credentialPath);
+            }
+        }
+        this.inferSupportedNodes();
+        console.debug(`Loaded all credentials and nodes from ${this.packageName}`, {
+            credentials: credentials?.length ?? 0,
+            nodes: nodes?.length ?? 0,
+        });
+    }
+    inferSupportedNodes() {
+        const knownCredentials = this.known.credentials;
+        for (const { type: credentialType } of Object.values(this.credentialTypes)) {
+            const supportedNodes = knownCredentials[credentialType.name].supportedNodes ?? [];
+            if (supportedNodes.length > 0 && credentialType.httpRequestNode) {
+                credentialType.httpRequestNode.hidden = true;
+            }
+            credentialType.supportedNodes = supportedNodes;
+            if (!credentialType.iconUrl && !credentialType.icon) {
+                for (const supportedNode of supportedNodes) {
+                    const nodeDescription = this.nodeTypes[supportedNode]?.type.description;
+                    if (!nodeDescription)
+                        continue;
+                    if (nodeDescription.icon) {
+                        credentialType.icon = nodeDescription.icon;
+                        credentialType.iconColor = nodeDescription.iconColor;
+                        break;
+                    }
+                    if (nodeDescription.iconUrl) {
+                        credentialType.iconUrl = nodeDescription.iconUrl;
+                        break;
+                    }
+                }
+            }
+        }
+    }
+    parseJSON(fileString, filePath) {
+        try {
+            return (0, workflow_1.jsonParse)(fileString);
+        }
+        catch (_error) {
+            throw new Error(`Failed to parse JSON, ${filePath}`);
+        }
+    }
+    readJSONSync(file) {
+        const filePath = this.resolvePath(file);
+        const fileString = (0, node_fs_1.readFileSync)(filePath, "utf8");
+        return this.parseJSON(fileString, filePath);
+    }
+    async readJSON(file) {
+        const filePath = this.resolvePath(file);
+        const fileString = await (0, promises_1.readFile)(filePath, "utf8");
+        return this.parseJSON(fileString, filePath);
+    }
+}
+exports.PackageDirectoryLoader = PackageDirectoryLoader;

package/dist/lib/NodesLoader/types.d.ts

@@ -0,0 +1,14 @@
+export declare namespace n8n {
+    interface PackageJson {
+        name: string;
+        version: string;
+        n8n?: {
+            credentials?: string[];
+            nodes?: string[];
+        };
+        author?: {
+            name?: string;
+            email?: string;
+        };
+    }
+}

package/dist/lib/NodesLoader/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/lib/RedisLeaderElectionManager.d.ts

@@ -0,0 +1,53 @@
+import { type RedisOptions } from "ioredis";
+export interface RedisLeaderElectionCallbacks {
+    onStartedLeading: () => void;
+    onStoppedLeading: () => void;
+    onNewLeader?: (identity: string) => void;
+}
+export declare class RedisLeaderElectionManager {
+    private redis;
+    private isLeader;
+    private lockKey;
+    private nodeId;
+    private lockTTL;
+    private renewalInterval;
+    private renewalTimer?;
+    private callbacks;
+    constructor(lockKey: string, redisConfig: string | RedisOptions, callbacks: RedisLeaderElectionCallbacks);
+    /**
+     * Wait for Redis connection to be ready
+     */
+    private waitForRedisConnection;
+    /**
+     * Start the leader election process
+     */
+    start(): Promise<void>;
+    /**
+     * Stop the leader election process
+     */
+    stop(): Promise<void>;
+    /**
+     * Check if this node is currently the leader
+     */
+    getIsLeader(): boolean;
+    /**
+     * Try to acquire leadership
+     */
+    private tryAcquireLeadership;
+    /**
+     * Renew the leadership lock
+     */
+    private renewLock;
+    /**
+     * Release the leadership lock
+     */
+    private releaseLock;
+    /**
+     * Start the renewal/retry loop
+     */
+    private startRenewalLoop;
+    /**
+     * Generate a unique node identifier
+     */
+    private generateNodeId;
+}

package/dist/lib/RedisLeaderElectionManager.js

@@ -0,0 +1,279 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RedisLeaderElectionManager = void 0;
+const workflow_1 = require("@fsai-flow/workflow");
+const ioredis_1 = __importDefault(require("ioredis"));
+class RedisLeaderElectionManager {
+    constructor(lockKey, redisConfig, callbacks) {
+        this.isLeader = false;
+        this.lockTTL = 30000; // 30 seconds in milliseconds
+        this.renewalInterval = 10000; // 10 seconds in milliseconds
+        this.lockKey = `leader:${lockKey}`;
+        this.nodeId = this.generateNodeId();
+        this.callbacks = callbacks;
+        // Initialize Redis connection
+        if (typeof redisConfig === "string") {
+            this.redis = new ioredis_1.default(redisConfig);
+        }
+        else {
+            this.redis = new ioredis_1.default(redisConfig);
+        }
+        // Handle Redis connection events
+        this.redis.on("connect", () => {
+            workflow_1.LoggerProxy.info(`Redis connected for leader election: ${this.lockKey}`);
+        });
+        this.redis.on("ready", () => {
+            workflow_1.LoggerProxy.info(`Redis ready for leader election: ${this.lockKey}`);
+        });
+        this.redis.on("error", (error) => {
+            workflow_1.LoggerProxy.error(`Redis connection error for leader election: ${error instanceof Error ? error.message : String(error)}`);
+        });
+    }
+    /**
+     * Wait for Redis connection to be ready
+     */
+    async waitForRedisConnection() {
+        return new Promise((resolve, reject) => {
+            if (this.redis.status === "ready") {
+                workflow_1.LoggerProxy.debug(`Redis already ready for ${this.lockKey}`);
+                resolve();
+                return;
+            }
+            let isSettled = false;
+            let timeoutId = null;
+            // Cleanup function to prevent memory leaks
+            const cleanup = () => {
+                if (isSettled)
+                    return; // Already cleaned up
+                isSettled = true;
+                // Clear timeout safely
+                if (timeoutId !== null) {
+                    clearTimeout(timeoutId);
+                    timeoutId = null;
+                }
+                // Remove event listeners safely
+                try {
+                    this.redis.off("ready", onReady);
+                    this.redis.off("error", onError);
+                }
+                catch (error) {
+                    // Ignore cleanup errors - Redis connection might be destroyed
+                    workflow_1.LoggerProxy.debug(`Cleanup warning for ${this.lockKey}: ${error}`);
+                }
+            };
+            const onReady = () => {
+                cleanup();
+                workflow_1.LoggerProxy.debug(`Redis connection established for ${this.lockKey}`);
+                resolve();
+            };
+            const onError = (error) => {
+                cleanup();
+                workflow_1.LoggerProxy.error(`Redis connection failed for ${this.lockKey}: ${error.message}`);
+                reject(error);
+            };
+            const onTimeout = () => {
+                cleanup();
+                reject(new Error(`Redis connection timeout after 10 seconds for ${this.lockKey}`));
+            };
+            // Set up timeout
+            timeoutId = setTimeout(onTimeout, 10000); // 10 second timeout
+            // Set up event listeners
+            this.redis.once("ready", onReady);
+            this.redis.once("error", onError);
+        });
+    }
+    /**
+     * Start the leader election process
+     */
+    async start() {
+        workflow_1.LoggerProxy.info(`🚀 Starting Redis leader election for ${this.nodeId} on key ${this.lockKey}`);
+        workflow_1.LoggerProxy.info(`🔧 Leader election config: TTL=${this.lockTTL}ms, RenewalInterval=${this.renewalInterval}ms`);
+        // Wait for Redis connection to be ready
+        workflow_1.LoggerProxy.info(`⏳ ${this.nodeId} waiting for Redis connection...`);
+        await this.waitForRedisConnection();
+        workflow_1.LoggerProxy.info(`✅ Redis connection ready for ${this.nodeId}`);
+        // Try to acquire leadership immediately
+        workflow_1.LoggerProxy.info(`🎯 ${this.nodeId} making initial leadership attempt...`);
+        await this.tryAcquireLeadership();
+        // Start the renewal/retry loop
+        this.startRenewalLoop();
+        workflow_1.LoggerProxy.info(`✅ Leader election process started for ${this.nodeId}`);
+    }
+    /**
+     * Stop the leader election process
+     */
+    async stop() {
+        workflow_1.LoggerProxy.info(`🛑 Stopping Redis leader election for ${this.nodeId}`);
+        // Stop renewal timer
+        if (this.renewalTimer) {
+            workflow_1.LoggerProxy.debug(`⏹️  Stopping leadership monitoring loop for ${this.nodeId}`);
+            clearInterval(this.renewalTimer);
+            this.renewalTimer = undefined;
+        }
+        // Release leadership if we have it
+        if (this.isLeader) {
+            workflow_1.LoggerProxy.info(`👋 ${this.nodeId} releasing leadership voluntarily for ${this.lockKey}`);
+            await this.releaseLock();
+        }
+        // Close Redis connection
+        workflow_1.LoggerProxy.debug(`🔌 Disconnecting Redis for ${this.nodeId}`);
+        this.redis.disconnect();
+        workflow_1.LoggerProxy.info(`✅ Leader election stopped for ${this.nodeId}`);
+    }
+    /**
+     * Check if this node is currently the leader
+     */
+    getIsLeader() {
+        return this.isLeader;
+    }
+    /**
+     * Try to acquire leadership
+     */
+    async tryAcquireLeadership() {
+        try {
+            // Check if Redis connection is ready before attempting operations
+            if (this.redis.status !== "ready") {
+                workflow_1.LoggerProxy.warn(`Redis not ready for ${this.nodeId}, current status: ${this.redis.status}`);
+                return false;
+            }
+            workflow_1.LoggerProxy.debug(`Node ${this.nodeId} attempting to acquire leadership for ${this.lockKey}`);
+            // Use SET with NX (not exists) and PX (expire in milliseconds)
+            const result = await this.redis.set(this.lockKey, this.nodeId, "PX", this.lockTTL, "NX");
+            if (result === "OK") {
+                // Successfully acquired leadership
+                if (!this.isLeader) {
+                    this.isLeader = true;
+                    workflow_1.LoggerProxy.info(`🏆 Node ${this.nodeId} ACQUIRED LEADERSHIP for ${this.lockKey} (TTL: ${this.lockTTL}ms)`);
+                    this.callbacks.onStartedLeading();
+                }
+                else {
+                    workflow_1.LoggerProxy.debug(`Node ${this.nodeId} renewed leadership lock for ${this.lockKey}`);
+                }
+                return true;
+            }
+            // Failed to acquire leadership - check who is the current leader
+            const currentLeader = await this.redis.get(this.lockKey);
+            const lockTTL = await this.redis.pttl(this.lockKey);
+            if (currentLeader) {
+                if (currentLeader !== this.nodeId) {
+                    workflow_1.LoggerProxy.debug(`👑 Node ${this.nodeId} sees ${currentLeader} is the current leader for ${this.lockKey} (TTL: ${lockTTL}ms)`);
+                    if (this.callbacks.onNewLeader) {
+                        this.callbacks.onNewLeader(currentLeader);
+                    }
+                }
+            }
+            else {
+                workflow_1.LoggerProxy.debug(`Node ${this.nodeId} found no current leader for ${this.lockKey}, but failed to acquire lock`);
+            }
+            // Lost leadership if we previously had it
+            if (this.isLeader) {
+                this.isLeader = false;
+                workflow_1.LoggerProxy.info(`📉 Node ${this.nodeId} LOST LEADERSHIP for ${this.lockKey}`);
+                this.callbacks.onStoppedLeading();
+            }
+            return false;
+        }
+        catch (error) {
+            workflow_1.LoggerProxy.error(`❌ Error during leader election for ${this.nodeId}: ${error instanceof Error ? error.message : String(error)}`);
+            // If we had leadership and there's an error, assume we lost it
+            if (this.isLeader) {
+                this.isLeader = false;
+                workflow_1.LoggerProxy.info(`💥 Node ${this.nodeId} LOST LEADERSHIP due to error: ${this.lockKey}`);
+                this.callbacks.onStoppedLeading();
+            }
+            return false;
+        }
+    }
+    /**
+     * Renew the leadership lock
+     */
+    async renewLock() {
+        try {
+            // Check if Redis connection is ready before attempting operations
+            if (this.redis.status !== "ready") {
+                workflow_1.LoggerProxy.warn(`Redis not ready for ${this.nodeId} renewal, current status: ${this.redis.status}`);
+                return false;
+            }
+            workflow_1.LoggerProxy.debug(`🔄 Node ${this.nodeId} attempting to renew leadership for ${this.lockKey}`);
+            // Use Lua script to atomically check ownership and renew
+            const script = `
+				if redis.call("get", KEYS[1]) == ARGV[1] then
+					return redis.call("pexpire", KEYS[1], ARGV[2])
+				else
+					return 0
+				end
+			`;
+            const result = await this.redis.eval(script, 1, this.lockKey, this.nodeId, this.lockTTL.toString());
+            if (result === 1) {
+                workflow_1.LoggerProxy.debug(`✅ Node ${this.nodeId} successfully renewed leadership for ${this.lockKey} (TTL: ${this.lockTTL}ms)`);
+                return true;
+            }
+            workflow_1.LoggerProxy.warn(`⚠️  Node ${this.nodeId} failed to renew leadership for ${this.lockKey} - lock no longer owned by this node`);
+            return false;
+        }
+        catch (error) {
+            workflow_1.LoggerProxy.error(`❌ Error renewing leadership lock for ${this.nodeId}: ${error instanceof Error ? error.message : String(error)}`);
+            return false;
+        }
+    }
+    /**
+     * Release the leadership lock
+     */
+    async releaseLock() {
+        try {
+            // Use Lua script to atomically check ownership and delete
+            const script = `
+				if redis.call("get", KEYS[1]) == ARGV[1] then
+					return redis.call("del", KEYS[1])
+				else
+					return 0
+				end
+			`;
+            await this.redis.eval(script, 1, this.lockKey, this.nodeId);
+            workflow_1.LoggerProxy.info(`Node ${this.nodeId} released leadership lock for ${this.lockKey}`);
+        }
+        catch (error) {
+            workflow_1.LoggerProxy.error(`Error releasing lock for ${this.nodeId}: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    /**
+     * Start the renewal/retry loop
+     */
+    startRenewalLoop() {
+        workflow_1.LoggerProxy.info(`Starting leadership monitoring loop for ${this.nodeId} (check every ${this.renewalInterval}ms)`);
+        this.renewalTimer = setInterval(async () => {
+            if (this.isLeader) {
+                // Leader: Try to renew the lock
+                workflow_1.LoggerProxy.debug(`⏰ [LEADER] Node ${this.nodeId} periodic leadership renewal check`);
+                const renewed = await this.renewLock();
+                if (!renewed) {
+                    // Failed to renew - we lost leadership
+                    this.isLeader = false;
+                    workflow_1.LoggerProxy.info(`💔 [LEADER] Node ${this.nodeId} LOST LEADERSHIP (failed to renew) for ${this.lockKey}`);
+                    this.callbacks.onStoppedLeading();
+                }
+                else {
+                    // Successfully renewed - keeping leadership
+                    //Logger.info(`🔒 [LEADER] Node ${this.nodeId} RENEWED LEADERSHIP - staying active for ${this.lockKey}`);
+                }
+            }
+            else {
+                // Follower: Try to acquire leadership
+                workflow_1.LoggerProxy.debug(`⏰ [FOLLOWER] Node ${this.nodeId} checking for available leadership`);
+                await this.tryAcquireLeadership();
+            }
+        }, this.renewalInterval);
+    }
+    /**
+     * Generate a unique node identifier
+     */
+    generateNodeId() {
+        return (process.env["POD_NAME"] ||
+            process.env["HOSTNAME"] ||
+            `node-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`);
+    }
+}
+exports.RedisLeaderElectionManager = RedisLeaderElectionManager;

package/dist/lib/RequestTypes.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Local replacement types for the deprecated `request` and `request-promise-native` packages.
+ *
+ * These interfaces provide type compatibility for function signatures that previously
+ * referenced types from those packages. The actual HTTP implementation uses axios.
+ */
+import type * as http from "node:http";
+import type * as url from "node:url";
+export interface RequestOptions {
+    uri?: string | url.Url;
+    url?: string | url.Url;
+    method?: string;
+    headers?: Record<string, unknown>;
+    body?: unknown;
+    json?: unknown;
+    qs?: Record<string, unknown>;
+    form?: Record<string, unknown>;
+    formData?: Record<string, unknown>;
+    encoding?: string | null;
+    timeout?: number;
+    followRedirect?: boolean;
+    followAllRedirects?: boolean;
+    maxRedirects?: number;
+    proxy?: string | {
+        host: string;
+        port: number;
+        auth?: {
+            username: string;
+            password: string;
+        };
+        protocol?: string;
+    };
+    auth?: {
+        user?: string;
+        username?: string;
+        pass?: string;
+        password?: string;
+        bearer?: string;
+    };
+    agent?: http.Agent;
+    agentOptions?: Record<string, unknown>;
+    rejectUnauthorized?: boolean;
+    strictSSL?: boolean;
+    gzip?: boolean;
+    [key: string]: unknown;
+}
+export interface OptionsWithUri extends RequestOptions {
+    uri: string | url.Url;
+}
+export interface OptionsWithUrl extends RequestOptions {
+    url: string | url.Url;
+}
+export interface RequestPromiseOptions extends RequestOptions {
+    simple?: boolean;
+    resolveWithFullResponse?: boolean;
+    transform?: (body: unknown, response: unknown, resolveWithFullResponse?: boolean) => unknown;
+    transform2xxOnly?: boolean;
+}

package/dist/lib/RequestTypes.js

@@ -0,0 +1,8 @@
+"use strict";
+/**
+ * Local replacement types for the deprecated `request` and `request-promise-native` packages.
+ *
+ * These interfaces provide type compatibility for function signatures that previously
+ * referenced types from those packages. The actual HTTP implementation uses axios.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/lib/UserSettings.d.ts

@@ -0,0 +1,80 @@
+import { type IUserSettings } from "..";
+/**
+ * Creates the user settings if they do not exist yet
+ *
+ * @export
+ */
+export declare function prepareUserSettings(): Promise<IUserSettings>;
+/**
+ * Returns the encryption key which is used to encrypt
+ * the credentials.
+ *
+ * @export
+ * @returns
+ */
+export declare function getEncryptionKey(): Promise<string | undefined>;
+/**
+ * Returns the instance ID
+ *
+ * @export
+ * @returns
+ */
+export declare function getInstanceId(): Promise<string>;
+/**
+ * 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>}
+ */
+export declare function addToUserSettings(addSettings: IUserSettings, settingsPath?: string): Promise<IUserSettings>;
+/**
+ * Writes a user settings file
+ *
+ * @export
+ * @param {IUserSettings} userSettings The settings to write
+ * @param {string} [settingsPath] Optional settings file path
+ * @returns {Promise<IUserSettings>}
+ */
+export declare function writeUserSettings(userSettings: IUserSettings, settingsPath?: string): Promise<IUserSettings>;
+/**
+ * Returns the content of the user settings
+ *
+ * @export
+ * @returns {UserSettings}
+ */
+export declare function getUserSettings(settingsPath?: string, ignoreCache?: boolean): Promise<IUserSettings | undefined>;
+/**
+ * Returns the path to the user settings
+ *
+ * @export
+ * @returns {string}
+ */
+export declare function getUserSettingsPath(): string;
+/**
+ * Retruns the path to the n8n folder in which all n8n
+ * related data gets saved
+ *
+ * @export
+ * @returns {string}
+ */
+export declare function getUserN8nFolderPath(): string;
+/**
+ * Returns the path to the n8n user folder with the custom
+ * extensions like nodes and credentials
+ *
+ * @export
+ * @returns {string}
+ */
+export declare function getUserN8nFolderCustomExtensionPath(): string;
+/**
+ * Returns the home folder path of the user if
+ * none can be found it falls back to the current
+ * working directory
+ *
+ * @export
+ * @returns {string}
+ */
+export declare function getUserHome(): string;