@invect/core 0.0.1

package/dist/services/node-executions/node-executions.model.d.cts

@@ -0,0 +1,102 @@
+import { 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 { InvectAdapter } from "../../database/adapter.cjs";
+
+//#region src/services/node-executions/node-executions.model.d.ts
+/**
+ * Execution Trace entity
+ */
+interface NodeExecution {
+  id: string;
+  flowRunId: string;
+  nodeId: string;
+  nodeType: string;
+  status: NodeExecutionStatus;
+  inputs: Record<string, unknown>;
+  outputs?: NodeOutput;
+  error?: string;
+  startedAt: Date | string;
+  completedAt?: Date | string;
+  duration?: number;
+  retryCount: number;
+}
+/**
+ * Input for creating a new execution trace
+ */
+interface CreateNodeExecutionInput {
+  flowRunId: string;
+  nodeId: string;
+  nodeType: string;
+  inputs: Record<string, unknown>;
+}
+/**
+ * Input for updating an execution trace
+ */
+interface UpdateNodeExecutionInput {
+  status?: NodeExecutionStatus;
+  outputs?: NodeOutput;
+  error?: string;
+  completedAt?: Date | string;
+  duration?: number;
+  retryCount?: number;
+}
+/**
+ * Node Executions CRUD operations class — uses InvectAdapter.
+ */
+declare class NodeExecutionsModel {
+  private readonly adapter;
+  private readonly logger;
+  constructor(adapter: InvectAdapter, logger: Logger);
+  /**
+   * Create a new execution trace
+   */
+  create(input: CreateNodeExecutionInput): Promise<NodeExecution>;
+  /**
+   * Get all execution traces with optional filtering
+   */
+  list(options?: QueryOptions<NodeExecution>): Promise<PaginatedResponse<NodeExecution>>;
+  /**
+   * Get execution trace by ID
+   */
+  findById(id: string): Promise<NodeExecution | null>;
+  /**
+   * Update execution trace
+   */
+  update(id: string, input: UpdateNodeExecutionInput): Promise<NodeExecution>;
+  /**
+   * Delete execution trace
+   */
+  delete(id: string): Promise<void>;
+  /**
+   * Get execution traces by flow run ID
+   */
+  findByFlowRunId(flowRunId: string): Promise<NodeExecution[]>;
+  /**
+   * Get execution traces by flow run ID and node ID
+   */
+  findByExecutionAndNode(flowRunId: string, nodeId: string): Promise<NodeExecution[]>;
+  /**
+   * Update trace status with optional additional data
+   */
+  updateTraceStatus(id: string, status: NodeExecutionStatus, data?: {
+    outputs?: NodeOutput;
+    error?: string;
+    reason?: string;
+  }): Promise<NodeExecution>;
+  /**
+   * Increment retry count
+   */
+  incrementRetryCount(id: string): Promise<NodeExecution>;
+  private serializeOutputs;
+  private calculatePaginationMetadata;
+  private processPaginatedResults;
+  private normalize;
+  private buildFilterWhere;
+  private mapFilterField;
+  private mapSortField;
+}
+//#endregion
+export { CreateNodeExecutionInput, NodeExecution, NodeExecutionsModel, UpdateNodeExecutionInput };
+//# sourceMappingURL=node-executions.model.d.cts.map

package/dist/services/node-executions/node-executions.model.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"node-executions.model.d.cts","names":[],"sources":["../../../src/services/node-executions/node-executions.model.ts"],"mappings":";;;;;;;;;;UAUiB,aAAA;EACf,EAAA;EACA,SAAA;EACA,MAAA;EACA,QAAA;EACA,MAAA,EAAQ,mBAAA;EACR,MAAA,EAAQ,MAAA;EACR,OAAA,GAAU,UAAA;EACV,KAAA;EACA,SAAA,EAAW,IAAA;EACX,WAAA,GAAc,IAAA;EACd,QAAA;EACA,UAAA;AAAA;;;;UAMe,wBAAA;EACf,SAAA;EACA,MAAA;EACA,QAAA;EACA,MAAA,EAAQ,MAAA;AAAA;;;;UAMO,wBAAA;EACf,MAAA,GAAS,mBAAA;EACT,OAAA,GAAU,UAAA;EACV,KAAA;EACA,WAAA,GAAc,IAAA;EACd,QAAA;EACA,UAAA;AAAA;;;;cAmBW,mBAAA;EAAA,iBAEQ,OAAA;EAAA,iBACA,MAAA;cADA,OAAA,EAAS,aAAA,EACT,MAAA,EAAQ,MAAA;EA1BjB;;;EAgCJ,MAAA,CAAO,KAAA,EAAO,wBAAA,GAA2B,OAAA,CAAQ,aAAA;EA7BvD;;;EAqDM,IAAA,CAAK,OAAA,GAAU,YAAA,CAAa,aAAA,IAAiB,OAAA,CAAQ,iBAAA,CAAkB,aAAA;EAjClE;;;EAgEL,QAAA,CAAS,EAAA,WAAa,OAAA,CAAQ,aAAA;EA7DT;;;EA6ErB,MAAA,CAAO,EAAA,UAAY,KAAA,EAAO,wBAAA,GAA2B,OAAA,CAAQ,aAAA;EA/CjC;;;EAyF5B,MAAA,CAAO,EAAA,WAAa,OAAA;EAzFyB;;;EAwG7C,eAAA,CAAgB,SAAA,WAAoB,OAAA,CAAQ,aAAA;EAzDiB;;;EAiE7D,sBAAA,CAAuB,SAAA,UAAmB,MAAA,WAAiB,OAAA,CAAQ,aAAA;EAR/B;;;EAgCpC,iBAAA,CACJ,EAAA,UACA,MAAA,EAAQ,mBAAA,EACR,IAAA;IACE,OAAA,GAAU,UAAA;IACV,KAAA;IACA,MAAA;EAAA,IAED,OAAA,CAAQ,aAAA;EA0B4B;;;EAAjC,mBAAA,CAAoB,EAAA,WAAa,OAAA,CAAQ,aAAA;EAAA,QAiBvC,gBAAA;EAAA,QAWA,2BAAA;EAAA,QAQA,uBAAA;EAAA,QASA,SAAA;EAAA,QAiBA,gBAAA;EAAA,QAgBA,cAAA;EAAA,QAYA,YAAA;AAAA"}

