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

4
// =============================================================================
5
// 11 - Context: Typed Dependency Injection
6
// =============================================================================
7
//
8
// Context.Service declares a service. yield* the Tag inside Effect.gen to look it
9
// up; the Tag is added to R. Effect.provideService removes it from R.
10

11
class Logger extends Context.Service<Logger, {
12
    readonly log: (message: string) => Effect.Effect<void>
13
  }>()("app/Logger") {}
14

15
class Random extends Context.Service<Random, {
16
    readonly next: () => Effect.Effect<number>
17
  }>()("app/Random") {}
18

19
describe("11 - Context Basics", () => {
20
  // @beat
21
  //   id: declare-tag
22
  //   shape: multi-todo
23
  //   title: A Tag carries its id as a runtime key
24
  //   teaches: A Context.Service becomes both a type and a value identified by a unique key string.
25
  //   hint: Tag.key equals the string you passed to Context.Service("…")
26
  describe("Context.Service", () => {
27
    it("the Tag carries its id as a runtime key", () => {
28
      // Predict: the key strings passed into Context.Service(...) above
29
      expect(Logger.key).toBe(/* @stub */ "app/Logger" /* @end */)
30
      expect(Random.key).toBe(/* @stub */ "app/Random" /* @end */)
31
    })
32
  })
33
  // @end-beat
34

35
  // @beat
36
  //   id: yield-a-tag
37
  //   shape: multi-todo
38
  //   title: Yield a Tag to look up a service
39
  //   teaches: yield* on a Tag returns the service value and adds the Tag to R; multiple yields widen R to a union.
40
  //   hint: const logger = yield* Logger
41
  describe("yield* a Tag inside Effect.gen", () => {
42
    it("looking up the service adds the Tag to R", async () => {
43
      //      ┌─── Effect<string, never, Logger>
44
      //      ▼
45
      const program = Effect.gen(function* () {
46
        const logger = yield* /* @stub */ Logger /* @end */
47
        yield* logger.log("hello")
48
        return "done"
49
      })
50

51
      const result = await Effect.runPromise(
52
        program.pipe(
53
          Effect.provideService(Logger, { log: () => Effect.void })
54
        )
55
      )
56

57
      expect(result).toBe("done")
58
    })
59

60
    it("multiple yields widen R to a union of Tags", async () => {
61
      //      ┌─── Effect<number, never, Logger | Random>
62
      //      ▼
63
      const program = Effect.gen(function* () {
64
        const logger = yield* /* @stub */ Logger /* @end */
65
        const random = yield* /* @stub */ Random /* @end */
66

67
        const value = yield* random.next()
68
        yield* logger.log(`got ${value}`)
69
        return value
70
      })
71

72
      const result = await Effect.runPromise(
73
        program.pipe(
74
          Effect.provideService(Logger, { log: () => Effect.void }),
75
          Effect.provideService(Random, { next: () => Effect.succeed(42) })
76
        )
77
      )
78

79
      expect(result).toBe(42)
80
    })
81
  })
82
  // @end-beat
83

84
  // @beat
85
  //   id: provide-service
86
  //   shape: one-todo
87
  //   title: Satisfy R with provideService
88
  //   teaches: Effect.provideService supplies an implementation and removes its Tag from R; same program runs against any implementation.
89
  //   hint: program.pipe(Effect.provideService(Tag, implementation))
90
  describe("Effect.provideService", () => {
91
    it("the same program runs against a silent test logger and would run against console in prod", async () => {
92
      const captured: Array<string> = []
93

94
      const program = Effect.gen(function* () {
95
        const logger = yield* Logger
96
        yield* logger.log("event: signed up")
97
        return "logged"
98
      })
99

100
      const result = await Effect.runPromise(
101
        program.pipe(
102
          /* @stub */ Effect.provideService(Logger, {
103
            log: (msg) =>
104
              Effect.sync(() => {
105
                captured.push(msg)
106
              }),
107
          }) /* @end */
108
        )
109
      )
110

111
      expect(result).toBe("logged")
112
      expect(captured).toEqual(["event: signed up"])
113
    })
114
  })
115
  // @end-beat
116

117
  // @beat
118
  //   id: requirements-propagate
119
  //   shape: one-todo
120
  //   title: Requirements propagate automatically
121
  //   teaches: A caller that uses a service-needing function inherits its R; provide once at the entry point.
122
  //   hint: getUser returns { name: "Alice" } — getGreeting interpolates that into a template string
123
  describe("requirements propagate automatically", () => {
124
    it("a caller that uses a service-needing function inherits the requirement", () => {
125
      const getUser = (id: string): Effect.Effect<{ name: string }, never, Logger> =>
126
        Effect.gen(function* () {
127
          const logger = yield* Logger
128
          yield* logger.log(`fetch ${id}`)
129
          return { name: "Alice" }
130
        })
131

132
      //      ┌─── Effect<string, never, Logger>
133
      //      ▼
134
      const getGreeting = (id: string) =>
135
        Effect.gen(function* () {
136
          const user = yield* getUser(id)
137
          return `Hello, ${user.name}!`
138
        })
139

140
      const result = Effect.runSync(
141
        getGreeting("123").pipe(
142
          Effect.provideService(Logger, { log: () => Effect.void })
143
        )
144
      )
145

146
      // Predict the final greeting string
147
      expect(result).toBe(/* @stub */ "Hello, Alice!" /* @end */)
148
    })
149
  })
150
  // @end-beat
151
})