@invect/core 0.0.1

package/dist/services/react-flow-renderer.service.js

@@ -0,0 +1,235 @@
+import { DatabaseError } from "../types/common/errors.types.js";
+import { NodeExecutionStatus } from "../types/base.js";
+import { getGlobalActionRegistry } from "../actions/action-registry.js";
+import { FlowIdParamsSchema } from "../types/schemas/flow/flow-executions.schema.js";
+import "../types/schemas/index.js";
+import { applyElkLayout } from "@invect/layouts";
+//#region src/services/react-flow-renderer.service.ts
+/**
+* Service for rendering flow data in React Flow compatible format
+* Transforms Invect flow definitions into React Flow compatible nodes and edges
+*/
+var ReactFlowRendererService = class ReactFlowRendererService {
+	initialized = false;
+	constructor(logger, flowsService, flowVersionsService, flowRunsService, nodeExecutionsService) {
+		this.logger = logger;
+		this.flowsService = flowsService;
+		this.flowVersionsService = flowVersionsService;
+		this.flowRunsService = flowRunsService;
+		this.nodeExecutionsService = nodeExecutionsService;
+	}
+	/**
+	* Initialize the service
+	*/
+	async initialize() {
+		if (this.initialized) {
+			this.logger.debug("React Flow renderer service already initialized");
+			return;
+		}
+		try {
+			this.initialized = true;
+			this.logger.info("React Flow renderer service initialized successfully");
+		} catch (error) {
+			this.logger.error("Failed to initialize React Flow renderer service", { error });
+			throw new DatabaseError("Failed to initialize React Flow renderer service", { error });
+		}
+	}
+	/**
+	* Transform flow version and execution data to React Flow format
+	*/
+	async renderToReactFlow(flowId, options) {
+		this.logger.debug("renderToReactFlow called with arguments:", JSON.stringify({
+			flowId,
+			options
+		}, null, 2));
+		const validatedParams = FlowIdParamsSchema.parse({ flowId });
+		const flowVersion = await this.flowVersionsService.getFlowVersion(validatedParams.flowId, options?.version || "latest");
+		if (!flowVersion) throw new DatabaseError(`Flow version not found for flow ${flowId}`);
+		const flow = await this.flowsService.getFlowById(validatedParams.flowId);
+		let flowRun;
+		let nodeExecutions;
+		if (options?.flowRunId) {
+			flowRun = await this.flowRunsService.getRunById(options.flowRunId);
+			nodeExecutions = await this.nodeExecutionsService.listNodeExecutionsByFlowRunId(options.flowRunId);
+		}
+		return this.transformToReactFlowData(flowVersion, flow.name, flow.description, flow.isActive, flowRun, nodeExecutions);
+	}
+	/**
+	* Internal method to transform data to React Flow format
+	*/
+	async transformToReactFlowData(flowVersion, flowName, flowDescription, isActive = true, flowRun, nodeExecutions) {
+		this.logger.debug("Rendering flow to React Flow format", {
+			flowId: flowVersion.flowId,
+			flowVersion: flowVersion.version,
+			flowRunId: flowRun?.id,
+			nodeExecutionsCount: nodeExecutions?.length || 0
+		});
+		const executionStatusMap = this.createExecutionStatusMap(nodeExecutions);
+		let nodes = this.transformNodes(flowVersion, executionStatusMap);
+		const edges = this.transformEdges(flowVersion, executionStatusMap);
+		nodes = await this.applyElkLayoutToNodes(nodes, edges);
+		return {
+			nodes,
+			edges,
+			version: flowVersion,
+			name: flowName,
+			description: flowDescription,
+			isActive,
+			executionStatus: executionStatusMap
+		};
+	}
+	/**
+	* Create execution status map from node executions
+	*/
+	createExecutionStatusMap(nodeExecutions) {
+		const statusMap = /* @__PURE__ */ new Map();
+		if (nodeExecutions) nodeExecutions.forEach((execution) => {
+			statusMap.set(execution.nodeId, {
+				status: execution.status,
+				error: execution.error,
+				output: execution.outputs
+			});
+		});
+		return statusMap;
+	}
+	/**
+	* Transform flow nodes to React Flow format
+	*/
+	transformNodes(flowVersion, executionStatusMap) {
+		const nodes = [];
+		const definition = flowVersion.invectDefinition;
+		if (!definition?.nodes) return nodes;
+		const actionRegistry = getGlobalActionRegistry();
+		definition.nodes.forEach((node) => {
+			const executionStatus = executionStatusMap.get(node.id);
+			const action = actionRegistry.get(node.type);
+			const displayName = this.getDisplayName(node, action);
+			const referenceId = this.getReferenceId(node, displayName);
+			const nodeData = {
+				id: node.id,
+				type: node.type,
+				display_name: displayName,
+				reference_id: referenceId,
+				description: action?.description,
+				icon: action?.provider.icon,
+				status: this.mapExecutionStatusToNodeStatus(executionStatus?.status),
+				executionStatus: executionStatus?.status,
+				executionError: executionStatus?.error,
+				executionOutput: executionStatus?.output,
+				params: node.params,
+				inputs: void 0,
+				outputs: executionStatus?.output?.data,
+				...node.params || {},
+				...node.mapper ? { mapper: node.mapper } : {}
+			};
+			const transformedNode = {
+				id: node.id,
+				type: node.type,
+				position: node.position || {
+					x: 0,
+					y: 0
+				},
+				data: nodeData,
+				width: 200,
+				height: 60
+			};
+			nodes.push(transformedNode);
+		});
+		return nodes;
+	}
+	/**
+	* Get display name for a node, with fallbacks
+	*/
+	getDisplayName(node, action) {
+		if (node.label && typeof node.label === "string") return node.label;
+		if (action?.name) return action.name;
+		return node.type.replace(/[._]/g, " ").replace(/\b\w/g, (c) => c.toUpperCase());
+	}
+	static MAX_REFERENCE_ID_LENGTH = 22;
+	/**
+	* Get or generate a reference_id for a node (snake_case, alphanumeric only)
+	* Truncates to MAX_REFERENCE_ID_LENGTH while preserving any increment suffix
+	*/
+	getReferenceId(node, displayName) {
+		if (node.referenceId && typeof node.referenceId === "string") return node.referenceId;
+		const baseId = displayName.toLowerCase().replace(/[^a-z0-9\s]/g, "").trim().replace(/\s+/g, "_");
+		return this.truncateReferenceId(baseId);
+	}
+	/**
+	* Truncate a reference ID to max length while preserving any numeric suffix
+	*/
+	truncateReferenceId(refId, suffix) {
+		const maxLen = ReactFlowRendererService.MAX_REFERENCE_ID_LENGTH;
+		if (refId.length <= maxLen) return refId;
+		if (suffix) {
+			const suffixWithUnderscore = `_${suffix}`;
+			const availableForBase = maxLen - suffixWithUnderscore.length;
+			if (availableForBase <= 0) return refId.substring(0, maxLen);
+			return refId.substring(0, availableForBase) + suffixWithUnderscore;
+		}
+		return refId.substring(0, maxLen);
+	}
+	/**
+	* Transform flow edges to React Flow format
+	*/
+	transformEdges(flowVersion, executionStatusMap) {
+		const edges = [];
+		const definition = flowVersion.invectDefinition;
+		if (!definition?.edges || !definition?.nodes) return edges;
+		const nodeTypeMap = /* @__PURE__ */ new Map();
+		definition.nodes.forEach((node) => {
+			nodeTypeMap.set(node.id, node.type);
+		});
+		definition.edges.forEach((edge) => {
+			const sourceNodeStatus = executionStatusMap.get(edge.source);
+			const targetNodeStatus = executionStatusMap.get(edge.target);
+			const isConnectedToSkippedNode = sourceNodeStatus?.status === NodeExecutionStatus.SKIPPED || targetNodeStatus?.status === NodeExecutionStatus.SKIPPED;
+			const transformedEdge = {
+				id: edge.id,
+				source: edge.source,
+				target: edge.target,
+				sourceHandle: edge.sourceHandle || "output",
+				targetHandle: edge.targetHandle || "input",
+				animated: edge.animated || false,
+				data: {
+					type: isConnectedToSkippedNode ? "skipped" : "default",
+					animated: edge.animated || false,
+					highlighted: false,
+					selected: false,
+					sourceNodeStatus: sourceNodeStatus?.status,
+					targetNodeStatus: targetNodeStatus?.status
+				}
+			};
+			edges.push(transformedEdge);
+		});
+		return edges;
+	}
+	/**
+	* Map execution status to node visual status
+	*/
+	mapExecutionStatusToNodeStatus(executionStatus) {
+		if (!executionStatus) return "idle";
+		switch (executionStatus) {
+			case NodeExecutionStatus.PENDING:
+			case NodeExecutionStatus.RUNNING: return "running";
+			case NodeExecutionStatus.SUCCESS: return "completed";
+			case NodeExecutionStatus.FAILED: return "error";
+			case NodeExecutionStatus.SKIPPED: return "skipped";
+			case NodeExecutionStatus.BATCH_SUBMITTED: return "running";
+			default: return "idle";
+		}
+	}
+	/**
+	* Apply ELK left-to-right layout to nodes
+	* Uses elkjs layered algorithm for better edge crossing minimization
+	*
+	* Note: ELK is async because elkjs uses web workers internally
+	*/
+	async applyElkLayoutToNodes(nodes, edges) {
+		return applyElkLayout(nodes, edges);
+	}
+};
+//#endregion
+export { ReactFlowRendererService };
+
+//# sourceMappingURL=react-flow-renderer.service.js.map

