@pikku/core 0.12.78 → 0.12.80

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

@@ -9,13 +9,13 @@ import { closeWireServices } from '../../utils.js'
 import { PikkuError, addError } from '../../errors/error-handler.js'
 import { InMemoryWorkflowService } from '../../services/in-memory-workflow-service.js'
 import { runScheduledTask } from '../scheduler/scheduler-runner.js'
-import {
-  WorkflowStepNameNotString,
-  type RunLifecycleContext,
-  type WorkflowRunEngine,
-  type WorkflowRunExtension,
-} from './pikku-workflow-service.js'
-import type { PikkuWire } from '../../types/core.types.js'
+import { WorkflowStepNameNotString } from './workflow-errors.js'
+import type {
+  RunLifecycleContext,
+  WorkflowRunEngine,
+  WorkflowRunExtension,
+} from './workflow-run-engine.types.js'
+import type { PikkuRawWire } from '../../types/core.types.js'
 import type { ScenarioPersonas } from '../../services/personas-service.js'
 import type { CorePikkuFunctionConfig } from '../../function/functions.types.js'
 import type {
@@ -66,7 +66,7 @@ export const createScenarioRunner = (
 type ScenarioHook = (
   services: any,
   data: any,
-  wire: PikkuWire
+  wire: PikkuRawWire
 ) => Promise<void> | void
 
 /**
@@ -245,6 +245,10 @@ export class PikkuScenarioService implements WorkflowRunExtension {
   // Scenario actors per run: live authenticated clients (cookie jars) are
   // process-local by nature, so they ride this map, never the persisted wire.
   private runActors = new Map<string, ScenarioPersonas>()
+  // What each run has accumulated so far. Process-local like the actors above:
+  // a scenario is a single in-process run, so the body and its hooks share one
+  // object rather than reading it back off the persisted wire.
+  private runContexts = new Map<string, Record<string, unknown>>()
   private scenarioBrowserProvider?: ScenarioBrowserProvider
   private scenarioEnvironment?: ScenarioEnvironment
   private runSurface: ScenarioSurface = 'default'
@@ -304,14 +308,42 @@ export class PikkuScenarioService implements WorkflowRunExtension {
     if (actors) {
       this.runActors.set(runId, actors)
     }
+    if (workflowMeta.source === 'scenario') {
+      this.runContexts.set(runId, {})
+    }
   }
 
   public detachRunContext(runId: string): void {
     this.runActors.delete(runId)
+    this.runContexts.delete(runId)
+  }
+
+  /**
+   * What the run has accumulated, for a reporter that wants to say what a
+   * failed scenario left behind. Undefined for a plain workflow.
+   */
+  public getRunContext(runId: string): Record<string, unknown> | undefined {
+    return this.runContexts.get(runId)
+  }
+
+  /**
+   * The run's context, created on demand.
+   *
+   * `attachRunContext` seeds it for an ordinary scenario run, but the wire is
+   * also built on paths that skip attach; without this the body would be
+   * writing to an `undefined` and teardown would read nothing.
+   */
+  private contextForRun(runId: string): Record<string, unknown> {
+    let runContext = this.runContexts.get(runId)
+    if (!runContext) {
+      runContext = {}
+      this.runContexts.set(runId, runContext)
+    }
+    return runContext
   }
 
   public decorateRunWire(
-    wire: PikkuWire,
+    wire: PikkuRawWire,
     context: {
       runId: string
       workflowMeta: any
@@ -409,7 +441,7 @@ export class PikkuScenarioService implements WorkflowRunExtension {
     phase: 'before' | 'after',
     scenarioName: string,
     hook: ScenarioHook,
-    wire: PikkuWire,
+    wire: PikkuRawWire,
     data: unknown,
     packageName: string | null
   ): Promise<void> {
@@ -424,10 +456,9 @@ export class PikkuScenarioService implements WorkflowRunExtension {
 
     let wireServices: Record<string, unknown> | undefined
     try {
-      wireServices = (await createWireServices?.(
-        singletonServices,
-        wire as any
-      )) as Record<string, unknown> | undefined
+      wireServices = (await createWireServices?.(singletonServices, wire)) as
+        | Record<string, unknown>
+        | undefined
       const services =
         wireServices && Object.keys(wireServices).length > 0
           ? { ...singletonServices, ...wireServices }
@@ -508,6 +539,11 @@ export class PikkuScenarioService implements WorkflowRunExtension {
       rpcService,
     })
     Object.assign(workflowWire, {
+      // One object per run, resolved through the map rather than created here,
+      // so the body and its before/after hooks share the same scratch even
+      // though the hooks are separate functions that cannot see its locals.
+      context: this.contextForRun(runId),
+
       // Durable polling step: invoke an RPC (as an actor when options.as is
       // set) until the predicate passes or `within` elapses. The whole poll is
       // ONE recorded step, so replay returns the cached outcome.
@@ -648,12 +684,7 @@ export class PikkuScenarioService implements WorkflowRunExtension {
         )
       },
 
-      // Scenario steps: a named `pikkuScenarioStep` run as one durable step.
-      // `given`/`when` are sugar for each other, differing only in the
-      // prose a reporter renders. `then` is not: the phase is what decides
-      // whether the step's bindings are alternatives or witnesses, so the same
-      // step function called two ways runs differently. See
-      // {@link resolveScenarioSurfaces}.
+      // knowledge: decisions/internals/scenario-given-and-when-are-sugar-but-then-is-not.md
       given: (stepName, stepFunc, data, options) =>
         this.scenarioStep(
           'given',
@@ -696,8 +727,7 @@ export class PikkuScenarioService implements WorkflowRunExtension {
     data?: any,
     options?: ScenarioStepOptions
   ): Promise<any> {
-    const { runId, workflowName, addonNamespace, workflowWire, rpcService } =
-      context
+    const { runId, workflowName, addonNamespace, workflowWire } = context
     // Also the guard for `then` being a wire member: an accidental
     // `await scenario` calls it with a resolve function, which lands here as a
     // loud, named error instead of a silent hang.
@@ -727,11 +757,10 @@ export class PikkuScenarioService implements WorkflowRunExtension {
       stepName,
       async () => {
         const runOnSurface = async (surface: ScenarioSurface) => {
-          const wire: PikkuWire = {
+          // No `rpc` yet — runPikkuFunc attaches it lazily for the invocation.
+          const wire: PikkuRawWire = {
             workflow: workflowWire,
             scenario: workflowWire,
-            rpc: rpcService?.wire?.rpc,
-            session: rpcService?.wire?.session,
             pikkuUserId: workflowWire.pikkuUserId,
             actors: this.runActors.get(runId),
             scenarioStep: {

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

@@ -8,8 +8,8 @@ import { addWorkflow } from './dsl/workflow-runner.js'
 import {
   WorkflowApprovalResolvedError,
   WorkflowSuspendedException,
-  type PikkuWorkflowWire,
-} from './pikku-workflow-service.js'
+} from './workflow-errors.js'
+import type { PikkuWorkflowWire } from './workflow.types.js'
 
 describe('pikku-workflow-service worker registration', () => {
   test('registers sleeper function metadata after wireQueueWorkers', () => {