@fsai-flow/core 0.0.4 → 0.1.0

package/src/lib/ActiveWorkflows.ts

@@ -1,575 +0,0 @@
-/* eslint-disable no-continue */
-/* eslint-disable no-await-in-loop */
-/* eslint-disable no-restricted-syntax */
-import { CronJob } from 'cron';
-
-import {
-	IGetExecutePollFunctions,
-	IGetExecuteTriggerFunctions,
-	INode,
-	IPollResponse,
-	ITriggerResponse,
-	IWorkflowExecuteAdditionalData,
-	LoggerProxy as Logger,
-	Workflow,
-	WorkflowActivateMode,
-	WorkflowExecuteMode,
-} from '@fsai-flow/workflow';
-
-import { secureRandomNumber } from '../utils/crypto';
-
-import { RedisLeaderElectionManager } from './RedisLeaderElectionManager';
-
-import type Redis from 'ioredis';
-
-// eslint-disable-next-line import/no-cycle
-import { ITriggerTime, IWorkflowData } from '..';
-import { RedisOptions } from 'ioredis';
-
-interface IPollingWorkflow {
-	workflow: Workflow;
-	node: INode;
-	cronTimes: string[];
-	timezone: string;
-	executeTrigger: () => Promise<void>;
-	activeCronJobs: CronJob[];
-}
-
-export class ActiveWorkflows {
-	private workflowData: {
-		[key: string]: IWorkflowData;
-	} = {};
-
-	private redisConfig: string | RedisOptions | undefined;
-	private instanceLeaderElection: RedisLeaderElectionManager | null = null;
-	private pollingWorkflows: Map<string, IPollingWorkflow> = new Map();
-	private isLeader = false;
-	private isInitializingLeaderElection = false;
-	private leaderElectionInitialized = false;
-	private leaderElectionEnabled = false;
-
-	constructor(redisConfig?: string | RedisOptions) {
-		this.redisConfig = redisConfig;
-		this.leaderElectionEnabled = redisConfig !== undefined;
-		
-		if (!this.leaderElectionEnabled) {
-			Logger.info('📴 Redis leader election disabled - workflows will run on all instances');
-			this.isLeader = true; // In non-queue mode, every instance is a "leader"
-			this.leaderElectionInitialized = true;
-		}
-	}
-
-
-
-	/**
-	 * Returns if the workflow is active
-	 *
-	 * @param {string} id The id of the workflow to check
-	 * @returns {boolean}
-	 * @memberof ActiveWorkflows
-	 */
-	isActive(id: string): boolean {
-		// eslint-disable-next-line no-prototype-builtins
-		return this.workflowData.hasOwnProperty(id);
-	}
-
-	/**
-	 * Returns the ids of the currently active workflows
-	 *
-	 * @returns {string[]}
-	 * @memberof ActiveWorkflows
-	 */
-	allActiveWorkflows(): string[] {
-		return Object.keys(this.workflowData);
-	}
-
-	/**
-	 * Returns the Workflow data for the workflow with
-	 * the given id if it is currently active
-	 *
-	 * @param {string} id
-	 * @returns {(WorkflowData | undefined)}
-	 * @memberof ActiveWorkflows
-	 */
-	get(id: string): IWorkflowData | undefined {
-		return this.workflowData[id];
-	}
-
-	/**
-	 * Makes a workflow active
-	 *
-	 * @param {string} id The id of the workflow to activate
-	 * @param {Workflow} workflow The workflow to activate
-	 * @param {IWorkflowExecuteAdditionalData} additionalData The additional data which is needed to run workflows
-	 * @returns {Promise<void>}
-	 * @memberof ActiveWorkflows
-	 */
-	async add(
-		id: string,
-		workflow: Workflow,
-		additionalData: IWorkflowExecuteAdditionalData,
-		mode: WorkflowExecuteMode,
-		activation: WorkflowActivateMode,
-		getTriggerFunctions: IGetExecuteTriggerFunctions,
-		getPollFunctions: IGetExecutePollFunctions,
-	): Promise<void> {
-		this.workflowData[id] = {};
-		const triggerNodes = workflow.getTriggerNodes();
-
-		let triggerResponse: ITriggerResponse | undefined;
-		this.workflowData[id].triggerResponses = [];
-		for (const triggerNode of triggerNodes) {
-			triggerResponse = await workflow.runTrigger(
-				triggerNode,
-				getTriggerFunctions,
-				additionalData,
-				mode,
-				activation,
-			);
-			if (triggerResponse !== undefined) {
-				// If a response was given save it
-				// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-				this.workflowData[id].triggerResponses!.push(triggerResponse);
-			}
-		}
-
-		const pollNodes = workflow.getPollNodes();
-		if (pollNodes.length) {
-			this.workflowData[id].pollResponses = [];
-			for (const pollNode of pollNodes) {
-				// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-				this.workflowData[id].pollResponses!.push(
-					await this.activatePolling(
-						pollNode,
-						workflow,
-						additionalData,
-						getPollFunctions,
-						mode,
-						activation,
-					),
-				);
-			}
-		}
-	}
-
-	/**
-	 * Initialize global leader election (called once per instance)
-	 */
-	private async initializeLeaderElection(): Promise<void> {
-		// Skip leader election if disabled
-		if (!this.leaderElectionEnabled) {
-			Logger.debug('📴 Leader election disabled - skipping initialization');
-			return;
-		}
-
-		// Prevent race condition - only one initialization at a time
-		if (this.leaderElectionInitialized || this.isInitializingLeaderElection) {
-			Logger.debug('⏳ Leader election already initialized or in progress, waiting...');
-			
-			// Wait for initialization to complete
-			while (this.isInitializingLeaderElection) {
-				await new Promise(resolve => setTimeout(resolve, 100));
-			}
-			return;
-		}
-
-		this.isInitializingLeaderElection = true;
-		
-		try {
-			const nodeId = process.env['POD_NAME'] || process.env['HOSTNAME'] || `flowx-instance-${Math.random().toString(36).substr(2, 9)}`;
-			const lockName = 'global-polling-leadership';
-
-			Logger.info(`🌟 Initializing global polling leadership for instance ${nodeId}`);
-
-			this.instanceLeaderElection = new RedisLeaderElectionManager(
-				lockName,
-				this.redisConfig!,  // We know it's not null because leaderElectionEnabled is true
-				{
-					onStartedLeading: () => {
-						Logger.info(`🏆 Instance ${nodeId} became GLOBAL POLLING LEADER - starting all registered workflows (current count: ${this.pollingWorkflows.size})`);
-						this.isLeader = true;
-						// Set initialized flag before starting workflows to prevent timing issue
-						this.leaderElectionInitialized = true;
-						this.startAllPollingWorkflows();
-					},
-					onStoppedLeading: () => {
-						Logger.info(`📉 Instance ${nodeId} lost GLOBAL POLLING LEADERSHIP - stopping all workflows`);
-						this.isLeader = false;
-						this.stopAllPollingWorkflows();
-					},
-					onNewLeader: (identity: string) => {
-						//Logger.info(`👑 New global polling leader: ${identity}`);
-					}
-				}
-			);
-
-			await this.instanceLeaderElection.start();
-			// Only set this if we didn't become leader during start() - prevent double-setting
-			if (!this.leaderElectionInitialized) {
-				this.leaderElectionInitialized = true;
-			}
-			
-			Logger.info(`✅ Global leader election initialized for ${nodeId}`);
-		} finally {
-			this.isInitializingLeaderElection = false;
-		}
-	}
-
-	/**
-	 * Start all registered polling workflows (called when becoming leader)
-	 */
-	private startAllPollingWorkflows(): void {
-		Logger.debug(`🔍 startAllPollingWorkflows called - isLeader: ${this.isLeader}, initialized: ${this.leaderElectionInitialized}, workflows: ${this.pollingWorkflows.size}`);
-		
-		// Safety check: Only start if we're truly the leader and initialization is complete
-		if (!this.isLeader || !this.leaderElectionInitialized) {
-			Logger.warn(`⚠️  Cannot start workflows - not leader (isLeader: ${this.isLeader}, initialized: ${this.leaderElectionInitialized})`);
-			return;
-		}
-
-		Logger.info(`🚀 Starting all ${this.pollingWorkflows.size} registered polling workflows`);
-		Logger.debug(`📋 Registered workflow keys: ${Array.from(this.pollingWorkflows.keys()).join(', ')}`);
-		
-		let startedCount = 0;
-		for (const [workflowKey, pollingWorkflow] of this.pollingWorkflows) {
-			try {
-				// Skip if already running (double-check safety)
-				if (pollingWorkflow.activeCronJobs.length > 0) {
-					Logger.warn(`⚠️  Workflow ${workflowKey} already has active cron jobs - skipping`);
-					continue;
-				}
-
-				Logger.info(`⏰ Starting cron jobs for workflow "${pollingWorkflow.workflow.name}", node "${pollingWorkflow.node.name}" (${pollingWorkflow.cronTimes.length} schedules)`);
-				
-				// Create and start cron jobs for this workflow
-				pollingWorkflow.activeCronJobs = pollingWorkflow.cronTimes.map(cronTime =>
-					new CronJob(cronTime, pollingWorkflow.executeTrigger, undefined, true, pollingWorkflow.timezone)
-				);
-				
-				startedCount++;
-				Logger.info(`✅ Started ${pollingWorkflow.activeCronJobs.length} cron jobs for workflow "${pollingWorkflow.workflow.name}"`);
-			} catch (error: any) {
-				Logger.error(`❌ Failed to start polling for ${workflowKey}: ${error.message}`);
-			}
-		}
-		
-		Logger.info(`🎯 Successfully started ${startedCount} of ${this.pollingWorkflows.size} polling workflows`);
-	}
-
-	/**
-	 * Stop all polling workflows (called when losing leadership)
-	 */
-	private stopAllPollingWorkflows(): void {
-		Logger.info(`🛑 Stopping all ${this.pollingWorkflows.size} polling workflows`);
-		
-		for (const [workflowKey, pollingWorkflow] of this.pollingWorkflows) {
-			try {
-				// Skip if already stopped (safety check)
-				if (pollingWorkflow.activeCronJobs.length === 0) {
-					Logger.debug(`⏭️  Workflow ${workflowKey} already stopped - skipping`);
-					continue;
-				}
-
-				Logger.info(`⏹️  Stopping cron jobs for workflow "${pollingWorkflow.workflow.name}", node "${pollingWorkflow.node.name}"`);
-				
-				// Stop all cron jobs for this workflow
-				pollingWorkflow.activeCronJobs.forEach(job => job.stop());
-				pollingWorkflow.activeCronJobs = [];
-				
-				Logger.debug(`✅ Stopped polling for ${workflowKey}`);
-			} catch (error: any) {
-				Logger.error(`❌ Failed to stop polling for ${workflowKey}: ${error.message}`);
-			}
-		}
-	}
-
-	/**
-	 * Activates polling for the given node with global Redis leader election
-	 *
-	 * @param {INode} node
-	 * @param {Workflow} workflow
-	 * @param {IWorkflowExecuteAdditionalData} additionalData
-	 * @param {IGetExecutePollFunctions} getPollFunctions
-	 * @returns {Promise<IPollResponse>}
-	 * @memberof ActiveWorkflows
-	 */
-	async activatePolling(
-		node: INode,
-		workflow: Workflow,
-		additionalData: IWorkflowExecuteAdditionalData,
-		getPollFunctions: IGetExecutePollFunctions,
-		mode: WorkflowExecuteMode,
-		activation: WorkflowActivateMode,
-	): Promise<IPollResponse> {
-		const pollFunctions = getPollFunctions(workflow, node, additionalData, mode, activation);
-
-		// Get polling configuration
-		const pollTimes = pollFunctions.getNodeParameter('pollTimes') as unknown as {
-			item: ITriggerTime[];
-		};
-
-		// Build cron times
-		const cronTimes = this.buildCronTimes(pollTimes);
-		const timezone = pollFunctions.getTimezone();
-
-		// Validate cron times
-		this.validateCronTimes(cronTimes);
-
-		// Create unique workflow key
-		const workflowKey = `${workflow.id}-${node.name}`;
-
-		// Check if this workflow is already registered (prevents duplicate registrations)
-		if (this.pollingWorkflows.has(workflowKey)) {
-			Logger.warn(`⚠️  Workflow ${workflowKey} is already registered - returning existing closeFunction`);
-			const existingWorkflow = this.pollingWorkflows.get(workflowKey)!;
-			return {
-				closeFunction: async () => {
-					Logger.info(`🗑️  Removing duplicate registration for: "${workflow.name}" (node: ${node.name})`);
-					// Just log - don't actually remove since this is a duplicate
-				}
-			};
-		}
-
-		// Create the polling execution function
-		const executeTrigger = async () => {
-			try {
-				Logger.info(`Polling trigger initiated for workflow "${workflow.name}"`, {
-					workflowName: workflow.name,
-					workflowId: workflow.id,
-				});
-				const pollResponse = await workflow.runPoll(node, pollFunctions);
-
-				if (pollResponse !== null) {
-					// eslint-disable-next-line no-underscore-dangle
-					pollFunctions.__emit(pollResponse);
-				}
-			} catch (error: any) {
-				Logger.error(
-					`Polling trigger failed for workflow "${workflow.name}"`,
-					{
-						workflowName: workflow.name,
-						workflowId: workflow.id,
-						nodeName: node.name,
-						error: error.message,
-						statusCode: error.statusCode,
-						httpCode: error.httpCode,
-						description: error.description,
-						cause: error.cause?.message,
-					}
-				);
-			}
-		};
-
-		// Register this polling workflow
-		const pollingWorkflow: IPollingWorkflow = {
-			workflow,
-			node,
-			cronTimes,
-			timezone,
-			executeTrigger,
-			activeCronJobs: []
-		};
-
-		this.pollingWorkflows.set(workflowKey, pollingWorkflow);
-		Logger.info(`📋 Registered polling workflow: "${workflow.name}" (node: ${node.name}) [Key: ${workflowKey}] - Total workflows: ${this.pollingWorkflows.size}`);
-
-		// Initialize global leader election if enabled
-		await this.initializeLeaderElection();
-
-		// Start workflow if we're the leader (or if leader election is disabled)
-		if (this.isLeader && this.leaderElectionInitialized && pollingWorkflow.activeCronJobs.length === 0) {
-			const reason = this.leaderElectionEnabled ? 'Leader established' : 'Leader election disabled';
-			Logger.info(`🔥 Post-registration start: "${workflow.name}" [Key: ${workflowKey}] - ${reason}, starting immediately`);
-			try {
-				pollingWorkflow.activeCronJobs = pollingWorkflow.cronTimes.map(cronTime =>
-					new CronJob(cronTime, pollingWorkflow.executeTrigger, undefined, true, pollingWorkflow.timezone)
-				);
-				Logger.info(`✅ Post-registration: Started ${pollingWorkflow.activeCronJobs.length} cron jobs for "${workflow.name}"`);
-			} catch (error: any) {
-				Logger.error(`❌ Failed to start newly registered workflow ${workflowKey}: ${error.message}`);
-			}
-		} else {
-			const leaderElectionStatus = this.leaderElectionEnabled ? 'enabled' : 'disabled';
-			Logger.debug(`⏳ Post-registration wait: "${workflow.name}" [Key: ${workflowKey}] (isLeader: ${this.isLeader}, initialized: ${this.leaderElectionInitialized}, activeCronJobs: ${pollingWorkflow.activeCronJobs.length}, leaderElection: ${leaderElectionStatus})`);
-		}
-
-		// Return cleanup function
-		return {
-			closeFunction: async () => {
-				Logger.info(`🗑️  Removing polling workflow: "${workflow.name}" (node: ${node.name})`);
-				
-				// Stop cron jobs for this workflow
-				const workflow_to_remove = this.pollingWorkflows.get(workflowKey);
-				if (workflow_to_remove) {
-					workflow_to_remove.activeCronJobs.forEach(job => job.stop());
-				}
-				
-				// Remove from registered workflows
-				this.pollingWorkflows.delete(workflowKey);
-				
-				Logger.debug(`✅ Removed polling workflow ${workflowKey}`);
-			}
-		};
-	}
-
-	/**
-	 * Extract cron time building logic (same as original)
-	 */
-	private buildCronTimes(pollTimes: { item: ITriggerTime[] }): string[] {
-		const parameterOrder = [
-			'second', 'minute', 'hour', 'dayOfMonth', 'month', 'weekday'
-		];
-
-		const cronTimes: string[] = [];
-		if (pollTimes.item !== undefined) {
-			for (const item of pollTimes.item) {
-				let cronTime: string[];
-				
-				if (item.mode === 'custom') {
-					cronTimes.push((item['cronExpression'] as string).trim());
-					continue;
-				}
-				if (item.mode === 'everyMinute') {
-					cronTimes.push(`${secureRandomNumber(1, 60).toString()} * * * * *`);
-					continue;
-				}
-				if (item.mode === 'everyX') {
-					if (item['unit'] === 'minutes') {
-						cronTimes.push(`${secureRandomNumber(1, 60).toString()} */${item['value']} * * * *`);
-					} else if (item['unit'] === 'hours') {
-						cronTimes.push(`${secureRandomNumber(1, 60).toString()} 0 */${item['value']} * * *`);
-					} else if (item['unit'] === 'seconds') {
-						cronTimes.push(`*/${item['value']} * * * * *`);
-					}
-					continue;
-				}
-
-				cronTime = [];
-				for (const parameterName of parameterOrder) {
-					if (item[parameterName] !== undefined) {
-						cronTime.push(item[parameterName] as string);
-					} else if (parameterName === 'second') {
-						cronTime.push(secureRandomNumber(1, 60).toString());
-					} else {
-						cronTime.push('*');
-					}
-				}
-				cronTimes.push(cronTime.join(' '));
-			}
-		}
-		return cronTimes;
-	}
-
-	/**
-	 * Validate cron times (same as original)
-	 */
-	private validateCronTimes(cronTimes: string[]): void {
-		for (const cronTime of cronTimes) {
-			const cronTimeParts = cronTime.split(' ');
-			
-			if (cronTimeParts.length === 6 && cronTimeParts[0].includes('/')) {
-				const secondsInterval = parseInt(cronTimeParts[0].replace('*/', ''), 10);
-				if (secondsInterval < 1) {
-					throw new Error('The polling interval is too short. It has to be at least 1 second!');
-				}
-			} else if (cronTimeParts.length > 0 && cronTimeParts[0].includes('*') && !cronTimeParts[0].includes('/')) {
-				throw new Error('The polling interval is too short. It has to be at least a minute!');
-			}
-		}
-	}
-
-	/**
-	 * Makes a workflow inactive
-	 *
-	 * @param {string} id The id of the workflow to deactivate
-	 * @returns {Promise<void>}
-	 * @memberof ActiveWorkflows
-	 */
-	async remove(id: string): Promise<void> {
-		if (!this.isActive(id)) {
-			// Workflow is currently not registered
-			throw new Error(
-				`The workflow with the id "${id}" is currently not active and can so not be removed`,
-			);
-		}
-
-		const workflowData = this.workflowData[id];
-
-		if (workflowData.triggerResponses) {
-			for (const triggerResponse of workflowData.triggerResponses) {
-				if (triggerResponse.closeFunction) {
-					try {
-						await triggerResponse.closeFunction();
-					} catch (error: any) {
-						Logger.error(
-							// eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, @typescript-eslint/restrict-template-expressions
-							`There was a problem deactivating trigger of workflow "${id}": "${error.message}"`,
-							{
-								workflowId: id,
-							},
-						);
-					}
-				}
-			}
-		}
-
-		if (workflowData.pollResponses) {
-			for (const pollResponse of workflowData.pollResponses) {
-				if (pollResponse.closeFunction) {
-					try {
-						await pollResponse.closeFunction();
-					} catch (error:any) {
-						Logger.error(
-							// eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, @typescript-eslint/restrict-template-expressions
-							`There was a problem deactivating polling trigger of workflow "${id}": "${error.message}"`,
-							{
-								workflowId: id,
-							},
-						);
-					}
-				}
-			}
-		}
-
-		// Remove polling workflows from the global map (closeFunction will handle stopping cron jobs)
-		const pollingWorkflowsToRemove: string[] = [];
-		for (const [workflowKey, pollingWorkflow] of this.pollingWorkflows) {
-			if (pollingWorkflow.workflow.id === id) {
-				pollingWorkflowsToRemove.push(workflowKey);
-			}
-		}
-
-		for (const workflowKey of pollingWorkflowsToRemove) {
-			const pollingWorkflow = this.pollingWorkflows.get(workflowKey);
-			if (pollingWorkflow) {
-				Logger.info(`🗑️  Removing polling workflow: "${pollingWorkflow.workflow.name}" (node: ${pollingWorkflow.node.name})`);
-				
-				// Stop cron jobs for this workflow
-				pollingWorkflow.activeCronJobs.forEach(job => job.stop());
-				
-				// Remove from registered workflows
-				this.pollingWorkflows.delete(workflowKey);
-				
-				Logger.debug(`✅ Removed polling workflow ${workflowKey}`);
-			}
-		}
-
-		// If no more polling workflows are registered and leader election is enabled, stop it
-		if (this.pollingWorkflows.size === 0 && this.instanceLeaderElection && this.leaderElectionEnabled) {
-			Logger.info(`📴 No more polling workflows - stopping global leader election`);
-			try {
-				await this.instanceLeaderElection.stop();
-				this.instanceLeaderElection = null;
-				this.isLeader = false;
-				this.leaderElectionInitialized = false;
-			} catch (error: any) {
-				Logger.error(
-					// eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, @typescript-eslint/restrict-template-expressions
-					`There was a problem stopping global leader election: "${error.message}"`
-				);
-			}
-		}
-
-		delete this.workflowData[id];
-	}
-}