package/dist/services/node-executions/node-executions.model.d.ts

@@ -0,0 +1,102 @@
+import { 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 { InvectAdapter } from "../../database/adapter.js";
+
+//#region src/services/node-executions/node-executions.model.d.ts
+/**
+ * Execution Trace entity
+ */
+interface NodeExecution {
+  id: string;
+  flowRunId: string;
+  nodeId: string;
+  nodeType: string;
+  status: NodeExecutionStatus;
+  inputs: Record<string, unknown>;
+  outputs?: NodeOutput;
+  error?: string;
+  startedAt: Date | string;
+  completedAt?: Date | string;
+  duration?: number;
+  retryCount: number;
+}
+/**
+ * Input for creating a new execution trace
+ */
+interface CreateNodeExecutionInput {
+  flowRunId: string;
+  nodeId: string;
+  nodeType: string;
+  inputs: Record<string, unknown>;
+}
+/**
+ * Input for updating an execution trace
+ */
+interface UpdateNodeExecutionInput {
+  status?: NodeExecutionStatus;
+  outputs?: NodeOutput;
+  error?: string;
+  completedAt?: Date | string;
+  duration?: number;
+  retryCount?: number;
+}
+/**
+ * Node Executions CRUD operations class — uses InvectAdapter.
+ */
+declare class NodeExecutionsModel {
+  private readonly adapter;
+  private readonly logger;
+  constructor(adapter: InvectAdapter, logger: Logger);
+  /**
+   * Create a new execution trace
+   */
+  create(input: CreateNodeExecutionInput): Promise<NodeExecution>;
+  /**
+   * Get all execution traces with optional filtering
+   */
+  list(options?: QueryOptions<NodeExecution>): Promise<PaginatedResponse<NodeExecution>>;
+  /**
+   * Get execution trace by ID
+   */
+  findById(id: string): Promise<NodeExecution | null>;
+  /**
+   * Update execution trace
+   */
+  update(id: string, input: UpdateNodeExecutionInput): Promise<NodeExecution>;
+  /**
+   * Delete execution trace
+   */
+  delete(id: string): Promise<void>;
+  /**
+   * Get execution traces by flow run ID
+   */
+  findByFlowRunId(flowRunId: string): Promise<NodeExecution[]>;
+  /**
+   * Get execution traces by flow run ID and node ID
+   */
+  findByExecutionAndNode(flowRunId: string, nodeId: string): Promise<NodeExecution[]>;
+  /**
+   * Update trace status with optional additional data
+   */
+  updateTraceStatus(id: string, status: NodeExecutionStatus, data?: {
+    outputs?: NodeOutput;
+    error?: string;
+    reason?: string;
+  }): Promise<NodeExecution>;
+  /**
+   * Increment retry count
+   */
+  incrementRetryCount(id: string): Promise<NodeExecution>;
+  private serializeOutputs;
+  private calculatePaginationMetadata;
+  private processPaginatedResults;
+  private normalize;
+  private buildFilterWhere;
+  private mapFilterField;
+  private mapSortField;
+}
+//#endregion
+export { CreateNodeExecutionInput, NodeExecution, NodeExecutionsModel, UpdateNodeExecutionInput };
+//# sourceMappingURL=node-executions.model.d.ts.map

package/dist/services/node-executions/node-executions.model.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"node-executions.model.d.ts","names":[],"sources":["../../../src/services/node-executions/node-executions.model.ts"],"mappings":";;;;;;;;;;UAUiB,aAAA;EACf,EAAA;EACA,SAAA;EACA,MAAA;EACA,QAAA;EACA,MAAA,EAAQ,mBAAA;EACR,MAAA,EAAQ,MAAA;EACR,OAAA,GAAU,UAAA;EACV,KAAA;EACA,SAAA,EAAW,IAAA;EACX,WAAA,GAAc,IAAA;EACd,QAAA;EACA,UAAA;AAAA;;;;UAMe,wBAAA;EACf,SAAA;EACA,MAAA;EACA,QAAA;EACA,MAAA,EAAQ,MAAA;AAAA;;;;UAMO,wBAAA;EACf,MAAA,GAAS,mBAAA;EACT,OAAA,GAAU,UAAA;EACV,KAAA;EACA,WAAA,GAAc,IAAA;EACd,QAAA;EACA,UAAA;AAAA;;;;cAmBW,mBAAA;EAAA,iBAEQ,OAAA;EAAA,iBACA,MAAA;cADA,OAAA,EAAS,aAAA,EACT,MAAA,EAAQ,MAAA;EA1B3B;;;EAgCM,MAAA,CAAO,KAAA,EAAO,wBAAA,GAA2B,OAAA,CAAQ,aAAA;EA9BzC;;;EAsDR,IAAA,CAAK,OAAA,GAAU,YAAA,CAAa,aAAA,IAAiB,OAAA,CAAQ,iBAAA,CAAkB,aAAA;EApDnE;AAmBZ;;EAgEQ,QAAA,CAAS,EAAA,WAAa,OAAA,CAAQ,aAAA;EA9DR;;;EA8EtB,MAAA,CAAO,EAAA,UAAY,KAAA,EAAO,wBAAA,GAA2B,OAAA,CAAQ,aAAA;EAvEpB;;;EAiHzC,MAAA,CAAO,EAAA,WAAa,OAAA;EAzFiC;;;EAwGrD,eAAA,CAAgB,SAAA,WAAoB,OAAA,CAAQ,aAAA;EAzDlB;;;EAiE1B,sBAAA,CAAuB,SAAA,UAAmB,MAAA,WAAiB,OAAA,CAAQ,aAAA;EARvB;;;EAgC5C,iBAAA,CACJ,EAAA,UACA,MAAA,EAAQ,mBAAA,EACR,IAAA;IACE,OAAA,GAAU,UAAA;IACV,KAAA;IACA,MAAA;EAAA,IAED,OAAA,CAAQ,aAAA;EA0BoC;;;EAAzC,mBAAA,CAAoB,EAAA,WAAa,OAAA,CAAQ,aAAA;EAAA,QAiBvC,gBAAA;EAAA,QAWA,2BAAA;EAAA,QAQA,uBAAA;EAAA,QASA,SAAA;EAAA,QAiBA,gBAAA;EAAA,QAgBA,cAAA;EAAA,QAYA,YAAA;AAAA"}

