add TaggedRequest class (#574)

.changeset/spotty-gorillas-cry.md

@@ -0,0 +1,5 @@
+---
+"@effect/schema": patch
+---
+
+add TaggedRequest class

docs/modules/Schema.ts.md

@@ -94,6 +94,10 @@ Added in v1.0.0
   - [Class (interface)](#class-interface)
   - [TaggedClass](#taggedclass)
   - [TaggedError](#taggederror)
+  - [TaggedRequest](#taggedrequest)
+  - [TaggedRequest (namespace)](#taggedrequest-namespace)
+    - [Base (interface)](#base-interface)
+    - [ResultSchemas (interface)](#resultschemas-interface)
 - [combinators](#combinators)
   - [array](#array)
   - [attachPropertySignature](#attachpropertysignature)
@@ -1159,6 +1163,67 @@ export declare const TaggedError: <Self>() => <Tag extends string, Fields extend
 
 Added in v1.0.0
 
+## TaggedRequest
+
+**Signature**
+
+```ts
+export declare const TaggedRequest: <Self>() => <Tag extends string, Fields extends StructFields, EI, EA, AI, AA>(
+  tag: Tag,
+  failure: Schema<EI, EA>,
+  success: Schema<AI, AA>,
+  fields: Fields
+) => [unknown] extends [Self]
+  ? 'Missing `Self` generic - use `class Self extends TaggedRequest<Self>()("Tag", SuccessSchema, FailureSchema, { ... })`'
+  : Class<
+      Simplify<
+        { readonly _tag: Tag } & {
+          readonly [K in Exclude<keyof Fields, FromOptionalKeys<Fields>>]: Schema.From<Fields[K]>
+        } & { readonly [K in FromOptionalKeys<Fields>]?: Schema.From<Fields[K]> | undefined }
+      >,
+      Simplify<
+        { readonly _tag: Tag } & {
+          readonly [K in Exclude<keyof Fields, ToOptionalKeys<Fields>>]: Schema.To<Fields[K]>
+        } & { readonly [K in ToOptionalKeys<Fields>]?: Schema.To<Fields[K]> | undefined }
+      >,
+      Simplify<ToStruct<Fields>>,
+      Self,
+      Request.Request<EA, AA>
+    > &
+      TaggedRequest.ResultSchemas<EI, EA, AI, AA>
+```
+
+Added in v1.0.0
+
+## TaggedRequest (namespace)
+
+Added in v1.0.0
+
+### Base (interface)
+
+**Signature**
+
+```ts
+export interface Base<EI, EA, AI, AA, I, Req extends Request.Request<EA, AA>>
+  extends Schema<I, Req>,
+    TaggedRequest.ResultSchemas<EI, EA, AI, AA> {}
+```
+
+Added in v1.0.0
+
+### ResultSchemas (interface)
+
+**Signature**
+
+```ts
+export interface ResultSchemas<EI, EA, AI, AA> {
+  readonly Failure: Schema<EI, EA>
+  readonly Success: Schema<AI, AA>
+}
+```
+
+Added in v1.0.0
+
 # combinators
 
 ## array

src/Schema.ts

@@ -19,6 +19,7 @@ import type { Pipeable } from "effect/Pipeable"
 import { pipeArguments } from "effect/Pipeable"
 import * as Predicate from "effect/Predicate"
 import * as ReadonlyArray from "effect/ReadonlyArray"
+import * as Request from "effect/Request"
 import * as S from "effect/String"
 import type { Equals, Simplify } from "effect/Types"
 import type { Arbitrary } from "./Arbitrary.js"
@@ -3691,6 +3692,64 @@ export const TaggedError = <Self>() =>
   )
 }
 
+/**
+ * @category classes
+ * @since 1.0.0
+ */
+export declare namespace TaggedRequest {
+  /**
+   * @category classes
+   * @since 1.0.0
+   */
+  export interface Base<EI, EA, AI, AA, I, Req extends Request.Request<EA, AA>>
+    extends Schema<I, Req>, TaggedRequest.ResultSchemas<EI, EA, AI, AA>
+  {}
+
+  /**
+   * @category classes
+   * @since 1.0.0
+   */
+  export interface ResultSchemas<EI, EA, AI, AA> {
+    readonly Failure: Schema<EI, EA>
+    readonly Success: Schema<AI, AA>
+  }
+}
+
+/**
+ * @category classes
+ * @since 1.0.0
+ */
+export const TaggedRequest =
+  <Self>() =>
+  <Tag extends string, Fields extends StructFields, EI, EA, AI, AA>(
+    tag: Tag,
+    failure: Schema<EI, EA>,
+    success: Schema<AI, AA>,
+    fields: Fields
+  ): [unknown] extends [Self] ?
+    MissingSelfGeneric<"TaggedRequest", `"Tag", SuccessSchema, FailureSchema, `>
+    :
+      & Class<
+        Simplify<{ readonly _tag: Tag } & FromStruct<Fields>>,
+        Simplify<{ readonly _tag: Tag } & ToStruct<Fields>>,
+        Simplify<ToStruct<Fields>>,
+        Self,
+        Request.Request<EA, AA>
+      >
+      & TaggedRequest.ResultSchemas<EI, EA, AI, AA> =>
+  {
+    const fieldsWithTag = { ...fields, _tag: literal(tag) }
+    const Base = makeClass(
+      struct(fieldsWithTag),
+      fieldsWithTag,
+      Request.Class,
+      { _tag: tag }
+    )
+    Base.Failure = failure
+    Base.Success = success
+    return Base
+  }
+
 const makeClass = <I, A>(
   selfSchema: Schema<I, A>,
   selfFields: StructFields,

test/Schema/Class.test.ts

@@ -6,6 +6,7 @@ import { Effect } from "effect"
 import * as Data from "effect/Data"
 import * as Equal from "effect/Equal"
 import * as O from "effect/Option"
+import * as Request from "effect/Request"
 import { describe, expect, it } from "vitest"
 
 class Person extends S.Class<Person>()({
@@ -237,4 +238,35 @@ describe("Schema/Class", () => {
     expect(err._tag).toEqual("MyError")
     expect(err.id).toEqual(1)
   })
+
+  it("TaggedRequest", () => {
+    class MyRequest extends S.TaggedRequest<MyRequest>()("MyRequest", S.string, S.number, {
+      id: S.number
+    }) {}
+
+    let req = new MyRequest({ id: 1 })
+    expect(req._tag).toEqual("MyRequest")
+    expect(req.id).toEqual(1)
+    expect(Request.isRequest(req)).toEqual(true)
+
+    req = S.decodeSync(MyRequest)({ _tag: "MyRequest", id: 1 })
+    expect(req._tag).toEqual("MyRequest")
+    expect(req.id).toEqual(1)
+    expect(Request.isRequest(req)).toEqual(true)
+
+    S.decodeSync(MyRequest.Success)(123)
+    S.decodeSync(MyRequest.Failure)("fail")
+  })
+
+  it("TaggedRequest assignable to TaggedRequest.Base", () => {
+    class MyRequest extends S.TaggedRequest<MyRequest>()("MyRequest", S.string, S.number, {
+      id: S.number
+    }) {}
+
+    const makeCache = <EI, EA, AI, AA, I, Req extends Request.Request<EA, AA>>(
+      schema: S.TaggedRequest.Base<EI, EA, AI, AA, I, Req>
+    ) => schema
+
+    makeCache(MyRequest)
+  })
 })