@invect/core 0.0.1

package/dist/services/node-executions/node-execution.service.cjs

@@ -0,0 +1,236 @@
+const require_errors_types = require("../../types/common/errors.types.cjs");
+//#region src/services/node-executions/node-execution.service.ts
+/**
+* Core Execution Trace Service implementation using database models
+*/
+var NodeExecutionService = class {
+	initialized = false;
+	eventBus = null;
+	constructor(logger, databaseService) {
+		this.logger = logger;
+		this.databaseService = databaseService;
+	}
+	/** Attach the event bus so state changes are broadcast to SSE subscribers. */
+	setEventBus(bus) {
+		this.eventBus = bus;
+	}
+	/**
+	* Initialize the service
+	*/
+	async initialize() {
+		if (this.initialized) {
+			this.logger.debug("Execution trace service already initialized");
+			return;
+		}
+		try {
+			await this.databaseService.initialize();
+			this.initialized = true;
+			this.logger.info("Execution trace service initialized successfully");
+		} catch (error) {
+			this.logger.error("Failed to initialize execution trace service", { error });
+			throw new require_errors_types.DatabaseError("Failed to initialize execution trace service", { error });
+		}
+	}
+	/**
+	* Create a new execution trace
+	*/
+	async createNodeExecution(executionId, nodeId, nodeType, inputs) {
+		this.logger.debug("Creating execution trace", {
+			executionId,
+			nodeId,
+			nodeType
+		});
+		try {
+			const trace = await this.databaseService.nodeExecutions.create({
+				flowRunId: executionId,
+				nodeId,
+				nodeType,
+				inputs
+			});
+			this.logger.debug("Execution trace created successfully", {
+				traceId: trace.id,
+				executionId,
+				nodeId
+			});
+			this.eventBus?.emitNodeExecutionCreate(trace);
+			return trace;
+		} catch (error) {
+			this.logger.error("Failed to create execution trace", {
+				executionId,
+				nodeId,
+				nodeType,
+				error
+			});
+			throw error;
+		}
+	}
+	/**
+	* Update execution trace
+	*/
+	async updateNodeExecution(nodeExecutionId, updates) {
+		this.logger.debug("Updating execution trace", {
+			nodeExecutionId,
+			updates
+		});
+		try {
+			const updateInput = {
+				status: updates.status,
+				outputs: updates.outputs,
+				error: updates.error,
+				completedAt: updates.completedAt,
+				duration: updates.duration,
+				retryCount: updates.retryCount
+			};
+			const updatedTrace = await this.databaseService.nodeExecutions.update(nodeExecutionId, updateInput);
+			this.logger.debug("Execution trace updated successfully", {
+				nodeExecutionId,
+				status: updatedTrace.status
+			});
+			this.eventBus?.emitNodeExecutionUpdate(updatedTrace);
+			return updatedTrace;
+		} catch (error) {
+			this.logger.error("Failed to update execution trace", {
+				nodeExecutionId,
+				error
+			});
+			throw error;
+		}
+	}
+	/**
+	* Get execution trace by ID
+	*/
+	async getNodeExecutionById(nodeExecutionId) {
+		this.logger.debug("Retrieving execution trace by ID", { nodeExecutionId });
+		try {
+			const trace = await this.databaseService.nodeExecutions.findById(nodeExecutionId);
+			if (!trace) throw new require_errors_types.DatabaseError("Execution trace not found", { nodeExecutionId });
+			this.logger.debug("Execution trace retrieved successfully", { nodeExecutionId });
+			return trace;
+		} catch (error) {
+			this.logger.error("Failed to retrieve execution trace", {
+				nodeExecutionId,
+				error
+			});
+			throw error;
+		}
+	}
+	/**
+	* Get all traces for an execution
+	*/
+	async listNodeExecutionsByFlowRunId(flowRunId) {
+		this.logger.debug("Retrieving execution traces", { flowRunId });
+		try {
+			const traces = await this.databaseService.nodeExecutions.findByFlowRunId(flowRunId);
+			this.logger.debug("Execution traces retrieved successfully", {
+				flowRunId,
+				count: traces.length
+			});
+			return traces;
+		} catch (error) {
+			this.logger.error("Failed to retrieve execution traces", {
+				flowRunId,
+				error
+			});
+			throw error;
+		}
+	}
+	/**
+	* Update trace status with optional additional data
+	*/
+	async updateNodeExecutionStatus(traceId, status, data) {
+		this.logger.debug("Updating node execution status", JSON.stringify({
+			traceId,
+			status,
+			data
+		}));
+		try {
+			const updated = await this.databaseService.nodeExecutions.updateTraceStatus(traceId, status, data);
+			this.eventBus?.emitNodeExecutionUpdate(updated);
+			return updated;
+		} catch (error) {
+			this.logger.error("Failed to update trace status", {
+				traceId,
+				status,
+				error
+			});
+			throw new require_errors_types.DatabaseError("Failed to update trace status", { error });
+		}
+	}
+	/**
+	* Increment retry count
+	*/
+	async incrementRetryCount(traceId) {
+		return this.databaseService.nodeExecutions.incrementRetryCount(traceId);
+	}
+	/**
+	* Get all executions across all flows with optional filtering, pagination, and sorting
+	*/
+	async listNodeExecutions(options) {
+		try {
+			this.logger.debug("Getting all node executions", { options });
+			const result = await this.databaseService.nodeExecutions.list(options);
+			this.logger.debug("Node executions retrieved successfully", {
+				count: result.data.length,
+				pagination: result.pagination
+			});
+			return result;
+		} catch (error) {
+			this.logger.error("Failed to get all node executions", {
+				options,
+				error
+			});
+			throw new require_errors_types.DatabaseError("Failed to get all node executions", { error });
+		}
+	}
+	/**
+	* Get execution with flow data (enhanced single execution retrieval)
+	*/
+	async getExecutionWithFlowData(executionId) {
+		try {
+			this.logger.debug("Getting execution with flow data", { executionId });
+			const execution = await this.databaseService.flowRuns.findById(executionId);
+			if (!execution) return null;
+			const flow = await this.databaseService.flows.findById(execution.flowId);
+			if (!flow) {
+				this.logger.warn("Flow not found for execution", {
+					executionId,
+					flowId: execution.flowId
+				});
+				return execution;
+			}
+			const flowVersion = await this.databaseService.flowVersions.findByKey(execution.flowId, execution.flowVersion);
+			if (!flowVersion) {
+				this.logger.warn("Flow version not found for execution", {
+					executionId,
+					flowId: execution.flowId,
+					flowVersion: execution.flowVersion
+				});
+				return execution;
+			}
+			const traces = await this.databaseService.nodeExecutions.findByFlowRunId(executionId);
+			return {
+				...execution,
+				flowData: flow,
+				flowVersionData: flowVersion,
+				traces
+			};
+		} catch (error) {
+			this.logger.error("Failed to get execution with flow data", {
+				executionId,
+				error
+			});
+			throw new require_errors_types.DatabaseError("Failed to get execution with flow data", { error });
+		}
+	}
+	/**
+	* Close the service
+	*/
+	async close() {
+		this.logger.debug("Closing execution trace service");
+		this.initialized = false;
+	}
+};
+//#endregion
+exports.NodeExecutionService = NodeExecutionService;
+
+//# sourceMappingURL=node-execution.service.cjs.map