package/dist/services/node-executions/node-executions.model.js

@@ -0,0 +1,300 @@
+import { DatabaseError } from "../../types/common/errors.types.js";
+//#region src/services/node-executions/node-executions.model.ts
+const TABLE = "execution_traces";
+/**
+* Node Executions CRUD operations class — uses InvectAdapter.
+*/
+var NodeExecutionsModel = class {
+	constructor(adapter, logger) {
+		this.adapter = adapter;
+		this.logger = logger;
+	}
+	/**
+	* Create a new execution trace
+	*/
+	async create(input) {
+		try {
+			const result = await this.adapter.create({
+				model: TABLE,
+				data: {
+					flow_run_id: input.flowRunId,
+					node_id: input.nodeId,
+					node_type: input.nodeType,
+					status: "PENDING",
+					inputs: input.inputs,
+					retry_count: 0,
+					started_at: /* @__PURE__ */ new Date()
+				}
+			});
+			return this.normalize(result);
+		} catch (error) {
+			this.logger.error("Failed to create execution trace", {
+				input,
+				error
+			});
+			throw new DatabaseError("Failed to create execution trace", { error });
+		}
+	}
+	/**
+	* Get all execution traces with optional filtering
+	*/
+	async list(options) {
+		const pagination = options?.pagination || {
+			limit: 100,
+			page: 1
+		};
+		const sort = options?.sort;
+		const filter = options?.filter || {};
+		const offset = (pagination.page - 1) * pagination.limit;
+		const where = this.buildFilterWhere(filter);
+		try {
+			const [data, totalCount] = await Promise.all([this.adapter.findMany({
+				model: TABLE,
+				where,
+				limit: pagination.limit,
+				offset,
+				sortBy: sort ? {
+					field: this.mapSortField(sort.sortBy),
+					direction: sort.sortOrder
+				} : {
+					field: "started_at",
+					direction: "desc"
+				}
+			}), this.adapter.count({
+				model: TABLE,
+				where
+			})]);
+			return this.processPaginatedResults(data, totalCount, pagination);
+		} catch (error) {
+			this.logger.error("Failed to retrieve execution traces", {
+				options,
+				error
+			});
+			throw new DatabaseError("Failed to retrieve execution traces", { error });
+		}
+	}
+	/**
+	* Get execution trace by ID
+	*/
+	async findById(id) {
+		try {
+			const result = await this.adapter.findOne({
+				model: TABLE,
+				where: [{
+					field: "id",
+					value: id
+				}]
+			});
+			return result ? this.normalize(result) : null;
+		} catch (error) {
+			this.logger.error("Failed to get execution trace by ID", {
+				traceId: id,
+				error
+			});
+			throw new DatabaseError("Failed to get execution trace by ID", { error });
+		}
+	}
+	/**
+	* Update execution trace
+	*/
+	async update(id, input) {
+		try {
+			const updateData = {};
+			if (input.status !== void 0) updateData.status = input.status;
+			if (input.outputs !== void 0) updateData.outputs = this.serializeOutputs(input.outputs);
+			if (input.error !== void 0) updateData.error = input.error;
+			if (input.completedAt !== void 0) updateData.completed_at = new Date(input.completedAt);
+			if (input.duration !== void 0) updateData.duration = input.duration;
+			if (input.retryCount !== void 0) updateData.retry_count = input.retryCount;
+			const result = await this.adapter.update({
+				model: TABLE,
+				where: [{
+					field: "id",
+					value: id
+				}],
+				update: updateData
+			});
+			if (!result) throw new DatabaseError("Execution trace not found");
+			return this.normalize(result);
+		} catch (error) {
+			this.logger.error("Failed to update execution trace", {
+				traceId: id,
+				error
+			});
+			throw new DatabaseError("Failed to update execution trace", { error });
+		}
+	}
+	/**
+	* Delete execution trace
+	*/
+	async delete(id) {
+		try {
+			await this.adapter.delete({
+				model: TABLE,
+				where: [{
+					field: "id",
+					value: id
+				}]
+			});
+		} catch (error) {
+			this.logger.error("Failed to delete execution trace", {
+				traceId: id,
+				error
+			});
+			throw new DatabaseError("Failed to delete execution trace", { error });
+		}
+	}
+	/**
+	* Get execution traces by flow run ID
+	*/
+	async findByFlowRunId(flowRunId) {
+		return (await this.list({ filter: { flowRunId: [flowRunId] } })).data;
+	}
+	/**
+	* Get execution traces by flow run ID and node ID
+	*/
+	async findByExecutionAndNode(flowRunId, nodeId) {
+		try {
+			return (await this.adapter.findMany({
+				model: TABLE,
+				where: [{
+					field: "flow_run_id",
+					value: flowRunId
+				}, {
+					field: "node_id",
+					value: nodeId
+				}],
+				sortBy: {
+					field: "started_at",
+					direction: "desc"
+				}
+			})).map((r) => this.normalize(r));
+		} catch (error) {
+			this.logger.error("Failed to get execution traces by execution and node", {
+				flowRunId,
+				nodeId,
+				error
+			});
+			throw new DatabaseError("Failed to get execution traces by execution and node", { error });
+		}
+	}
+	/**
+	* Update trace status with optional additional data
+	*/
+	async updateTraceStatus(id, status, data) {
+		try {
+			this.logger.debug("Updating trace status", {
+				traceId: id,
+				status,
+				data
+			});
+			const updateInput = {
+				status,
+				completedAt: status !== "PENDING" && status !== "RUNNING" ? /* @__PURE__ */ new Date() : void 0,
+				...data
+			};
+			const updatedTrace = await this.update(id, updateInput);
+			this.logger.debug("Trace status updated successfully", {
+				traceId: id,
+				status: updatedTrace.status
+			});
+			return updatedTrace;
+		} catch (error) {
+			this.logger.error("Failed to update trace status", {
+				traceId: id,
+				status,
+				error
+			});
+			throw new DatabaseError("Failed to update trace status", { error });
+		}
+	}
+	/**
+	* Increment retry count
+	*/
+	async incrementRetryCount(id) {
+		try {
+			const trace = await this.findById(id);
+			if (!trace) throw new DatabaseError("Execution trace not found");
+			return this.update(id, { retryCount: trace.retryCount + 1 });
+		} catch (error) {
+			this.logger.error("Failed to increment retry count", {
+				traceId: id,
+				error
+			});
+			throw new DatabaseError("Failed to increment retry count", { error });
+		}
+	}
+	serializeOutputs(outputs) {
+		if (!outputs) return;
+		try {
+			return JSON.parse(JSON.stringify(outputs));
+		} catch (error) {
+			throw new Error(`Failed to serialize node outputs: ${error}`);
+		}
+	}
+	calculatePaginationMetadata(totalCount, pagination) {
+		const totalPages = Math.ceil(totalCount / pagination.limit);
+		return {
+			page: pagination.page,
+			limit: pagination.limit,
+			totalPages
+		};
+	}
+	processPaginatedResults(result, totalCount, pagination) {
+		return {
+			data: result.map((r) => this.normalize(r)),
+			pagination: this.calculatePaginationMetadata(totalCount, pagination)
+		};
+	}
+	normalize(raw) {
+		return {
+			id: String(raw.id),
+			flowRunId: String(raw.flow_run_id ?? raw.flowRunId),
+			nodeId: String(raw.node_id ?? raw.nodeId),
+			nodeType: String(raw.node_type ?? raw.nodeType),
+			status: raw.status || "PENDING",
+			inputs: raw.inputs || {},
+			outputs: raw.outputs,
+			error: raw.error ? String(raw.error) : void 0,
+			startedAt: raw.started_at ?? raw.startedAt ?? /* @__PURE__ */ new Date(),
+			completedAt: raw.completed_at ?? raw.completedAt ?? void 0,
+			duration: raw.duration ? Number(raw.duration) : void 0,
+			retryCount: Number(raw.retry_count ?? raw.retryCount ?? 0)
+		};
+	}
+	buildFilterWhere(filter) {
+		const clauses = [];
+		for (const [key, values] of Object.entries(filter)) {
+			if (!values || !Array.isArray(values) || values.length === 0) continue;
+			const dbField = this.mapFilterField(key);
+			if (values.length === 1) clauses.push({
+				field: dbField,
+				operator: "eq",
+				value: values[0]
+			});
+			else clauses.push({
+				field: dbField,
+				operator: "in",
+				value: values
+			});
+		}
+		return clauses;
+	}
+	mapFilterField(field) {
+		return {
+			flowRunId: "flow_run_id",
+			nodeId: "node_id",
+			nodeType: "node_type",
+			startedAt: "started_at",
+			completedAt: "completed_at",
+			retryCount: "retry_count"
+		}[field] ?? field;
+	}
+	mapSortField(field) {
+		return this.mapFilterField(field);
+	}
+};
+//#endregion
+export { NodeExecutionsModel };
+
+//# sourceMappingURL=node-executions.model.js.map

