@solidxai/core 0.1.12 → 0.1.13-beta.2

package/dist/services/workflow/workflow-runtime.service.d.ts

@@ -0,0 +1,53 @@
+import { EntityManager } from 'typeorm';
+import { WorkflowExecutionRequest, WorkflowExecutionResponse } from '../../types/workflow-dsl.types';
+import { WorkflowExecutionWriterService } from './workflow-execution-writer.service';
+import { WorkflowExpressionService } from './workflow-expression.service';
+import { WorkflowDefinitionValidatorService } from './workflow-definition-validator.service';
+import { WorkflowNodeRegistryService } from './workflow-node-registry.service';
+import { WorkflowSecretService } from '../workflow-secret.service';
+import { PublisherFactory } from '../queues/publisher-factory.service';
+import { WorkflowExecutionQueuePayload } from '../../types/workflow-execution-queue.types';
+export declare class WorkflowRuntimeService {
+    private readonly entityManager;
+    private readonly registry;
+    private readonly expression;
+    private readonly writer;
+    private readonly validator;
+    private readonly workflowSecretService;
+    private readonly workflowExecutionPublisherFactory;
+    private readonly logger;
+    constructor(entityManager: EntityManager, registry: WorkflowNodeRegistryService, expression: WorkflowExpressionService, writer: WorkflowExecutionWriterService, validator: WorkflowDefinitionValidatorService, workflowSecretService: WorkflowSecretService, workflowExecutionPublisherFactory: PublisherFactory<WorkflowExecutionQueuePayload>);
+    executeDefinitionById(id: number, request: WorkflowExecutionRequest): Promise<WorkflowExecutionResponse>;
+    executeDefinitionByIdAsync(id: number, request?: WorkflowExecutionRequest): Promise<WorkflowExecutionResponse>;
+    executeDefinitionByKey(key: string, request: WorkflowExecutionRequest): Promise<WorkflowExecutionResponse>;
+    executeDefinitionByKeyAsync(key: string, request?: WorkflowExecutionRequest): Promise<WorkflowExecutionResponse>;
+    private queueWorkflowExecution;
+    private enqueueDefinition;
+    executeEnqueuedExecution(executionId: number): Promise<WorkflowExecutionResponse>;
+    private executeDefinition;
+    getExecutionStatus(executionId: number): Promise<WorkflowExecutionResponse>;
+    getLastStepOutput(executionId: number): Promise<any>;
+    getStepOutput(executionId: number, stepNameOrId: string, options?: {
+        latest?: boolean;
+        limit?: number;
+        offset?: number;
+    }): Promise<any>;
+    private resolveWorkflowInput;
+    private resolveWorkflowVariables;
+    private runNodes;
+    private runNode;
+    private assertDefinitionYaml;
+    private readEnqueuedExecutionRequest;
+    private findExecutionOrThrow;
+    private toStepOutputResponse;
+    private buildPagedMeta;
+    private toResponse;
+    private nextStepSequence;
+    private nextLogSequence;
+    private countNodes;
+    private nodeLogMetadata;
+    private summarizeValue;
+    private errorMessage;
+    private summarizeError;
+}
+//# sourceMappingURL=workflow-runtime.service.d.ts.map

