@pikku/core 0.12.28 → 0.12.30

package/src/wirings/workflow/graph/graph-runner.test.ts

@@ -485,7 +485,7 @@ describe('graph-runner bugs', () => {
     delete metaState['testInlineRpcMissing']
   })
 
-  test('graph workflow with inline: true in meta should run inline', async () => {
+  test('graph workflow started with the inline flag should run inline', async () => {
     const ws = new InMemoryWorkflowService()
     let executed = false
 
@@ -511,7 +511,6 @@ describe('graph-runner bugs', () => {
       name: 'testInlineMetaGraph',
       pikkuFuncId: 'testInlineMetaGraph',
       source: 'graph',
-      inline: true,
       entryNodeIds: ['a'],
       graphHash: 'inline-meta-graph-hash',
       nodes: {

package/src/wirings/workflow/graph/graph-runner.ts

@@ -497,8 +497,7 @@ export async function executeGraphStep(
         parentRunId: runId,
         parentStepId: stepId,
       }
-      const shouldInline =
-        subWorkflowMeta.inline || !getSingletonServices()?.queueService
+      const shouldInline = !getSingletonServices()?.queueService
       const { runId: childRunId } = await workflowService.startWorkflow(
         rpcName,
         data,

package/src/wirings/workflow/pikku-workflow-service.test.ts

@@ -26,14 +26,13 @@ describe('pikku-workflow-service worker registration', () => {
   })
 })
 
-describe('pikku-workflow-service inline meta flag', () => {
-  test('workflow with inline: true in meta should create inline run and not queue', async () => {
+describe('pikku-workflow-service run-level inline', () => {
+  test('workflow runs inline (and queues nothing) when no queue service is configured', async () => {
     const ws = new InMemoryWorkflowService()
-    const workflowName = 'testInlineMetaFlag'
-    const graphHash = 'inline-meta-hash'
+    const workflowName = 'testRunInlineNoQueue'
+    const graphHash = 'run-inline-no-queue-hash'
 
-    // Set up a queue service that tracks if anything was queued
-    let queued = false
+    // No queueService configured at all → the run executes inline.
     pikkuState(null, 'package', 'singletonServices', {
       logger: {
         error: () => {},
@@ -41,11 +40,6 @@ describe('pikku-workflow-service inline meta flag', () => {
         warn: () => {},
         debug: () => {},
       },
-      queueService: {
-        add: async () => {
-          queued = true
-        },
-      },
     } as any)
 
     const metaState = pikkuState(null, 'workflows', 'meta')
@@ -54,7 +48,6 @@ describe('pikku-workflow-service inline meta flag', () => {
       pikkuFuncId: workflowName,
       source: 'dsl',
       graphHash,
-      inline: true,
     }
 
     const functionMetaState = pikkuState(null, 'function', 'meta')
@@ -72,21 +65,16 @@ describe('pikku-workflow-service inline meta flag', () => {
 
     const { runId } = await ws.startWorkflow(workflowName, {}, {}, {})
 
-    // The run should be created as inline
+    // With no queue service the run is created as inline.
     const run = await ws.getRun(runId)
     assert.equal(run?.inline, true, 'run should be marked as inline')
-    assert.equal(
-      queued,
-      false,
-      'nothing should have been queued to the queue service'
-    )
 
     delete metaState[workflowName]
     delete functionMetaState[workflowName]
     pikkuState(null, 'workflows', 'registrations').delete(workflowName)
   })
 
-  test('workflow without inline flag should use queue when queueService exists', async () => {
+  test('workflow is dispatched to the queue when a queueService exists', async () => {
     const ws = new InMemoryWorkflowService()
     const workflowName = 'testNonInlineMetaFlag'
     const graphHash = 'non-inline-meta-hash'
@@ -135,6 +123,95 @@ describe('pikku-workflow-service inline meta flag', () => {
   })
 })
 
+describe('pikku-workflow-service per-function step dispatch', () => {
+  // Expose the protected dispatchStep so we can assert the dispatch decision
+  // in isolation: a step queues only when its function opts out of inline
+  // execution (inline: false).
+  class TestWorkflowService extends InMemoryWorkflowService {
+    public callDispatchStep(rpcName: string) {
+      return this.dispatchStep('run-1', 'step-1', rpcName, {})
+    }
+  }
+
+  const setupFunction = (rpcName: string, inline?: boolean) => {
+    pikkuState(null, 'rpc', 'meta')[rpcName] = rpcName as any
+    pikkuState(null, 'function', 'meta')[rpcName] = {
+      pikkuFuncId: rpcName,
+      sessionless: true,
+      ...(inline === undefined ? {} : { inline }),
+    } as any
+  }
+
+  const cleanup = (rpcName: string) => {
+    delete pikkuState(null, 'rpc', 'meta')[rpcName]
+    delete pikkuState(null, 'function', 'meta')[rpcName]
+  }
+
+  test('default (inline) step is NOT dispatched to the queue', async () => {
+    const ws = new TestWorkflowService()
+    let queued = false
+    pikkuState(null, 'package', 'singletonServices', {
+      logger: { error() {}, info() {}, warn() {}, debug() {} },
+      queueService: {
+        add: async () => {
+          queued = true
+        },
+      },
+    } as any)
+
+    setupFunction('defaultInlineStep')
+    const dispatched = await ws.callDispatchStep('defaultInlineStep')
+    assert.equal(dispatched, false, 'default step should run inline')
+    assert.equal(queued, false, 'default step should not queue')
+    cleanup('defaultInlineStep')
+  })
+
+  test('inline: false step IS dispatched to the queue when a queueService exists', async () => {
+    const ws = new TestWorkflowService()
+    let queued = false
+    pikkuState(null, 'package', 'singletonServices', {
+      logger: { error() {}, info() {}, warn() {}, debug() {} },
+      queueService: {
+        add: async () => {
+          queued = true
+        },
+      },
+    } as any)
+
+    setupFunction('queuedStep', false)
+    const dispatched = await ws.callDispatchStep('queuedStep')
+    assert.equal(dispatched, true, 'inline:false step should dispatch')
+    assert.equal(queued, true, 'inline:false step should queue')
+    cleanup('queuedStep')
+  })
+
+  test('inline: false step warns and runs inline when no queueService is configured', async () => {
+    const ws = new TestWorkflowService()
+    let warned = false
+    pikkuState(null, 'package', 'singletonServices', {
+      logger: {
+        error() {},
+        info() {},
+        warn: () => {
+          warned = true
+        },
+        debug() {},
+      },
+      // no queueService
+    } as any)
+
+    setupFunction('queuedStepNoQueue', false)
+    const dispatched = await ws.callDispatchStep('queuedStepNoQueue')
+    assert.equal(
+      dispatched,
+      false,
+      'falls back to inline when no queue service'
+    )
+    assert.equal(warned, true, 'should warn about the misconfiguration')
+    cleanup('queuedStepNoQueue')
+  })
+})
+
 describe('pikku-workflow-service version mismatch fallback', () => {
   test('should fall back to stored graph for dsl workflow version mismatch', async () => {
     const ws = new InMemoryWorkflowService()
@@ -323,4 +400,76 @@ describe('pikku-workflow-service suspend', () => {
     delete functionMetaState[workflowName]
     pikkuState(null, 'workflows', 'registrations').delete(workflowName)
   })
+
+  test('should support multiple independent suspend points in one workflow', async () => {
+    const ws = new InMemoryWorkflowService()
+    pikkuState(null, 'package', 'singletonServices', {
+      queueService: {
+        add: async () => {},
+      },
+    } as any)
+
+    const workflowName = 'testMultiSuspendWorkflow'
+    const graphHash = 'multi-suspend-hash'
+    const metaState = pikkuState(null, 'workflows', 'meta')
+    metaState[workflowName] = {
+      name: workflowName,
+      pikkuFuncId: workflowName,
+      source: 'dsl',
+      graphHash,
+    }
+    const functionMetaState = pikkuState(null, 'function', 'meta')
+    functionMetaState[workflowName] = {
+      name: workflowName,
+      sessionless: true,
+      permissions: [],
+    } as any
+
+    addWorkflow(workflowName, {
+      func: async (
+        _services: any,
+        _data: any,
+        { workflow }: { workflow: PikkuWorkflowWire }
+      ) => {
+        await workflow.suspend('Building')
+        await workflow.suspend('Awaiting approval')
+        return { ok: true }
+      },
+    })
+
+    const runId = await ws.createRun(workflowName, {}, false, graphHash, {
+      type: 'test',
+    })
+
+    // First suspend: 'await_build' pauses the run.
+    await assert.rejects(
+      ws.runWorkflowJob(runId, {}),
+      (error: unknown) => error instanceof WorkflowSuspendedException
+    )
+    let run = await ws.getRun(runId)
+    assert.equal(run?.status, 'suspended')
+    assert.equal(run?.error?.message, 'Building')
+
+    // Resuming must hit the SECOND suspend ('awaiting_approval'), not fall
+    // through it — this is what the shared-step-name bug broke.
+    await ws.resumeWorkflow(runId)
+    await assert.rejects(
+      ws.runWorkflowJob(runId, {}),
+      (error: unknown) => error instanceof WorkflowSuspendedException
+    )
+    run = await ws.getRun(runId)
+    assert.equal(run?.status, 'suspended')
+    assert.equal(run?.error?.message, 'Awaiting approval')
+
+    // Resuming again completes the workflow.
+    await ws.resumeWorkflow(runId)
+    await ws.runWorkflowJob(runId, {})
+    run = await ws.getRun(runId)
+    assert.equal(run?.status, 'completed')
+    assert.deepEqual(run?.output, { ok: true })
+
+    delete metaState[workflowName]
+    delete functionMetaState[workflowName]
+    pikkuState(null, 'workflows', 'registrations').delete(workflowName)
+  })
 })

package/src/wirings/workflow/pikku-workflow-service.ts

@@ -879,16 +879,28 @@ export abstract class PikkuWorkflowService implements WorkflowService {
     data: unknown,
     stepOptions?: WorkflowStepOptions
   ): Promise<boolean> {
-    if (!getSingletonServices()?.queueService) {
-      return false
-    }
-    // Functions default to inline execution. Only dispatch via queue when the
-    // function explicitly sets inline: false.
+    // Step execution is decided purely by the function's `inline` flag (default
+    // true). Only a function explicitly marked `inline: false` dispatches via
+    // the queue. The run-level inline state is intentionally NOT consulted
+    // here: default steps run inline even inside a queue-dispatched run, so a
+    // normally-started workflow executes its steps in one orchestrator-worker
+    // pass instead of one queue round-trip per step.
     const functionsMeta = pikkuState(null, 'function', 'meta')
     const rpcFuncId = pikkuState(null, 'rpc', 'meta')[rpcName]
-    const rpcMeta = typeof rpcFuncId === 'string' ? functionsMeta[rpcFuncId] : undefined
+    const rpcMeta =
+      typeof rpcFuncId === 'string' ? functionsMeta[rpcFuncId] : undefined
     const forceQueue = rpcMeta?.inline === false
-    if (!forceQueue && this.isInline(runId)) {
+    if (!forceQueue) {
+      return false
+    }
+    // The function opted out of inline execution (`inline: false`) but no queue
+    // service is configured to dispatch it. Fall back to inline so the workflow
+    // still progresses, but warn loudly — silently swallowing this hides a real
+    // misconfiguration (the step won't get its own worker/retry isolation).
+    if (!getSingletonServices()?.queueService) {
+      getSingletonServices()?.logger.warn(
+        `Workflow step '${stepName}' (function '${rpcName}') is marked 'inline: false' but no queue service is configured — running it inline instead of dispatching to a queue.`
+      )
       return false
     }
     const retries = stepOptions?.retries ?? 0
@@ -977,9 +989,7 @@ export abstract class PikkuWorkflowService implements WorkflowService {
       workflowMeta.source === 'dynamic-workflow'
     ) {
       const shouldInline =
-        options?.inline ||
-        workflowMeta.inline ||
-        !getSingletonServices()?.queueService
+        options?.inline || !getSingletonServices()?.queueService
       return runWorkflowGraph(
         this,
         name,
@@ -1005,9 +1015,7 @@ export abstract class PikkuWorkflowService implements WorkflowService {
     }
 
     const shouldInline =
-      options?.inline ||
-      workflowMeta.inline ||
-      !getSingletonServices()?.queueService
+      options?.inline || !getSingletonServices()?.queueService
 
     const runId = await this.createRun(
       name,
@@ -1351,8 +1359,7 @@ export abstract class PikkuWorkflowService implements WorkflowService {
               parentRunId: runId,
               parentStepId: stepState.stepId,
             }
-            const shouldInline =
-              subWorkflowMeta.inline || !getSingletonServices()?.queueService
+            const shouldInline = !getSingletonServices()?.queueService
             const { runId: childRunId } = await this.startWorkflow(
               rpcName,
               data,
@@ -1762,23 +1769,31 @@ export abstract class PikkuWorkflowService implements WorkflowService {
     await this.setStepResult(stepState.stepId, null)
   }
 
+  /**
+   * Derive the durable step name for a suspend point from its `reason`, so each
+   * distinct reason is its own step row — letting one workflow have multiple
+   * independent suspends (e.g. wait-for-build, then wait-for-approval), and
+   * supporting dynamic reasons in loops (`suspend(`Wait for ${i}`)`) exactly
+   * like dynamic `do()` step names. The reason is used raw (it's just a text
+   * step name), only namespaced so it can't collide with a `do`/`sleep` step of
+   * the same name. Like `do()` / `sleep()`, the reason is the step's stable
+   * identity: it MUST be derived deterministically so it's the same every time
+   * the workflow replays through that point.
+   */
   private getSuspendStepName(reason: string): string {
-    if (!reason) {
-      return '__workflow_suspend'
-    }
-    return '__workflow_suspend'
+    return `__workflow_suspend:${reason}`
   }
 
   private async suspendStep(runId: string, reason: string): Promise<void> {
-    const stepName = this.getSuspendStepName(reason)
-    await this.withStepLock(runId, stepName, async () => {
+    const suspendStepName = this.getSuspendStepName(reason)
+    await this.withStepLock(runId, suspendStepName, async () => {
       let stepState: StepState
       try {
-        stepState = await this.getStepState(runId, stepName)
+        stepState = await this.getStepState(runId, suspendStepName)
       } catch {
         stepState = await this.insertStepState(
           runId,
-          stepName,
+          suspendStepName,
           'pikkuWorkflowSuspend',
           {
             reason,
@@ -1788,7 +1803,7 @@ export abstract class PikkuWorkflowService implements WorkflowService {
       if (!stepState.stepId) {
         stepState = await this.insertStepState(
           runId,
-          stepName,
+          suspendStepName,
           'pikkuWorkflowSuspend',
           {
             reason,
@@ -1865,7 +1880,8 @@ export abstract class PikkuWorkflowService implements WorkflowService {
       },
 
       suspend: async (reason: string) => {
-        await this.suspendStep(runId, reason || 'Workflow suspended')
+        this.verifyStepName(reason)
+        await this.suspendStep(runId, reason)
       },
     }
     return workflowWire

package/src/wirings/workflow/workflow.types.ts

@@ -315,7 +315,6 @@ export type WorkflowsMeta = Record<
     steps: WorkflowStepMeta[]
     context?: WorkflowContext
     dsl?: boolean
-    inline?: boolean
     expose?: boolean
   }
 >
@@ -336,8 +335,6 @@ export interface WorkflowRuntimeMeta {
   description?: string
   /** Tags for organization */
   tags?: string[]
-  /** If true, workflow always executes inline without queues */
-  inline?: boolean
   /** Serialized nodes */
   nodes?: Record<string, any>
   /** Entry node IDs for graph workflows (computed at build time) */