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

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # @effect-app/vue
 
+## 4.0.0-beta.187
+
+### Patch Changes
+
+- 0d4e0b8: Fix `isGeneratorFunction` using `isObject` instead of `isFunction`: generator functions have `typeof === "function"`, not `"object"`, so the check always returned `false`. This caused `Command.streamFn` generator-form handlers to silently pass a raw `Generator` object rather than an `Effect<Stream>`, meaning the mutation was never executed.
+- Updated dependencies [0d4e0b8]
+  - effect-app@4.0.0-beta.187
+
 ## 4.0.0-beta.186
 
 ### Patch Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@effect-app/vue",
-  "version": "4.0.0-beta.186",
+  "version": "4.0.0-beta.187",
   "license": "MIT",
   "type": "module",
   "homepage": "https://github.com/effect-ts-app/libs/tree/main/packages/vue",
@@ -11,7 +11,7 @@
     "@vueuse/core": "^14.2.1",
     "change-case": "^5.4.4",
     "query-string": "^9.3.1",
-    "effect-app": "4.0.0-beta.186"
+    "effect-app": "4.0.0-beta.187"
   },
   "peerDependencies": {
     "@effect/atom-vue": "^4.0.0-beta.59",

package/test/dist/streamFn.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"streamFn.test.d.ts","sourceRoot":"","sources":["../streamFn.test.ts"],"names":[],"mappings":""}

package/test/streamFn.test.ts