package/dist/services/workflow/workflow-runtime.service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workflow-runtime.service.d.ts","sourceRoot":"","sources":["../../../src/services/workflow/workflow-runtime.service.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAIxC,OAAO,EAEL,wBAAwB,EACxB,yBAAyB,EAG1B,MAAM,gCAAgC,CAAC;AACxC,OAAO,EAAE,8BAA8B,EAAE,MAAM,qCAAqC,CAAC;AACrF,OAAO,EAAE,yBAAyB,EAAE,MAAM,+BAA+B,CAAC;AAC1E,OAAO,EAAE,kCAAkC,EAAE,MAAM,yCAAyC,CAAC;AAC7F,OAAO,EAAE,2BAA2B,EAAE,MAAM,kCAAkC,CAAC;AAC/E,OAAO,EAAE,qBAAqB,EAAE,MAAM,4BAA4B,CAAC;AACnE,OAAO,EAAE,gBAAgB,EAAE,MAAM,qCAAqC,CAAC;AACvE,OAAO,EAAE,6BAA6B,EAAE,MAAM,4CAA4C,CAAC;AAG3F,qBACa,sBAAsB;IAK/B,OAAO,CAAC,QAAQ,CAAC,aAAa;IAC9B,OAAO,CAAC,QAAQ,CAAC,QAAQ;IACzB,OAAO,CAAC,QAAQ,CAAC,UAAU;IAC3B,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,SAAS;IAC1B,OAAO,CAAC,QAAQ,CAAC,qBAAqB;IACtC,OAAO,CAAC,QAAQ,CAAC,iCAAiC;IAVpD,OAAO,CAAC,QAAQ,CAAC,MAAM,CAA2C;gBAI/C,aAAa,EAAE,aAAa,EAC5B,QAAQ,EAAE,2BAA2B,EACrC,UAAU,EAAE,yBAAyB,EACrC,MAAM,EAAE,8BAA8B,EACtC,SAAS,EAAE,kCAAkC,EAC7C,qBAAqB,EAAE,qBAAqB,EAC5C,iCAAiC,EAAE,gBAAgB,CAAC,6BAA6B,CAAC;IAG/F,qBAAqB,CACzB,EAAE,EAAE,MAAM,EACV,OAAO,EAAE,wBAAwB,GAChC,OAAO,CAAC,yBAAyB,CAAC;IAQ/B,0BAA0B,CAC9B,EAAE,EAAE,MAAM,EACV,OAAO,GAAE,wBAA6B,GACrC,OAAO,CAAC,yBAAyB,CAAC;IAQ/B,sBAAsB,CAC1B,GAAG,EAAE,MAAM,EACX,OAAO,EAAE,wBAAwB,GAChC,OAAO,CAAC,yBAAyB,CAAC;IAQ/B,2BAA2B,CAC/B,GAAG,EAAE,MAAM,EACX,OAAO,GAAE,wBAA6B,GACrC,OAAO,CAAC,yBAAyB,CAAC;YAQvB,sBAAsB;YAqBtB,iBAAiB;IAiBzB,wBAAwB,CAC5B,WAAW,EAAE,MAAM,GAClB,OAAO,CAAC,yBAAyB,CAAC;YAoBvB,iBAAiB;IA+FzB,kBAAkB,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,yBAAyB,CAAC;IAK3E,iBAAiB,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,GAAG,CAAC;IAiBpD,aAAa,CACjB,WAAW,EAAE,MAAM,EACnB,YAAY,EAAE,MAAM,EACpB,OAAO,GAAE;QAAE,MAAM,CAAC,EAAE,OAAO,CAAC;QAAC,KAAK,CAAC,EAAE,MAAM,CAAC;QAAC,MAAM,CAAC,EAAE,MAAM,CAAA;KAAO,GAClE,OAAO,CAAC,GAAG,CAAC;IAkCf,OAAO,CAAC,oBAAoB;IA6C5B,OAAO,CAAC,wBAAwB;YAoBlB,QAAQ;YAWR,OAAO;IAkIrB,OAAO,CAAC,oBAAoB;IA+B5B,OAAO,CAAC,4BAA4B;YAkBtB,oBAAoB;IAYlC,OAAO,CAAC,oBAAoB;IAoB5B,OAAO,CAAC,cAAc;IAatB,OAAO,CAAC,UAAU;IAclB,OAAO,CAAC,gBAAgB;IAMxB,OAAO,CAAC,eAAe;IAMvB,OAAO,CAAC,UAAU;IAclB,OAAO,CAAC,eAAe;IA0BvB,OAAO,CAAC,cAAc;IAqBtB,OAAO,CAAC,YAAY;IAIpB,OAAO,CAAC,cAAc;CAWvB"}

package/dist/services/workflow/workflow-runtime.service.js

