@effect-app/infra 4.0.0-beta.33 → 4.0.0-beta.330

package/test/validateSample.test.ts

@@ -1,9 +1,15 @@
-import { Effect, S } from "effect-app"
+import * as Effect from "effect-app/Effect"
+import * as Layer from "effect-app/Layer"
+import { makeRepo, ValidationError, ValidationResult } from "effect-app/Model/Repository"
+import { RepositoryRegistryLive } from "effect-app/Model/Repository/Registry"
+import * as S from "effect-app/Schema"
+import { setupRequestContextFromCurrent } from "effect-app/setupRequest"
+import type { JsonRecord } from "effect-app/Store"
 import { describe, expect, it } from "vitest"
-import { setupRequestContextFromCurrent } from "../src/api/setupRequest.js"
-import { makeRepo, ValidationError, ValidationResult } from "../src/Model/Repository.js"
 import { MemoryStoreLive } from "../src/Store/Memory.js"
 
+const TestStoreLive = Layer.merge(MemoryStoreLive, RepositoryRegistryLive)
+
 // simple schema for valid items
 class SimpleItem extends S.Class<SimpleItem>("SimpleItem")({
   id: S.String,
@@ -11,6 +17,26 @@ class SimpleItem extends S.Class<SimpleItem>("SimpleItem")({
   count: S.NonNegativeInt
 }) {}
 
+/**
+ * `count` is stored as a *string*, so its Encoded shape accepts anything the
+ * JSON document happens to hold while the domain decode still demands a finite
+ * number.
+ *
+ * That split is what `validateSample` exists for, and it is the only way to
+ * observe a repository-level validation error now that `jitM` runs at the store
+ * boundary: the store's `toCodecJson(toEncoded(schema))` decode is strict, so a
+ * `jitM` that produced a value the *Encoded* shape rejects would fail loudly in
+ * the store instead of ever reaching the repository.
+ */
+class LooseCountItem extends S.Class<LooseCountItem>("LooseCountItem")({
+  id: S.String,
+  name: S.NonEmptyString255,
+  count: S.FiniteFromString
+}) {}
+
+/** build a `LooseCountItem` from its encoded (stored) form */
+const looseItem = (id: string, name: string, count: string) => S.decodeSync(LooseCountItem)({ id, name, count })
+
 describe("validateSample", () => {
   it("returns success when all items pass validation", () =>
     Effect
@@ -25,41 +51,42 @@ describe("validateSample", () => {
 
         const result = yield* repo.validateSample({ percentage: 1.0 }) // 100%
 
-        expect(result).toBeInstanceOf(ValidationResult)
+        expect(S.is(ValidationResult)(result)).toBe(true)
         expect(result.total).toBe(3)
         expect(result.sampled).toBe(3)
         expect(result.valid).toBe(3)
         expect(result.errors).toHaveLength(0)
       })
       .pipe(
-        Effect.provide(MemoryStoreLive),
+        Effect.provide(TestStoreLive),
         setupRequestContextFromCurrent(),
+        Effect.scoped,
         Effect.runPromise
       ))
 
-  it("returns errors when jitM produces invalid data", () =>
+  it("returns errors when jitM produces data the domain schema rejects", () =>
     Effect
       .gen(function*() {
-        // jitM that corrupts one specific item's count to be negative
-        const corruptingJitM = (pm: typeof SimpleItem.Encoded) => {
-          if (pm.id === "2" || pm.id === "3") {
-            return { ...pm, count: -999 } // make count negative (invalid for NonNegativeInt)
+        // jitM that corrupts two specific items' count into a non-numeric string
+        const corruptingJitM = (json: JsonRecord): JsonRecord => {
+          if (json["id"] === "2" || json["id"] === "3") {
+            return { ...json, count: "not-a-number" } // still a string, so the store decode is happy
           }
-          return pm
+          return json
         }
 
-        const repo = yield* makeRepo("CorruptItem", SimpleItem, {
+        const repo = yield* makeRepo("CorruptItem", LooseCountItem, {
           jitM: corruptingJitM,
           makeInitial: Effect.succeed([
-            new SimpleItem({ id: "1", name: S.NonEmptyString255("Valid"), count: S.NonNegativeInt(10) }),
-            new SimpleItem({ id: "2", name: S.NonEmptyString255("WillBeInvalid1"), count: S.NonNegativeInt(20) }),
-            new SimpleItem({ id: "3", name: S.NonEmptyString255("WillBeInvalid2"), count: S.NonNegativeInt(30) })
+            looseItem("1", "Valid", "10"),
+            looseItem("2", "WillBeInvalid1", "20"),
+            looseItem("3", "WillBeInvalid2", "30")
           ])
         })
 
         const result = yield* repo.validateSample({ percentage: 1.0 }) // 100%
 
-        expect(result).toBeInstanceOf(ValidationResult)
+        expect(S.is(ValidationResult)(result)).toBe(true)
         expect(result.total).toBe(3)
         expect(result.sampled).toBe(3)
         expect(result.valid).toBe(1)
@@ -67,7 +94,7 @@ describe("validateSample", () => {
 
         // verify error structure
         for (const error of result.errors) {
-          expect(error).toBeInstanceOf(ValidationError)
+          expect(S.is(ValidationError)(error)).toBe(true)
           expect(error.id).toBeDefined()
           expect(error.rawData).toBeDefined()
           expect(error.jitMResult).toBeDefined()
@@ -80,8 +107,9 @@ describe("validateSample", () => {
         expect(failingIds).toContain("3")
       })
       .pipe(
-        Effect.provide(MemoryStoreLive),
+        Effect.provide(TestStoreLive),
         setupRequestContextFromCurrent(),
+        Effect.scoped,
         Effect.runPromise
       ))
 
@@ -98,8 +126,9 @@ describe("validateSample", () => {
         expect(result.errors).toHaveLength(0)
       })
       .pipe(
-        Effect.provide(MemoryStoreLive),
+        Effect.provide(TestStoreLive),
         setupRequestContextFromCurrent(),
+        Effect.scoped,
         Effect.runPromise
       ))
 
@@ -127,8 +156,9 @@ describe("validateSample", () => {
         expect(result.errors).toHaveLength(0)
       })
       .pipe(
-        Effect.provide(MemoryStoreLive),
+        Effect.provide(TestStoreLive),
         setupRequestContextFromCurrent(),
+        Effect.scoped,
         Effect.runPromise
       ))
 
@@ -138,14 +168,14 @@ describe("validateSample", () => {
         // schema that expects a 'status' field
         class ItemWithStatus extends S.Class<ItemWithStatus>("ItemWithStatus")({
           id: S.String,
-          status: S.Literal("active", "inactive")
+          status: S.Literals(["active", "inactive"])
         }) {}
 
         // jitM that adds default status for items
         const repo = yield* makeRepo("ItemWithStatus", ItemWithStatus, {
-          jitM: (pm) => ({
-            ...pm,
-            status: pm.status ?? "active" // default to active if missing
+          jitM: (json) => ({
+            ...json,
+            status: json["status"] ?? "active" // default to active if missing
           }),
           makeInitial: Effect.succeed([
             new ItemWithStatus({ id: "1", status: "active" }),
@@ -161,8 +191,9 @@ describe("validateSample", () => {
         expect(result.errors).toHaveLength(0)
       })
       .pipe(
-        Effect.provide(MemoryStoreLive),
+        Effect.provide(TestStoreLive),
         setupRequestContextFromCurrent(),
+        Effect.scoped,
         Effect.runPromise
       ))
 
@@ -170,16 +201,14 @@ describe("validateSample", () => {
     Effect
       .gen(function*() {
         // jitM that corrupts the data
-        const corruptingJitM = (pm: typeof SimpleItem.Encoded) => ({
-          ...pm,
-          count: -999 // always corrupt count
+        const corruptingJitM = (json: JsonRecord): JsonRecord => ({
+          ...json,
+          count: "not-a-number" // always corrupt count
         })
 
-        const repo = yield* makeRepo("ContextErrorTest", SimpleItem, {
+        const repo = yield* makeRepo("ContextErrorTest", LooseCountItem, {
           jitM: corruptingJitM,
-          makeInitial: Effect.succeed([
-            new SimpleItem({ id: "bad-item", name: S.NonEmptyString255("Test"), count: S.NonNegativeInt(100) })
-          ])
+          makeInitial: Effect.succeed([looseItem("bad-item", "Test", "100")])
         })
 
         const result = yield* repo.validateSample({ percentage: 1.0 })
@@ -189,27 +218,25 @@ describe("validateSample", () => {
         const error = result.errors[0]!
         expect(error.id).toBe("bad-item")
 
-        // rawData should contain the original db data (with valid count)
+        // rawData is what the store returned: jitM already ran at the store
+        // boundary, so the corrupted count is what the repository decoded
         expect(error.rawData).toMatchObject({
           id: "bad-item",
           name: "Test",
-          count: 100
+          count: "not-a-number"
         })
 
-        // jitMResult should contain the corrupted data
-        expect(error.jitMResult).toMatchObject({
-          id: "bad-item",
-          name: "Test",
-          count: -999
-        })
+        // jitMResult is kept for compatibility and is identical to rawData
+        expect(error.jitMResult).toEqual(error.rawData)
 
         // error should be a SchemaError
         expect(error.error).toBeDefined()
-        expect((error.error as any)._tag).toBe("SchemaError")
+        expect((error.error as { _tag?: string })._tag).toBe("SchemaError")
       })
       .pipe(
-        Effect.provide(MemoryStoreLive),
+        Effect.provide(TestStoreLive),
         setupRequestContextFromCurrent(),
+        Effect.scoped,
         Effect.runPromise
       ))
 
@@ -230,8 +257,9 @@ describe("validateSample", () => {
         expect(result.errors).toHaveLength(0)
       })
       .pipe(
-        Effect.provide(MemoryStoreLive),
+        Effect.provide(TestStoreLive),
         setupRequestContextFromCurrent(),
+        Effect.scoped,
         Effect.runPromise
       ))
 })

package/test/workflow-engine-cosmos.test.ts

@@ -0,0 +1,345 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/**
+ * Workflow engine conformance tests.
+ *
+ * The `runSuite` body is engine-agnostic: it runs against
+ * `WorkflowEngine.layerMemory` (fast, always) and — when `COSMOS_TEST_URL`
+ * is set — against the Cosmos adapter (`layerCosmos`) pointed at a Cosmos
+ * emulator. Both must satisfy the same observable contract: idempotent
+ * execution, activity replay (no double side effects), suspend → durable-
+ * deferred completion → resume with a correctly decoded result, interrupt
+ * propagation, and first-writer-wins deferred completion.
+ *
+ * A second describe block (Cosmos emulator only) exercises adapter
+ * internals — the recovery poller (driving execs whose lease has lapsed)
+ * and the clock poller (firing past-due clocks) — by seeding rows
+ * directly against the Cosmos container.
+ */
+import { assert, describe, it } from "@effect/vitest"
+import { Context, Duration, Effect, Exit, Layer, Option, Redacted, Schema } from "effect"
+import { Activity, DurableDeferred, Workflow, WorkflowEngine } from "effect/unstable/workflow"
+import { CosmosClient, CosmosClientLayer } from "../src/cosmos-client.js"
+import { layerCosmos } from "../src/WorkflowEngineCosmos.js"
+
+// --- Shared mutable counter for activity-side-effect assertions --------
+
+class CounterRef extends Context.Service<CounterRef, { count: number }>()("CounterRef") {
+  static readonly layer = Layer.effect(CounterRef, Effect.sync(() => ({ count: 0 })))
+}
+
+// --- Workflow definitions ----------------------------------------------
+
+const IncrementWorkflow = Workflow.make("WorkflowEngineCosmos/IncrementWorkflow", {
+  payload: { value: Schema.Number },
+  success: Schema.Number,
+  idempotencyKey: ({ value }) => String(value)
+})
+
+const IncrementHandler = IncrementWorkflow.toLayer(({ value }) => Effect.succeed(value + 1))
+
+// Counts activity body invocations across re-executes so the test can
+// prove side-effects don't repeat when a persisted result is available.
+const CounterWorkflow = Workflow.make("WorkflowEngineCosmos/CounterWorkflow", {
+  payload: { id: Schema.String },
+  success: Schema.Number,
+  idempotencyKey: ({ id }) => id
+})
+
+const CounterHandler = CounterWorkflow.toLayer(Effect.fn(function*() {
+  const counter = yield* CounterRef
+  return yield* Activity.make({
+    name: "Bump",
+    success: Schema.Number,
+    execute: Effect.sync(() => {
+      counter.count++
+      return counter.count
+    })
+  })
+}))
+
+// Suspends on a deferred, then composes the persisted activity result
+// with the resumed deferred value. Exercises Result/Exit round-trip.
+const Trigger = DurableDeferred.make("WorkflowEngineCosmos/Trigger", { success: Schema.String })
+
+const SuspendWorkflow = Workflow.make("WorkflowEngineCosmos/SuspendWorkflow", {
+  payload: { id: Schema.String },
+  success: Schema.String,
+  idempotencyKey: ({ id }) => id
+})
+
+const SuspendHandler = SuspendWorkflow.toLayer(Effect.fn(function*({ id }) {
+  const n = yield* Activity.make({
+    name: "step",
+    success: Schema.Number,
+    execute: Effect.succeed(1)
+  })
+  const v = yield* DurableDeferred.await(Trigger)
+  return `${id}:${n}:${v}`
+}))
+
+// Plain durable-deferred await — used to assert first-writer-wins on done().
+const AwaitOnly = Workflow.make("WorkflowEngineCosmos/AwaitOnly", {
+  payload: { id: Schema.String },
+  success: Schema.String,
+  idempotencyKey: ({ id }) => id
+})
+
+const AwaitOnlyHandler = AwaitOnly.toLayer(Effect.fn(function*() {
+  return yield* DurableDeferred.await(Trigger)
+}))
+
+const Handlers = Layer.mergeAll(IncrementHandler, SuspendHandler, CounterHandler, AwaitOnlyHandler)
+
+// Helper that polls until the workflow completes (or `maxIterations` elapse).
+const waitForComplete = (
+  workflow: { readonly poll: (id: string) => Effect.Effect<Option.Option<Workflow.Result<any, any>>, never, any> },
+  executionId: string,
+  step = Duration.millis(10),
+  maxIterations = 200
+) =>
+  Effect.gen(function*() {
+    for (let i = 0; i < maxIterations; i++) {
+      const polled = yield* workflow.poll(executionId)
+      if (Option.isSome(polled) && polled.value._tag === "Complete") {
+        return polled.value
+      }
+      yield* Effect.sleep(step)
+    }
+    return undefined
+  })
+
+const runSuite = (engineLayer: Layer.Layer<WorkflowEngine.WorkflowEngine>) => {
+  const TestLayer = Handlers.pipe(
+    Layer.provideMerge(CounterRef.layer),
+    Layer.provideMerge(engineLayer)
+  )
+
+  it.live("executes a workflow and polls the result", () =>
+    Effect
+      .gen(function*() {
+        const executionId = yield* IncrementWorkflow.execute({ value: 41 }, { discard: true })
+        const result = yield* IncrementWorkflow.execute({ value: 41 })
+        const polled = yield* IncrementWorkflow.poll(executionId)
+
+        assert.strictEqual(result, 42)
+        assert(
+          Option.isSome(polled)
+            && polled.value._tag === "Complete"
+            && Exit.isSuccess(polled.value.exit)
+        )
+        assert.strictEqual(polled.value.exit.value, 42)
+      })
+      .pipe(Effect.provide(TestLayer)))
+
+  it.live("re-executing the same id is idempotent", () =>
+    Effect
+      .gen(function*() {
+        const a = yield* IncrementWorkflow.execute({ value: 7 })
+        const b = yield* IncrementWorkflow.execute({ value: 7 })
+        assert.strictEqual(a, b)
+      })
+      .pipe(Effect.provide(TestLayer)))
+
+  it.live("activity side effects run once across re-executions", () =>
+    Effect
+      .gen(function*() {
+        const counter = yield* CounterRef
+        yield* CounterWorkflow.execute({ id: "once" })
+        yield* CounterWorkflow.execute({ id: "once" })
+        yield* CounterWorkflow.execute({ id: "once" })
+        assert.strictEqual(counter.count, 1)
+      })
+      .pipe(Effect.provide(TestLayer)))
+
+  it.live("suspends on a durable deferred, then resumes with the decoded result", () =>
+    Effect
+      .gen(function*() {
+        // The execution suspends on `Trigger`; completing the deferred resumes
+        // it (the workflow body replays, the `step` activity is served from its
+        // persisted result), and the final value round-trips through the engine.
+        const executionId = yield* SuspendWorkflow.execute({ id: "abc" }, { discard: true })
+
+        const token = yield* DurableDeferred.tokenFromPayload(Trigger, {
+          workflow: SuspendWorkflow,
+          payload: { id: "abc" }
+        })
+        yield* DurableDeferred.done(Trigger, { token, exit: Exit.succeed("ok") })
+
+        const done = yield* waitForComplete(SuspendWorkflow, executionId)
+        assert(done && Exit.isSuccess(done.exit))
+        assert.strictEqual(done.exit.value, "abc:1:ok")
+      })
+      .pipe(Effect.provide(TestLayer)))
+
+  it.live("deferredDone is idempotent (first-writer-wins)", () =>
+    Effect
+      .gen(function*() {
+        const executionId = yield* AwaitOnly.execute({ id: "dup" }, { discard: true })
+        const token = yield* DurableDeferred.tokenFromPayload(Trigger, {
+          workflow: AwaitOnly,
+          payload: { id: "dup" }
+        })
+        yield* DurableDeferred.done(Trigger, { token, exit: Exit.succeed("first") })
+        // Second completion must lose; the workflow body sees "first".
+        yield* DurableDeferred.done(Trigger, { token, exit: Exit.succeed("second") })
+
+        const done = yield* waitForComplete(AwaitOnly, executionId)
+        assert(done && Exit.isSuccess(done.exit))
+        assert.strictEqual(done.exit.value, "first")
+      })
+      .pipe(Effect.provide(TestLayer)))
+
+  it.live("interrupt eventually completes a suspended execution", () =>
+    Effect
+      .gen(function*() {
+        const executionId = yield* AwaitOnly.execute({ id: "int" }, { discard: true })
+        // Give the workflow time to suspend on the deferred.
+        yield* Effect.sleep(Duration.millis(50))
+        yield* AwaitOnly.interrupt(executionId)
+
+        // Interrupt collapses the suspended execution into a completion. A
+        // durable engine re-drives across several storage round-trips, so poll
+        // until it reports Complete rather than asserting a fixed delay.
+        const done = yield* waitForComplete(AwaitOnly, executionId)
+        assert(done !== undefined && done._tag === "Complete")
+      })
+      .pipe(Effect.provide(TestLayer)))
+}
+
+describe("WorkflowEngine (in-memory)", () => {
+  runSuite(WorkflowEngine.layerMemory)
+})
+
+// --- Cosmos-emulator-only adapter tests --------------------------------
+//
+// Opt-in. Run with e.g.
+//   COSMOS_TEST_URL="https://localhost:8081" COSMOS_TEST_DB="workflow-test" \
+//   NODE_TLS_REJECT_UNAUTHORIZED=0 pnpm vitest run workflow-engine-cosmos
+const cosmosUrl = process.env["COSMOS_TEST_URL"]
+const cosmosDb = process.env["COSMOS_TEST_DB"] ?? "workflow-test"
+
+describe.skipIf(!cosmosUrl)("WorkflowEngine (Cosmos) — conformance", () => {
+  runSuite(
+    layerCosmos({
+      url: Redacted.make(cosmosUrl ?? ""),
+      dbName: cosmosDb,
+      prefix: `test-${Date.now()}-`,
+      // Tight cadences so the suite doesn't wait on the background pollers.
+      recoveryInterval: Duration.seconds(2),
+      clockPollInterval: Duration.seconds(1)
+    })
+  )
+})
+
+describe.skipIf(!cosmosUrl)("WorkflowEngine (Cosmos) — adapter internals", () => {
+  // Each test gets its own container prefix so seeded docs don't leak.
+  const prefixFor = (label: string) => `test-${Date.now()}-${label}-`
+
+  const adapterLayer = (prefix: string) =>
+    Layer
+      .mergeAll(
+        IncrementHandler,
+        AwaitOnlyHandler,
+        CounterRef.layer,
+        CosmosClientLayer(cosmosUrl ?? "", cosmosDb)
+      )
+      .pipe(
+        Layer.provideMerge(
+          layerCosmos({
+            url: Redacted.make(cosmosUrl ?? ""),
+            dbName: cosmosDb,
+            prefix,
+            recoveryInterval: Duration.millis(500),
+            clockPollInterval: Duration.millis(500)
+          })
+        )
+      )
+
+  it.live("recovery poller drives execs with stale leases", () => {
+    const prefix = prefixFor("recovery")
+    const containerId = `${prefix}workflow-engine`
+    return Effect
+      .gen(function*() {
+        const { db } = yield* CosmosClient
+        const container = db.container(containerId)
+        // Pre-seed a running exec whose lease has already expired and whose
+        // payload is the schema-encoded form of `{ value: 99 }`.
+        yield* Effect.promise(() =>
+          container.items.upsert({
+            id: "exec",
+            _partitionKey: "recover-1",
+            type: "exec",
+            workflowName: IncrementWorkflow._tag,
+            payload: JSON.stringify({ value: 99 }),
+            status: "running",
+            suspended: false,
+            interrupted: false,
+            worker: "ghost",
+            leaseExpiresAt: new Date(Date.now() - 60_000).toISOString(),
+            etag: "seed"
+          })
+        )
+
+        // Wait for the recovery poller (500ms cadence) to drive it.
+        yield* Effect.sleep(Duration.seconds(2))
+
+        const polled = yield* IncrementWorkflow.poll("recover-1")
+        assert(
+          Option.isSome(polled)
+            && polled.value._tag === "Complete"
+            && Exit.isSuccess(polled.value.exit)
+        )
+        assert.strictEqual(polled.value.exit.value, 100)
+      })
+      .pipe(Effect.provide(adapterLayer(prefix)))
+  })
+
+  it.live("clock poller fires past-due clocks", () => {
+    const prefix = prefixFor("clocks")
+    const containerId = `${prefix}workflow-engine`
+    return Effect
+      .gen(function*() {
+        const { db } = yield* CosmosClient
+        const container = db.container(containerId)
+        // Seed an exec + a clock that fired in the past. No in-process timer
+        // exists (we never called scheduleClock), so only the poller can
+        // resolve the deferred.
+        yield* Effect.promise(() =>
+          container.items.upsert({
+            id: "exec",
+            _partitionKey: "exec-clock",
+            type: "exec",
+            workflowName: AwaitOnly._tag,
+            payload: JSON.stringify({ id: "wake" }),
+            status: "running",
+            suspended: false,
+            interrupted: false,
+            etag: "seed"
+          })
+        )
+        yield* Effect.promise(() =>
+          container.items.upsert({
+            id: "clock::wake",
+            _partitionKey: "exec-clock",
+            type: "clock",
+            workflowName: AwaitOnly._tag,
+            deferredName: Trigger.name,
+            fireAt: new Date(Date.now() - 60_000).toISOString()
+          })
+        )
+
+        yield* Effect.sleep(Duration.seconds(2))
+
+        // The clock fire is a deferred-complete; assert the deferred row
+        // now exists for this execution.
+        const deferred = yield* Effect.promise(() =>
+          container.item(encodeURIComponent(`deferred::${Trigger.name}`), "exec-clock").read<{ exit: string }>()
+        )
+        assert(deferred.resource !== undefined)
+        // And the clock doc has been deleted.
+        const clockGone = yield* Effect.promise(() => container.item("clock::wake", "exec-clock").read())
+        assert.strictEqual(clockGone.statusCode, 404)
+      })
+      .pipe(Effect.provide(adapterLayer(prefix)))
+  })
+})