@fiducian/temporal 0.4.0

package/dist/index.d.ts

@@ -0,0 +1,44 @@
+import type { StoryContext, TraceEvent } from "@fiducian/conductor";
+import type { FiduciaTrace } from "@fiducian/runtime";
+export declare const TEMPORAL_HEADER_CONTEXT = "fiducia-context";
+export declare const TEMPORAL_HEADER_WORKFLOW = "fiducia-workflow-id";
+export interface WorkflowStep {
+    from: string;
+    to: string;
+    payload?: Record<string, unknown>;
+    op?: string;
+}
+export interface TemporalHeaders {
+    [TEMPORAL_HEADER_CONTEXT]?: string;
+    [TEMPORAL_HEADER_WORKFLOW]?: string;
+    [key: string]: string | undefined;
+}
+export declare class FiduciaTemporal {
+    readonly ct: FiduciaTrace;
+    readonly workflowType: string;
+    constructor(ct: FiduciaTrace, workflowType: string);
+    contextForWorkflowRun(workflowId: string): StoryContext;
+    encodeHeaders(ctx: StoryContext, workflowId: string): TemporalHeaders;
+    decodeHeaders(headers: TemporalHeaders | undefined): StoryContext | undefined;
+    emitStep(ctx: StoryContext, step: WorkflowStep): TraceEvent;
+}
+export interface ActivityInterceptorHandlers {
+    inbound: {
+        execute: (input: unknown, next: (input: unknown) => Promise<unknown>) => Promise<unknown>;
+    };
+}
+export interface ActivityExecutionInput {
+    headers?: TemporalHeaders;
+    activityType: string;
+    args: unknown[];
+}
+export interface TemporalActivityInterceptorOptions {
+    bridge: FiduciaTemporal;
+    mapActivity: (activityType: string, args: unknown[]) => WorkflowStep | undefined;
+}
+export declare function createActivityInterceptor(options: TemporalActivityInterceptorOptions): ActivityInterceptorHandlers;
+export type CheckoutMode = "bug" | "fix";
+export declare function simulateCheckoutWorkflow(bridge: FiduciaTemporal, workflowId: string, mode: CheckoutMode): Promise<{
+    ctx: StoryContext;
+    evaluation: ReturnType<FiduciaTrace["evaluateRecorded"]>;
+}>;

package/dist/index.js

@@ -0,0 +1,93 @@
+export const TEMPORAL_HEADER_CONTEXT = "fiducia-context";
+export const TEMPORAL_HEADER_WORKFLOW = "fiducia-workflow-id";
+export class FiduciaTemporal {
+    ct;
+    workflowType;
+    constructor(ct, workflowType) {
+        this.ct = ct;
+        this.workflowType = workflowType;
+    }
+    contextForWorkflowRun(workflowId) {
+        return this.ct.conductor.startStoryWithId(`${this.workflowType}:${workflowId}`);
+    }
+    encodeHeaders(ctx, workflowId) {
+        return {
+            [TEMPORAL_HEADER_CONTEXT]: ctx.contextId,
+            [TEMPORAL_HEADER_WORKFLOW]: workflowId,
+        };
+    }
+    decodeHeaders(headers) {
+        if (!headers?.[TEMPORAL_HEADER_CONTEXT])
+            return undefined;
+        return { contextId: headers[TEMPORAL_HEADER_CONTEXT] };
+    }
+    emitStep(ctx, step) {
+        return this.ct.emit(ctx, {
+            from: step.from,
+            to: step.to,
+            op: step.op ?? "send",
+            payload: step.payload ?? {},
+        });
+    }
+}
+export function createActivityInterceptor(options) {
+    return {
+        inbound: {
+            execute: async (input, next) => {
+                const execution = input;
+                const ctx = options.bridge.decodeHeaders(execution.headers);
+                const step = options.mapActivity(execution.activityType, execution.args);
+                if (ctx && step) {
+                    options.bridge.emitStep(ctx, step);
+                }
+                return next(input);
+            },
+        },
+    };
+}
+export async function simulateCheckoutWorkflow(bridge, workflowId, mode) {
+    const ctx = bridge.contextForWorkflowRun(workflowId);
+    const headers = bridge.encodeHeaders(ctx, workflowId);
+    const runActivity = (activityType, args) => {
+        const interceptor = createActivityInterceptor({
+            bridge,
+            mapActivity: (type, activityArgs) => activityMapping(type, activityArgs),
+        });
+        return interceptor.inbound.execute({ headers, activityType, args }, async () => undefined);
+    };
+    await runActivity("PlaceOrder", [{ orderId: "ord-99" }]);
+    if (mode === "bug") {
+        await runActivity("ChargePayment", [{ orderId: "ord-99", charged: true }]);
+        await runActivity("AcceptKitchen", [{ orderId: "ord-99", accepted: true }]);
+    }
+    else {
+        await runActivity("AcceptKitchen", [{ orderId: "ord-99", accepted: true }]);
+        await runActivity("ChargePayment", [{ orderId: "ord-99", charged: true }]);
+    }
+    return { ctx, evaluation: bridge.ct.evaluateRecorded() };
+}
+function activityMapping(activityType, args) {
+    const record = (args[0] ?? {});
+    switch (activityType) {
+        case "PlaceOrder":
+            return {
+                from: "client",
+                to: "order",
+                payload: { orderId: record.orderId },
+            };
+        case "AcceptKitchen":
+            return {
+                from: "order",
+                to: "kitchen",
+                payload: { orderId: record.orderId, accepted: record.accepted === true },
+            };
+        case "ChargePayment":
+            return {
+                from: "order",
+                to: "billing",
+                payload: { orderId: record.orderId, charged: record.charged === true },
+            };
+        default:
+            return undefined;
+    }
+}

