@pikku/core 0.11.0 → 0.11.2

package/dist/wirings/workflow/pikku-workflow-service.js

@@ -1,8 +1,50 @@
 import { runPikkuFunc } from '../../function/function-runner.js';
 import { pikkuState } from '../../pikku-state.js';
 import { getDurationInMilliseconds } from '../../time-utils.js';
-import { PikkuWiringTypes, } from '../../types/core.types.js';
-import { WorkflowAsyncException, WorkflowCancelledException, WorkflowNotFoundError, WorkflowRunNotFound, } from './workflow-runner.js';
+import { executeGraphStep, runWorkflowGraph } from './graph/graph-runner.js';
+import { PikkuError } from '../../errors/error-handler.js';
+/**
+ * Exception thrown when workflow needs to pause for async step
+ */
+export class WorkflowAsyncException extends Error {
+    runId;
+    stepName;
+    constructor(runId, stepName) {
+        super(`Workflow paused at step: ${stepName}`);
+        this.runId = runId;
+        this.stepName = stepName;
+        this.name = 'WorkflowAsyncException';
+    }
+}
+/**
+ * Exception thrown when workflow is cancelled
+ */
+export class WorkflowCancelledException extends Error {
+    runId;
+    reason;
+    constructor(runId, reason) {
+        super(reason || 'Workflow cancelled');
+        this.runId = runId;
+        this.reason = reason;
+        this.name = 'WorkflowCancelledException';
+    }
+}
+/**
+ * Error class for workflow not found
+ */
+export class WorkflowNotFoundError extends PikkuError {
+    constructor(name) {
+        super(`Workflow not found: ${name}`);
+    }
+}
+/**
+ * Error class for workflow not found
+ */
+export class WorkflowRunNotFound extends PikkuError {
+    constructor(runId) {
+        super(`Workflow run not found: ${runId}`);
+    }
+}
 export class WorkflowServiceNotInitialized extends Error {
 }
 export class WorkflowStepNameNotString extends Error {
@@ -18,17 +60,36 @@ export class WorkflowStepNameNotString extends Error {
 export class PikkuWorkflowService {
     config;
     singletonServices;
-    createSessionServices;
+    createWireServices;
+    inlineRuns = new Set();
     constructor() { }
-    setServices(singletonServices, createSessionServices, { workflow }) {
+    /**
+     * Check if a run is executing inline (without queues)
+     */
+    isInline(runId) {
+        return this.inlineRuns.has(runId);
+    }
+    /**
+     * Register a run as inline (for graph-runner to use)
+     */
+    registerInlineRun(runId) {
+        this.inlineRuns.add(runId);
+    }
+    /**
+     * Unregister a run from inline tracking
+     */
+    unregisterInlineRun(runId) {
+        this.inlineRuns.delete(runId);
+    }
+    setServices(singletonServices, createWireServices, { workflow }) {
         this.singletonServices = singletonServices;
-        this.createSessionServices = createSessionServices;
+        this.createWireServices = createWireServices;
         this.config = {
             retries: workflow?.retries ?? 0,
             retryDelay: workflow?.retryDelay ?? 0,
             orchestratorQueueName: workflow?.orchestratorQueueName ?? 'pikku-workflow-orchestrator',
             stepWorkerQueueName: workflow?.stepWorkerQueueName ?? 'pikku-workflow-step-worker',
-            sleeperRPCName: workflow?.sleeperRPCName ?? 'pikkuWorkflowStepSleeper',
+            sleeperRPCName: workflow?.sleeperRPCName ?? 'pikkuWorkflowSleeper',
         };
     }
     // ============================================================================
@@ -47,7 +108,7 @@ export class PikkuWorkflowService {
      * Sets the step result to null and resumes the workflow
      * @param data - Sleeper input data
      */
-    async executeWorkflowSleep(runId, stepId) {
+    async executeWorkflowSleepCompleted(runId, stepId) {
         await this.setStepResult(stepId, null);
         await this.resumeWorkflow(runId);
     }
@@ -62,81 +123,91 @@ export class PikkuWorkflowService {
     }
     /**
      * Start a new workflow run
+     * Automatically detects workflow type (DSL or graph) from meta and executes accordingly
+     * @param options.inline - If true, execute workflow directly without queue service
+     * @param options.startNode - Starting node ID for graph workflows (from wire config)
      */
-    async startWorkflow(name, input, rpcService) {
-        const registrations = pikkuState('workflows', 'registrations');
+    async startWorkflow(name, input, rpcService, options) {
+        // Check meta to determine workflow type
+        const meta = pikkuState(null, 'workflows', 'meta');
+        const workflowMeta = meta[name];
+        if (!workflowMeta) {
+            throw new WorkflowNotFoundError(name);
+        }
+        // Check if this is a graph workflow (source === 'graph')
+        if (workflowMeta.source === 'graph') {
+            // Graph workflows use the graph scheduler
+            return runWorkflowGraph(this, name, input, rpcService, options?.inline, options?.startNode);
+        }
+        // DSL workflow - check registration exists
+        const registrations = pikkuState(null, 'workflows', 'registrations');
         const workflow = registrations.get(name);
         if (!workflow) {
             throw new WorkflowNotFoundError(name);
         }
         // Create workflow run in state
-        const runId = await this.createRun(name, input);
-        // If queue service is available, use remote execution (queue-based)
-        // Otherwise, execute directly (inline/synchronous)
-        if (this.singletonServices?.queueService) {
-            // Queue orchestrator to start the workflow
-            await this.resumeWorkflow(runId);
+        const runId = await this.createRun(name, input, options?.inline);
+        // Register inline run for fast lookup
+        if (options?.inline) {
+            this.inlineRuns.add(runId);
         }
-        else {
-            // No queue service - execute directly via runWorkflowJob
-            await this.runWorkflowJob(runId, rpcService);
+        try {
+            // If inline mode or no queue service, execute directly
+            // Otherwise, use remote execution (queue-based)
+            if (options?.inline || !this.singletonServices?.queueService) {
+                await this.runWorkflowJob(runId, rpcService);
+            }
+            else {
+                await this.resumeWorkflow(runId);
+            }
+            return { runId };
+        }
+        finally {
+            // Clean up inline tracking
+            if (options?.inline) {
+                this.inlineRuns.delete(runId);
+            }
         }
-        return { runId };
     }
     async runWorkflowJob(runId, rpcService) {
-        // Get the run
         const run = await this.getRun(runId);
         if (!run) {
             throw new WorkflowRunNotFound(runId);
         }
-        // Get workflow registration
-        const registrations = pikkuState('workflows', 'registrations');
+        const registrations = pikkuState(null, 'workflows', 'registrations');
         const workflow = registrations.get(run.workflow);
         if (!workflow) {
             throw new WorkflowNotFoundError(run.workflow);
         }
-        // Use lock to prevent concurrent execution
         await this.withRunLock(runId, async () => {
-            // Create workflow interaction object
-            const workflowInteraction = this.createWorkflowInteraction(run.workflow, runId, rpcService);
-            // Get function metadata
-            const meta = pikkuState('workflows', 'meta');
+            const meta = pikkuState(null, 'workflows', 'meta');
             const workflowMeta = meta[run.workflow];
-            // Execute workflow function with workflow interaction
+            const workflowWire = this.createWorkflowWire(run.workflow, runId, rpcService);
+            const wire = { workflow: workflowWire };
             try {
-                const getAllServices = () => {
-                    let sessionServices = {};
-                    const interaction = { workflow: workflowInteraction };
-                    if (this.createSessionServices) {
-                        sessionServices = this.createSessionServices(this.singletonServices, interaction, undefined);
-                    }
-                    return {
-                        ...this.singletonServices,
-                        ...sessionServices,
-                        ...interaction,
-                    };
-                };
-                const result = await runPikkuFunc(PikkuWiringTypes.workflow, workflowMeta.workflowName, workflowMeta.pikkuFuncName, {
+                const result = await runPikkuFunc('workflow', workflowMeta.name, workflowMeta.pikkuFuncName, {
                     singletonServices: this.singletonServices,
-                    interaction: { workflow: workflowInteraction },
-                    getAllServices,
+                    wire,
+                    createWireServices: this.createWireServices,
                     data: () => run.input,
                 });
-                // Workflow completed successfully
                 await this.updateRunStatus(runId, 'completed', result);
             }
             catch (error) {
-                // Check if it's a WorkflowAsyncException
                 if (error instanceof WorkflowAsyncException) {
                     // Normal - workflow paused for step execution
                     throw error;
                 }
                 // Check if it's a WorkflowCancelledException
                 if (error instanceof WorkflowCancelledException) {
-                    // Workflow was cancelled - status already updated, just rethrow
+                    // Workflow was cancelled - update status and rethrow
+                    await this.updateRunStatus(runId, 'cancelled', undefined, {
+                        message: error.message || 'Workflow cancelled',
+                        stack: '',
+                        code: 'WORKFLOW_CANCELLED',
+                    });
                     throw error;
                 }
-                // Real error - mark as failed
                 await this.updateRunStatus(runId, 'failed', undefined, {
                     message: error.message,
                     stack: error.stack,
@@ -151,56 +222,68 @@ export class PikkuWorkflowService {
      * Handles idempotency, RPC execution, result storage, retry logic, and orchestrator triggering
      */
     async executeWorkflowStep(runId, stepName, rpcName, data, rpcService) {
-        // Get step state
-        let stepState = await this.getStepState(runId, stepName);
-        // Idempotency - if already succeeded, resume orchestrator and return
-        if (stepState.status === 'succeeded') {
-            await this.resumeWorkflow(runId);
-            return;
-        }
-        // Log warning if already running (race condition)
-        if (stepState.status === 'running') {
-            return;
-        }
-        // If status is 'failed', this is a retry - create new attempt history
-        if (stepState.status === 'failed') {
-            stepState = await this.createRetryAttempt(stepState.stepId, 'running');
-        }
-        if (stepState.status !== 'pending') {
-            // Mark step as running (pending or failed status)
-            await this.setStepRunning(stepState.stepId);
-        }
-        try {
-            // Execute RPC with workflow step context
-            const result = await rpcService.rpcWithInteraction(rpcName, data, {
-                workflowStep: {
-                    runId,
-                    stepId: stepState.stepId,
-                    attemptCount: stepState.attemptCount,
-                },
-            });
-            // Store result and mark succeeded
-            await this.setStepResult(stepState.stepId, result);
-            // Resume orchestrator to continue workflow
-            try {
+        // Use step-level lock to prevent concurrent execution of same step
+        await this.withStepLock(runId, stepName, async () => {
+            // Get step state
+            let stepState = await this.getStepState(runId, stepName);
+            // Idempotency - if already succeeded, resume orchestrator and return
+            if (stepState.status === 'succeeded') {
                 await this.resumeWorkflow(runId);
+                return;
             }
-            catch (resumeError) {
-                throw resumeError;
+            // Log warning if already running (race condition)
+            if (stepState.status === 'running') {
+                return;
             }
-        }
-        catch (error) {
-            // Store error and mark failed
-            await this.setStepError(stepState.stepId, error);
-            const maxAttempts = (stepState.retries ?? 0) + 1;
-            const retriesExhausted = stepState.attemptCount >= maxAttempts;
-            if (retriesExhausted) {
-                // No more retries - resume orchestrator to mark workflow as failed
+            // If status is 'failed', this is a retry - create new attempt history
+            if (stepState.status === 'failed') {
+                stepState = await this.createRetryAttempt(stepState.stepId, 'running');
+            }
+            if (stepState.status !== 'pending') {
+                // Mark step as running (pending or failed status)
+                await this.setStepRunning(stepState.stepId);
+            }
+            try {
+                let result;
+                // Check if this is a graph node step (step name starts with 'node:')
+                if (stepName.startsWith('node:')) {
+                    // Get the graph name from the workflow run
+                    const run = await this.getRun(runId);
+                    if (!run) {
+                        throw new Error(`Workflow run not found: ${runId}`);
+                    }
+                    const graphName = run.workflow;
+                    // Execute as graph step with graph wire context
+                    result = await executeGraphStep(this, rpcService, runId, stepState.stepId, stepName, rpcName, data, graphName);
+                }
+                else {
+                    // Execute RPC with workflow step context (regular workflow)
+                    result = await rpcService.rpcWithWire(rpcName, data, {
+                        workflowStep: {
+                            runId,
+                            stepId: stepState.stepId,
+                            attemptCount: stepState.attemptCount,
+                        },
+                    });
+                }
+                // Store result and mark succeeded
+                await this.setStepResult(stepState.stepId, result);
+                // Resume orchestrator to continue workflow
                 await this.resumeWorkflow(runId);
             }
-            // Always throw so queue knows the job failed and can retry if needed
-            throw error;
-        }
+            catch (error) {
+                // Store error and mark failed
+                await this.setStepError(stepState.stepId, error);
+                const maxAttempts = (stepState.retries ?? 0) + 1;
+                const retriesExhausted = stepState.attemptCount >= maxAttempts;
+                if (retriesExhausted) {
+                    // No more retries - resume orchestrator to mark workflow as failed
+                    await this.resumeWorkflow(runId);
+                }
+                // Always throw so queue knows the job failed and can retry if needed
+                throw error;
+            }
+        });
     }
     /**
      * Orchestrate workflow execution (called by orchestrator)
@@ -236,7 +319,7 @@ export class PikkuWorkflowService {
         try {
             stepState = await this.getStepState(runId, stepName);
         }
-        catch (error) {
+        catch {
             // Step doesn't exist - create it
             stepState = await this.insertStepState(runId, stepName, rpcName, data, stepOptions);
         }
@@ -260,8 +343,8 @@ export class PikkuWorkflowService {
         }
         // Step is pending - schedule it
         await this.setStepScheduled(stepState.stepId);
-        // Enqueue step worker
-        if (this.singletonServices.queueService) {
+        // Enqueue step worker (unless inline mode)
+        if (!this.isInline(runId) && this.singletonServices.queueService) {
             // Map step retry options to queue job options
             const retries = stepOptions?.retries ?? 0;
             const retryDelay = stepOptions?.retryDelay;
@@ -280,41 +363,47 @@ export class PikkuWorkflowService {
                         ? 'exponential'
                         : undefined,
             });
+            // Pause workflow - step will callback when done
+            throw new WorkflowAsyncException(runId, stepName);
         }
         else {
-            // No queue service - execute locally
+            // Inline or no queue service - execute locally with retry loop
             const retries = stepOptions?.retries ?? 0;
             const retryDelay = stepOptions?.retryDelay;
-            const attemptCount = stepState.attemptCount;
-            try {
-                const result = await rpcService.rpcWithInteraction(rpcName, data, {
-                    workflowStep: {
-                        runId,
-                        stepId: stepState.stepId,
-                        attemptCount: stepState.attemptCount,
-                    },
-                });
-                await this.setStepResult(stepState.stepId, result);
-                return result;
-            }
-            catch (error) {
-                // Record the error (marks step as failed)
-                await this.setStepError(stepState.stepId, error);
-                // Check if we should retry
-                if (attemptCount < retries) {
-                    // Create a new pending retry attempt (copies metadata from failed step)
-                    await this.createRetryAttempt(stepState.stepId, 'pending');
-                    // Schedule orchestrator to retry after delay
-                    await this.scheduleOrchestratorRetry(runId, retryDelay);
-                    // Pause workflow - orchestrator will replay and pick up new attempt
-                    throw new WorkflowAsyncException(runId, stepName);
+            let currentStepState = stepState;
+            while (true) {
+                try {
+                    await this.setStepRunning(currentStepState.stepId);
+                    const result = await rpcService.rpcWithWire(rpcName, data, {
+                        workflowStep: {
+                            runId,
+                            stepId: currentStepState.stepId,
+                            attemptCount: currentStepState.attemptCount,
+                        },
+                    });
+                    await this.setStepResult(currentStepState.stepId, result);
+                    return result;
+                }
+                catch (error) {
+                    // Record the error (marks step as failed)
+                    await this.setStepError(currentStepState.stepId, error);
+                    // Check if we should retry
+                    if (currentStepState.attemptCount < retries) {
+                        // Create a new pending retry attempt
+                        currentStepState = await this.createRetryAttempt(currentStepState.stepId, 'pending');
+                        // Wait for retry delay if specified
+                        if (retryDelay) {
+                            await new Promise((resolve) => setTimeout(resolve, getDurationInMilliseconds(retryDelay)));
+                        }
+                        // Continue loop to retry
+                    }
+                    else {
+                        // No more retries, fail the workflow
+                        throw error;
+                    }
                 }
-                // No more retries, fail the workflow
-                throw error;
             }
         }
-        // Pause workflow - step will callback when done
-        throw new WorkflowAsyncException(runId, stepName);
     }
     async inlineStep(runId, stepName, fn, stepOptions) {
         // Check if step already exists
@@ -322,7 +411,7 @@ export class PikkuWorkflowService {
         try {
             stepState = await this.getStepState(runId, stepName);
         }
-        catch (error) {
+        catch {
             // Step doesn't exist - create it (inline, no RPC)
             stepState = await this.insertStepState(runId, stepName, null, // No RPC for inline steps
             null, // No data for inline steps
@@ -335,26 +424,60 @@ export class PikkuWorkflowService {
         // Execute inline function
         const retries = stepOptions?.retries ?? this.getConfig().retries;
         const retryDelay = stepOptions?.retryDelay ?? this.getConfig().retryDelay;
-        const attemptCount = stepState.attemptCount;
-        try {
-            const result = await fn();
-            await this.setStepResult(stepState.stepId, result);
-            return result;
+        let currentStepState = stepState;
+        // Check if we're running inline (in-memory) or remote (queue-based)
+        if (this.isInline(runId)) {
+            // Inline mode - execute with retry loop
+            while (true) {
+                try {
+                    await this.setStepRunning(currentStepState.stepId);
+                    const result = await fn();
+                    await this.setStepResult(currentStepState.stepId, result);
+                    return result;
+                }
+                catch (error) {
+                    // Record the error (marks step as failed)
+                    await this.setStepError(currentStepState.stepId, error);
+                    // Check if we should retry
+                    if (currentStepState.attemptCount < retries) {
+                        // Create a new pending retry attempt
+                        currentStepState = await this.createRetryAttempt(currentStepState.stepId, 'pending');
+                        // Wait for retry delay if specified
+                        if (retryDelay) {
+                            await new Promise((resolve) => setTimeout(resolve, getDurationInMilliseconds(retryDelay)));
+                        }
+                        // Continue loop to retry
+                    }
+                    else {
+                        // No more retries, fail the workflow
+                        throw error;
+                    }
+                }
+            }
         }
-        catch (error) {
-            // Record the error (marks step as failed)
-            await this.setStepError(stepState.stepId, error);
-            // Check if we should retry
-            if (attemptCount < retries) {
-                // Create a new pending retry attempt (copies metadata from failed step)
-                await this.createRetryAttempt(stepState.stepId, 'pending');
-                // Schedule orchestrator to retry after delay
-                await this.scheduleOrchestratorRetry(runId, retryDelay);
-                // Pause workflow - orchestrator will replay and pick up new attempt
-                throw new WorkflowAsyncException(runId, stepName);
+        else {
+            // Remote mode - use queue-based retry
+            try {
+                await this.setStepRunning(currentStepState.stepId);
+                const result = await fn();
+                await this.setStepResult(currentStepState.stepId, result);
+                return result;
+            }
+            catch (error) {
+                // Record the error (marks step as failed)
+                await this.setStepError(currentStepState.stepId, error);
+                // Check if we should retry
+                if (currentStepState.attemptCount < retries) {
+                    // Create a new pending retry attempt (copies metadata from failed step)
+                    await this.createRetryAttempt(currentStepState.stepId, 'pending');
+                    // Schedule orchestrator to retry after delay
+                    await this.scheduleOrchestratorRetry(runId, retryDelay);
+                    // Pause workflow - orchestrator will replay and pick up new attempt
+                    throw new WorkflowAsyncException(runId, stepName);
+                }
+                // No more retries, fail the workflow
+                throw error;
             }
-            // No more retries, fail the workflow
-            throw error;
         }
     }
     async sleepStep(runId, stepName, duration) {
@@ -363,7 +486,7 @@ export class PikkuWorkflowService {
         try {
             stepState = await this.getStepState(runId, stepName);
         }
-        catch (error) {
+        catch {
             // Step doesn't exist - create it (sleep step, no RPC)
             stepState = await this.insertStepState(runId, stepName, null, // No RPC for sleep steps
             { duration }, // Store duration as data
@@ -380,13 +503,15 @@ export class PikkuWorkflowService {
         }
         // Step is pending - schedule it
         await this.setStepScheduled(stepState.stepId);
-        // Check if we have queue service (remote mode) or inline mode
-        if (this.singletonServices.schedulerService) {
-            // Remote mode - enqueue sleep worker with delay
+        // Check if inline mode or no scheduler service
+        if (!this.isInline(runId) && this.singletonServices.schedulerService) {
+            // Remote mode - schedule sleep via scheduler service
             await this.singletonServices.schedulerService.scheduleRPC(duration, this.getConfig().sleeperRPCName, {
                 runId,
                 stepId: stepState.stepId,
             });
+            // Pause workflow - sleep will callback when done
+            throw new WorkflowAsyncException(runId, stepName);
         }
         else {
             // Inline mode - use setTimeout with actual duration
@@ -394,21 +519,9 @@ export class PikkuWorkflowService {
             await this.setStepResult(stepState.stepId, null);
             return;
         }
-        // Pause workflow - sleep will callback when done
-        throw new WorkflowAsyncException(runId, stepName);
     }
-    async cancelWorkflow(runId, reason) {
-        // Update workflow run status to cancelled
-        await this.updateRunStatus(runId, 'cancelled', undefined, {
-            message: reason || 'Workflow cancelled by user',
-            stack: '',
-            code: 'WORKFLOW_CANCELLED',
-        });
-        // Throw cancellation exception to stop workflow execution
-        throw new WorkflowCancelledException(runId, reason);
-    }
-    createWorkflowInteraction(workflowName, runId, rpcService) {
-        const workflowInteraction = {
+    createWorkflowWire(workflowName, runId, rpcService) {
+        const workflowWire = {
             workflowName,
             runId,
             getRun: async () => (await this.getRun(runId)),
@@ -427,12 +540,8 @@ export class PikkuWorkflowService {
                 this.verifyStepName(stepName);
                 await this.sleepStep(runId, stepName, getDurationInMilliseconds(duration));
             },
-            // Implement workflow.cancel()
-            cancel: async (reason) => {
-                await this.cancelWorkflow(runId, reason);
-            },
         };
-        return workflowInteraction;
+        return workflowWire;
     }
     verifyStepName(stepName) {
         if (typeof stepName !== 'string') {

package/dist/wirings/workflow/wire-workflow.d.ts

@@ -0,0 +1,42 @@
+import type { WorkflowWires } from './workflow.types.js';
+import type { GraphNodeConfig } from './graph/workflow-graph.types.js';
+/**
+ * Workflow definition with DSL function
+ */
+export interface WorkflowDefinitionFunc {
+    wires: WorkflowWires;
+    func: {
+        func: (...args: any[]) => any;
+    } | ((...args: any[]) => any);
+}
+/**
+ * Workflow definition with graph
+ */
+export interface WorkflowDefinitionGraph<T extends Record<string, GraphNodeConfig<string>> = Record<string, GraphNodeConfig<string>>> {
+    wires: WorkflowWires;
+    graph: T;
+}
+/**
+ * Union type for workflow definitions
+ */
+export type WorkflowDefinition<T extends Record<string, GraphNodeConfig<string>> = Record<string, GraphNodeConfig<string>>> = WorkflowDefinitionFunc | WorkflowDefinitionGraph<T>;
+/**
+ * Wire a workflow with triggers.
+ * Accepts either a DSL function (func) or a graph definition (graph).
+ *
+ * @example
+ * ```typescript
+ * // DSL workflow
+ * wireWorkflow({
+ *   wires: { http: { route: '/start', method: 'post' } },
+ *   func: myWorkflowFunc,
+ * })
+ *
+ * // Graph workflow
+ * wireWorkflow({
+ *   wires: { http: { route: '/graph-start', method: 'post' } },
+ *   graph: myGraphWorkflow,
+ * })
+ * ```
+ */
+export declare function wireWorkflow<T extends Record<string, GraphNodeConfig<string>>>(definition: WorkflowDefinitionFunc | WorkflowDefinitionGraph<T>): void;