effect-app 4.0.0-beta.271 → 4.0.0-beta.273

package/test/special.test.ts

@@ -1,8 +1,10 @@
 import { InvalidStateError, LoginError, NotFoundError, NotLoggedInError, OptimisticConcurrencyException, ServiceUnavailableError, UnauthorizedError, ValidationError } from "effect-app/client/errors"
+import { RequestContext } from "effect-app/RequestContext"
 import * as AppSchema from "effect-app/Schema"
 import { Class } from "effect-app/Schema/Class"
 import { flattenNestedAnyOf, flattenSimpleAllOf, specialJsonSchemaDocument } from "effect-app/Schema/SpecialJsonSchema"
 import { deduplicateOpenApiSchemas } from "effect-app/Schema/SpecialOpenApi"
+import * as Effect from "effect/Effect"
 import * as Option from "effect/Option"
 import * as Predicate from "effect/Predicate"
 import * as Schema from "effect/Schema"
@@ -10,6 +12,133 @@ import * as S from "effect/Schema"
 import * as SchemaGetter from "effect/SchemaGetter"
 import { describe, expect, it } from "vitest"
 
+class _FacadeModel extends AppSchema.Class<_FacadeModel>("FacadeModel")({ value: S.String }) {
+  get upperValue() {
+    return this.value.toUpperCase()
+  }
+
+  static describe(self: { readonly value: string }) {
+    return `value:${self.value}`
+  }
+}
+
+interface FacadeModelEncoded {
+  readonly value: string
+}
+
+interface FacadeModelMake {
+  readonly value: string
+}
+
+class FacadeModel extends AppSchema.OpaqueFacade<
+  FacadeModel,
+  FacadeModelEncoded,
+  FacadeModelMake,
+  never,
+  never
+>()(_FacadeModel) {
+  declare readonly value: string
+  declare readonly upperValue: string
+
+  get decoratedValue() {
+    return `facade:${this.value}`
+  }
+
+  label() {
+    return this.decoratedValue
+  }
+}
+
+class _RenamedFacadeModel extends AppSchema.Class<_RenamedFacadeModel>("RenamedFacadeModel")({
+  internalName: S.String
+}) {
+  get upperName() {
+    return this.internalName.toUpperCase()
+  }
+}
+
+interface RenamedFacadeModelEncoded {
+  readonly external_name: string
+}
+
+interface RenamedFacadeModelMake {
+  readonly internalName: string
+}
+
+class RenamedFacadeModel extends AppSchema.OpaqueFacade<
+  RenamedFacadeModel,
+  RenamedFacadeModelEncoded,
+  RenamedFacadeModelMake,
+  never,
+  never
+>()(_RenamedFacadeModel.pipe(S.encodeKeys({ internalName: "external_name" }))) {
+  declare readonly internalName: string
+  declare readonly upperName: string
+
+  get decoratedName() {
+    return `facade:${this.internalName}`
+  }
+}
+
+const _StructFacadeModel = AppSchema.Struct({ value: S.String })
+
+interface StructFacadeModelEncoded {
+  readonly value: string
+}
+
+interface StructFacadeModelMake {
+  readonly value: string
+}
+
+class StructFacadeModel extends AppSchema.OpaqueFacade<
+  StructFacadeModel,
+  StructFacadeModelEncoded,
+  StructFacadeModelMake,
+  never,
+  never
+>()(_StructFacadeModel) {
+  declare readonly value: string
+}
+
+const _RenamedStructFacadeModel = AppSchema.Struct({ internalName: S.String }).pipe(
+  S.encodeKeys({ internalName: "external_name" })
+)
+
+interface RenamedStructFacadeModelEncoded {
+  readonly external_name: string
+}
+
+interface RenamedStructFacadeModelMake {
+  readonly internalName: string
+}
+
+class RenamedStructFacadeModel extends AppSchema.OpaqueFacade<
+  RenamedStructFacadeModel,
+  RenamedStructFacadeModelEncoded,
+  RenamedStructFacadeModelMake,
+  never,
+  never
+>()(_RenamedStructFacadeModel) {
+  declare readonly internalName: string
+}
+
+const _RenamedOpaqueStructFacadeModel = AppSchema
+  .Opaque<
+    { readonly internalName: string },
+    RenamedStructFacadeModelEncoded
+  >()(AppSchema.Struct({ internalName: S.String }))
+  .pipe(S.encodeKeys({ internalName: "external_name" }))
+
+class RenamedOpaqueStructFacadeModel extends AppSchema.OpaqueFacade<
+  RenamedOpaqueStructFacadeModel,
+  RenamedStructFacadeModelEncoded,
+  RenamedStructFacadeModelMake,
+  never,
+  never
+>()(_RenamedOpaqueStructFacadeModel) {
+  declare readonly internalName: string
+}
+
 describe("Class", () => {
   describe("strict", () => {
     it("encoding doesnt accepts plain objects matching the struct (Fields argument)", () => {
@@ -268,6 +397,109 @@ describe("TaggedStruct (opaque).copy", () => {
   })
 })
 
+describe("OpaqueFacade", () => {
+  it("keeps OpaqueFacade usable with struct schemas", () => {
+    const decoded = S.decodeSync(StructFacadeModel)({ value: "hello" })
+
+    expect(decoded).toStrictEqual({ value: "hello" })
+    expect(S.encodeSync(StructFacadeModel)(decoded)).toStrictEqual({ value: "hello" })
+    expect(S.is(StructFacadeModel)(decoded)).toBe(true)
+    expect(S.is(StructFacadeModel)({ value: 1 })).toBe(false)
+  })
+
+  it("keeps encoded-key struct facades on the struct path", () => {
+    const decoded = S.decodeSync(RenamedStructFacadeModel)({ external_name: "fran" })
+
+    expect(decoded).toStrictEqual({ internalName: "fran" })
+    expect(decoded).not.toBeInstanceOf(RenamedStructFacadeModel)
+    expect(S.encodeSync(RenamedStructFacadeModel)(decoded)).toStrictEqual({ external_name: "fran" })
+    expect(S.is(RenamedStructFacadeModel)(decoded)).toBe(true)
+    expect(S.is(RenamedStructFacadeModel)({ external_name: "fran" })).toBe(false)
+  })
+
+  it("keeps encoded-key opaque struct facades on the struct path", () => {
+    const decoded = S.decodeSync(RenamedOpaqueStructFacadeModel)({ external_name: "fran" })
+
+    expect(decoded).toStrictEqual({ internalName: "fran" })
+    expect(decoded).not.toBeInstanceOf(RenamedOpaqueStructFacadeModel)
+    expect(S.encodeSync(RenamedOpaqueStructFacadeModel)(decoded)).toStrictEqual({ external_name: "fran" })
+    expect(S.is(RenamedOpaqueStructFacadeModel)(decoded)).toBe(true)
+    expect(S.is(RenamedOpaqueStructFacadeModel)({ external_name: "fran" })).toBe(false)
+  })
+
+  it("decodes through the public facade class", () => {
+    const decoded = S.decodeSync(FacadeModel)({ value: "hello" })
+    const decodedEffect = Effect.runSync(S.decodeUnknownEffect(FacadeModel)({ value: "effect" }))
+
+    expect(decoded).toBeInstanceOf(FacadeModel)
+    expect(decodedEffect).toBeInstanceOf(FacadeModel)
+    expect(decoded).toBeInstanceOf(_FacadeModel)
+    expect(decoded.value).toBe("hello")
+    expect(decoded.upperValue).toBe("HELLO")
+    expect(decoded.decoratedValue).toBe("facade:hello")
+    expect(decoded.label()).toBe("facade:hello")
+    expect(FacadeModel.describe(decoded)).toBe("value:hello")
+  })
+
+  it("validates facade instances with S.is", () => {
+    const instance = new FacadeModel({ value: "hello" })
+
+    expect(instance).toBeInstanceOf(FacadeModel)
+    expect(instance.upperValue).toBe("HELLO")
+    expect(instance.label()).toBe("facade:hello")
+    expect(S.is(FacadeModel)(instance)).toBe(true)
+    expect(S.is(FacadeModel)(S.decodeSync(FacadeModel)({ value: "world" }))).toBe(true)
+    expect(S.is(FacadeModel)({ value: "plain" })).toBe(false)
+    expect(S.is(FacadeModel)({ value: 1 })).toBe(false)
+  })
+
+  it("decodes renamed keys through the public facade class", () => {
+    const decoded = S.decodeSync(RenamedFacadeModel)({ external_name: "fran" })
+
+    expect(decoded).toBeInstanceOf(RenamedFacadeModel)
+    expect(decoded).toBeInstanceOf(_RenamedFacadeModel)
+    expect(Object.getPrototypeOf(decoded)).toBe(RenamedFacadeModel.prototype)
+    expect(decoded.internalName).toBe("fran")
+    expect(decoded.upperName).toBe("FRAN")
+    expect(decoded.decoratedName).toBe("facade:fran")
+    expect(S.encodeSync(RenamedFacadeModel)(decoded)).toStrictEqual({ external_name: "fran" })
+    expect(S.is(RenamedFacadeModel)(decoded)).toBe(true)
+    expect(S.is(RenamedFacadeModel)({ internalName: "plain" })).toBe(false)
+    expect(S.is(RenamedFacadeModel)({ external_name: "plain" })).toBe(false)
+  })
+
+  it("keeps generated struct facades decodable with public statics", () => {
+    const input: RequestContext.Encoded = {
+      span: { traceId: "trace", spanId: "span", sampled: true },
+      name: "operation",
+      locale: "en",
+      namespace: "tenant"
+    }
+
+    const decoded = S.decodeSync(RequestContext)(input)
+
+    expect(decoded).not.toBeInstanceOf(RequestContext)
+    expect(S.is(RequestContext)(decoded)).toBe(true)
+    expect(RequestContext.toMonitoring(decoded)).toStrictEqual({ operationName: "operation", locale: "en" })
+  })
+
+  it("keeps error facades class-only", () => {
+    const makeStructErrorFacade = () =>
+      AppSchema.OpaqueErrorFacadeClass<
+        { readonly value: string },
+        { readonly value: string },
+        { readonly value: string },
+        never,
+        never
+      >()(
+        // @ts-expect-error OpaqueErrorFacadeClass requires a class schema.
+        AppSchema.Struct({ value: S.String })
+      )
+
+    expect(makeStructErrorFacade).toThrow("OpaqueErrorFacadeClass requires a class schema")
+  })
+})
+
 describe("Struct.copy", () => {
   it("creates a new value with updated fields", () => {
     const A = AppSchema.Struct({ a: S.String, b: S.Number })