@effect-app/vue 4.0.0-beta.187 → 4.0.0-beta.188

package/test/makeClient.test.ts

@@ -1,9 +1,9 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 import { expect, expectTypeOf, it } from "@effect/vitest"
-import { type Effect, S } from "effect-app"
+import { S } from "effect-app"
 import { configureInvalidation, makeQueryKey } from "effect-app/client"
 import * as Exit from "effect/Exit"
-import { type ExportComplete, Something, SomethingElse, SomethingElseReq, SomethingReq, useClient, useExperimental } from "./stubs.js"
+import { Something, SomethingElse, SomethingElseReq, SomethingReq, useClient, useExperimental } from "./stubs.js"
 
 const somethingInvalidationResources = {
   Something: {
@@ -273,25 +273,3 @@ it.skip("works", () => {
     projectedStruct
   })
 })
-
-it.skip("stream final type tests", () => {
-  const { clientFor } = useClient()
-  const client = clientFor(Something, undefined, somethingInvalidationResources)
-
-  const execNoFinal = client.StreamWithoutFinal.mutateToResult()
-  const execWithFinal = client.StreamWithFinal.mutateToResult()
-
-  // Without `final`: execute input is {id: string} and resolves with void
-  const _execNoFinalResult: ReturnType<typeof execNoFinal> = execNoFinal({ id: "test" })
-  // @ts-expect-error result of execNoFinal should be void-typed, not ExportComplete
-  const _badAssign: Effect.Effect<ExportComplete, never, never> = _execNoFinalResult
-
-  // With `final: ExportComplete`: execute resolves with ExportComplete
-  const _execWithFinalResult: ReturnType<typeof execWithFinal> = execWithFinal({ id: "test" })
-  // Assignment should compile — result IS Effect<ExportComplete, ...>
-  const _goodAssign: Effect.Effect<ExportComplete, never, never> = _execWithFinalResult
-  void _execNoFinalResult
-  void _execWithFinalResult
-  void _goodAssign
-  void _badAssign
-})

package/test/streamFinal.test.ts

@@ -2,23 +2,13 @@
  * Runtime and type tests for the `final` schema on stream requests.
  *
  * The `final` option on a stream request schema lets callers model which type
- * the last emitted stream element is.  When present, the execute effect returned
- * by `mutateToResult` resolves with that final value instead of `void`.
+ * the last emitted stream element is.
  */
 import { expect, it } from "@effect/vitest"
 import { Effect, S } from "effect-app"
 import * as Stream from "effect/Stream"
 import { asStreamResult } from "../src/mutate.js"
-import { ExportComplete, OperationProgress, Something, useClient } from "./stubs.js"
-
-const somethingInvalidationResources = {
-  Something: {
-    GetSomething2: Something.GetSomething2,
-    GetSomething2WithDependencies: Something.GetSomething2WithDependencies,
-    GetSomething3: Something.GetSomething3,
-    GetSomething4: Something.GetSomething4
-  }
-}
+import { ExportComplete, OperationProgress, Something } from "./stubs.js"
 
 // ---------------------------------------------------------------------------
 // asStreamResult — low-level primitive, always returns void
@@ -39,43 +29,6 @@ it.live("asStreamResult returns void and updates ref with each element", () =>
     }
   }))
 
-// ---------------------------------------------------------------------------
-// mutateToResult with no `final` — execute resolves with void (type-level)
-// ---------------------------------------------------------------------------
-
-it.skip("mutateToResult without final: execute resolves void (type-level)", () => {
-  const { clientFor } = useClient()
-  const client = clientFor(Something, undefined, somethingInvalidationResources)
-
-  const execute = client.StreamWithoutFinal.mutateToResult()
-
-  // execute returns void — assigning to ExportComplete Effect should fail
-  const result = execute({ id: "test" })
-  // @ts-expect-error result should be void-typed, not ExportComplete
-  const _bad: Effect.Effect<ExportComplete, never, never> = result
-  void _bad
-})
-
-// ---------------------------------------------------------------------------
-// mutateToResult with `final` — execute resolves with Final type (type-level)
-// ---------------------------------------------------------------------------
-
-it.skip("mutateToResult with final: execute resolves with ExportComplete (type-level)", () => {
-  const { clientFor } = useClient()
-  const client = clientFor(Something, undefined, somethingInvalidationResources)
-
-  const execute = client.StreamWithFinal.mutateToResult()
-
-  // execute returns ExportComplete — assignment should compile cleanly
-  const result = execute({ id: "test" })
-  const _ok: Effect.Effect<ExportComplete, never, never> = result
-  void _ok
-})
-
-// ---------------------------------------------------------------------------
-// Request class — final schema stored on class
-// ---------------------------------------------------------------------------
-
 it("stream request without final: .final is undefined", () => {
   const req = Something.StreamWithoutFinal
   expect((req as any).final).toBeUndefined()

package/test/streamFn.test.ts

@@ -1,6 +1,7 @@
 import { expect, it } from "@effect/vitest"
-import { Effect, Fiber } from "effect-app"
+import { Deferred, Effect, Fiber } from "effect-app"
 import * as Stream from "effect/Stream"
+import { CommanderStatic } from "../src/commander.js"
 import { AsyncResult } from "../src/lib.js"
 import { useExperimental } from "./stubs.js"
 
@@ -216,3 +217,220 @@ it.live("streamFn: generator form Stream.ensuring cleanup runs after stream ends
       expect(cmd.result.value).toBe(107)
     }
   }))