package/dist/services/node-executions/node-execution.service.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"node-execution.service.cjs","names":["DatabaseError"],"sources":["../../../src/services/node-executions/node-execution.service.ts"],"sourcesContent":["import type { DatabaseService } from '../database/database.service';\nimport { Logger } from 'src/types/schemas';\nimport { DatabaseError } from 'src/types/common/errors.types';\nimport { NodeExecutionStatus } from 'src/types/base';\nimport { PaginatedResponse, QueryOptions } from 'src/types/schemas/pagination-sort-filter';\nimport { NodeExecution } from './node-executions.model';\nimport type { NodeOutput } from 'src/types/node-io-types';\nimport type { ExecutionEventBus } from '../execution-event-bus';\n\n/**\n * Core Execution Trace Service implementation using database models\n */\nexport class NodeExecutionService {\n  private initialized: boolean = false;\n  private eventBus: ExecutionEventBus | null = null;\n\n  constructor(\n    private readonly logger: Logger,\n    private readonly databaseService: DatabaseService,\n  ) {}\n\n  /** Attach the event bus so state changes are broadcast to SSE subscribers. */\n  setEventBus(bus: ExecutionEventBus): void {\n    this.eventBus = bus;\n  }\n\n  /**\n   * Initialize the service\n   */\n  async initialize(): Promise<void> {\n    if (this.initialized) {\n      this.logger.debug('Execution trace service already initialized');\n      return;\n    }\n\n    try {\n      // Ensure database service is initialized\n      await this.databaseService.initialize();\n      this.initialized = true;\n      this.logger.info('Execution trace service initialized successfully');\n    } catch (error) {\n      this.logger.error('Failed to initialize execution trace service', { error });\n      throw new DatabaseError('Failed to initialize execution trace service', { error });\n    }\n  }\n\n  /**\n   * Create a new execution trace\n   */\n  async createNodeExecution(\n    executionId: string,\n    nodeId: string,\n    nodeType: string,\n    inputs: Record<string, unknown>,\n  ) {\n    this.logger.debug('Creating execution trace', { executionId, nodeId, nodeType });\n\n    try {\n      const trace = await this.databaseService.nodeExecutions.create({\n        flowRunId: executionId,\n        nodeId,\n        nodeType,\n        inputs,\n      });\n\n      this.logger.debug('Execution trace created successfully', {\n        traceId: trace.id,\n        executionId,\n        nodeId,\n      });\n      this.eventBus?.emitNodeExecutionCreate(trace);\n      return trace;\n    } catch (error) {\n      this.logger.error('Failed to create execution trace', {\n        executionId,\n        nodeId,\n        nodeType,\n        error,\n      });\n      throw error;\n    }\n  }\n\n  /**\n   * Update execution trace\n   */\n  async updateNodeExecution(nodeExecutionId: string, updates: Partial<NodeExecution>) {\n    this.logger.debug('Updating execution trace', { nodeExecutionId, updates });\n\n    try {\n      // Map the updates to the model's update input type\n      const updateInput = {\n        status: updates.status,\n        outputs: updates.outputs,\n        error: updates.error,\n        completedAt: updates.completedAt,\n        duration: updates.duration,\n        retryCount: updates.retryCount,\n      };\n\n      const updatedTrace = await this.databaseService.nodeExecutions.update(\n        nodeExecutionId,\n        updateInput,\n      );\n\n      this.logger.debug('Execution trace updated successfully', {\n        nodeExecutionId,\n        status: updatedTrace.status,\n      });\n      this.eventBus?.emitNodeExecutionUpdate(updatedTrace);\n      return updatedTrace;\n    } catch (error) {\n      this.logger.error('Failed to update execution trace', { nodeExecutionId, error });\n      throw error;\n    }\n  }\n\n  /**\n   * Get execution trace by ID\n   */\n  async getNodeExecutionById(nodeExecutionId: string) {\n    this.logger.debug('Retrieving execution trace by ID', { nodeExecutionId });\n\n    try {\n      const trace = await this.databaseService.nodeExecutions.findById(nodeExecutionId);\n\n      if (!trace) {\n        throw new DatabaseError('Execution trace not found', { nodeExecutionId });\n      }\n\n      this.logger.debug('Execution trace retrieved successfully', { nodeExecutionId });\n      return trace;\n    } catch (error) {\n      this.logger.error('Failed to retrieve execution trace', { nodeExecutionId, error });\n      throw error;\n    }\n  }\n\n  /**\n   * Get all traces for an execution\n   */\n  async listNodeExecutionsByFlowRunId(flowRunId: string) {\n    this.logger.debug('Retrieving execution traces', { flowRunId: flowRunId });\n\n    try {\n      const traces = await this.databaseService.nodeExecutions.findByFlowRunId(flowRunId);\n\n      this.logger.debug('Execution traces retrieved successfully', {\n        flowRunId: flowRunId,\n        count: traces.length,\n      });\n      return traces;\n    } catch (error) {\n      this.logger.error('Failed to retrieve execution traces', { flowRunId: flowRunId, error });\n      throw error;\n    }\n  }\n\n  /**\n   * Update trace status with optional additional data\n   */\n  async updateNodeExecutionStatus(\n    traceId: string,\n    status: NodeExecutionStatus,\n    data?: {\n      outputs?: NodeOutput;\n      error?: string;\n      reason?: string;\n    },\n  ): Promise<NodeExecution> {\n    this.logger.debug('Updating node execution status', JSON.stringify({ traceId, status, data }));\n\n    try {\n      const updated = await this.databaseService.nodeExecutions.updateTraceStatus(\n        traceId,\n        status,\n        data,\n      );\n      this.eventBus?.emitNodeExecutionUpdate(updated);\n      return updated;\n    } catch (error) {\n      this.logger.error('Failed to update trace status', { traceId, status, error });\n      throw new DatabaseError('Failed to update trace status', { error });\n    }\n  }\n\n  /**\n   * Increment retry count\n   */\n  async incrementRetryCount(traceId: string) {\n    return this.databaseService.nodeExecutions.incrementRetryCount(traceId);\n  }\n\n  /**\n   * Get all executions across all flows with optional filtering, pagination, and sorting\n   */\n  async listNodeExecutions(\n    options?: QueryOptions<NodeExecution>,\n  ): Promise<PaginatedResponse<NodeExecution>> {\n    try {\n      this.logger.debug('Getting all node executions', { options });\n\n      // Call the model's list method which now handles pagination, sorting, and filtering\n      const result = await this.databaseService.nodeExecutions.list(options);\n\n      this.logger.debug('Node executions retrieved successfully', {\n        count: result.data.length,\n        pagination: result.pagination,\n      });\n\n      return result;\n    } catch (error) {\n      this.logger.error('Failed to get all node executions', { options, error });\n      throw new DatabaseError('Failed to get all node executions', { error });\n    }\n  }\n\n  /**\n   * Get execution with flow data (enhanced single execution retrieval)\n   */\n  async getExecutionWithFlowData(executionId: string) {\n    try {\n      this.logger.debug('Getting execution with flow data', { executionId });\n\n      // Get the execution\n      const execution = await this.databaseService.flowRuns.findById(executionId);\n      if (!execution) {\n        return null;\n      }\n\n      // Get the flow data\n      const flow = await this.databaseService.flows.findById(execution.flowId);\n      if (!flow) {\n        this.logger.warn('Flow not found for execution', {\n          executionId,\n          flowId: execution.flowId,\n        });\n        return execution;\n      }\n\n      // Get the flow version data\n      const flowVersion = await this.databaseService.flowVersions.findByKey(\n        execution.flowId,\n        execution.flowVersion,\n      );\n      if (!flowVersion) {\n        this.logger.warn('Flow version not found for execution', {\n          executionId,\n          flowId: execution.flowId,\n          flowVersion: execution.flowVersion,\n        });\n        return execution;\n      }\n\n      // Get execution traces\n      const traces = await this.databaseService.nodeExecutions.findByFlowRunId(executionId);\n\n      return {\n        ...execution,\n        flowData: flow,\n        flowVersionData: flowVersion,\n        traces,\n      };\n    } catch (error) {\n      this.logger.error('Failed to get execution with flow data', { executionId, error });\n      throw new DatabaseError('Failed to get execution with flow data', { error });\n    }\n  }\n\n  /**\n   * Close the service\n   */\n  async close(): Promise<void> {\n    this.logger.debug('Closing execution trace service');\n    this.initialized = false;\n    // Database connection lifecycle is managed externally\n  }\n}\n"],"mappings":"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"}