package/dist/services/node-executions/node-executions.model.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"node-executions.model.js","names":[],"sources":["../../../src/services/node-executions/node-executions.model.ts"],"sourcesContent":["// Node Executions Model for Invect core — adapter-based implementation\nimport type { InvectAdapter, WhereClause } from '../../database/adapter';\nimport { NodeExecutionStatus } from 'src/types/base';\nimport { DatabaseError } from 'src/types/common/errors.types';\nimport { Logger, PaginatedResponse, QueryOptions } from 'src/types/schemas';\nimport type { NodeOutput } from 'src/types/node-io-types';\n\n/**\n * Execution Trace entity\n */\nexport interface NodeExecution {\n  id: string;\n  flowRunId: string;\n  nodeId: string;\n  nodeType: string;\n  status: NodeExecutionStatus;\n  inputs: Record<string, unknown>;\n  outputs?: NodeOutput;\n  error?: string;\n  startedAt: Date | string;\n  completedAt?: Date | string;\n  duration?: number;\n  retryCount: number;\n}\n\n/**\n * Input for creating a new execution trace\n */\nexport interface CreateNodeExecutionInput {\n  flowRunId: string;\n  nodeId: string;\n  nodeType: string;\n  inputs: Record<string, unknown>;\n}\n\n/**\n * Input for updating an execution trace\n */\nexport interface UpdateNodeExecutionInput {\n  status?: NodeExecutionStatus;\n  outputs?: NodeOutput;\n  error?: string;\n  completedAt?: Date | string;\n  duration?: number;\n  retryCount?: number;\n}\n\n/**\n * Execution trace query parameters\n */\nexport interface NodeExecutionQuery {\n  nodeExecutionId?: string;\n  nodeId?: string;\n  status?: NodeExecutionStatus;\n  limit?: number;\n  offset?: number;\n}\n\nconst TABLE = 'execution_traces';\n\n/**\n * Node Executions CRUD operations class — uses InvectAdapter.\n */\nexport class NodeExecutionsModel {\n  constructor(\n    private readonly adapter: InvectAdapter,\n    private readonly logger: Logger,\n  ) {}\n\n  /**\n   * Create a new execution trace\n   */\n  async create(input: CreateNodeExecutionInput): Promise<NodeExecution> {\n    try {\n      const result = await this.adapter.create({\n        model: TABLE,\n        data: {\n          flow_run_id: input.flowRunId,\n          node_id: input.nodeId,\n          node_type: input.nodeType,\n          status: 'PENDING' as NodeExecutionStatus,\n          inputs: input.inputs,\n          retry_count: 0,\n          started_at: new Date(),\n        },\n      });\n      return this.normalize(result);\n    } catch (error) {\n      this.logger.error('Failed to create execution trace', { input, error });\n      throw new DatabaseError('Failed to create execution trace', { error });\n    }\n  }\n\n  /**\n   * Get all execution traces with optional filtering\n   */\n  async list(options?: QueryOptions<NodeExecution>): Promise<PaginatedResponse<NodeExecution>> {\n    const pagination = options?.pagination || { limit: 100, page: 1 };\n    const sort = options?.sort;\n    const filter = options?.filter || {};\n    const offset = (pagination.page - 1) * pagination.limit;\n    const where = this.buildFilterWhere(filter);\n\n    try {\n      const [data, totalCount] = await Promise.all([\n        this.adapter.findMany<Record<string, unknown>>({\n          model: TABLE,\n          where,\n          limit: pagination.limit,\n          offset,\n          sortBy: sort\n            ? { field: this.mapSortField(sort.sortBy as string), direction: sort.sortOrder }\n            : { field: 'started_at', direction: 'desc' },\n        }),\n        this.adapter.count({ model: TABLE, where }),\n      ]);\n\n      return this.processPaginatedResults(data, totalCount, pagination);\n    } catch (error) {\n      this.logger.error('Failed to retrieve execution traces', { options, error });\n      throw new DatabaseError('Failed to retrieve execution traces', { error });\n    }\n  }\n\n  /**\n   * Get execution trace by ID\n   */\n  async findById(id: string): Promise<NodeExecution | null> {\n    try {\n      const result = await this.adapter.findOne<Record<string, unknown>>({\n        model: TABLE,\n        where: [{ field: 'id', value: id }],\n      });\n      return result ? this.normalize(result) : null;\n    } catch (error) {\n      this.logger.error('Failed to get execution trace by ID', { traceId: id, error });\n      throw new DatabaseError('Failed to get execution trace by ID', { error });\n    }\n  }\n\n  /**\n   * Update execution trace\n   */\n  async update(id: string, input: UpdateNodeExecutionInput): Promise<NodeExecution> {\n    try {\n      const updateData: Record<string, unknown> = {};\n\n      if (input.status !== undefined) {\n        updateData.status = input.status;\n      }\n      if (input.outputs !== undefined) {\n        updateData.outputs = this.serializeOutputs(input.outputs);\n      }\n      if (input.error !== undefined) {\n        updateData.error = input.error;\n      }\n      if (input.completedAt !== undefined) {\n        updateData.completed_at = new Date(input.completedAt as string);\n      }\n      if (input.duration !== undefined) {\n        updateData.duration = input.duration;\n      }\n      if (input.retryCount !== undefined) {\n        updateData.retry_count = input.retryCount;\n      }\n\n      const result = await this.adapter.update<Record<string, unknown>>({\n        model: TABLE,\n        where: [{ field: 'id', value: id }],\n        update: updateData,\n      });\n\n      if (!result) {\n        throw new DatabaseError('Execution trace not found');\n      }\n      return this.normalize(result);\n    } catch (error) {\n      this.logger.error('Failed to update execution trace', { traceId: id, error });\n      throw new DatabaseError('Failed to update execution trace', { error });\n    }\n  }\n\n  /**\n   * Delete execution trace\n   */\n  async delete(id: string): Promise<void> {\n    try {\n      await this.adapter.delete({\n        model: TABLE,\n        where: [{ field: 'id', value: id }],\n      });\n    } catch (error) {\n      this.logger.error('Failed to delete execution trace', { traceId: id, error });\n      throw new DatabaseError('Failed to delete execution trace', { error });\n    }\n  }\n\n  /**\n   * Get execution traces by flow run ID\n   */\n  async findByFlowRunId(flowRunId: string): Promise<NodeExecution[]> {\n    const result = await this.list({ filter: { flowRunId: [flowRunId] } });\n    return result.data;\n  }\n\n  /**\n   * Get execution traces by flow run ID and node ID\n   */\n  async findByExecutionAndNode(flowRunId: string, nodeId: string): Promise<NodeExecution[]> {\n    try {\n      const results = await this.adapter.findMany<Record<string, unknown>>({\n        model: TABLE,\n        where: [\n          { field: 'flow_run_id', value: flowRunId },\n          { field: 'node_id', value: nodeId },\n        ],\n        sortBy: { field: 'started_at', direction: 'desc' },\n      });\n      return results.map((r) => this.normalize(r));\n    } catch (error) {\n      this.logger.error('Failed to get execution traces by execution and node', {\n        flowRunId,\n        nodeId,\n        error,\n      });\n      throw new DatabaseError('Failed to get execution traces by execution and node', { error });\n    }\n  }\n\n  /**\n   * Update trace status with optional additional data\n   */\n  async updateTraceStatus(\n    id: string,\n    status: NodeExecutionStatus,\n    data?: {\n      outputs?: NodeOutput;\n      error?: string;\n      reason?: string;\n    },\n  ): Promise<NodeExecution> {\n    try {\n      this.logger.debug('Updating trace status', { traceId: id, status, data });\n\n      const updateInput: UpdateNodeExecutionInput = {\n        status,\n        completedAt: status !== 'PENDING' && status !== 'RUNNING' ? new Date() : undefined,\n        ...data,\n      };\n\n      const updatedTrace = await this.update(id, updateInput);\n\n      this.logger.debug('Trace status updated successfully', {\n        traceId: id,\n        status: updatedTrace.status,\n      });\n      return updatedTrace;\n    } catch (error) {\n      this.logger.error('Failed to update trace status', { traceId: id, status, error });\n      throw new DatabaseError('Failed to update trace status', { error });\n    }\n  }\n\n  /**\n   * Increment retry count\n   */\n  async incrementRetryCount(id: string): Promise<NodeExecution> {\n    try {\n      const trace = await this.findById(id);\n      if (!trace) {\n        throw new DatabaseError('Execution trace not found');\n      }\n      return this.update(id, { retryCount: trace.retryCount + 1 });\n    } catch (error) {\n      this.logger.error('Failed to increment retry count', { traceId: id, error });\n      throw new DatabaseError('Failed to increment retry count', { error });\n    }\n  }\n\n  // =========================================================================\n  // Private helpers\n  // =========================================================================\n\n  private serializeOutputs(outputs: NodeOutput | undefined): unknown {\n    if (!outputs) {\n      return undefined;\n    }\n    try {\n      return JSON.parse(JSON.stringify(outputs));\n    } catch (error) {\n      throw new Error(`Failed to serialize node outputs: ${error}`);\n    }\n  }\n\n  private calculatePaginationMetadata(\n    totalCount: number,\n    pagination: { page: number; limit: number },\n  ) {\n    const totalPages = Math.ceil(totalCount / pagination.limit);\n    return { page: pagination.page, limit: pagination.limit, totalPages };\n  }\n\n  private processPaginatedResults(\n    result: Record<string, unknown>[],\n    totalCount: number,\n    pagination: { page: number; limit: number },\n  ): PaginatedResponse<NodeExecution> {\n    const data = result.map((r) => this.normalize(r));\n    return { data, pagination: this.calculatePaginationMetadata(totalCount, pagination) };\n  }\n\n  private normalize(raw: Record<string, unknown>): NodeExecution {\n    return {\n      id: String(raw.id),\n      flowRunId: String(raw.flow_run_id ?? raw.flowRunId),\n      nodeId: String(raw.node_id ?? raw.nodeId),\n      nodeType: String(raw.node_type ?? raw.nodeType),\n      status: (raw.status || 'PENDING') as NodeExecutionStatus,\n      inputs: (raw.inputs || {}) as Record<string, unknown>,\n      outputs: raw.outputs as NodeOutput | undefined,\n      error: raw.error ? String(raw.error) : undefined,\n      startedAt: (raw.started_at ?? raw.startedAt ?? new Date()) as Date | string,\n      completedAt: (raw.completed_at ?? raw.completedAt ?? undefined) as Date | string | undefined,\n      duration: raw.duration ? Number(raw.duration) : undefined,\n      retryCount: Number(raw.retry_count ?? raw.retryCount ?? 0),\n    };\n  }\n\n  private buildFilterWhere(filter: Record<string, unknown[]>): WhereClause[] {\n    const clauses: WhereClause[] = [];\n    for (const [key, values] of Object.entries(filter)) {\n      if (!values || !Array.isArray(values) || values.length === 0) {\n        continue;\n      }\n      const dbField = this.mapFilterField(key);\n      if (values.length === 1) {\n        clauses.push({ field: dbField, operator: 'eq', value: values[0] });\n      } else {\n        clauses.push({ field: dbField, operator: 'in', value: values });\n      }\n    }\n    return clauses;\n  }\n\n  private mapFilterField(field: string): string {\n    const map: Record<string, string> = {\n      flowRunId: 'flow_run_id',\n      nodeId: 'node_id',\n      nodeType: 'node_type',\n      startedAt: 'started_at',\n      completedAt: 'completed_at',\n      retryCount: 'retry_count',\n    };\n    return map[field] ?? field;\n  }\n\n  private mapSortField(field: string): string {\n    return this.mapFilterField(field);\n  }\n}\n"],"mappings":"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"}