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

4
// =============================================================================
5
// 48 - Schema Classes: Domain Models with a Schema Built-In
6
// =============================================================================
7
//
8
// Schema.Class produces a TypeScript class, a Schema, and a Data value at once.
9
// Schema.TaggedClass adds a _tag field. Schema.TaggedErrorClass adds a _tag and
10
// extends Error so the value works in the Effect failure channel.
11

12
class Person extends Schema.Class<Person>("Person")({
13
  id: Schema.Number,
14
  name: Schema.NonEmptyString,
15
  age: Schema.Number,
16
}) {
17
  get displayName(): string {
18
    return `${this.name} (${this.age})`
19
  }
20
}
21

22
describe("48 - Schema Classes: Domain Models with a Schema Built-In", () => {
23
  // @beat
24
  //   id: schema-class-construct
25
  //   shape: one-todo
26
  //   title: Build a domain class with Schema.Class
27
  //   teaches: Schema.Class<Self>("Name")({ fields }) returns a class with constructor, .make factory, and methods on the body.
28
  //   hint: new Person({ id, name, age }) — fields land as instance properties
29
  describe("Schema.Class construction", () => {
30
    it("creates an instance via the constructor", () => {
31
      const person = /* @stub */ new Person({ id: 1, name: "Alice", age: 30 }) /* @end */
32
      expect(person.id).toBe(1)
33
      expect(person.name).toBe("Alice")
34
      expect(person.age).toBe(30)
35
    })
36

37
    it("supports the .make factory", () => {
38
      const person = Person.make({ id: 1, name: "Alice", age: 30 })
39
      expect(person.name).toBe("Alice")
40
    })
41

42
    it("retains methods declared on the class body", () => {
43
      const person = new Person({ id: 1, name: "Alice", age: 30 })
44
      expect(person.displayName).toBe("Alice (30)")
45
    })
46
  })
47
  // @end-beat
48

49
  describe("Schema.Class structural equality", () => {
50
    it("compares two instances by their fields", () => {
51
      const a = new Person({ id: 1, name: "Alice", age: 30 })
52
      const b = new Person({ id: 1, name: "Alice", age: 30 })
53
      expect(Equal.equals(a, b)).toBe(true)
54
    })
55

56
    it("returns false when any field differs", () => {
57
      const a = new Person({ id: 1, name: "Alice", age: 30 })
58
      const b = new Person({ id: 2, name: "Bob", age: 25 })
59
      expect(Equal.equals(a, b)).toBe(false)
60
    })
61
  })
62

63
  // @beat
64
  //   id: schema-class-decode-encode
65
  //   shape: one-todo
66
  //   title: Decode and encode a Schema.Class
67
  //   teaches: Schema.decodeUnknownSync produces a real class instance; Schema.encodeSync returns the plain object form.
68
  //   hint: Schema.decodeUnknownSync(Person)(raw) returns a Person
69
  describe("Schema.Class decoding", () => {
70
    it("decodes unknown input into a class instance", () => {
71
      const raw = { id: 1, name: "Alice", age: 30 }
72
      //      ┌─── Person
73
      //      ▼
74
      const person = /* @stub */ Schema.decodeUnknownSync(Person)(raw) /* @end */
75

76
      expect(person).toBeInstanceOf(Person)
77
      expect(person.displayName).toBe("Alice (30)")
78
    })
79

80
    it("fails when a field has the wrong type", () => {
81
      const raw = { id: "not-a-number", name: "Alice", age: 30 }
82
      expect(() => Schema.decodeUnknownSync(Person)(raw)).toThrow()
83
    })
84

85
    it("fails when a refinement is violated", () => {
86
      expect(() =>
87
        Schema.decodeUnknownSync(Person)({ id: 1, name: "", age: 30 }),
88
      ).toThrow()
89
    })
90
  })
91

92
  describe("Schema.Class encoding", () => {
93
    it("encodes an instance back to a plain object", () => {
94
      const person = new Person({ id: 1, name: "Alice", age: 30 })
95
      const encoded = /* @stub */ Schema.encodeSync(Person)(person) /* @end */
96
      expect(encoded).toEqual({ id: 1, name: "Alice", age: 30 })
97
    })
98
  })
99
  // @end-beat
100

101
  // @beat
102
  //   id: schema-tagged-class
103
  //   shape: one-todo
104
  //   title: Tag a class for discriminated unions
105
  //   teaches: Schema.TaggedClass<Self>()("Tag", { fields }) adds a _tag field that Match.tag and Effect.catchTag consume.
106
  //   hint: class SuccessResult extends Schema.TaggedClass<SuccessResult>()("SuccessResult", {...}) {}
107
  describe("Schema.TaggedClass", () => {
108
    class SuccessResult extends /* @stub */ Schema.TaggedClass<SuccessResult>()(
109
      "SuccessResult",
110
      { value: Schema.Number },
111
    ) /* @end */ {}
112

113
    class FailureResult extends Schema.TaggedClass<FailureResult>()(
114
      "FailureResult",
115
      { message: Schema.String },
116
    ) {}
117

118
    it("sets _tag from the identifier", () => {
119
      const ok = new SuccessResult({ value: 42 })
120
      expect(ok._tag).toBe("SuccessResult")
121
    })
122

123
    it("narrows in a discriminated union", () => {
124
      const result: SuccessResult | FailureResult = new SuccessResult({
125
        value: 1,
126
      })
127
      if (result._tag === "SuccessResult") {
128
        expect(result.value).toBe(1)
129
      }
130
    })
131
  })
132
  // @end-beat
133

134
  // @beat
135
  //   id: schema-tagged-error
136
  //   shape: one-todo
137
  //   title: Define a typed failure with Schema.TaggedErrorClass
138
  //   teaches: Schema.TaggedErrorClass extends Error and carries a _tag, so Effect.fail and Effect.catchTag work directly.
139
  //   hint: Effect.catchTag("ValidationError", (e) => Effect.succeed(`${e.field}: ${e.message}`))
140
  describe("Schema.TaggedErrorClass", () => {
141
    class ValidationError extends Schema.TaggedErrorClass<ValidationError>()(
142
      "ValidationError",
143
      { field: Schema.String, message: Schema.String },
144
    ) {}
145

146
    it("works as a typed Effect failure", async () => {
147
      const program = Effect.fail(
148
        new ValidationError({ field: "email", message: "invalid format" }),
149
      )
150

151
      const exit = await Effect.runPromiseExit(program)
152
      expect(exit._tag).toBe("Failure")
153
    })
154

155
    it("is recoverable via Effect.catchTag", async () => {
156
      const result = await Effect.runPromise(
157
        /* @stub */ Effect.fail(
158
          new ValidationError({ field: "name", message: "required" }),
159
        ).pipe(
160
          Effect.catchTag("ValidationError", (e) =>
161
            Effect.succeed(`${e.field}: ${e.message}`),
162
          ),
163
        ) /* @end */,
164
      )
165

166
      expect(result).toBe("name: required")
167
    })
168
  })
169
  // @end-beat
170
})