package/dist/services/node-executions/node-execution.service.d.cts

@@ -0,0 +1,126 @@
+import { FlowRunStatus, NodeExecutionStatus } from "../../types/base.cjs";
+import { PaginatedResponse, QueryOptions } from "../../types/schemas/pagination-sort-filter.cjs";
+import { Logger } from "../../types/schemas-fresh/invect-config.cjs";
+import { NodeOutput } from "../../types/node-io-types.cjs";
+import { FlowRun } from "../flow-runs/flow-runs.model.cjs";
+import { Flow } from "../flows/flows.model.cjs";
+import { NodeExecution } from "./node-executions.model.cjs";
+import { DatabaseService } from "../database/database.service.cjs";
+import { ExecutionEventBus } from "../execution-event-bus.cjs";
+//#region src/services/node-executions/node-execution.service.d.ts
+/**
+ * Core Execution Trace Service implementation using database models
+ */
+declare class NodeExecutionService {
+  private readonly logger;
+  private readonly databaseService;
+  private initialized;
+  private eventBus;
+  constructor(logger: Logger, databaseService: DatabaseService);
+  /** Attach the event bus so state changes are broadcast to SSE subscribers. */
+  setEventBus(bus: ExecutionEventBus): void;
+  /**
+   * Initialize the service
+   */
+  initialize(): Promise<void>;
+  /**
+   * Create a new execution trace
+   */
+  createNodeExecution(executionId: string, nodeId: string, nodeType: string, inputs: Record<string, unknown>): Promise<NodeExecution>;
+  /**
+   * Update execution trace
+   */
+  updateNodeExecution(nodeExecutionId: string, updates: Partial<NodeExecution>): Promise<NodeExecution>;
+  /**
+   * Get execution trace by ID
+   */
+  getNodeExecutionById(nodeExecutionId: string): Promise<NodeExecution>;
+  /**
+   * Get all traces for an execution
+   */
+  listNodeExecutionsByFlowRunId(flowRunId: string): Promise<NodeExecution[]>;
+  /**
+   * Update trace status with optional additional data
+   */
+  updateNodeExecutionStatus(traceId: string, status: NodeExecutionStatus, data?: {
+    outputs?: NodeOutput;
+    error?: string;
+    reason?: string;
+  }): Promise<NodeExecution>;
+  /**
+   * Increment retry count
+   */
+  incrementRetryCount(traceId: string): Promise<NodeExecution>;
+  /**
+   * Get all executions across all flows with optional filtering, pagination, and sorting
+   */
+  listNodeExecutions(options?: QueryOptions<NodeExecution>): Promise<PaginatedResponse<NodeExecution>>;
+  /**
+   * Get execution with flow data (enhanced single execution retrieval)
+   */
+  getExecutionWithFlowData(executionId: string): Promise<FlowRun | {
+    flowData: Flow;
+    flowVersionData: {
+      createdAt: string;
+      flowId: string;
+      version: number;
+      invectDefinition: {
+        nodes: {
+          id: string;
+          type: string;
+          params: Record<string, unknown>;
+          position?: {
+            x: number;
+            y: number;
+          } | undefined;
+          label?: string | undefined;
+          referenceId?: string | undefined;
+          _loop?: unknown;
+          mapper?: {
+            enabled: boolean;
+            expression: string;
+            mode: "auto" | "iterate" | "reshape";
+            outputMode: "object" | "array" | "concat" | "first" | "last";
+            concurrency: number;
+            onEmpty: "error" | "skip";
+            keyField?: string | undefined;
+          } | undefined;
+        }[];
+        edges: {
+          id: string;
+          source: string;
+          target: string;
+          sourceHandle?: string | undefined;
+          targetHandle?: string | undefined;
+          metadata?: Record<string, unknown> | undefined;
+        }[];
+        metadata?: Record<string, unknown> | undefined;
+      };
+      createdBy: string | null;
+    };
+    traces: NodeExecution[];
+    id: string;
+    flowId: string;
+    flowVersion: number;
+    status: FlowRunStatus;
+    inputs: Record<string, unknown>;
+    outputs?: Record<string, unknown>;
+    error?: string;
+    startedAt: Date | string;
+    completedAt?: Date | string;
+    duration?: number;
+    createdBy?: string;
+    triggerType?: string | null;
+    triggerId?: string | null;
+    triggerNodeId?: string | null;
+    triggerData?: Record<string, unknown> | null;
+    lastHeartbeatAt?: Date | string | null;
+  } | null>;
+  /**
+   * Close the service
+   */
+  close(): Promise<void>;
+}
+//#endregion
+export { NodeExecutionService };
+//# sourceMappingURL=node-execution.service.d.cts.map