@@ -0,0 +1,218 @@
+import { expect, it } from "@effect/vitest"
+import { Effect, Fiber } from "effect-app"
+import * as Stream from "effect/Stream"
+import { AsyncResult } from "../src/lib.js"
+import { useExperimental } from "./stubs.js"
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+/** Wait for the fiber spawned by `cmd.handle()` to finish. */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const join = (fiber: Fiber.Fiber<any, any>) => Fiber.join(fiber)
+
+// ---------------------------------------------------------------------------
+// Non-generator form — (arg) => Stream
+// ---------------------------------------------------------------------------
+
+it.live("streamFn: non-generator returning Stream runs stream and updates result", () =>
+  Effect.gen(function*() {
+    const Command = useExperimental({ toasts: [] })
+
+    const cmd = Command.streamFn("test-stream-plain")(
+      (_arg: number) => Stream.make(10, 20, 30)
+    )
+
+    expect(cmd.waiting).toBe(false)
+    yield* join(cmd.handle(1))
+
+    expect(cmd.result._tag).toBe("Success")
+    if (cmd.result._tag === "Success") {
+      expect(cmd.result.value).toBe(30)
+      expect(cmd.result.waiting).toBe(false)
+    }
+  }))
+
+// ---------------------------------------------------------------------------
+// Generator form — function*(arg) { yield* effect; return Stream }
+// ---------------------------------------------------------------------------
+
+it.live("streamFn: generator form executes yielded effects and subscribes to returned stream", () =>
+  Effect.gen(function*() {
+    const Command = useExperimental({ toasts: [] })
+
+    let generatorBodyExecuted = false
+
+    const cmd = Command.streamFn("test-stream-gen")(
+      function*(arg: number) {
+        generatorBodyExecuted = true
+        const doubled = yield* Effect.succeed(arg * 2)
+        return Stream.make(doubled, doubled + 1, doubled + 2)
+      }
+    )
+
+    yield* join(cmd.handle(5))
+
+    // Generator body MUST have run
+    expect(generatorBodyExecuted).toBe(true)
+
+    // Stream emitted three values: 10, 11, 12; last one should be in result
+    expect(cmd.result._tag).toBe("Success")
+    if (cmd.result._tag === "Success") {
+      expect(cmd.result.value).toBe(12)
+      expect(cmd.result.waiting).toBe(false)
+    }
+  }))
+
+// ---------------------------------------------------------------------------
+// Generator form with async effect (Effect.promise)
+// ---------------------------------------------------------------------------
+
+it.live("streamFn: generator form with async Effect.promise works", () =>
+  Effect.gen(function*() {
+    const Command = useExperimental({ toasts: [] })
+
+    let asyncValueReceived: string | undefined
+
+    const cmd = Command.streamFn("test-stream-gen-async")(
+      function*(arg: string) {
+        // Simulate the pattern from the bug report: yield* Effect.promise(...)
+        const result = yield* Effect.promise(() => Promise.resolve(`processed:${arg}`))
+        asyncValueReceived = result
+        return Stream.make(result, result + "!")
+      }
+    )
+
+    yield* join(cmd.handle("hello"))
+
+    expect(asyncValueReceived).toBe("processed:hello")
+    expect(cmd.result._tag).toBe("Success")
+    if (cmd.result._tag === "Success") {
+      expect(cmd.result.value).toBe("processed:hello!")
+    }
+  }))
+
+// ---------------------------------------------------------------------------
+// Non-generator returning Effect<Stream>
+// ---------------------------------------------------------------------------
+
+it.live("streamFn: non-generator returning Effect<Stream> runs stream", () =>
+  Effect.gen(function*() {
+    const Command = useExperimental({ toasts: [] })
+
+    const cmd = Command.streamFn("test-stream-effect-stream")(
+      (arg: number) => Effect.succeed(Stream.make(arg * 3, arg * 3 + 1))
+    )
+
+    yield* join(cmd.handle(4))
+
+    expect(cmd.result._tag).toBe("Success")
+    if (cmd.result._tag === "Success") {
+      expect(cmd.result.value).toBe(13) // 4*3+1 = 13
+    }
+  }))
+
+// ---------------------------------------------------------------------------
+// Generator form — waiting state flips correctly
+// ---------------------------------------------------------------------------
+
+it.live("streamFn: generator form sets waiting=true during execution then false after", () =>
+  Effect.gen(function*() {
+    const Command = useExperimental({ toasts: [] })
+
+    const cmd = Command.streamFn("test-stream-gen-waiting")(
+      function*(_arg: void) {
+        return Stream.make(1, 2, 3)
+      }
+    )
+
+    expect(cmd.waiting).toBe(false)
+    const fiber = cmd.handle()
+
+    // result transitions to initial(true) = waiting synchronously inside runStream
+    // after the fiber runs, waiting should settle to false
+    yield* join(fiber)
+    expect(cmd.waiting).toBe(false)
+
+    expect(AsyncResult.isSuccess(cmd.result)).toBe(true)
+  }))
+
+// ---------------------------------------------------------------------------
+// Generator form with a stream-transformer combinator
+// ---------------------------------------------------------------------------
+
+it.live("streamFn: generator form with combinator — combinator transforms the stream", () =>
+  Effect.gen(function*() {
+    const Command = useExperimental({ toasts: [] })
+
+    const emittedByCombinator: number[] = []
+
+    // A combinator that records each element it sees.
+    // The first argument may be a Stream or an Effect<Stream> (for generator-form handlers),
+    // matching how withDefaultToastStream handles it.
+    const spyCombinator = (
+      input: Stream.Stream<number, never, never> | Effect.Effect<Stream.Stream<number, never, never>>
+    ) => {
+      const stream: Stream.Stream<number, never, never> = Stream.isStream(input)
+        ? input
+        : Stream.unwrap(input as Effect.Effect<Stream.Stream<number, never, never>>)
+      return stream.pipe(
+        Stream.tap((v) =>
+          Effect.sync(() => {
+            emittedByCombinator.push(v)
+          })
+        )
+      )
+    }
+
+    const cmd = Command.streamFn("test-stream-gen-combinator")(
+      function*(arg: number) {
+        const base = yield* Effect.succeed(arg * 10)
+        return Stream.make(base, base + 1, base + 2)
+      },
+      // combinator receives (input, arg, ctx) — input is Stream or Effect<Stream> depending on handler form
+      (input: Stream.Stream<number, never, never> | Effect.Effect<Stream.Stream<number, never, never>>) =>
+        spyCombinator(input)
+    )
+
+    yield* join(cmd.handle(3))
+
+    // combinator must have seen all elements: 30, 31, 32
+    expect(emittedByCombinator).toEqual([30, 31, 32])
+
+    expect(cmd.result._tag).toBe("Success")
+    if (cmd.result._tag === "Success") {
+      expect(cmd.result.value).toBe(32)
+    }
+  }))
+
+// ---------------------------------------------------------------------------
+// Generator form — Stream.ensuring runs after stream completes
+// ---------------------------------------------------------------------------
+
+it.live("streamFn: generator form Stream.ensuring cleanup runs after stream ends", () =>
+  Effect.gen(function*() {
+    const Command = useExperimental({ toasts: [] })
+
+    let cleanupRan = false
+
+    const cmd = Command.streamFn("test-stream-gen-ensuring")(
+      function*(arg: number) {
+        const value = yield* Effect.succeed(arg + 100)
+        return Stream.make(value).pipe(
+          Stream.ensuring(Effect.sync(() => {
+            cleanupRan = true
+          }))
+        )
+      }
+    )
+
+    yield* join(cmd.handle(7))
+
+    expect(cleanupRan).toBe(true)
+    expect(cmd.result._tag).toBe("Success")
+    if (cmd.result._tag === "Success") {
+      expect(cmd.result.value).toBe(107)
+    }
+  }))