@pikku/core 0.12.39 → 0.12.41

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

@@ -144,7 +144,10 @@ export class WorkflowDispatchException extends Error {
     public readonly stepName: string,
     options?: { cause?: unknown }
   ) {
-    super(`Failed to dispatch workflow step '${stepName}' (run ${runId})`, options)
+    super(
+      `Failed to dispatch workflow step '${stepName}' (run ${runId})`,
+      options
+    )
     this.name = 'WorkflowDispatchException'
   }
 }
@@ -184,6 +187,16 @@ addError(WorkflowRunFailedError, {
   message: 'Workflow run failed.',
 })
 
+export class WorkflowRunCancelledError extends PikkuError {
+  constructor() {
+    super('Workflow was cancelled')
+  }
+}
+addError(WorkflowRunCancelledError, {
+  status: 409,
+  message: 'Workflow was cancelled.',
+})
+
 export class WorkflowServiceNotInitialized extends Error {}
 export class WorkflowStepNameNotString extends Error {
   constructor(stepName: any) {
@@ -237,16 +250,13 @@ export abstract class PikkuWorkflowService implements WorkflowService {
     }
   }
 
-  public rewireQueueWorkers(): void {
-    this.wireQueueWorkers()
-  }
-
   /**
    * Wire the queue-based orchestrator/step/sleeper workers.
    * Subclasses that orchestrate without queues (e.g. Durable Objects) should
    * pass `wireQueues: false` to the base constructor and skip this entirely.
+   * Call this explicitly after adding addons dynamically.
    */
-  protected wireQueueWorkers(): void {
+  public wireQueueWorkers(): void {
     const functions = pikkuState(null, 'function', 'functions')
     const functionsMeta = pikkuState(null, 'function', 'meta')
 
@@ -426,7 +436,12 @@ export abstract class PikkuWorkflowService implements WorkflowService {
     // Build step summaries from history (latest attempt per step)
     const stepMap = new Map<
       string,
-      { status: StepStatus; startedAt?: Date; completedAt?: Date; attempts: number }
+      {
+        status: StepStatus
+        startedAt?: Date
+        completedAt?: Date
+        attempts: number
+      }
     >()
     for (const step of history) {
       const existing = stepMap.get(step.stepName)
@@ -920,7 +935,9 @@ export abstract class PikkuWorkflowService implements WorkflowService {
     const queueService = this.verifyQueueService()
     await queueService.add(
       this.getStepWorkerQueueName(rpcName),
-      JSON.parse(JSON.stringify({ runId, stepName, rpcName, data, fromStepName })),
+      JSON.parse(
+        JSON.stringify({ runId, stepName, rpcName, data, fromStepName })
+      ),
       this.resolveStepJobOptions(stepOptions)
     )
   }
@@ -982,29 +999,22 @@ export abstract class PikkuWorkflowService implements WorkflowService {
     stepOptions?: WorkflowStepOptions,
     fromStepName?: string
   ): Promise<boolean> {
-    // 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.
+    // Step execution is decided purely by the function's `workflowQueued` flag
+    // (default false). Only a function explicitly marked `workflowQueued: true`
+    // dispatches via the queue. If the queue service is not configured that is
+    // a hard error — there is no inline fallback.
     const functionsMeta = pikkuState(null, 'function', 'meta')
     const rpcFuncId = pikkuState(null, 'rpc', 'meta')[rpcName]
     const rpcMeta =
       typeof rpcFuncId === 'string' ? functionsMeta[rpcFuncId] : undefined
-    const forceQueue = rpcMeta?.inline === false
+    const forceQueue = rpcMeta?.workflowQueued === true
     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.`
+      throw new Error(
+        `Workflow step '${stepName}' (function '${rpcName}') is marked 'workflowQueued: true' but no queue service is configured.`
       )
-      return false
     }
     try {
       await getSingletonServices()!.queueService!.add(
@@ -1192,7 +1202,7 @@ export abstract class PikkuWorkflowService implements WorkflowService {
           throw new WorkflowRunFailedError(run.error?.message)
         }
         if (run.status === 'cancelled') {
-          throw new Error('Workflow was cancelled')
+          throw new WorkflowRunCancelledError()
         }
         return run.output
       }
@@ -1844,7 +1854,9 @@ export abstract class PikkuWorkflowService implements WorkflowService {
             }
             if (WORKFLOW_END_STATES.has(childRun.status)) {
               if (childRun.status === 'failed') {
-                throw new Error(childRun.error?.message || 'Sub-workflow failed')
+                throw new Error(
+                  childRun.error?.message || 'Sub-workflow failed'
+                )
               }
               if (childRun.status === 'cancelled') {
                 throw new Error('Sub-workflow was cancelled')

package/src/wirings/workflow/workflow-dispatch-durability.test.ts

@@ -5,13 +5,13 @@ import { InMemoryWorkflowService } from '../../services/in-memory-workflow-servi
 import { pikkuState } from '../../pikku-state.js'
 import { WorkflowDispatchException } from './pikku-workflow-service.js'
 
-// Register an `inline: false` function so the workflow's `do()` routes the step
-// through the queue (dispatchStep) instead of running it inline.
+// Register a `workflowQueued: true` function so the workflow's `do()` routes
+// the step through the queue (dispatchStep) instead of running it inline.
 function registerDispatchedFn(rpcName: string): void {
   const funcId = `fn:${rpcName}`
   pikkuState(null, 'rpc', 'meta', { [rpcName]: funcId } as any)
   pikkuState(null, 'function', 'meta', {
-    [funcId]: { inline: false },
+    [funcId]: { workflowQueued: true },
   } as any)
 }