package/dist/services/node-executions/node-execution.service.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"node-execution.service.d.cts","names":[],"sources":["../../../src/services/node-executions/node-execution.service.ts"],"mappings":";;;;;;;;;;;;;cAYa,oBAAA;EAAA,iBAKQ,MAAA;EAAA,iBACA,eAAA;EAAA,QALX,WAAA;EAAA,QACA,QAAA;cAGW,MAAA,EAAQ,MAAA,EACR,eAAA,EAAiB,eAAA;EAAA;EAIpC,WAAA,CAAY,GAAA,EAAK,iBAAA;EAOG;;;EAAd,UAAA,CAAA,GAAc,OAAA;EAyDgD;;;EArC9D,mBAAA,CACJ,WAAA,UACA,MAAA,UACA,QAAA,UACA,MAAA,EAAQ,MAAA,oBAAuB,OAAA,CAAA,aAAA;EAmEiB;;;EAlC5C,mBAAA,CAAoB,eAAA,UAAyB,OAAA,EAAS,OAAA,CAAQ,aAAA,IAAc,OAAA,CAAA,aAAA;EA6ExE;;;EA3CJ,oBAAA,CAAqB,eAAA,WAAuB,OAAA,CAAA,aAAA;EAqET;;;EAhDnC,6BAAA,CAA8B,SAAA,WAAiB,OAAA,CAAA,aAAA;EAyDxB;;;EArCvB,yBAAA,CACJ,OAAA,UACA,MAAA,EAAQ,mBAAA,EACR,IAAA;IACE,OAAA,GAAU,UAAA;IACV,KAAA;IACA,MAAA;EAAA,IAED,OAAA,CAAQ,aAAA;;;;EAoBL,mBAAA,CAAoB,OAAA,WAAe,OAAA,CAAA,aAAA;;;;EAOnC,kBAAA,CACJ,OAAA,GAAU,YAAA,CAAa,aAAA,IACtB,OAAA,CAAQ,iBAAA,CAAkB,aAAA;EAsBqB;;;EAA5C,wBAAA,CAAyB,WAAA,WAAmB,OAAA,CAtBxC,OAAA;cAsBwC,IAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAtBvC;;;EA0EL,KAAA,CAAA,GAAS,OAAA;AAAA"}