+
+// ---------------------------------------------------------------------------
+// Command.mapProgress — updates progress ref for each element
+// ---------------------------------------------------------------------------
+
+it.live("streamFn: Command.mapProgress updates progress ref for each stream element", () =>
+  Effect.gen(function*() {
+    const Command = useExperimental({ toasts: [] })
+
+    const cmd = Command.streamFn("test-map-progress")(
+      function*(_arg: void) {
+        return Stream.make(1, 2, 3).pipe(
+          CommanderStatic.mapProgress((r) =>
+            AsyncResult.isSuccess(r)
+              ? { text: `item-${r.value}`, percentage: r.value * 10 }
+              : undefined
+          )
+        )
+      }
+    )
+
+    // progress starts undefined (reactive unwraps the ref)
+    expect(cmd.progress).toBeUndefined()
+
+    yield* join(cmd.handle())
+
+    // after stream drains, last mapped progress value should be set
+    expect(cmd.progress).toEqual({ text: "item-3", percentage: 30 })
+  }))
+
+// ---------------------------------------------------------------------------
+// Command.updateProgress — imperative progress update from stream
+// ---------------------------------------------------------------------------
+
+it.live("streamFn: Command.updateProgress imperatively drives the progress ref", () =>
+  Effect.gen(function*() {
+    const Command = useExperimental({ toasts: [] })
+
+    const cmd = Command.streamFn("test-update-progress")(
+      function*(_arg: void) {
+        return Stream.make("a", "b").pipe(
+          Stream.tap((v) => CommanderStatic.updateProgress(`processing ${v}`))
+        )
+      }
+    )
+
+    expect(cmd.progress).toBeUndefined()
+    yield* join(cmd.handle())
+
+    expect(cmd.progress).toBe("processing b")
+  }))
+
+// ---------------------------------------------------------------------------
+// Command.withDefaultToastStream — in-progress (waiting) initial toast
+// ---------------------------------------------------------------------------
+
+it.live("withDefaultToastStream: shows info toast while stream is running", () =>
+  Effect.gen(function*() {
+    const toasts: any[] = []
+    const Command = useExperimental({ toasts, messages: { "handle.waiting": "{action} waiting…" } })
+
+    // Gate that lets us inspect toast state while the stream is paused mid-flight.
+    const streamPaused = yield* Deferred.make<void>()
+    const resume = yield* Deferred.make<void>()
+
+    const cmd = Command.streamFn("doWork")(
+      function*(_arg: void) {
+        return Stream.make(1).pipe(
+          Stream.tap(() =>
+            Effect.gen(function*() {
+              yield* Deferred.succeed(streamPaused, undefined)
+              yield* Deferred.await(resume)
+            })
+          )
+        )
+      },
+      Command.withDefaultToastStream()
+    )
+
+    const fiber = cmd.handle()
+
+    // Wait until the stream has emitted its first element (and paused).
+    yield* Deferred.await(streamPaused)
+
+    // The waiting info toast should exist before the stream finishes.
+    expect(toasts.some((t) => t.type === "info")).toBe(true)
+    const infoToast = toasts.find((t) => t.type === "info")
+    expect(infoToast.message).toContain("doWork")
+
+    // Let the stream finish.
+    yield* Deferred.succeed(resume, undefined)
+    yield* join(fiber)
+
+    // After completion the same toast slot is replaced with a success toast.
+    expect(toasts.some((t) => t.type === "success")).toBe(true)
+  }))
+
+// ---------------------------------------------------------------------------
+// Command.withDefaultToastStream — progress text/percent updates the toast
+// ---------------------------------------------------------------------------
+
+it.live("withDefaultToastStream: progress option updates waiting toast message", () =>
+  Effect.gen(function*() {
+    const toasts: any[] = []
+    const Command = useExperimental({
+      toasts,
+      messages: { "handle.waiting": "Working…", "handle.success": "{action} done" }
+    })
+
+    const progressSnapshots: string[] = []
+
+    const cmd = Command.streamFn("doWorkProgress")(
+      function*(_arg: void) {
+        return Stream.make(10, 50, 100).pipe(
+          Stream.tap((pct) =>
+            Effect.sync(() => {
+              progressSnapshots.push(`${pct}%`)
+            })
+          )
+        )
+      },
+      Command.withDefaultToastStream({
+        progress: (r) =>
+          AsyncResult.isSuccess(r)
+            ? { text: `${r.value}%`, percentage: r.value }
+            : undefined
+      })
+    )
+
+    yield* join(cmd.handle())
+
+    // All three stream elements were visited by the tap above
+    expect(progressSnapshots).toEqual(["10%", "50%", "100%"])
+
+    // cmd.progress reflects the last mapped value (reactive unwraps the ref)
+    expect(cmd.progress).toEqual({ text: "100%", percentage: 100 })
+
+    // A success toast should appear after the stream completes
+    expect(toasts.some((t) => t.type === "success")).toBe(true)
+  }))
+
+// ---------------------------------------------------------------------------
+// Command.withDefaultToastStream — failure shows warning/error toast
+// ---------------------------------------------------------------------------
+
+it.live("withDefaultToastStream: failure shows failure toast, not success toast", () =>
+  Effect.gen(function*() {
+    const toasts: any[] = []
+    const Command = useExperimental({ toasts })
+
+    class BoomError {
+      readonly _tag = "BoomError"
+      readonly message = "boom"
+    }
+
+    const cmd = Command.streamFn("doWorkFail")(
+      function*(_arg: void) {
+        return Stream.fail(new BoomError())
+      },
+      Command.withDefaultToastStream()
+    )
+
+    yield* join(cmd.handle())
+
+    // Typed errors → withDefaultToastStream calls toast.warning (level: "warn")
+    expect(toasts.some((t) => t.type === "warning" || t.type === "error")).toBe(true)
+    expect(toasts.some((t) => t.type === "success")).toBe(false)
+  }))
+
+// ---------------------------------------------------------------------------
+// Command.withDefaultToastStream — die (defect) shows error toast
+// ---------------------------------------------------------------------------
+
+it.live("withDefaultToastStream: die/defect shows error toast, not warning or success", () =>
+  Effect.gen(function*() {
+    const toasts: any[] = []
+    const Command = useExperimental({ toasts })
+
+    const cmd = Command.streamFn("doWorkDie")(
+      function*(_arg: void) {
+        // Stream.die produces a defect — Cause.findErrorOption returns Option.none()
+        // so defaultFailureMessageHandler returns a plain string → toast.error
+        return Stream.die(new Error("unexpected defect"))
+      },
+      Command.withDefaultToastStream()
+    )
+
+    yield* join(cmd.handle())
+
+    expect(toasts.some((t) => t.type === "error")).toBe(true)
+    expect(toasts.some((t) => t.type === "warning")).toBe(false)
+    expect(toasts.some((t) => t.type === "success")).toBe(false)
+  }))
+
+// ---------------------------------------------------------------------------
+// Command.withDefaultToastStream — success shows success toast
+// ---------------------------------------------------------------------------
+
+it.live("withDefaultToastStream: success shows success toast after stream drains", () =>
+  Effect.gen(function*() {
+    const toasts: any[] = []
+    const Command = useExperimental({ toasts, messages: { "handle.success": "{action} complete" } })
+
+    const cmd = Command.streamFn("doWorkSuccess")(
+      function*(_arg: void) {
+        return Stream.make(42)
+      },
+      Command.withDefaultToastStream()
+    )
+
+    yield* join(cmd.handle())
+
+    const successToast = toasts.find((t) => t.type === "success")
+    expect(successToast).toBeDefined()
+    expect(successToast.message).toContain("doWorkSuccess")
+    expect(toasts.some((t) => t.type === "error")).toBe(false)
+  }))