@pikku/core 0.12.69 → 0.12.70

package/src/wirings/workflow/feature.ts

@@ -0,0 +1,78 @@
+import { pikkuState } from '../../pikku-state.js'
+import type {
+  CoreFeature,
+  CoreWorkflow,
+  FeaturePlanEntry,
+} from './workflow.types.js'
+
+/**
+ * Register a feature under the name it is exported as. Called from generated
+ * wiring, the same way `addWorkflow` is.
+ */
+export const addFeature = (
+  featureId: string,
+  feature: CoreFeature,
+  packageName: string | null = null
+) => {
+  pikkuState(packageName, 'workflows', 'features').set(featureId, feature)
+}
+
+/**
+ * Resolve every feature's scenario references back to the names their
+ * scenarios are registered under.
+ *
+ * Matching is by **object identity**: `pikkuScenario` returns its config
+ * verbatim and `addWorkflow` registers that same object, so a feature holding
+ * the imported identifier holds the very object that was registered. Nothing
+ * is matched by shape, by name, or by any other guess — which is also why a
+ * scenario built inline inside a feature (and therefore never registered)
+ * comes back as unresolved rather than silently running as something else.
+ *
+ * Entries are returned in declaration order, features in registration order.
+ * A scenario's effective tags are its own plus the containing feature's, so
+ * `--tags credential` selects through the feature.
+ */
+export const resolveFeatureScenarios = (
+  features: Map<string, CoreFeature>,
+  registrations: Map<string, CoreWorkflow>
+): {
+  entries: FeaturePlanEntry[]
+  unresolved: Array<{ featureId: string; index: number }>
+} => {
+  const nameByConfig = new Map<unknown, string>()
+  for (const [name, registration] of registrations) {
+    nameByConfig.set(registration.func, name)
+  }
+
+  const entries: FeaturePlanEntry[] = []
+  const unresolved: Array<{ featureId: string; index: number }> = []
+
+  for (const [featureId, feature] of features) {
+    const scenarios = feature.scenarios ?? []
+    for (let index = 0; index < scenarios.length; index++) {
+      const entry = scenarios[index]!
+      const paired =
+        typeof entry === 'object' && entry !== null && 'scenario' in entry
+      const config = paired ? (entry as any).scenario : entry
+      const scenarioName = nameByConfig.get(config)
+      if (!scenarioName) {
+        unresolved.push({ featureId, index })
+        continue
+      }
+      entries.push({
+        featureId,
+        featureName: feature.name ?? featureId,
+        scenarioName,
+        data: paired ? (entry as any).data : undefined,
+        tags: [
+          ...new Set([
+            ...((registrations.get(scenarioName)?.func as any)?.tags ?? []),
+            ...(feature.tags ?? []),
+          ]),
+        ],
+      })
+    }
+  }
+
+  return { entries, unresolved }
+}

package/src/wirings/workflow/index.ts

@@ -11,6 +11,11 @@ export {
   WorkflowApprovalResolvedError,
   DEFAULT_STEP_RETRIES,
 } from './pikku-workflow-service.js'
+export type {
+  RunLifecycleContext,
+  WorkflowRunEngine,
+  WorkflowRunExtension,
+} from './pikku-workflow-service.js'
 export { deriveInvocationId, uuidv5 } from './workflow-invocation-id.js'
 
 // Time-travel: reconstruct run state at any point from durable history
@@ -29,6 +34,7 @@ export type {
 
 // Internal registration functions (used by generated code)
 export { addWorkflow } from './dsl/workflow-runner.js'
+export { addFeature, resolveFeatureScenarios } from './feature.js'
 
 // Graph helpers (template, pikkuWorkflowGraph)
 export { template, type TemplateString } from './graph/template.js'
@@ -72,6 +78,12 @@ export type {
   WorkflowRunService,
   WorkflowRunMirror,
   CoreWorkflow,
+  CoreFeature,
+  CoreFeatureScenario,
+  FeatureMeta,
+  FeatureMetaEntry,
+  FeaturesMeta,
+  FeaturePlanEntry,
   PikkuWorkflow,
   ContextVariable,
   WorkflowContext,
@@ -113,8 +125,69 @@ export type {
   SwitchStepMeta,
   FilterStepMeta,
   ArrayPredicateStepMeta,
+  ScenarioStepInvocation,
+  ScenarioStepMeta,
   WorkflowStepMeta,
   WorkflowStepWire,
   PikkuWorkflowWire,
   PikkuScenarioWire,
 } from './workflow.types.js'
+
+/* ------------------------------------------------------------------ *
+ * Scenarios — writing a step
+ *
+ * What a step file imports. Everything here is reached from inside a
+ * `pikkuScenarioStep` body.
+ * ------------------------------------------------------------------ */
+
+// The step's own wire, and the shape of what it was given
+export type {
+  ScenarioStepPhase,
+  ScenarioStepOptions,
+  PikkuScenarioStepWire,
+  ScenarioEnvironment,
+} from './scenario-step.types.js'
+
+// Narrows the optional halves of the step wire, with a message that says what to do
+export { requireActor, requireScenarioEnv } from './scenario-step-guards.js'
+
+// Waits for the target to catch up, without every step writing the loop again
+export { pollUntil, type PollOptions } from './scenario-poll.js'
+
+// Persists cookies across a step's requests, the way a browser would
+export { createCookieJar } from './scenario-cookie-jar.js'
+export type { ScenarioCookieJar } from './scenario-cookie-jar.js'
+
+// What the transport answered — an actor's `invokeRaw`, or a route reached
+// directly — and the one way to POST JSON at a route and keep its status
+export type {
+  ScenarioHttpResponse,
+  ScenarioJsonRequest,
+} from '../../services/scenario-actors-service.js'
+export {
+  readScenarioHttpResponse,
+  postScenarioJson,
+} from '../../services/scenario-actors-service.js'
+
+/* ------------------------------------------------------------------ *
+ * Scenarios — driving a browser
+ *
+ * How a step names an element, and what a driver package
+ * (`@pikku/playwright`, or another) implements.
+ * ------------------------------------------------------------------ */
+
+export type {
+  PikkuBrowserWire,
+  TestIdSelector,
+  ScenarioBrowserProvider,
+  ScenarioBrowserFailure,
+} from './scenario-step.types.js'
+
+/* ------------------------------------------------------------------ *
+ * Scenarios — reporting a run
+ *
+ * Used by the CLI reporter and the console, so the two render the same
+ * sentence for the same step. A step body needs none of it.
+ * ------------------------------------------------------------------ */
+
+export { composeStepProse, renderStepTemplate } from './scenario-prose.js'