package/dist/services/node-executions/node-execution.service.d.ts

@@ -0,0 +1,126 @@
+import { FlowRunStatus, NodeExecutionStatus } from "../../types/base.js";
+import { PaginatedResponse, QueryOptions } from "../../types/schemas/pagination-sort-filter.js";
+import { Logger } from "../../types/schemas-fresh/invect-config.js";
+import { NodeOutput } from "../../types/node-io-types.js";
+import { FlowRun } from "../flow-runs/flow-runs.model.js";
+import { Flow } from "../flows/flows.model.js";
+import { NodeExecution } from "./node-executions.model.js";
+import { DatabaseService } from "../database/database.service.js";
+import { ExecutionEventBus } from "../execution-event-bus.js";
+//#region src/services/node-executions/node-execution.service.d.ts
+/**
+ * Core Execution Trace Service implementation using database models
+ */
+declare class NodeExecutionService {
+  private readonly logger;
+  private readonly databaseService;
+  private initialized;
+  private eventBus;
+  constructor(logger: Logger, databaseService: DatabaseService);
+  /** Attach the event bus so state changes are broadcast to SSE subscribers. */
+  setEventBus(bus: ExecutionEventBus): void;
+  /**
+   * Initialize the service
+   */
+  initialize(): Promise<void>;
+  /**
+   * Create a new execution trace
+   */
+  createNodeExecution(executionId: string, nodeId: string, nodeType: string, inputs: Record<string, unknown>): Promise<NodeExecution>;
+  /**
+   * Update execution trace
+   */
+  updateNodeExecution(nodeExecutionId: string, updates: Partial<NodeExecution>): Promise<NodeExecution>;
+  /**
+   * Get execution trace by ID
+   */
+  getNodeExecutionById(nodeExecutionId: string): Promise<NodeExecution>;
+  /**
+   * Get all traces for an execution
+   */
+  listNodeExecutionsByFlowRunId(flowRunId: string): Promise<NodeExecution[]>;
+  /**
+   * Update trace status with optional additional data
+   */
+  updateNodeExecutionStatus(traceId: string, status: NodeExecutionStatus, data?: {
+    outputs?: NodeOutput;
+    error?: string;
+    reason?: string;
+  }): Promise<NodeExecution>;
+  /**
+   * Increment retry count
+   */
+  incrementRetryCount(traceId: string): Promise<NodeExecution>;
+  /**
+   * Get all executions across all flows with optional filtering, pagination, and sorting
+   */
+  listNodeExecutions(options?: QueryOptions<NodeExecution>): Promise<PaginatedResponse<NodeExecution>>;
+  /**
+   * Get execution with flow data (enhanced single execution retrieval)
+   */
+  getExecutionWithFlowData(executionId: string): Promise<FlowRun | {
+    flowData: Flow;
+    flowVersionData: {
+      createdAt: string;
+      flowId: string;
+      version: number;
+      invectDefinition: {
+        nodes: {
+          id: string;
+          type: string;
+          params: Record<string, unknown>;
+          position?: {
+            x: number;
+            y: number;
+          } | undefined;
+          label?: string | undefined;
+          referenceId?: string | undefined;
+          _loop?: unknown;
+          mapper?: {
+            enabled: boolean;
+            expression: string;
+            mode: "auto" | "iterate" | "reshape";
+            outputMode: "object" | "array" | "concat" | "first" | "last";
+            concurrency: number;
+            onEmpty: "error" | "skip";
+            keyField?: string | undefined;
+          } | undefined;
+        }[];
+        edges: {
+          id: string;
+          source: string;
+          target: string;
+          sourceHandle?: string | undefined;
+          targetHandle?: string | undefined;
+          metadata?: Record<string, unknown> | undefined;
+        }[];
+        metadata?: Record<string, unknown> | undefined;
+      };
+      createdBy: string | null;
+    };
+    traces: NodeExecution[];
+    id: string;
+    flowId: string;
+    flowVersion: number;
+    status: FlowRunStatus;
+    inputs: Record<string, unknown>;
+    outputs?: Record<string, unknown>;
+    error?: string;
+    startedAt: Date | string;
+    completedAt?: Date | string;
+    duration?: number;
+    createdBy?: string;
+    triggerType?: string | null;
+    triggerId?: string | null;
+    triggerNodeId?: string | null;
+    triggerData?: Record<string, unknown> | null;
+    lastHeartbeatAt?: Date | string | null;
+  } | null>;
+  /**
+   * Close the service
+   */
+  close(): Promise<void>;
+}
+//#endregion
+export { NodeExecutionService };
+//# sourceMappingURL=node-execution.service.d.ts.map