@@ -0,0 +1,541 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var WorkflowRuntimeService_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkflowRuntimeService = void 0;
+const common_1 = require("@nestjs/common");
+const typeorm_1 = require("@nestjs/typeorm");
+const typeorm_2 = require("typeorm");
+const workflow_definition_entity_1 = require("../../entities/workflow-definition.entity");
+const workflow_execution_entity_1 = require("../../entities/workflow-execution.entity");
+const workflow_step_execution_entity_1 = require("../../entities/workflow-step-execution.entity");
+const workflow_execution_writer_service_1 = require("./workflow-execution-writer.service");
+const workflow_expression_service_1 = require("./workflow-expression.service");
+const workflow_definition_validator_service_1 = require("./workflow-definition-validator.service");
+const workflow_node_registry_service_1 = require("./workflow-node-registry.service");
+const workflow_secret_service_1 = require("../workflow-secret.service");
+const publisher_factory_service_1 = require("../queues/publisher-factory.service");
+const yaml_1 = __importDefault(require("yaml"));
+let WorkflowRuntimeService = WorkflowRuntimeService_1 = class WorkflowRuntimeService {
+    constructor(entityManager, registry, expression, writer, validator, workflowSecretService, workflowExecutionPublisherFactory) {
+        this.entityManager = entityManager;
+        this.registry = registry;
+        this.expression = expression;
+        this.writer = writer;
+        this.validator = validator;
+        this.workflowSecretService = workflowSecretService;
+        this.workflowExecutionPublisherFactory = workflowExecutionPublisherFactory;
+        this.logger = new common_1.Logger(WorkflowRuntimeService_1.name);
+    }
+    async executeDefinitionById(id, request) {
+        const definition = await this.entityManager.findOne(workflow_definition_entity_1.WorkflowDefinition, {
+            where: { id },
+        });
+        return this.executeDefinition(definition, request);
+    }
+    async executeDefinitionByIdAsync(id, request = {}) {
+        const definition = await this.entityManager.findOne(workflow_definition_entity_1.WorkflowDefinition, {
+            where: { id },
+        });
+        return this.enqueueDefinition(definition, request);
+    }
+    async executeDefinitionByKey(key, request) {
+        const definition = await this.entityManager.findOne(workflow_definition_entity_1.WorkflowDefinition, {
+            where: { key },
+        });
+        return this.executeDefinition(definition, request);
+    }
+    async executeDefinitionByKeyAsync(key, request = {}) {
+        const definition = await this.entityManager.findOne(workflow_definition_entity_1.WorkflowDefinition, {
+            where: { key },
+        });
+        return this.enqueueDefinition(definition, request);
+    }
+    async queueWorkflowExecution(payload) {
+        const messageId = await this.workflowExecutionPublisherFactory.publish({
+            payload,
+            parentEntityId: payload.executionId,
+            parentEntity: 'workflowExecution',
+            retryCount: 0,
+            retryInterval: 1000,
+        }, 'WorkflowExecutionPublisher');
+        this.logger.log(`Queued workflow execution message ${messageId} for execution id ${payload.executionId}.`);
+        return messageId;
+    }
+    async enqueueDefinition(definition, request) {
+        if (!definition) {
+            throw new common_1.BadRequestException('Workflow definition not found.');
+        }
+        this.validator.validate(this.assertDefinitionYaml(definition.definitionYaml));
+        const execution = await this.writer.createEnqueuedExecution(definition, request);
+        await this.queueWorkflowExecution({
+            executionId: execution.id,
+        });
+        return this.toResponse(execution);
+    }
+    async executeEnqueuedExecution(executionId) {
+        const execution = await this.entityManager.findOne(workflow_execution_entity_1.WorkflowExecution, {
+            where: { id: executionId },
+            relations: ['workflowDefinition'],
+        });
+        if (!execution) {
+            throw new common_1.NotFoundException(`Workflow execution ${executionId} not found.`);
+        }
+        if (execution.status !== 'enqueued') {
+            throw new common_1.BadRequestException(`Workflow execution ${executionId} is ${execution.status}; expected enqueued.`);
+        }
+        const request = this.readEnqueuedExecutionRequest(execution);
+        return this.executeDefinition(execution.workflowDefinition, request, execution);
+    }
+    async executeDefinition(definition, request, existingExecution) {
+        if (!definition) {
+            throw new common_1.BadRequestException('Workflow definition not found.');
+        }
+        const definitionDsl = this.assertDefinitionYaml(definition.definitionYaml);
+        this.validator.validate(definitionDsl);
+        const secrets = await this.workflowSecretService.getWorkflowSecretsContext();
+        const input = this.resolveWorkflowInput(definitionDsl, request, secrets);
+        const variables = this.resolveWorkflowVariables(definitionDsl, request, input, secrets);
+        const effectiveRequest = {
+            ...request,
+            input,
+            variables,
+        };
+        const execution = existingExecution
+            ? await this.writer.startExecution(existingExecution, effectiveRequest)
+            : await this.writer.createExecution(definition, effectiveRequest);
+        const nodeCount = this.countNodes(definitionDsl.nodes);
+        const outputs = {};
+        const runtimeContext = {
+            execution,
+            input,
+            variables,
+            secrets,
+            outputs,
+            counters: {
+                step: 0,
+                log: 0,
+            },
+        };
+        try {
+            this.logger.log(`Starting workflow execution ${execution.executionIdentifier} for ${definition.key} with ${nodeCount} node(s).`);
+            await this.writer.writeLog(execution, undefined, {
+                level: 'info',
+                eventType: 'execution.started',
+                message: `Workflow execution started for ${definition.key}.`,
+                metadata: {
+                    executionIdentifier: execution.executionIdentifier,
+                    workflowKey: definition.key,
+                    triggerType: execution.triggerType,
+                    nodeCount,
+                    inputKeys: Object.keys(runtimeContext.input ?? {}),
+                    variableKeys: Object.keys(runtimeContext.variables ?? {}),
+                },
+            }, this.nextLogSequence(runtimeContext));
+            await this.runNodes(definitionDsl.nodes, runtimeContext);
+            const completed = await this.writer.completeExecution(execution, outputs);
+            this.logger.log(`Completed workflow execution ${completed.executionIdentifier} for ${definition.key} in ${completed.durationMs ?? 0} ms.`);
+            await this.writer.writeLog(completed, undefined, {
+                level: 'info',
+                eventType: 'execution.completed',
+                message: `Workflow execution completed for ${definition.key}.`,
+                metadata: {
+                    executionIdentifier: completed.executionIdentifier,
+                    durationMs: completed.durationMs,
+                    outputNodeIds: Object.keys(outputs),
+                },
+            }, this.nextLogSequence(runtimeContext));
+            return this.toResponse(completed);
+        }
+        catch (error) {
+            const failed = await this.writer.failExecution(execution, error);
+            this.logger.error(`Failed workflow execution ${failed.executionIdentifier} for ${definition.key}: ${failed.errorSummary}`, error instanceof Error ? error.stack : undefined);
+            await this.writer.writeLog(failed, undefined, {
+                level: 'error',
+                eventType: 'execution.failed',
+                message: failed.errorSummary,
+                context: this.summarizeError(error),
+                metadata: {
+                    executionIdentifier: failed.executionIdentifier,
+                    durationMs: failed.durationMs,
+                },
+            }, this.nextLogSequence(runtimeContext));
+            return this.toResponse(failed);
+        }
+    }
+    async getExecutionStatus(executionId) {
+        const execution = await this.findExecutionOrThrow(executionId);
+        return this.toResponse(execution);
+    }
+    async getLastStepOutput(executionId) {
+        await this.findExecutionOrThrow(executionId);
+        const step = await this.entityManager.findOne(workflow_step_execution_entity_1.WorkflowStepExecution, {
+            where: { workflowExecution: { id: executionId } },
+            order: {
+                sequenceNumber: 'DESC',
+                id: 'DESC',
+            },
+        });
+        if (!step) {
+            throw new common_1.NotFoundException(`No step executions found for workflow execution ${executionId}.`);
+        }
+        return this.toStepOutputResponse(step);
+    }
+    async getStepOutput(executionId, stepNameOrId, options = {}) {
+        await this.findExecutionOrThrow(executionId);
+        const qb = this.entityManager
+            .createQueryBuilder(workflow_step_execution_entity_1.WorkflowStepExecution, 'step')
+            .innerJoin('step.workflowExecution', 'execution')
+            .where('execution.id = :executionId', { executionId })
+            .andWhere('(step.nodeId = :stepNameOrId OR step.nodeName = :stepNameOrId OR step.stepExecutionKey = :stepNameOrId)', { stepNameOrId })
+            .orderBy('step.sequenceNumber', options.latest === false ? 'ASC' : 'DESC')
+            .addOrderBy('step.id', options.latest === false ? 'ASC' : 'DESC');
+        if (options.latest !== false && options.limit === undefined && options.offset === undefined) {
+            const step = await qb.getOne();
+            if (!step) {
+                throw new common_1.NotFoundException(`No step output found for '${stepNameOrId}' in workflow execution ${executionId}.`);
+            }
+            return this.toStepOutputResponse(step);
+        }
+        const limit = Math.max(1, Math.min(Number(options.limit ?? 50), 200));
+        const offset = Math.max(0, Number(options.offset ?? 0));
+        const [steps, totalRecords] = await qb.limit(limit).offset(offset).getManyAndCount();
+        return {
+            meta: this.buildPagedMeta(offset, limit, totalRecords),
+            records: steps.map((step) => this.toStepOutputResponse(step)),
+        };
+    }
+    resolveWorkflowInput(definitionDsl, request, secrets) {
+        const requestedInput = request.input ?? {};
+        const defaultInput = Object.entries(definitionDsl.inputs ?? {}).reduce((acc, [key, inputDefinition]) => {
+            if (inputDefinition &&
+                typeof inputDefinition === 'object' &&
+                !Array.isArray(inputDefinition) &&
+                Object.prototype.hasOwnProperty.call(inputDefinition, 'default')) {
+                acc[key] = inputDefinition.default;
+                return acc;
+            }
+            if (inputDefinition === null ||
+                inputDefinition === undefined ||
+                (typeof inputDefinition === 'object' && !Array.isArray(inputDefinition))) {
+                return acc;
+            }
+            acc[key] = inputDefinition;
+            return acc;
+        }, {});
+        const rawInput = {
+            ...defaultInput,
+            ...requestedInput,
+        };
+        return this.expression.interpolate(rawInput, {
+            execution: undefined,
+            input: rawInput,
+            variables: definitionDsl.variables ?? {},
+            secrets,
+            outputs: {},
+        });
+    }
+    resolveWorkflowVariables(definitionDsl, request, input, secrets) {
+        const rawVariables = {
+            ...(definitionDsl.variables ?? {}),
+            ...(request.variables ?? {}),
+        };
+        return this.expression.interpolate(rawVariables, {
+            execution: undefined,
+            input,
+            variables: rawVariables,
+            secrets,
+            outputs: {},
+        });
+    }
+    async runNodes(nodes, context) {
+        for (const node of nodes ?? []) {
+            await this.runNode(node, context);
+        }
+        return context.outputs;
+    }
+    async runNode(node, context) {
+        const inputPayload = {
+            configuration: node.configuration,
+            input: context.input,
+            variables: context.variables,
+            item: context.item,
+            index: context.index,
+        };
+        const step = await this.writer.createStep(context.execution, node, this.nextStepSequence(context), inputPayload, context.parentNodeId, context.parentStepExecutionKey);
+        if (node.disabled) {
+            context.outputs[node.id] = { skipped: true };
+            await this.writer.completeStep(step, 'skipped', context.outputs[node.id]);
+            await this.writer.writeLog(context.execution, step, {
+                level: 'debug',
+                eventType: 'node.skipped',
+                message: `Skipped disabled node ${node.id}.`,
+                metadata: this.nodeLogMetadata(node, context, step),
+            }, this.nextLogSequence(context));
+            return;
+        }
+        try {
+            await this.writer.writeLog(context.execution, step, {
+                level: 'debug',
+                eventType: 'node.started',
+                message: `Starting node ${node.id} (${node.type}).`,
+                metadata: this.nodeLogMetadata(node, context, step),
+            }, this.nextLogSequence(context));
+            this.logger.debug(`Starting workflow node ${node.id} (${node.type}) for execution ${context.execution.executionIdentifier}.`);
+            const startedAtMs = Date.now();
+            const handler = this.registry.get(node.type);
+            const result = await handler.execute({
+                ...context,
+                node,
+                stepExecution: step,
+                expression: this.expression,
+                runNodes: async (childNodes, options = {}) => this.runNodes(childNodes, {
+                    ...context,
+                    ...options,
+                    execution: context.execution,
+                    outputs: options.outputs ?? context.outputs,
+                    parentNodeId: node.id,
+                    parentStepExecutionKey: step.stepExecutionKey,
+                }),
+                emitLog: async (entry) => {
+                    await this.writer.writeLog(context.execution, step, entry, this.nextLogSequence(context));
+                },
+                emitArtifact: async (entry) => {
+                    await this.writer.writeArtifact(context.execution, step, entry);
+                },
+            });
+            const output = result.output ?? {};
+            context.outputs[node.id] = output;
+            for (const artifact of result.artifacts ?? []) {
+                await this.writer.writeArtifact(context.execution, step, artifact);
+            }
+            await this.writer.completeStep(step, result.status ?? 'success', output, {
+                item: context.item,
+                index: context.index,
+            });
+            await this.writer.writeLog(context.execution, step, {
+                level: 'debug',
+                eventType: 'node.completed',
+                message: `Completed node ${node.id} (${node.type}).`,
+                metadata: {
+                    ...this.nodeLogMetadata(node, context, step),
+                    status: result.status ?? 'success',
+                    durationMs: Date.now() - startedAtMs,
+                    outputSummary: this.summarizeValue(output),
+                    artifactCount: result.artifacts?.length ?? 0,
+                },
+            }, this.nextLogSequence(context));
+        }
+        catch (error) {
+            await this.writer.failStep(step, error);
+            if (node.onError === 'continue') {
+                context.outputs[node.id] = {
+                    error: error instanceof Error ? error.message : String(error),
+                };
+                await this.writer.writeLog(context.execution, step, {
+                    level: 'warn',
+                    eventType: 'node.failed.continued',
+                    message: `Node ${node.id} failed but workflow continued: ${this.errorMessage(error)}.`,
+                    context: this.summarizeError(error),
+                    metadata: this.nodeLogMetadata(node, context, step),
+                }, this.nextLogSequence(context));
+                return;
+            }
+            await this.writer.writeLog(context.execution, step, {
+                level: 'error',
+                eventType: 'node.failed',
+                message: `Node ${node.id} failed: ${this.errorMessage(error)}.`,
+                context: this.summarizeError(error),
+                metadata: this.nodeLogMetadata(node, context, step),
+            }, this.nextLogSequence(context));
+            throw error;
+        }
+    }
+    assertDefinitionYaml(value) {
+        if (!value || typeof value !== 'string') {
+            throw new common_1.BadRequestException('Workflow definition YAML must be stored as a string.');
+        }
+        let parsed;
+        try {
+            parsed = yaml_1.default.parse(value);
+        }
+        catch (error) {
+            throw new common_1.BadRequestException(error?.message ?? 'Workflow definition YAML could not be parsed.');
+        }
+        if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+            throw new common_1.BadRequestException('Workflow definition YAML must resolve to an object with a nodes array.');
+        }
+        if (!Array.isArray(parsed.nodes)) {
+            throw new common_1.BadRequestException('Workflow definition YAML must include a nodes array.');
+        }
+        return parsed;
+    }
+    readEnqueuedExecutionRequest(execution) {
+        const payload = execution.inputPayload;
+        if (!payload || typeof payload !== 'object' || Array.isArray(payload)) {
+            return {
+                triggerType: execution.triggerType,
+                requestedByUserId: execution.requestedByUserId,
+            };
+        }
+        return {
+            ...payload,
+            triggerType: payload.triggerType ?? execution.triggerType,
+            requestedByUserId: payload.requestedByUserId ??
+                execution.requestedByUserId,
+        };
+    }
+    async findExecutionOrThrow(executionId) {
+        const execution = await this.entityManager.findOne(workflow_execution_entity_1.WorkflowExecution, {
+            where: { id: executionId },
+        });
+        if (!execution) {
+            throw new common_1.NotFoundException(`Workflow execution ${executionId} not found.`);
+        }
+        return execution;
+    }
+    toStepOutputResponse(step) {
+        return {
+            id: step.id,
+            stepExecutionKey: step.stepExecutionKey,
+            nodeId: step.nodeId,
+            nodeName: step.nodeName,
+            nodeType: step.nodeType,
+            nodeKind: step.nodeKind,
+            sequenceNumber: step.sequenceNumber,
+            attemptNumber: step.attemptNumber,
+            status: step.status,
+            startedAt: step.startedAt,
+            finishedAt: step.finishedAt,
+            durationMs: step.durationMs,
+            runtimeContext: step.runtimeContext,
+            outputPayload: step.outputPayload,
+            errorSummary: step.errorSummary,
+        };
+    }
+    buildPagedMeta(offset, limit, totalRecords) {
+        const currentPage = limit ? Math.floor(offset / limit) + 1 : 1;
+        const totalPages = limit ? Math.max(1, Math.ceil(totalRecords / limit)) : 1;
+        return {
+            totalRecords,
+            currentPage,
+            nextPage: currentPage < totalPages ? currentPage + 1 : null,
+            prevPage: currentPage > 1 ? currentPage - 1 : null,
+            totalPages,
+            perPage: limit,
+        };
+    }
+    toResponse(execution) {
+        return {
+            id: execution.id,
+            executionIdentifier: execution.executionIdentifier,
+            workflowKey: execution.workflowKey,
+            status: execution.status,
+            startedAt: execution.startedAt,
+            finishedAt: execution.finishedAt,
+            durationMs: execution.durationMs,
+            outputPayload: execution.outputPayload,
+            errorSummary: execution.errorSummary,
+        };
+    }
+    nextStepSequence(context) {
+        context.counters = context.counters ?? { step: 0, log: 0 };
+        context.counters.step += 1;
+        return context.counters.step;
+    }
+    nextLogSequence(context) {
+        context.counters = context.counters ?? { step: 0, log: 0 };
+        context.counters.log += 1;
+        return context.counters.log;
+    }
+    countNodes(nodes = []) {
+        return nodes.reduce((count, node) => {
+            const nestedNodes = [
+                ...(node.tasks ?? []),
+                ...(node.then ?? []),
+                ...(node.else ?? []),
+                ...(node.defaults ?? []),
+                ...Object.values(node.cases ?? {}).flat(),
+            ];
+            return count + 1 + this.countNodes(nestedNodes);
+        }, 0);
+    }
+    nodeLogMetadata(node, context, step) {
+        return {
+            executionIdentifier: context.execution.executionIdentifier,
+            stepExecutionKey: step?.stepExecutionKey,
+            nodeId: node.id,
+            nodeName: node.name,
+            nodeType: node.type,
+            nodeKind: node.kind,
+            parentNodeId: context.parentNodeId,
+            parentStepExecutionKey: context.parentStepExecutionKey,
+            index: context.index,
+            hasItem: context.item !== undefined,
+            configurationKeys: node.configuration && typeof node.configuration === 'object'
+                ? Object.keys(node.configuration)
+                : [],
+            availableInputKeys: Object.keys(context.input ?? {}),
+            availableVariableKeys: Object.keys(context.variables ?? {}),
+            availableOutputNodeIds: Object.keys(context.outputs ?? {}),
+        };
+    }
+    summarizeValue(value) {
+        if (Array.isArray(value)) {
+            return {
+                type: 'array',
+                length: value.length,
+            };
+        }
+        if (value && typeof value === 'object') {
+            return {
+                type: 'object',
+                keys: Object.keys(value),
+            };
+        }
+        return {
+            type: value === null ? 'null' : typeof value,
+            empty: value === undefined || value === null || value === '',
+        };
+    }
+    errorMessage(error) {
+        return error instanceof Error ? error.message : String(error);
+    }
+    summarizeError(error) {
+        if (error instanceof Error) {
+            return {
+                name: error.name,
+                message: error.message,
+                stack: error.stack,
+            };
+        }
+        return { error };
+    }
+};
+exports.WorkflowRuntimeService = WorkflowRuntimeService;
+exports.WorkflowRuntimeService = WorkflowRuntimeService = WorkflowRuntimeService_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, typeorm_1.InjectEntityManager)('default')),
+    __metadata("design:paramtypes", [typeorm_2.EntityManager,
+        workflow_node_registry_service_1.WorkflowNodeRegistryService,
+        workflow_expression_service_1.WorkflowExpressionService,
+        workflow_execution_writer_service_1.WorkflowExecutionWriterService,
+        workflow_definition_validator_service_1.WorkflowDefinitionValidatorService,
+        workflow_secret_service_1.WorkflowSecretService,
+        publisher_factory_service_1.PublisherFactory])
+], WorkflowRuntimeService);
+//# sourceMappingURL=workflow-runtime.service.js.map