@pikku/core 0.12.134 → 0.12.136

package/dist/testing/service-tests/queued-workflow-harness.js

@@ -0,0 +1,151 @@
+import { pikkuState, resetPikkuState } from '../../pikku-state.js';
+import { addWorkflow } from '../../wirings/workflow/dsl/workflow-runner.js';
+/**
+ * Drives a workflow the way a deployment does: every orchestration and every
+ * `workflowQueued` step goes through a queue, and a pump plays the workers.
+ * Delays are ignored, so a retry runs on the next pass.
+ */
+export class QueuedWorkflowHarness {
+    handlers = {};
+    log = [];
+    contexts = [];
+    recovering = [];
+    queue = [];
+    jobsRun = [];
+    ws;
+    /** Return true to drop the job instead of running it, simulating a worker that never ran. */
+    dropWhen;
+    /** Make `queue.add` throw for a job, simulating the broker being unreachable. */
+    rejectAddWhen;
+    constructor(service) {
+        resetPikkuState();
+        this.ws = service;
+        const queueService = {
+            add: async (queue, data, options) => {
+                if (this.rejectAddWhen?.(queue, data)) {
+                    throw new Error('broker unreachable');
+                }
+                this.queue.push({ queue, data, attempts: options?.attempts ?? 1 });
+            },
+        };
+        pikkuState(null, 'package', 'singletonServices', {
+            logger: { error() { }, info() { }, warn() { }, debug() { } },
+            queueService,
+            workflowService: this.ws,
+        });
+    }
+    rpc = {
+        rpcWithWire: async (rpcName, data, wire) => {
+            const isCompensation = rpcName.endsWith(':compensate');
+            const base = isCompensation
+                ? rpcName.slice(0, -':compensate'.length)
+                : rpcName;
+            const handler = this.handlers[base];
+            this.contexts.push({
+                rpc: rpcName,
+                context: wire.workflow?.compensatingFor,
+            });
+            if (isCompensation) {
+                this.log.push(`undo:${base}`);
+                return handler.compensate(data, wire.workflow.compensatingFor);
+            }
+            this.log.push(`do:${base}`);
+            if (wire.graph?.recoveringFrom) {
+                this.recovering.push({ rpc: base, from: wire.graph.recoveringFrom });
+            }
+            return handler.forward(data, wire);
+        },
+    };
+    register(name, handler) {
+        this.handlers[name] = handler;
+        pikkuState(null, 'rpc', 'meta')[name] = name;
+        pikkuState(null, 'function', 'meta')[name] = {
+            name,
+            pikkuFuncId: name,
+            sessionless: true,
+            permissions: [],
+            workflowQueued: handler.queued !== false,
+            ...(handler.compensate ? { compensate: true } : {}),
+        };
+    }
+    defineDsl(name, body) {
+        pikkuState(null, 'workflows', 'meta')[name] = {
+            name,
+            pikkuFuncId: name,
+            source: 'dsl',
+            graphHash: `${name}-hash`,
+        };
+        pikkuState(null, 'function', 'meta')[name] = {
+            name,
+            sessionless: true,
+            permissions: [],
+        };
+        addWorkflow(name, {
+            func: async (_services, input, wire) => body(wire.workflow, input),
+        });
+    }
+    defineGraph(name, entry, nodes) {
+        pikkuState(null, 'workflows', 'meta')[name] = {
+            name,
+            pikkuFuncId: name,
+            source: 'graph',
+            entryNodeIds: [entry],
+            graphHash: `${name}-hash`,
+            nodes: Object.fromEntries(Object.entries(nodes).map(([id, node]) => [
+                id,
+                { nodeId: id, rpcName: id, retries: 0, ...node },
+            ])),
+        };
+    }
+    async start(name, input = {}) {
+        const { runId } = await this.ws.startWorkflow(name, input, { type: 'test' }, this.rpc);
+        await this.pump();
+        return runId;
+    }
+    /** Run jobs until the queue is empty. */
+    async pump(limit = 500) {
+        for (let i = 0; i < limit && this.queue.length > 0; i++) {
+            const job = this.queue.shift();
+            if (this.dropWhen?.(job))
+                continue;
+            this.jobsRun.push({ queue: job.queue, step: job.data.stepName });
+            try {
+                if (job.data.stepName !== undefined) {
+                    await this.ws.executeWorkflowStep(job.data.runId, job.data.stepName, job.data.rpcName, job.data.data, this.rpc);
+                }
+                else {
+                    await this.ws.orchestrateWorkflow(job.data.runId, this.rpc);
+                }
+            }
+            catch {
+                job.attempt = (job.attempt ?? 1) + 1;
+                if (job.attempt <= (job.attempts ?? 1))
+                    this.queue.push(job);
+            }
+        }
+        if (this.queue.length > 0)
+            throw new Error('queue did not drain');
+    }
+    async run(runId) {
+        return (await this.ws.getRun(runId));
+    }
+    async steps(runId) {
+        return this.ws.getRunSteps(runId);
+    }
+    get undone() {
+        return this.log.filter((l) => l.startsWith('undo'));
+    }
+    ok(output = {}) {
+        return { forward: async () => output };
+    }
+    boom(message = 'boom') {
+        return {
+            forward: async () => {
+                throw new Error(message);
+            },
+        };
+    }
+    undoable(output = {}) {
+        return { ...this.ok(output), compensate: async () => { } };
+    }
+}

package/dist/testing/service-tests/workflow-compensation-queued-tests.d.ts

@@ -0,0 +1,11 @@
+import type { PikkuWorkflowService } from '../../wirings/workflow/pikku-workflow-service.js';
+/**
+ * Conformance suite for saga compensation and graph `recover` on the queued
+ * path: every orchestration and step goes through a queue and is played back by
+ * a pump, as in a deployment. Each test gets a fresh service.
+ */
+export interface QueuedCompensationOptions {
+    /** False for a runtime where one run owns its storage and cannot start a child run. */
+    childWorkflows?: boolean;
+}
+export declare const defineWorkflowCompensationQueuedTests: (name: string, create: () => Promise<PikkuWorkflowService>, options?: QueuedCompensationOptions) => void;