package/dist/services/node-executions/node-execution.service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"node-execution.service.d.ts","names":[],"sources":["../../../src/services/node-executions/node-execution.service.ts"],"mappings":";;;;;;;;;;;;;cAYa,oBAAA;EAAA,iBAKQ,MAAA;EAAA,iBACA,eAAA;EAAA,QALX,WAAA;EAAA,QACA,QAAA;cAGW,MAAA,EAAQ,MAAA,EACR,eAAA,EAAiB,eAAA;EADT;EAK3B,WAAA,CAAY,GAAA,EAAK,iBAAA;EAAA;;;EAOX,UAAA,CAAA,GAAc,OAAA;EAwBa;;;EAJ3B,mBAAA,CACJ,WAAA,UACA,MAAA,UACA,QAAA,UACA,MAAA,EAAQ,MAAA,oBAAuB,OAAA,CAAA,aAAA;EAiCiD;;;EAA5E,mBAAA,CAAoB,eAAA,UAAyB,OAAA,EAAS,OAAA,CAAQ,aAAA,IAAc,OAAA,CAAA,aAAA;EAuD7B;;;EArB/C,oBAAA,CAAqB,eAAA,WAAuB,OAAA,CAAA,aAAA;EAiD/C;;;EA5BG,6BAAA,CAA8B,SAAA,WAAiB,OAAA,CAAA,aAAA;EAwDzC;;;EApCN,yBAAA,CACJ,OAAA,UACA,MAAA,EAAQ,mBAAA,EACR,IAAA;IACE,OAAA,GAAU,UAAA;IACV,KAAA;IACA,MAAA;EAAA,IAED,OAAA,CAAQ,aAAA;;;;EAoBL,mBAAA,CAAoB,OAAA,WAAe,OAAA,CAAA,aAAA;;;;EAOnC,kBAAA,CACJ,OAAA,GAAU,YAAA,CAAa,aAAA,IACtB,OAAA,CAAQ,iBAAA,CAAkB,aAAA;;;;EAsBvB,wBAAA,CAAyB,WAAA,WAAmB,OAAA,CAtBxC,OAAA;cAsBwC,IAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAtB/C;;;EA0EG,KAAA,CAAA,GAAS,OAAA;AAAA"}