package/dist/index.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/index.test.js

@@ -0,0 +1,33 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { FiduciaTrace, parseWaltzFile } from "@fiducian/runtime";
+import { simulateCheckoutWorkflow, FiduciaTemporal } from "./index.js";
+const spec = parseWaltzFile(`
+  Omega(
+    send client->order{orderId} : true
+    ;
+    send order->kitchen{orderId, accepted} : accepted == true
+    ;
+    send order->billing{orderId, charged} : charged == true
+  )
+`);
+test("simulateCheckoutWorkflow fix mode passes", async () => {
+    const ct = new FiduciaTrace({ spec });
+    const bridge = new FiduciaTemporal(ct, "CheckoutWorkflow");
+    const { evaluation } = await simulateCheckoutWorkflow(bridge, "run-1", "fix");
+    assert.equal(evaluation.passed, true);
+});
+test("simulateCheckoutWorkflow bug mode fails", async () => {
+    const ct = new FiduciaTrace({ spec });
+    const bridge = new FiduciaTemporal(ct, "CheckoutWorkflow");
+    const { evaluation } = await simulateCheckoutWorkflow(bridge, "run-2", "bug");
+    assert.equal(evaluation.passed, false);
+});
+test("FiduciaTemporal encodes headers for activity propagation", () => {
+    const ct = new FiduciaTrace({ spec });
+    const bridge = new FiduciaTemporal(ct, "CheckoutWorkflow");
+    const ctx = bridge.contextForWorkflowRun("wf-1");
+    const headers = bridge.encodeHeaders(ctx, "wf-1");
+    assert.equal(headers["fiducia-context"], ctx.contextId);
+    assert.equal(headers["fiducia-workflow-id"], "wf-1");
+});

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@fiducian/temporal",
+  "version": "0.4.0",
+  "description": "Temporal workflow and activity hooks for FiduciaTrace",
+  "license": "AGPL-3.0-or-later",
+  "keywords": ["fiducia", "fiducia", "temporal", "workflow", "activities"],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/thesnmc/Fiducian.git",
+    "directory": "trace/packages/temporal"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": ["dist"],
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "dependencies": {
+    "@fiducian/conductor": "0.4.0",
+    "@fiducian/runtime": "0.4.0"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "test": "node --test dist/**/*.test.js",
+    "prepublishOnly": "npm run build"
+  }
+}