package/dist/services/react-flow-renderer.service.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"react-flow-renderer.service.js","names":[],"sources":["../../src/services/react-flow-renderer.service.ts"],"sourcesContent":["import { FlowVersion } from '../database';\nimport { FlowRun } from './flow-runs/flow-runs.model';\nimport { NodeExecution } from './node-executions/node-executions.model';\nimport { NodeExecutionStatus } from '../types/base';\nimport { Logger } from '../types/schemas';\nimport { DatabaseError } from '../types/common/errors.types';\nimport { FlowEdge, FlowNodeDefinitions } from './flow-versions/schemas-fresh';\nimport type { NodeOutput, NodeInputData } from '../types/node-io-types';\nimport { getGlobalActionRegistry } from '../actions/action-registry';\nimport { applyElkLayout } from '@invect/layouts';\nimport { FlowsService } from './flows/flows.service';\nimport { FlowVersionsService } from './flow-versions/flow-versions.service';\nimport { FlowRunsService } from './flow-runs/flow-runs.service';\nimport { NodeExecutionService } from './node-executions/node-execution.service';\nimport * as Schemas from '../types/schemas';\n\n// Position interface matching existing schema\nexport interface Position {\n  x: number;\n  y: number;\n}\n\n// Node visual status for React Flow rendering\nexport type NodeVisualStatus = 'idle' | 'running' | 'completed' | 'error' | 'skipped';\n\n// Layout will be handled on the frontend\n\n// Node execution status for rendering\nexport interface NodeExecutionStatusInfo {\n  status: NodeExecutionStatus;\n  error?: string;\n  output?: NodeOutput;\n}\n\n// Base React Flow node data interface\nexport interface ReactFlowNodeData extends Record<string, unknown> {\n  id: string;\n  type: string;\n  display_name: string;\n  reference_id: string; // snake_case unique identifier for input mapping\n  description?: string;\n  icon?: string;\n  status: NodeVisualStatus;\n  executionStatus?: NodeExecutionStatus;\n  executionError?: string;\n  executionOutput?: NodeOutput;\n  // Node configuration parameters (dynamic based on node definition)\n  params?: Record<string, unknown>;\n  // Runtime inputs (what the node receives during execution)\n  inputs?: NodeInputData;\n  // Runtime outputs (what the node produces during execution)\n  outputs?: NodeOutput['data'];\n}\n\n// React Flow compatible node interface with strong typing\nexport interface ReactFlowNode<T extends string = string> {\n  id: string;\n  type: T;\n  position: Position;\n  data: ReactFlowNodeData;\n  width?: number;\n  height?: number;\n  measured?: { width: number; height: number };\n  dragHandle?: string;\n}\n\n// React Flow compatible edge interface\nexport interface ReactFlowEdge {\n  id: string;\n  source: string;\n  target: string;\n  sourceHandle?: string;\n  targetHandle?: string;\n  animated?: boolean;\n  data?: {\n    type: 'default' | 'skipped';\n    animated: boolean;\n    highlighted: boolean;\n    selected: boolean;\n    sourceNodeStatus?: NodeExecutionStatus;\n    targetNodeStatus?: NodeExecutionStatus;\n  };\n}\n\n// Complete React Flow data response\nexport interface ReactFlowData {\n  nodes: ReactFlowNode[];\n  edges: ReactFlowEdge[];\n  version: FlowVersion;\n  name: string;\n  description?: string;\n  isActive: boolean;\n  executionStatus?: Map<string, NodeExecutionStatusInfo>;\n}\n\n// Strongly typed React Flow data for specific node types\nexport interface TypedReactFlowData<T extends string = string> {\n  nodes: ReactFlowNode<T>[];\n  edges: ReactFlowEdge[];\n  version: FlowVersion;\n  name: string;\n  description?: string;\n  executionStatus?: Map<string, NodeExecutionStatusInfo>;\n}\n\n/**\n * Service for rendering flow data in React Flow compatible format\n * Transforms Invect flow definitions into React Flow compatible nodes and edges\n */\nexport class ReactFlowRendererService {\n  private initialized = false;\n\n  constructor(\n    private readonly logger: Logger,\n    private readonly flowsService: FlowsService,\n    private readonly flowVersionsService: FlowVersionsService,\n    private readonly flowRunsService: FlowRunsService,\n    private readonly nodeExecutionsService: NodeExecutionService,\n  ) {}\n\n  /**\n   * Initialize the service\n   */\n  async initialize(): Promise<void> {\n    if (this.initialized) {\n      this.logger.debug('React Flow renderer service already initialized');\n      return;\n    }\n\n    try {\n      this.initialized = true;\n      this.logger.info('React Flow renderer service initialized successfully');\n    } catch (error) {\n      this.logger.error('Failed to initialize React Flow renderer service', { error });\n      throw new DatabaseError('Failed to initialize React Flow renderer service', { error });\n    }\n  }\n\n  /**\n   * Transform flow version and execution data to React Flow format\n   */\n  async renderToReactFlow(\n    flowId: string,\n    options?: { version?: string | number | 'latest'; flowRunId?: string },\n  ): Promise<ReactFlowData> {\n    this.logger.debug(\n      'renderToReactFlow called with arguments:',\n      JSON.stringify({ flowId, options }, null, 2),\n    );\n\n    const validatedParams = Schemas.flow.FlowIdParamsSchema.parse({ flowId });\n\n    // Get flow version\n    const flowVersion = await this.flowVersionsService.getFlowVersion(\n      validatedParams.flowId,\n      options?.version || 'latest',\n    );\n\n    if (!flowVersion) {\n      throw new DatabaseError(`Flow version not found for flow ${flowId}`);\n    }\n\n    // Get flow details for name/description\n    const flow = await this.flowsService.getFlowById(validatedParams.flowId);\n\n    // Get execution data if flowRunId provided\n    let flowRun: FlowRun | undefined;\n    let nodeExecutions: NodeExecution[] | undefined;\n\n    if (options?.flowRunId) {\n      flowRun = await this.flowRunsService.getRunById(options.flowRunId);\n      nodeExecutions = await this.nodeExecutionsService.listNodeExecutionsByFlowRunId(\n        options.flowRunId,\n      );\n    }\n\n    return this.transformToReactFlowData(\n      flowVersion,\n      flow.name,\n      flow.description,\n      flow.isActive,\n      flowRun,\n      nodeExecutions,\n    );\n  }\n\n  /**\n   * Internal method to transform data to React Flow format\n   */\n  private async transformToReactFlowData(\n    flowVersion: FlowVersion,\n    flowName: string,\n    flowDescription?: string,\n    isActive: boolean = true,\n    flowRun?: FlowRun,\n    nodeExecutions?: NodeExecution[],\n  ): Promise<ReactFlowData> {\n    this.logger.debug('Rendering flow to React Flow format', {\n      flowId: flowVersion.flowId,\n      flowVersion: flowVersion.version,\n      flowRunId: flowRun?.id,\n      nodeExecutionsCount: nodeExecutions?.length || 0,\n    });\n\n    // Create execution status map\n    const executionStatusMap = this.createExecutionStatusMap(nodeExecutions);\n\n    // Transform nodes and edges\n    let nodes = this.transformNodes(flowVersion, executionStatusMap);\n    const edges = this.transformEdges(flowVersion, executionStatusMap);\n\n    // Apply ELK left-to-right layout by default (using elkjs layered algorithm)\n    nodes = await this.applyElkLayoutToNodes(nodes, edges);\n\n    return {\n      nodes,\n      edges,\n      version: flowVersion,\n      name: flowName,\n      description: flowDescription,\n      isActive,\n      executionStatus: executionStatusMap,\n    };\n  }\n\n  /**\n   * Create execution status map from node executions\n   */\n  private createExecutionStatusMap(\n    nodeExecutions?: NodeExecution[],\n  ): Map<string, NodeExecutionStatusInfo> {\n    const statusMap = new Map<string, NodeExecutionStatusInfo>();\n\n    if (nodeExecutions) {\n      nodeExecutions.forEach((execution) => {\n        statusMap.set(execution.nodeId, {\n          status: execution.status,\n          error: execution.error,\n          output: execution.outputs,\n        });\n      });\n    }\n\n    return statusMap;\n  }\n\n  /**\n   * Transform flow nodes to React Flow format\n   */\n  private transformNodes(\n    flowVersion: FlowVersion,\n    executionStatusMap: Map<string, NodeExecutionStatusInfo>,\n  ): ReactFlowNode[] {\n    const nodes: ReactFlowNode[] = [];\n\n    const definition = flowVersion.invectDefinition;\n    if (!definition?.nodes) {\n      return nodes;\n    }\n\n    const actionRegistry = getGlobalActionRegistry();\n\n    definition.nodes.forEach((node: FlowNodeDefinitions) => {\n      const executionStatus = executionStatusMap.get(node.id);\n      const action = actionRegistry.get(node.type);\n\n      const displayName = this.getDisplayName(node, action);\n      const referenceId = this.getReferenceId(\n        node as FlowNodeDefinitions & { referenceId?: string },\n        displayName,\n      );\n\n      // Create strongly typed node data\n      const nodeData: ReactFlowNodeData = {\n        id: node.id,\n        type: node.type,\n        display_name: displayName,\n        reference_id: referenceId,\n        description: action?.description,\n        icon: action?.provider.icon,\n        status: this.mapExecutionStatusToNodeStatus(executionStatus?.status),\n        executionStatus: executionStatus?.status,\n        executionError: executionStatus?.error,\n        executionOutput: executionStatus?.output,\n        params: node.params,\n        // Runtime data will be populated during execution\n        inputs: undefined, // Could be populated from execution context if available\n        outputs: executionStatus?.output?.data,\n        // Flatten params to top level for component access\n        ...(node.params || {}),\n        // Data mapper config (top-level node field)\n        ...(node.mapper ? { mapper: node.mapper } : {}),\n      };\n\n      const transformedNode: ReactFlowNode = {\n        id: node.id,\n        type: node.type,\n        position: node.position || { x: 0, y: 0 },\n        data: nodeData,\n        width: 200,\n        height: 60,\n      };\n\n      nodes.push(transformedNode);\n    });\n\n    return nodes;\n  }\n\n  /**\n   * Get display name for a node, with fallbacks\n   */\n  private getDisplayName(node: FlowNodeDefinitions, action: { name: string } | undefined): string {\n    // First priority: user-defined label on the node itself\n    if (node.label && typeof node.label === 'string') {\n      return node.label;\n    }\n\n    // Second priority: action registry name\n    if (action?.name) {\n      return action.name;\n    }\n\n    // Fallback: humanise the node type string (e.g. \"core.javascript\" → \"Core Javascript\")\n    return node.type.replace(/[._]/g, ' ').replace(/\\b\\w/g, (c) => c.toUpperCase());\n  }\n\n  private static readonly MAX_REFERENCE_ID_LENGTH = 22;\n\n  /**\n   * Get or generate a reference_id for a node (snake_case, alphanumeric only)\n   * Truncates to MAX_REFERENCE_ID_LENGTH while preserving any increment suffix\n   */\n  private getReferenceId(\n    node: FlowNodeDefinitions & { referenceId?: string },\n    displayName: string,\n  ): string {\n    // Use existing referenceId if present (already truncated when saved)\n    if (node.referenceId && typeof node.referenceId === 'string') {\n      return node.referenceId;\n    }\n\n    // Generate from display name: lowercase, alphanumeric + underscores only\n    const baseId = displayName\n      .toLowerCase()\n      .replace(/[^a-z0-9\\s]/g, '') // Remove non-alphanumeric chars except spaces\n      .trim()\n      .replace(/\\s+/g, '_'); // Replace spaces with underscores\n\n    // Truncate to max length\n    return this.truncateReferenceId(baseId);\n  }\n\n  /**\n   * Truncate a reference ID to max length while preserving any numeric suffix\n   */\n  private truncateReferenceId(refId: string, suffix?: string): string {\n    const maxLen = ReactFlowRendererService.MAX_REFERENCE_ID_LENGTH;\n\n    if (refId.length <= maxLen) {\n      return refId;\n    }\n\n    if (suffix) {\n      const suffixWithUnderscore = `_${suffix}`;\n      const availableForBase = maxLen - suffixWithUnderscore.length;\n      if (availableForBase <= 0) {\n        return refId.substring(0, maxLen);\n      }\n      return refId.substring(0, availableForBase) + suffixWithUnderscore;\n    }\n\n    return refId.substring(0, maxLen);\n  }\n\n  /**\n   * Transform flow edges to React Flow format\n   */\n  private transformEdges(\n    flowVersion: FlowVersion,\n    executionStatusMap: Map<string, NodeExecutionStatusInfo>,\n  ): ReactFlowEdge[] {\n    const edges: ReactFlowEdge[] = [];\n\n    const definition = flowVersion.invectDefinition;\n    if (!definition?.edges || !definition?.nodes) {\n      return edges;\n    }\n\n    // Create a map of node IDs to their types for handle validation\n    const nodeTypeMap = new Map<string, string>();\n    definition.nodes.forEach((node: FlowNodeDefinitions) => {\n      nodeTypeMap.set(node.id, node.type);\n    });\n\n    definition.edges.forEach((edge: FlowEdge & { animated?: boolean }) => {\n      const sourceNodeStatus = executionStatusMap.get(edge.source);\n      const targetNodeStatus = executionStatusMap.get(edge.target);\n\n      // Check if either node is skipped\n      const isConnectedToSkippedNode =\n        sourceNodeStatus?.status === NodeExecutionStatus.SKIPPED ||\n        targetNodeStatus?.status === NodeExecutionStatus.SKIPPED;\n\n      // Pass through source/target handles from the stored edge definition\n      // These are needed by React Flow to connect edges to the correct handles\n      // Default to \"output\"/\"input\" if not specified (standard single-handle nodes)\n      const transformedEdge: ReactFlowEdge = {\n        id: edge.id,\n        source: edge.source,\n        target: edge.target,\n        sourceHandle: edge.sourceHandle || 'output',\n        targetHandle: edge.targetHandle || 'input',\n        animated: edge.animated || false,\n        data: {\n          type: isConnectedToSkippedNode ? 'skipped' : 'default',\n          animated: edge.animated || false,\n          highlighted: false,\n          selected: false,\n          sourceNodeStatus: sourceNodeStatus?.status,\n          targetNodeStatus: targetNodeStatus?.status,\n        },\n      };\n\n      edges.push(transformedEdge);\n    });\n\n    return edges;\n  }\n\n  /**\n   * Map execution status to node visual status\n   */\n  private mapExecutionStatusToNodeStatus(executionStatus?: NodeExecutionStatus): NodeVisualStatus {\n    if (!executionStatus) {\n      return 'idle';\n    }\n\n    switch (executionStatus) {\n      case NodeExecutionStatus.PENDING:\n      case NodeExecutionStatus.RUNNING:\n        return 'running';\n      case NodeExecutionStatus.SUCCESS:\n        return 'completed';\n      case NodeExecutionStatus.FAILED:\n        return 'error';\n      case NodeExecutionStatus.SKIPPED:\n        return 'skipped';\n      case NodeExecutionStatus.BATCH_SUBMITTED:\n        return 'running'; // Treat batch submitted as running\n      default:\n        return 'idle';\n    }\n  }\n\n  /**\n   * Apply ELK left-to-right layout to nodes\n   * Uses elkjs layered algorithm for better edge crossing minimization\n   *\n   * Note: ELK is async because elkjs uses web workers internally\n   */\n  private async applyElkLayoutToNodes(\n    nodes: ReactFlowNode[],\n    edges: ReactFlowEdge[],\n  ): Promise<ReactFlowNode[]> {\n    return applyElkLayout(nodes, edges);\n  }\n}\n"],"mappings":"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"}

