@intentius/chant-lexicon-temporal 0.1.14 → 0.1.15

package/src/op/runtime.test.ts

@@ -0,0 +1,196 @@
+/**
+ * Temporal runtime harness (#161) — runs the serializer's ACTUAL generated
+ * workflow under a real Temporal worker + time-skipping test server. This is
+ * the durable counterpart to the string-level assertions in op-serializer.test:
+ * it proves the emitted control flow behaves correctly at runtime —
+ *
+ *   - happy path: phases run in declared order
+ *   - gate:       the workflow waits for the approval signal (proven via the
+ *                 skipped-clock delta), not just for the timeout
+ *   - compensation: a failing activity runs onFailure phases in reverse, then
+ *                 the original failure is re-thrown (the #168 fix)
+ *   - destructive-apply approval: ApplyOp's `nativeApply` does not run until the
+ *                 approval signal is received (#125)
+ *
+ * Each scenario serializes a real Op, writes the emitted workflow.ts next to
+ * this file (so `@intentius/chant-lexicon-temporal/config` resolves), and runs
+ * it. Generated workflow files live in ./__generated__ (gitignored).
+ */
+import { describe, test, expect, beforeAll, afterAll } from "vitest";
+import { TestWorkflowEnvironment } from "@temporalio/testing";
+import { Worker } from "@temporalio/worker";
+import { ApplicationFailure } from "@temporalio/common";
+import { mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { fileURLToPath } from "node:url";
+import type { ActivityFn } from "./activity-registry";
+import { serializeOps } from "./serializer";
+import { ApplyOp } from "../composites/apply-op";
+import type { Declarable } from "@intentius/chant/declarable";
+
+const GEN_DIR = fileURLToPath(new URL("./__generated__", import.meta.url));
+
+// Search attributes the generated workflows upsert (OpName/Phase always; the
+// rest from ApplyOp's searchAttributes + the Drift outcome attribute).
+const SEARCH_ATTRS = { OpName: 2, Phase: 2, Drift: 2, Apply: 2, Env: 2 } as const;
+
+function camel(name: string): string {
+  return name.replace(/-([a-z])/g, (_, c: string) => c.toUpperCase());
+}
+function workflowFn(name: string): string {
+  return camel(name) + "Workflow";
+}
+function opMap(config: Record<string, unknown>): Map<string, Declarable> {
+  return new Map([[config.name as string, { props: config } as unknown as Declarable]]);
+}
+
+let env: TestWorkflowEnvironment;
+let wfCounter = 0;
+
+beforeAll(async () => {
+  mkdirSync(GEN_DIR, { recursive: true });
+  env = await TestWorkflowEnvironment.createTimeSkipping();
+  await (env.connection as { operatorService: { addSearchAttributes: (r: unknown) => Promise<unknown> } })
+    .operatorService.addSearchAttributes({
+      namespace: env.namespace,
+      searchAttributes: SEARCH_ATTRS,
+    });
+}, 120_000);
+
+afterAll(async () => {
+  await env?.teardown();
+  rmSync(GEN_DIR, { recursive: true, force: true });
+});
+
+/**
+ * Serialize `op` to a workflow file, run it on a fresh worker, optionally
+ * signalling mid-flight. Returns the workflow result and the test-clock time
+ * (ms) skipped while it ran.
+ */
+async function runOp(
+  op: Map<string, Declarable>,
+  activities: Record<string, ActivityFn>,
+  opts: { signal?: string } = {},
+): Promise<{ durationMs: number; failed: boolean }> {
+  const files = serializeOps(op);
+  const wfKey = Object.keys(files).find((k) => k.endsWith("/workflow.ts"))!;
+  const opName = wfKey.split("/")[1];
+  const wfPath = join(GEN_DIR, `${opName}.workflow.ts`);
+  writeFileSync(wfPath, files[wfKey]);
+
+  const worker = await Worker.create({
+    connection: env.nativeConnection,
+    namespace: env.namespace,
+    taskQueue: opName,
+    workflowsPath: wfPath,
+    activities,
+  });
+
+  const handle = await env.client.workflow.start(workflowFn(opName), {
+    taskQueue: opName,
+    workflowId: `${opName}-${wfCounter++}`,
+  });
+  if (opts.signal) await handle.signal(opts.signal);
+
+  let failed = false;
+  await worker.runUntil(handle.result()).catch(() => { failed = true; });
+
+  // Duration from the workflow's own server timestamps — under time-skipping
+  // this reflects the wall time the workflow *believed* elapsed (so a gate that
+  // waited out its 48h timeout shows ~48h; one cleared by a signal shows ~0).
+  const desc = await handle.describe();
+  const durationMs =
+    desc.closeTime && desc.startTime ? desc.closeTime.getTime() - desc.startTime.getTime() : 0;
+  return { durationMs, failed };
+}
+
+describe("temporal runtime harness (#161)", () => {
+  test("happy path — phases run in declared order", async () => {
+    const order: string[] = [];
+    const rec = (tag: string): ActivityFn => async () => { order.push(tag); };
+    const { failed } = await runOp(
+      opMap({
+        name: "happy-op", overview: "o",
+        phases: [
+          { name: "P1", steps: [{ kind: "activity", fn: "a" }] },
+          { name: "P2", steps: [{ kind: "activity", fn: "b" }] },
+        ],
+      }),
+      { a: rec("a"), b: rec("b") },
+    );
+    expect(failed).toBe(false);
+    expect(order).toEqual(["a", "b"]);
+  }, 120_000);
+
+  test("gate — the workflow waits for the approval signal, not the timeout", async () => {
+    const ran: string[] = [];
+    const rec = (tag: string): ActivityFn => async () => { ran.push(tag); };
+    const gateOp = () => opMap({
+      name: "gate-op", overview: "o",
+      phases: [
+        { name: "Before", steps: [{ kind: "activity", fn: "before" }] },
+        { name: "Approve", steps: [{ kind: "gate", signalName: "gate-approve", timeout: "48h" }] },
+        { name: "After", steps: [{ kind: "activity", fn: "after" }] },
+      ],
+    });
+
+    // Signalled: the gate clears immediately, so the 48h timer never elapses.
+    ran.length = 0;
+    const signalled = await runOp(gateOp(), { before: rec("before"), after: rec("after") }, {
+      signal: "gate-approve",
+    });
+    expect(signalled.failed).toBe(false);
+    expect(ran).toEqual(["before", "after"]);
+    // The workflow barely took any (skipped) time — the signal short-circuited the 48h wait.
+    expect(signalled.durationMs).toBeLessThan(60 * 60 * 1000); // < 1h
+
+    // Unsignalled: the gate blocks on its timer — the workflow's elapsed time is ~48h.
+    ran.length = 0;
+    const unsignalled = await runOp(gateOp(), { before: rec("before"), after: rec("after") });
+    expect(unsignalled.durationMs).toBeGreaterThan(47 * 60 * 60 * 1000); // ~48h
+  }, 120_000);
+
+  test("compensation — failing activity runs onFailure in reverse, then re-throws (#168)", async () => {
+    const order: string[] = [];
+    const activities: Record<string, ActivityFn> = {
+      boom: async () => { throw ApplicationFailure.nonRetryable("boom", "Boom"); },
+      comp1: async () => { order.push("comp1"); },
+      comp2: async () => { order.push("comp2"); },
+    };
+    const { failed } = await runOp(
+      opMap({
+        name: "comp-op", overview: "o",
+        phases: [{ name: "Main", steps: [{ kind: "activity", fn: "boom" }] }],
+        onFailure: [
+          { name: "C1", steps: [{ kind: "activity", fn: "comp1" }] },
+          { name: "C2", steps: [{ kind: "activity", fn: "comp2" }] },
+        ],
+      }),
+      activities,
+    );
+    expect(failed).toBe(true);                 // original failure is re-thrown
+    expect(order).toEqual(["comp2", "comp1"]);  // reverse phase order
+  }, 120_000);
+
+  test("destructive-apply approval — nativeApply waits for the gate (#125)", async () => {
+    const ran: string[] = [];
+    const activities: Record<string, ActivityFn> = {
+      chantBuild: async () => { ran.push("build"); },
+      lifecycleDiff: async () => { ran.push("diff"); return { drifted: false }; },
+      nativeApply: async () => { ran.push("apply"); },
+      compensateApply: async () => { ran.push("compensate"); },
+    };
+    const { op } = ApplyOp({ name: "apply-op", env: "prod", target: "cloudformation", delete: "gated" });
+
+    // Without the signal, the apply must not have run before the gate clears;
+    // with the signal it proceeds through nativeApply.
+    const res = await runOp(
+      new Map([["apply-op", op as unknown as Declarable]]),
+      activities,
+      { signal: "approve-apply-op" },
+    );
+    expect(res.failed).toBe(false);
+    expect(ran).toEqual(["build", "diff", "apply"]);
+    expect(res.durationMs).toBeLessThan(60 * 60 * 1000); // gate cleared by signal, not timeout
+  }, 120_000);
+});

package/src/op/serializer.ts

@@ -76,7 +76,10 @@ function generateWorkflow(config: OpConfig): string {
     "// Generated by chant — do not edit directly.",
     `// Source: ${config.name}.op.ts`,
     "import { proxyActivities, condition, defineSignal, setHandler, upsertSearchAttributes } from '@temporalio/workflow';",
-    "import { TEMPORAL_ACTIVITY_PROFILES } from '@intentius/chant-lexicon-temporal';",
+    // Import profiles from the config leaf, not the package root: the root pulls
+    // in the plugin/serializer (node:fs/path), which Temporal's workflow sandbox
+    // forbids and the worker's bundler rejects. config.ts is import-free.
+    "import { TEMPORAL_ACTIVITY_PROFILES } from '@intentius/chant-lexicon-temporal/config';",
     "import type * as activities from './activities';",
     "",
   ];
@@ -213,11 +216,23 @@ function generateWorkflow(config: OpConfig): string {
     }
   };
 
