1
import { describe, it, expect } from "vite-plus/test"
2
import { Effect, Data, Exit } from "effect"
3

4
// =============================================================================
5
// 08 - Async Operations: Promises and Side Effects
6
// =============================================================================
7
//
8
// Four wrappers, split by synchrony and failure mode:
9
//   Effect.sync         sync,  no throw      (E = never)
10
//   Effect.try          sync,  may throw     (E = your typed error)
11
//   Effect.promise      async, no rejection  (E = never)
12
//   Effect.tryPromise   async, may reject    (E = your typed error)
13

14
class FetchError extends Data.TaggedError("FetchError")<{
15
  readonly url: string
16
  readonly cause: unknown
17
}> {}
18

19
class ParseError extends Data.TaggedError("ParseError")<{
20
  readonly input: string
21
}> {}
22

23
describe("08 - Async Operations", () => {
24
  // @beat
25
  //   id: wrap-resolving-promise
26
  //   shape: one-todo
27
  //   title: Wrap a Promise you trust
28
  //   teaches: Effect.promise lifts a non-rejecting Promise; E stays never.
29
  //   hint: Effect.promise takes a thunk returning a Promise
30
  describe("Effect.promise", () => {
31
    it("wraps a Promise you guarantee will resolve", async () => {
32
      //      ┌─── Effect<number, never, never>
33
      //      ▼
34
      const program = /* @stub */ Effect.promise(() => Promise.resolve(42)) /* @end */
35

36
      await expect(Effect.runPromise(program)).resolves.toBe(42)
37
    })
38

39
    it("re-invokes the thunk on every execution", async () => {
40
      let calls = 0
41
      const program = /* @stub */ Effect.promise(() => {
42
        calls += 1
43
        return Promise.resolve(calls)
44
      }) /* @end */
45

46
      await expect(Effect.runPromise(program)).resolves.toBe(1)
47
      await expect(Effect.runPromise(program)).resolves.toBe(2)
48
    })
49
  })
50
  // @end-beat
51

52
  // @beat
53
  //   id: wrap-rejecting-promise
54
  //   shape: multi-todo
55
  //   title: Catch a Promise rejection as a typed error
56
  //   teaches: Effect.tryPromise maps an unknown rejection into a typed E via catch.
57
  //   hint: Effect.tryPromise takes { try, catch }; catch returns your domain error
58
  describe("Effect.tryPromise", () => {
59
    it("catches a rejection into a typed error", async () => {
60
      const failing = /* @stub */ Effect.tryPromise({
61
        try: () => Promise.reject(new Error("boom")),
62
        catch: (cause) => new FetchError({ url: "/x", cause }),
63
      }) /* @end */
64

65
      const exit = await Effect.runPromiseExit(failing)
66
      expect(Exit.isFailure(exit)).toBe(true)
67
    })
68

69
    it("returns the resolved value when the Promise succeeds", async () => {
70
      const ok = /* @stub */ Effect.tryPromise({
71
        try: () => Promise.resolve({ data: "hello" }),
72
        catch: (cause) => new FetchError({ url: "/x", cause }),
73
      }) /* @end */
74

75
      await expect(Effect.runPromise(ok)).resolves.toEqual({ data: "hello" })
76
    })
77

78
    it("catch maps the unknown rejection to a typed structured error", async () => {
79
      const program = Effect.tryPromise({
80
        try: () => Promise.reject({ status: 404, message: "Not found" }),
81
        catch: /* @stub */ (raw) => {
82
          const err = raw as { status?: number; message?: string }
83
          return new FetchError({
84
            url: "/missing",
85
            cause: { status: err.status ?? 0, message: err.message ?? "" },
86
          })
87
        } /* @end */,
88
      })
89

90
      const exit = await Effect.runPromiseExit(program)
91
      expect(Exit.isFailure(exit)).toBe(true)
92
      if (Exit.isFailure(exit) && exit.cause.reasons[0]?._tag === "Fail") {
93
        expect(exit.cause.reasons[0].error._tag).toBe("FetchError")
94
        expect(exit.cause.reasons[0].error.url).toBe("/missing")
95
      }
96
    })
97
  })
98
  // @end-beat
99

100
  // @beat
101
  //   id: sync-counterparts
102
  //   shape: multi-todo
103
  //   title: Sync counterparts alongside the async wrappers
104
  //   teaches: Effect.sync and Effect.try are the synchronous pair; the failure split is the same.
105
  //   hint: Effect.sync for non-throwing thunks; Effect.try for throwing ones
106
  describe("Effect.sync and Effect.try alongside the async wrappers", () => {
107
    it("Effect.sync defers a non-throwing side effect", () => {
108
      let value = 0
109
      const program = /* @stub */ Effect.sync(() => {
110
        value += 1
111
        return value
112
      }) /* @end */
113

114
      expect(value).toBe(0)
115
      expect(Effect.runSync(program)).toBe(1)
116
    })
117

118
    it("Effect.try catches a throw into a typed error", () => {
119
      const program = /* @stub */ Effect.try({
120
        try: () => JSON.parse("{ invalid") as unknown,
121
        catch: () => new ParseError({ input: "{ invalid" }),
122
      }) /* @end */
123

124
      const exit = Effect.runSyncExit(program)
125
      expect(Exit.isFailure(exit)).toBe(true)
126
    })
127
  })
128
  // @end-beat
129

130
  // @beat
131
  //   id: mix-sync-and-async
132
  //   shape: multi-todo
133
  //   title: Sequence sync and async in Effect.gen
134
  //   teaches: Effect.gen sequences sync and async wrappers; runPromise drives the async result.
135
  //   hint: yield* each wrapper in order; use Effect.tryPromise for the awaited calls
136
  describe("composite — mixing sync and async in Effect.gen", () => {
137
    it("sequences sync config, async user fetch, async posts fetch", async () => {
138
      const fetchUser = async (id: string) => ({ id, name: "Alice" })
139
      const fetchPosts = async (_userId: string) => [{ id: "p1" }]
140

141
      //      ┌─── Effect<{ user: { id: string; name: string }; posts: Array<{ id: string }> }, FetchError, never>
142
      //      ▼
143
      const program = Effect.gen(function* () {
144
        const config = yield* /* @stub */ Effect.sync(() => ({ userId: "123" })) /* @end */
145

146
        const user = yield* /* @stub */ Effect.tryPromise({
147
          try: () => fetchUser(config.userId),
148
          catch: (cause) => new FetchError({ url: "/users", cause }),
149
        }) /* @end */
150

151
        const posts = yield* /* @stub */ Effect.tryPromise({
152
          try: () => fetchPosts(user.id),
153
          catch: (cause) => new FetchError({ url: "/posts", cause }),
154
        }) /* @end */
155

156
        return { user, posts }
157
      })
158

159
      const result = await Effect.runPromise(program)
160
      expect(result.user.name).toBe("Alice")
161
      expect(result.posts).toHaveLength(1)
162
    })
163
  })
164
  // @end-beat
165
})