package/dist/services/service-factory.cjs

@@ -0,0 +1,301 @@
+const require_errors_types = require("../types/common/errors.types.cjs");
+const require_flows_service = require("./flows/flows.service.cjs");
+const require_flow_runs_service = require("./flow-runs/flow-runs.service.cjs");
+const require_node_execution_service = require("./node-executions/node-execution.service.cjs");
+const require_base_client = require("./ai/base-client.cjs");
+const require_graph_service = require("./graph.service.cjs");
+const require_flow_orchestration_service = require("./flow-orchestration.service.cjs");
+const require_database_service = require("./database/database.service.cjs");
+const require_node_data_service = require("./node-data.service.cjs");
+const require_batch_jobs_service = require("./batch-jobs/batch-jobs.service.cjs");
+const require_credentials_service = require("./credentials/credentials.service.cjs");
+const require_encryption_service = require("./credentials/encryption.service.cjs");
+const require_agent_tool_execution_service = require("./agent-tool-executions/agent-tool-execution.service.cjs");
+const require_flow_access_service = require("./auth/flow-access.service.cjs");
+const require_flow_triggers_service = require("./triggers/flow-triggers.service.cjs");
+const require_cron_scheduler_service = require("./triggers/cron-scheduler.service.cjs");
+const require_chat_stream_service = require("./chat/chat-stream.service.cjs");
+const require_execution_event_bus = require("./execution-event-bus.cjs");
+const require_flow_versions_service = require("./flow-versions/flow-versions.service.cjs");
+const require_react_flow_renderer_service = require("./react-flow-renderer.service.cjs");
+//#region src/services/service-factory.ts
+/**
+* Service Factory for creating and managing core services
+*/
+var ServiceFactory = class {
+	services = null;
+	initialized = false;
+	logger;
+	constructor(config, nodeRegistry, invectRef, actionRegistryRef, pluginHookRunner, jsExpressionServiceRef, templateServiceRef) {
+		this.config = config;
+		this.nodeRegistry = nodeRegistry;
+		this.invectRef = invectRef;
+		this.actionRegistryRef = actionRegistryRef;
+		this.pluginHookRunner = pluginHookRunner;
+		this.jsExpressionServiceRef = jsExpressionServiceRef;
+		this.templateServiceRef = templateServiceRef;
+		this.logger = config.logger;
+		if (!this.nodeRegistry) throw new Error("Node registry is not provided, cannot initialize services without it");
+		else this.logger.debug("Node registry provided, will register default executors");
+	}
+	/**
+	* Initialize all services
+	*/
+	async initialize() {
+		if (this.initialized) {
+			this.logger.debug("Service factory already initialized");
+			return;
+		}
+		this.logger.info("Initializing service factory");
+		try {
+			const schemaVerification = this.config.schemaVerification;
+			const verificationOpts = schemaVerification ? {
+				strict: typeof schemaVerification === "object" ? schemaVerification.strict : false,
+				plugins: this.config.plugins || []
+			} : void 0;
+			const databaseService = new require_database_service.DatabaseService(this.config.baseDatabaseConfig, this.logger, verificationOpts, this.config.plugins || []);
+			await databaseService.initialize();
+			const batchJobsService = new require_batch_jobs_service.BatchJobsService(this.logger, databaseService);
+			const baseAIClient = new require_base_client.BaseAIClient(this.logger, batchJobsService);
+			const flowVersionsService = new require_flow_versions_service.FlowVersionsService(this.logger, databaseService);
+			const flowsService = new require_flows_service.FlowsService(this.logger, databaseService);
+			const nodeExecutionsService = new require_node_execution_service.NodeExecutionService(this.logger, databaseService);
+			const flowRunsService = new require_flow_runs_service.FlowRunsService(this.logger, databaseService, flowsService);
+			const nodeDataService = new require_node_data_service.NodeDataService(this.config, this.logger, databaseService, baseAIClient, this.templateServiceRef);
+			const graphService = new require_graph_service.GraphService(this.logger, nodeExecutionsService);
+			const reactFlowRendererService = new require_react_flow_renderer_service.ReactFlowRendererService(this.logger, flowsService, flowVersionsService, flowRunsService, nodeExecutionsService);
+			const encryptionService = new require_encryption_service.EncryptionService({ masterKey: process.env.ENCRYPTION_KEY || "default-dev-key-change-in-production" });
+			const credentialsService = new require_credentials_service.CredentialsService(databaseService.adapter, encryptionService, this.logger);
+			const agentToolExecutionService = new require_agent_tool_execution_service.AgentToolExecutionService(this.logger, databaseService);
+			let flowAccessService = null;
+			if (this.config.auth?.useFlowAccessTable) {
+				flowAccessService = new require_flow_access_service.FlowAccessService({
+					adapter: databaseService.adapter,
+					logger: this.logger
+				});
+				this.logger.info("Flow access table enabled - using Invect-managed flow permissions");
+			}
+			const orchestrationService = new require_flow_orchestration_service.FlowOrchestrationService(this.logger, flowRunsService, nodeExecutionsService, flowsService, nodeDataService, graphService, this.nodeRegistry, batchJobsService, credentialsService, baseAIClient, agentToolExecutionService, {
+				heartbeatIntervalMs: this.config.execution?.heartbeatIntervalMs ?? 3e4,
+				flowTimeoutMs: this.config.execution?.flowTimeoutMs ?? 6e5,
+				staleRunCheckIntervalMs: this.config.execution?.staleRunCheckIntervalMs ?? 6e4
+			}, this.pluginHookRunner, this.jsExpressionServiceRef, this.templateServiceRef);
+			const triggersService = new require_flow_triggers_service.FlowTriggersService(this.logger, databaseService, flowsService, flowVersionsService, orchestrationService);
+			const cronScheduler = new require_cron_scheduler_service.CronSchedulerService(this.logger, triggersService);
+			const chatStreamService = new require_chat_stream_service.ChatStreamService(this.logger, this.config, credentialsService, flowsService, flowVersionsService, this.actionRegistryRef ?? null, this.invectRef);
+			const executionEventBus = require_execution_event_bus.getExecutionEventBus();
+			flowRunsService.setEventBus(executionEventBus);
+			nodeExecutionsService.setEventBus(executionEventBus);
+			await Promise.all([
+				batchJobsService.initialize(),
+				flowsService.initialize(),
+				flowRunsService.initialize(),
+				nodeExecutionsService.initialize(),
+				orchestrationService.initialize(),
+				nodeDataService.initialize(),
+				reactFlowRendererService.initialize(),
+				agentToolExecutionService.initialize(),
+				triggersService.initialize()
+			]);
+			this.services = {
+				flowsService,
+				flowVersionsService,
+				flowRunsService,
+				nodeExecutionsService,
+				orchestrationService,
+				databaseService,
+				nodeDataService,
+				graphService,
+				batchJobsService,
+				baseAIClient,
+				reactFlowRendererService,
+				credentialsService,
+				agentToolExecutionService,
+				flowAccessService,
+				triggersService,
+				cronScheduler,
+				chatStreamService,
+				executionEventBus
+			};
+			this.initialized = true;
+			this.logger.info("Service factory initialized successfully");
+		} catch (error) {
+			this.logger.error("Failed to initialize service factory", error);
+			throw new require_errors_types.DatabaseError("Failed to initialize service factory", { error });
+		}
+	}
+	/**
+	* Get all services
+	*/
+	getServices() {
+		if (!this.services) throw new Error("Service factory not initialized");
+		return this.services;
+	}
+	/**
+	* Get flow service
+	*/
+	getFlowService() {
+		return this.getServices().flowsService;
+	}
+	/**
+	* Get execution service
+	*/
+	getFlowRunsService() {
+		return this.getServices().flowRunsService;
+	}
+	/**
+	* Get execution trace service
+	*/
+	getNodeExecutionsService() {
+		return this.getServices().nodeExecutionsService;
+	}
+	/**
+	* Get orchestration service
+	*/
+	getOrchestrationService() {
+		return this.getServices().orchestrationService;
+	}
+	getFlowVersionsService() {
+		return this.getServices().flowVersionsService;
+	}
+	/**
+	* Get database service
+	*/
+	getDatabaseService() {
+		return this.getServices().databaseService;
+	}
+	/**
+	* Get node data service
+	*/
+	getNodeDataService() {
+		return this.getServices().nodeDataService;
+	}
+	/**
+	* Get graph service
+	*/
+	getGraphService() {
+		return this.getServices().graphService;
+	}
+	/**
+	* Get base AI client
+	*/
+	getBaseAIClient() {
+		return this.getServices().baseAIClient;
+	}
+	/**
+	* Get React Flow renderer service
+	*/
+	getReactFlowRendererService() {
+		return this.getServices().reactFlowRendererService;
+	}
+	/**
+	* Get credentials service
+	*/
+	getCredentialsService() {
+		return this.getServices().credentialsService;
+	}
+	/**
+	* Get agent tool execution service
+	*/
+	getAgentToolExecutionService() {
+		return this.getServices().agentToolExecutionService;
+	}
+	/**
+	* Get flow access service (for Invect-managed flow permissions).
+	* Returns null if useFlowAccessTable is not enabled.
+	*/
+	getFlowAccessService() {
+		return this.getServices().flowAccessService;
+	}
+	/**
+	* Get triggers service
+	*/
+	getTriggersService() {
+		return this.getServices().triggersService;
+	}
+	/**
+	* Get cron scheduler service
+	*/
+	getCronScheduler() {
+		return this.getServices().cronScheduler;
+	}
+	/**
+	* Get chat stream service
+	*/
+	getChatStreamService() {
+		return this.getServices().chatStreamService;
+	}
+	/**
+	* Get execution event bus for SSE streaming
+	*/
+	getExecutionEventBus() {
+		return this.getServices().executionEventBus;
+	}
+	/**
+	* Health check for all services
+	*/
+	async healthCheck() {
+		const serviceResults = {};
+		let allHealthy = true;
+		if (!this.services) return {
+			healthy: false,
+			services: { factory: false },
+			timestamp: (/* @__PURE__ */ new Date()).toISOString()
+		};
+		try {
+			await this.services.databaseService.healthCheck();
+			serviceResults.database = true;
+		} catch (error) {
+			this.logger.error("Database health check failed", error);
+			serviceResults.database = false;
+			allHealthy = false;
+		}
+		serviceResults.nodeData = !!this.services.nodeDataService;
+		serviceResults.flow = !!this.services.flowsService;
+		serviceResults.execution = !!this.services.flowRunsService;
+		serviceResults.executionTrace = !!this.services.nodeExecutionsService;
+		serviceResults.orchestration = !!this.services.orchestrationService;
+		serviceResults.graph = !!this.services.graphService;
+		return {
+			healthy: allHealthy,
+			services: serviceResults,
+			timestamp: (/* @__PURE__ */ new Date()).toISOString()
+		};
+	}
+	/**
+	* Close all services and cleanup
+	*/
+	async close() {
+		if (!this.services) {
+			this.logger.debug("Service factory not initialized, nothing to close");
+			return;
+		}
+		this.logger.info("Closing service factory");
+		try {
+			await Promise.all([
+				this.services.flowsService.close(),
+				this.services.flowRunsService.close(),
+				this.services.nodeExecutionsService.close(),
+				this.services.orchestrationService.close(),
+				this.services.databaseService.close(),
+				this.services.nodeDataService.close()
+			]);
+			this.services = null;
+			this.initialized = false;
+			this.logger.info("Service factory closed successfully");
+		} catch (error) {
+			this.logger.error("Error closing service factory", error);
+			throw new require_errors_types.DatabaseError("Error closing service factory", { error });
+		}
+	}
+	/**
+	* Check if the factory is initialized
+	*/
+	isInitialized() {
+		return this.initialized;
+	}
+};
+//#endregion
+exports.ServiceFactory = ServiceFactory;
+
+//# sourceMappingURL=service-factory.cjs.map