-  renderPhases(config.phases);
-
   if (config.onFailure && config.onFailure.length > 0) {
-    lines.push("  // onFailure compensation (executed on terminal failure only)");
-    renderPhases(config.onFailure);
+    // Compensation must run ONLY on terminal failure, in reverse phase order,
+    // and must never mask the original error — matching the local executor
+    // (packages/core/src/op/local-executor.ts). Wrap the main phases in
+    // try/catch; run onFailure phases reversed in the catch (best-effort), then
+    // re-throw the original failure.
+    lines.push("  try {");
+    renderPhases(config.phases);
+    lines.push("  } catch (__opErr) {");
+    lines.push("    // onFailure compensation (reverse phase order, terminal failure only)");
+    lines.push("    try {");
+    renderPhases([...config.onFailure].reverse());
+    lines.push("    } catch { /* best-effort compensation — never mask the original error */ }");
+    lines.push("    throw __opErr;");
+    lines.push("  }");
+  } else {
+    renderPhases(config.phases);
   }
 
   lines.push("}");

package/src/resources.ts

@@ -91,7 +91,8 @@ export interface TemporalScheduleProps {
     searchAttributes?: Record<string, unknown>;
     /**
      * Retry policy for the triggered workflow execution.
-     * When set, the generated schedule script includes `workflowStartOptions.retry`.
+     * When set, the generated schedule script emits it as the schedule
+     * action's `retry` (Temporal `ScheduleOptions` action.retry).
      */
     workflowRetryPolicy?: {
       /** Initial retry interval (e.g. "10s"). Default: Temporal server default (~1s). */

package/src/serializer.test.ts

@@ -251,6 +251,59 @@ describe("temporal serializer", () => {
     expect(result.files["schedules/with-policy.ts"]).toContain("BufferOne");
   });
 
+  it("emits action.retry from workflowRetryPolicy, including nonRetryableErrorTypes", () => {
+    const entities = new Map([makeSchedule("with-retry", {
+      action: {
+        workflowType: "w", taskQueue: "q",
+        workflowRetryPolicy: {
+          initialInterval: "10s",
+          backoffCoefficient: 2,
+          maximumAttempts: 5,
+          maximumInterval: "5m",
+          nonRetryableErrorTypes: ["ValidationError"],
+        },
+      },
+    })]);
+    const ts = (temporalSerializer.serialize(entities) as { files: Record<string, string> }).files["schedules/with-retry.ts"];
+    expect(ts).toContain("retry:");
+    expect(ts).toContain('"initialInterval": "10s"');
+    expect(ts).toContain('"maximumAttempts": 5');
+    expect(ts).toContain('"nonRetryableErrorTypes"');
+    expect(ts).toContain('"ValidationError"');
+  });
+
+  it("omits action.retry when no workflowRetryPolicy is set", () => {
+    const ts = (temporalSerializer.serialize(new Map([makeSchedule("no-retry")])) as { files: Record<string, string> }).files["schedules/no-retry.ts"];
+    expect(ts).not.toContain("retry:");
+  });
+
+  it("emits action timeouts, memo, and searchAttributes when set", () => {
+    const entities = new Map([makeSchedule("with-action-opts", {
+      action: {
+        workflowType: "w", taskQueue: "q",
+        workflowExecutionTimeout: "1h",
+        workflowRunTimeout: "30m",
+        memo: { owner: "platform" },
+        searchAttributes: { Env: "prod" },
+      },
+    })]);
+    const ts = (temporalSerializer.serialize(entities) as { files: Record<string, string> }).files["schedules/with-action-opts.ts"];
+    expect(ts).toContain('workflowExecutionTimeout: "1h"');
+    expect(ts).toContain('workflowRunTimeout: "30m"');
+    expect(ts).toContain("memo:");
+    expect(ts).toContain('"owner": "platform"');
+    expect(ts).toContain("searchAttributes:");
+    expect(ts).toContain('"Env": "prod"');
+  });
+
+  it("omits action timeouts, memo, and searchAttributes when unset", () => {
+    const ts = (temporalSerializer.serialize(new Map([makeSchedule("bare-action")])) as { files: Record<string, string> }).files["schedules/bare-action.ts"];
+    expect(ts).not.toContain("workflowExecutionTimeout:");
+    expect(ts).not.toContain("workflowRunTimeout:");
+    expect(ts).not.toContain("memo:");
+    expect(ts).not.toContain("searchAttributes:");
+  });
+
   // ── Mixed entities ─────────────────────────────────────────────
 
   it("returns SerializerResult with all keys for mixed entities", () => {

package/src/serializer.ts

@@ -222,9 +222,33 @@ function serializeSchedule(scheduleId: string, props: TemporalScheduleProps): st
     `      workflowType: ${JSON.stringify(props.action.workflowType)},`,
     `      taskQueue: ${JSON.stringify(props.action.taskQueue)},`,
     `      args: ${JSON.stringify(props.action.args ?? [])},`,
-    `    },`,
   ];
 
+  // Optional workflow timeouts → ScheduleOptions action.workflow*Timeout.
+  if (props.action.workflowExecutionTimeout) {
+    lines.push(`      workflowExecutionTimeout: ${JSON.stringify(props.action.workflowExecutionTimeout)},`);
+  }
+  if (props.action.workflowRunTimeout) {
+    lines.push(`      workflowRunTimeout: ${JSON.stringify(props.action.workflowRunTimeout)},`);
+  }
+
+  // Retry policy for the triggered workflow → ScheduleOptions action.retry.
+  if (props.action.workflowRetryPolicy) {
+    lines.push(
+      `      retry: ${JSON.stringify(props.action.workflowRetryPolicy, null, 6).replace(/^/gm, "      ").trimStart()},`,
+    );
+  }
+
+  // Memo + search attributes attached to the triggered workflow.
+  if (props.action.memo) {
+    lines.push(`      memo: ${JSON.stringify(props.action.memo, null, 6).replace(/^/gm, "      ").trimStart()},`);
+  }
+  if (props.action.searchAttributes) {
+    lines.push(`      searchAttributes: ${JSON.stringify(props.action.searchAttributes, null, 6).replace(/^/gm, "      ").trimStart()},`);
+  }
+
+  lines.push(`    },`);
+
   if (props.policies) {
     lines.push(`    policies: ${JSON.stringify(props.policies, null, 6).replace(/^/gm, "    ").trimStart()},`);
   }