package/dist/services/service-factory.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"service-factory.cjs","names":["DatabaseService","BatchJobsService","BaseAIClient","FlowVersionsService","FlowsService","NodeExecutionService","FlowRunsService","NodeDataService","GraphService","ReactFlowRendererService","EncryptionService","CredentialsService","AgentToolExecutionService","FlowAccessService","FlowOrchestrationService","FlowTriggersService","CronSchedulerService","ChatStreamService","getExecutionEventBus","DatabaseError"],"sources":["../../src/services/service-factory.ts"],"sourcesContent":["// Framework-agnostic Service Factory for Invect core\nimport { FlowsService } from './flows/flows.service';\nimport { FlowRunsService } from './flow-runs/flow-runs.service';\nimport { NodeExecutionService } from './node-executions/node-execution.service';\nimport { FlowOrchestrationService } from './flow-orchestration.service';\nimport { DatabaseService } from './database/database.service';\nimport { NodeDataService } from './node-data.service';\nimport { GraphService } from './graph.service';\nimport { BatchJobsService } from './batch-jobs/batch-jobs.service';\nimport { BaseAIClient } from './ai/base-client';\nimport { CredentialsService } from './credentials/credentials.service';\nimport { EncryptionService } from './credentials/encryption.service';\nimport { AgentToolExecutionService } from './agent-tool-executions/agent-tool-execution.service';\nimport { FlowAccessService } from './auth/flow-access.service';\nimport { FlowTriggersService } from './triggers/flow-triggers.service';\nimport { CronSchedulerService } from './triggers/cron-scheduler.service';\nimport { ChatStreamService } from './chat/chat-stream.service';\nimport { ExecutionEventBus, getExecutionEventBus } from './execution-event-bus';\nimport { DatabaseError } from 'src/types/common/errors.types';\nimport { Logger, InvectConfig } from 'src/types/schemas';\nimport { NodeExecutorRegistry } from 'src/nodes/executor-registry';\nimport { FlowVersionsService } from './flow-versions/flow-versions.service';\nimport { ReactFlowRendererService } from './react-flow-renderer.service';\nimport type { PluginHookRunner } from 'src/types/plugin.types';\n\n/**\n * Core Services container\n */\nexport interface CoreServices {\n  flowsService: FlowsService;\n  flowVersionsService: FlowVersionsService;\n  flowRunsService: FlowRunsService;\n  nodeExecutionsService: NodeExecutionService;\n  orchestrationService: FlowOrchestrationService;\n  databaseService: DatabaseService;\n  nodeDataService: NodeDataService;\n  graphService: GraphService;\n  batchJobsService: BatchJobsService;\n  baseAIClient: BaseAIClient;\n  reactFlowRendererService: ReactFlowRendererService;\n  credentialsService: CredentialsService;\n  agentToolExecutionService: AgentToolExecutionService;\n  flowAccessService: FlowAccessService | null;\n  triggersService: FlowTriggersService;\n  cronScheduler: CronSchedulerService;\n  chatStreamService: ChatStreamService;\n  executionEventBus: ExecutionEventBus;\n}\n\n/**\n * Service Factory for creating and managing core services\n */\nexport class ServiceFactory {\n  private services: CoreServices | null = null;\n  private initialized = false;\n  logger: Logger;\n\n  constructor(\n    private readonly config: InvectConfig,\n    private readonly nodeRegistry: NodeExecutorRegistry,\n    /** The Invect core instance (for passing to ChatStreamService → tools) */\n    private readonly invectRef?: unknown,\n    /** Action registry for chat system prompt context */\n    private readonly actionRegistryRef?: unknown,\n    /** Plugin hook runner for lifecycle hooks */\n    private readonly pluginHookRunner?: PluginHookRunner,\n    /** JS expression service for data mapper (sandbox) */\n    private readonly jsExpressionServiceRef?: import('./templating/js-expression.service').JsExpressionService,\n    /** Template service for resolving {{ }} expressions in node params */\n    private readonly templateServiceRef?: import('./templating/template.service').TemplateService,\n  ) {\n    this.logger = config.logger; // Fallback to console if no logger provided\n    if (!this.nodeRegistry) {\n      throw new Error('Node registry is not provided, cannot initialize services without it');\n    } else {\n      this.logger.debug('Node registry provided, will register default executors');\n    }\n  }\n\n  /**\n   * Initialize all services\n   */\n  async initialize(): Promise<void> {\n    if (this.initialized) {\n      this.logger.debug('Service factory already initialized');\n      return;\n    }\n\n    this.logger.info('Initializing service factory');\n\n    try {\n      // 1. Create database service first (no dependencies)\n      // Schema verification is opt-in via config.schemaVerification.\n      // It only checks that required tables/columns exist — does NOT run migrations.\n      const schemaVerification = this.config.schemaVerification;\n      const verificationOpts = schemaVerification\n        ? {\n            strict: typeof schemaVerification === 'object' ? schemaVerification.strict : false,\n            plugins: (this.config.plugins || []) as import('src/types/plugin.types').InvectPlugin[],\n          }\n        : undefined;\n      const databaseService = new DatabaseService(\n        this.config.baseDatabaseConfig,\n        this.logger,\n        verificationOpts,\n        (this.config.plugins || []) as import('src/types/plugin.types').InvectPlugin[],\n      );\n      await databaseService.initialize();\n\n      // 3. Create BatchJobsService (database only, no AI client)\n      const batchJobsService = new BatchJobsService(this.logger, databaseService);\n\n      // 4. Create BaseAIClient (adapters are registered dynamically from credentials)\n      const baseAIClient = new BaseAIClient(this.logger, batchJobsService);\n\n      // 5. Create other services\n      const flowVersionsService = new FlowVersionsService(this.logger, databaseService);\n      const flowsService = new FlowsService(this.logger, databaseService);\n      const nodeExecutionsService = new NodeExecutionService(this.logger, databaseService);\n      const flowRunsService = new FlowRunsService(this.logger, databaseService, flowsService);\n      const nodeDataService = new NodeDataService(\n        this.config,\n        this.logger,\n        databaseService,\n        baseAIClient,\n        this.templateServiceRef,\n      );\n      const graphService = new GraphService(this.logger, nodeExecutionsService);\n      const reactFlowRendererService = new ReactFlowRendererService(\n        this.logger,\n        flowsService,\n        flowVersionsService,\n        flowRunsService,\n        nodeExecutionsService,\n      );\n\n      // 5b. Create credentials service with encryption\n      const encryptionService = new EncryptionService({\n        masterKey: process.env.ENCRYPTION_KEY || 'default-dev-key-change-in-production',\n      });\n      const credentialsService = new CredentialsService(\n        databaseService.adapter,\n        encryptionService,\n        this.logger,\n      );\n\n      // 5c. Create agent tool execution service\n      const agentToolExecutionService = new AgentToolExecutionService(this.logger, databaseService);\n\n      // 5d. Create flow access service if enabled\n      let flowAccessService: FlowAccessService | null = null;\n      if (this.config.auth?.useFlowAccessTable) {\n        flowAccessService = new FlowAccessService({\n          adapter: databaseService.adapter,\n          logger: this.logger,\n        });\n        this.logger.info('Flow access table enabled - using Invect-managed flow permissions');\n      }\n\n      // 5e. Create triggers service (needs orchestration, wired after orchestration is created)\n      // Placeholder — we wire the real orchestrationService reference below.\n\n      // 6. Create orchestration service with proper dependencies\n      const orchestrationService = new FlowOrchestrationService(\n        this.logger,\n        flowRunsService,\n        nodeExecutionsService,\n        flowsService,\n        nodeDataService,\n        graphService,\n        this.nodeRegistry,\n        batchJobsService,\n        credentialsService, // Add credentials service\n        baseAIClient, // Add baseAIClient for agent prompt support\n        agentToolExecutionService, // Add agent tool execution service\n        // Execution config: heartbeat, flow timeout, stale-run detection\n        {\n          heartbeatIntervalMs: this.config.execution?.heartbeatIntervalMs ?? 30_000,\n          flowTimeoutMs: this.config.execution?.flowTimeoutMs ?? 600_000,\n          staleRunCheckIntervalMs: this.config.execution?.staleRunCheckIntervalMs ?? 60_000,\n        },\n        this.pluginHookRunner, // Plugin hooks for flow/node execution lifecycle\n        this.jsExpressionServiceRef, // JS expression engine for data mapper\n        this.templateServiceRef, // Template service for {{ }} expression resolution\n      );\n\n      // 6b. Create triggers service (depends on orchestration)\n      const triggersService = new FlowTriggersService(\n        this.logger,\n        databaseService,\n        flowsService,\n        flowVersionsService,\n        orchestrationService,\n      );\n\n      // 6c. Create cron scheduler (depends on triggers service)\n      const cronScheduler = new CronSchedulerService(this.logger, triggersService);\n\n      // 6d. Create chat stream service\n      const chatStreamService = new ChatStreamService(\n        this.logger,\n        this.config,\n        credentialsService,\n        flowsService,\n        flowVersionsService,\n        (this.actionRegistryRef as import('src/actions').ActionRegistry) ?? null,\n        this.invectRef,\n      );\n\n      // 6e. Wire execution event bus to services that write state\n      const executionEventBus = getExecutionEventBus();\n      flowRunsService.setEventBus(executionEventBus);\n      nodeExecutionsService.setEventBus(executionEventBus);\n\n      // Initialize services\n      await Promise.all([\n        batchJobsService.initialize(),\n        flowsService.initialize(),\n        flowRunsService.initialize(),\n        nodeExecutionsService.initialize(),\n        orchestrationService.initialize(),\n        nodeDataService.initialize(),\n        reactFlowRendererService.initialize(),\n        agentToolExecutionService.initialize(),\n        triggersService.initialize(),\n      ]);\n\n      // Store services\n      this.services = {\n        flowsService,\n        flowVersionsService,\n        flowRunsService,\n        nodeExecutionsService,\n        orchestrationService,\n        databaseService,\n        nodeDataService,\n        graphService,\n        batchJobsService,\n        baseAIClient,\n        reactFlowRendererService,\n        credentialsService,\n        agentToolExecutionService,\n        flowAccessService,\n        triggersService,\n        cronScheduler,\n        chatStreamService,\n        executionEventBus,\n      };\n\n      this.initialized = true;\n      this.logger.info('Service factory initialized successfully');\n    } catch (error) {\n      this.logger.error('Failed to initialize service factory', error);\n      throw new DatabaseError('Failed to initialize service factory', { error });\n    }\n  }\n\n  /**\n   * Get all services\n   */\n  getServices(): CoreServices {\n    if (!this.services) {\n      throw new Error('Service factory not initialized');\n    }\n    return this.services;\n  }\n\n  /**\n   * Get flow service\n   */\n  getFlowService(): FlowsService {\n    return this.getServices().flowsService;\n  }\n\n  /**\n   * Get execution service\n   */\n  getFlowRunsService(): FlowRunsService {\n    return this.getServices().flowRunsService;\n  }\n\n  /**\n   * Get execution trace service\n   */\n  getNodeExecutionsService(): NodeExecutionService {\n    return this.getServices().nodeExecutionsService;\n  }\n\n  /**\n   * Get orchestration service\n   */\n  getOrchestrationService(): FlowOrchestrationService {\n    return this.getServices().orchestrationService;\n  }\n\n  getFlowVersionsService() {\n    return this.getServices().flowVersionsService;\n  }\n\n  /**\n   * Get database service\n   */\n  getDatabaseService(): DatabaseService {\n    return this.getServices().databaseService;\n  }\n\n  /**\n   * Get node data service\n   */\n  getNodeDataService(): NodeDataService {\n    return this.getServices().nodeDataService;\n  }\n\n  /**\n   * Get graph service\n   */\n  getGraphService(): GraphService {\n    return this.getServices().graphService;\n  }\n\n  /**\n   * Get base AI client\n   */\n  getBaseAIClient(): BaseAIClient {\n    return this.getServices().baseAIClient;\n  }\n\n  /**\n   * Get React Flow renderer service\n   */\n  getReactFlowRendererService(): ReactFlowRendererService {\n    return this.getServices().reactFlowRendererService;\n  }\n\n  /**\n   * Get credentials service\n   */\n  getCredentialsService(): CredentialsService {\n    return this.getServices().credentialsService;\n  }\n\n  /**\n   * Get agent tool execution service\n   */\n  getAgentToolExecutionService(): AgentToolExecutionService {\n    return this.getServices().agentToolExecutionService;\n  }\n\n  /**\n   * Get flow access service (for Invect-managed flow permissions).\n   * Returns null if useFlowAccessTable is not enabled.\n   */\n  getFlowAccessService(): FlowAccessService | null {\n    return this.getServices().flowAccessService;\n  }\n\n  /**\n   * Get triggers service\n   */\n  getTriggersService(): FlowTriggersService {\n    return this.getServices().triggersService;\n  }\n\n  /**\n   * Get cron scheduler service\n   */\n  getCronScheduler(): CronSchedulerService {\n    return this.getServices().cronScheduler;\n  }\n\n  /**\n   * Get chat stream service\n   */\n  getChatStreamService(): ChatStreamService {\n    return this.getServices().chatStreamService;\n  }\n\n  /**\n   * Get execution event bus for SSE streaming\n   */\n  getExecutionEventBus(): ExecutionEventBus {\n    return this.getServices().executionEventBus;\n  }\n\n  /**\n   * Health check for all services\n   */\n  async healthCheck(): Promise<{\n    healthy: boolean;\n    services: Record<string, boolean>;\n    timestamp: string;\n  }> {\n    const serviceResults: Record<string, boolean> = {};\n    let allHealthy = true;\n\n    if (!this.services) {\n      return {\n        healthy: false,\n        services: { factory: false },\n        timestamp: new Date().toISOString(),\n      };\n    }\n\n    try {\n      // Test database connectivity\n      await this.services.databaseService.healthCheck();\n      serviceResults.database = true;\n    } catch (error) {\n      this.logger.error('Database health check failed', error);\n      serviceResults.database = false;\n      allHealthy = false;\n    }\n\n    // For other services, we'll just check if they're initialized\n    serviceResults.nodeData = !!this.services.nodeDataService;\n    serviceResults.flow = !!this.services.flowsService;\n    serviceResults.execution = !!this.services.flowRunsService;\n    serviceResults.executionTrace = !!this.services.nodeExecutionsService;\n    serviceResults.orchestration = !!this.services.orchestrationService;\n    serviceResults.graph = !!this.services.graphService;\n\n    return {\n      healthy: allHealthy,\n      services: serviceResults,\n      timestamp: new Date().toISOString(),\n    };\n  }\n\n  /**\n   * Close all services and cleanup\n   */\n  async close(): Promise<void> {\n    if (!this.services) {\n      this.logger.debug('Service factory not initialized, nothing to close');\n      return;\n    }\n\n    this.logger.info('Closing service factory');\n\n    try {\n      await Promise.all([\n        this.services.flowsService.close(),\n        this.services.flowRunsService.close(),\n        this.services.nodeExecutionsService.close(),\n        this.services.orchestrationService.close(),\n        this.services.databaseService.close(),\n        this.services.nodeDataService.close(),\n        // Note: GraphService doesn't have a close method as it's stateless\n      ]);\n\n      this.services = null;\n      this.initialized = false;\n      this.logger.info('Service factory closed successfully');\n    } catch (error) {\n      this.logger.error('Error closing service factory', error);\n      throw new DatabaseError('Error closing service factory', { error });\n    }\n  }\n\n  /**\n   * Check if the factory is initialized\n   */\n  isInitialized(): boolean {\n    return this.initialized;\n  }\n}\n"],"mappings":"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"}