effect-app 4.0.0-beta.15 → 4.0.0-beta.151

package/src/Schema/strings.ts

@@ -9,9 +9,8 @@ export type NonEmptyString = string & NonEmptyStringBrand
 export const NonEmptyString = S
   .NonEmptyString
   .pipe(
-    fromBrand(nominal<NonEmptyString>(), {
+    fromBrand<NonEmptyString>(nominal<NonEmptyString>(), {
       identifier: "NonEmptyString",
-      title: "NonEmptyString",
       jsonSchema: {}
     }),
     withDefaultMake
@@ -23,9 +22,8 @@ export const NonEmptyString64k = S
   .NonEmptyString
   .pipe(
     S.check(S.isMaxLength(64 * 1024)),
-    fromBrand(nominal<NonEmptyString64k>(), {
+    fromBrand<NonEmptyString64k>(nominal<NonEmptyString64k>(), {
       identifier: "NonEmptyString64k",
-      title: "NonEmptyString64k",
       jsonSchema: {}
     }),
     withDefaultMake
@@ -37,9 +35,8 @@ export const NonEmptyString2k = S
   .NonEmptyString
   .pipe(
     S.check(S.isMaxLength(2 * 1024)),
-    fromBrand(nominal<NonEmptyString2k>(), {
+    fromBrand<NonEmptyString2k>(nominal<NonEmptyString2k>(), {
       identifier: "NonEmptyString2k",
-      title: "NonEmptyString2k",
       jsonSchema: {}
     }),
     withDefaultMake
@@ -51,9 +48,8 @@ export const NonEmptyString255 = S
   .NonEmptyString
   .pipe(
     S.check(S.isMaxLength(255)),
-    fromBrand(nominal<NonEmptyString255>(), {
+    fromBrand<NonEmptyString255>(nominal<NonEmptyString255>(), {
       identifier: "NonEmptyString255",
-      title: "NonEmptyString255",
       jsonSchema: {}
     }),
     withDefaultMake

package/src/Schema.ts

@@ -1,22 +1,19 @@
-import { Array, Option, pipe, SchemaAST, type Tracer } from "effect"
+import { SchemaAST, type Tracer } from "effect"
 import * as S from "effect/Schema"
 import type { NonEmptyReadonlyArray } from "./Array.js"
 import { fakerArb } from "./faker.js"
 import { Email as EmailT, type Email as EmailType } from "./Schema/email.js"
-import { withDefaultMake } from "./Schema/ext.js"
+import { concurrencyUnbounded, withDefaultMake } from "./Schema/ext.js"
 import { PhoneNumber as PhoneNumberT, type PhoneNumber as PhoneNumberType } from "./Schema/phoneNumber.js"
-import type { AST } from "./Schema/schema.js"
-import { extendM } from "./utils.js"
+import { copy, extendM, type StructuralCopyOrigin } from "./utils.js"
 
 export * from "effect/Schema"
-// v4: TaggedError renamed to TaggedErrorClass
-export { TaggedErrorClass as TaggedError } from "effect/Schema"
 
 export * from "./Schema/Class.js"
-export { Class, TaggedClass } from "./Schema/Class.js"
+export { Class, ErrorClass, Opaque, TaggedClass, TaggedErrorClass } from "./Schema/Class.js"
 
 export { fromBrand, nominal } from "./Schema/brand.js"
-export { Array, Boolean, Date, Literal, Map, NullOr, Number, ReadonlyMap, ReadonlySet } from "./Schema/ext.js"
+export { Array, Boolean, Date, DateFromString, DateValid, Finite, Literals, NullOr, Number, ReadonlyMap, ReadonlySet } from "./Schema/ext.js"
 export { Int, NonNegativeInt } from "./Schema/numbers.js"
 
 export * from "./Schema/email.js"
@@ -25,6 +22,8 @@ export * from "./Schema/moreStrings.js"
 export * from "./Schema/numbers.js"
 export * from "./Schema/phoneNumber.js"
 export * from "./Schema/schema.js"
+export * from "./Schema/SpecialJsonSchema.js"
+export * from "./Schema/SpecialOpenApi.js"
 export * from "./Schema/strings.js"
 export { NonEmptyString } from "./Schema/strings.js"
 
@@ -33,6 +32,128 @@ export * as SchemaParser from "effect/SchemaParser"
 
 export { Void as Void_ } from "effect/Schema"
 
+// ---------------------------------------------------------------------------
+// Struct / NonEmptyArray / Record — with concurrency: "unbounded"
+// ---------------------------------------------------------------------------
+
+type WithSchemaCopy<Self extends S.Top & { readonly Type: object }> = Self & {
+  readonly copy: StructuralCopyOrigin<Self["Type"]>
+}
+
+type OptionalMakeInput<Fields extends S.Struct.Fields> = {} extends S.Struct.MakeIn<Fields> ? {
+    make(input?: S.Struct.MakeIn<Fields>, options?: S.MakeOptions): S.Struct.Type<Fields>
+  }
+  : {}
+
+export function Struct<const Fields extends S.Struct.Fields>(
+  fields: Fields
+): Struct<Fields> & OptionalMakeInput<Fields> {
+  const result = S.Struct(fields).annotate(concurrencyUnbounded)
+  const allowVoidMake = (schema: any): any => {
+    // Normalize omitted input to an empty object so optional/default-only structs can be constructed with make().
+    const origMake: any = schema.make
+    const origMakeOption: any = schema.makeOption
+    const origMakeEffect: any = schema.makeEffect
+    schema.make = function(this: any, input: any, options?: any) {
+      return origMake.call(this, input === undefined ? {} : input, options)
+    }
+    schema.makeOption = function(this: any, input: any, options?: any) {
+      return origMakeOption.call(this, input === undefined ? {} : input, options)
+    }
+    schema.makeEffect = function(this: any, input: any, options?: any) {
+      return origMakeEffect.call(this, input === undefined ? {} : input, options)
+    }
+    return schema
+  }
+  // eslint-disable-next-line @typescript-eslint/unbound-method, @typescript-eslint/no-unsafe-assignment
+  const origMapFields: any = result.mapFields
+  // eslint-disable-next-line @typescript-eslint/unbound-method, @typescript-eslint/no-unsafe-assignment
+  const origAnnotate: any = result.annotate
+  // eslint-disable-next-line @typescript-eslint/unbound-method, @typescript-eslint/no-unsafe-assignment
+  const origAnnotateKey: any = result.annotateKey
+
+  const preserveCopyAndMethods = (schema: any): any => {
+    schema.copy = copy
+    schema.mapFields = function(this: any, f: any, options?: any) {
+      return (result as any).mapFields.call(this, f, options)
+    }
+    schema.annotate = function(this: any, annotations?: any) {
+      return (result as any).annotate.call(this, annotations)
+    }
+    schema.annotateKey = function(this: any, annotations?: any) {
+      return (result as any).annotateKey.call(this, annotations)
+    }
+    return allowVoidMake(schema)
+  }
+  ;(result as any).mapFields = function(this: any, f: any, options?: any) {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-call
+    const mapped = origMapFields.call(this, f, options).annotate(concurrencyUnbounded)
+    return preserveCopyAndMethods(mapped)
+  }
+  ;(result as any).annotate = function(this: any, annotations?: any) {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-call
+    const annotated = origAnnotate.call(this, annotations)
+    return preserveCopyAndMethods(annotated)
+  }
+  ;(result as any).annotateKey = function(this: any, annotations?: any) {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-call
+    const annotated = origAnnotateKey.call(this, annotations)
+    return preserveCopyAndMethods(annotated)
+  }
+  ;(result as any).copy = copy
+  allowVoidMake(result)
+  return result as Struct<Fields> & OptionalMakeInput<Fields>
+}
+export interface Struct<Fields extends S.Struct.Fields> extends WithSchemaCopy<S.Struct<Fields>> {
+  annotate(
+    annotations: S.Annotations.Bottom<S.Struct.Type<Fields>, S.Struct<Fields>["~type.parameters"]>
+  ): Struct<Fields>
+  annotateKey(annotations: S.Annotations.Key<S.Struct.Type<Fields>>): Struct<Fields>
+  mapFields<To extends S.Struct.Fields>(
+    f: (fields: Fields) => To,
+    options?: {
+      readonly unsafePreserveChecks?: boolean | undefined
+    }
+  ): Struct<Readonly<To>>
+}
+export declare namespace Struct {
+  export type Fields = S.Struct.Fields
+  export type Type<F extends S.Struct.Fields> = S.Struct.Type<F>
+  export type Encoded<F extends S.Struct.Fields> = S.Struct.Encoded<F>
+  export type DecodingServices<F extends S.Struct.Fields> = S.Struct.DecodingServices<F>
+  export type EncodingServices<F extends S.Struct.Fields> = S.Struct.EncodingServices<F>
+  export type MakeIn<F extends S.Struct.Fields> = S.Struct.MakeIn<F>
+  export type Iso<F extends S.Struct.Fields> = S.Struct.Iso<F>
+}
+
+export function NonEmptyArray<Value extends S.Top>(value: Value): S.NonEmptyArray<Value> {
+  return S.NonEmptyArray(value).annotate(concurrencyUnbounded)
+}
+
+export function TaggedStruct<const Tag extends SchemaAST.LiteralValue, const Fields extends S.Struct.Fields>(
+  value: Tag,
+  fields: Fields
+): TaggedStruct<Tag, Fields> {
+  return Struct({ _tag: S.tag(value), ...fields }) as any
+}
+export type TaggedStruct<Tag extends SchemaAST.LiteralValue, Fields extends S.Struct.Fields> =
+  & WithSchemaCopy<
+    S.TaggedStruct<Tag, Fields>
+  >
+  & OptionalMakeInput<Readonly<{ readonly _tag: S.tag<Tag> } & Fields>>
+
+export function Record<Key extends S.Record.Key, Value extends S.Top>(
+  key: Key,
+  value: Value
+): S.$Record<Key, Value> {
+  return S.Record(key, value).annotate(concurrencyUnbounded)
+}
+export declare namespace Record {
+  export type Key = S.Record.Key
+  export type Type<K extends S.Record.Key, V extends S.Top> = S.Record.Type<K, V>
+  export type Encoded<K extends S.Record.Key, V extends S.Top> = S.Record.Encoded<K, V>
+}
+
 export const SpanId = Symbol()
 export type SpanId = typeof SpanId
 
@@ -66,104 +187,141 @@ export const PhoneNumber = PhoneNumberT
 
 export type PhoneNumber = PhoneNumberType
 
-export const makeIs = <A extends { _tag: string }, I, R>(
-  schema: S.Codec<A, I, R>
-) => {
-  // In v4, transformations are stored as encoding on nodes, not as wrapper nodes.
-  // Union member ASTs are directly Objects (TypeLiteral equivalent).
-  if (SchemaAST.isUnion(schema.ast)) {
-    return schema.ast.types.reduce((acc: any, t: AST.AST) => {
-      if (!SchemaAST.isObjects(t)) return acc
-      const tag = Array.findFirst(t.propertySignatures, (_: any) => {
-        if (_.name === "_tag" && SchemaAST.isLiteral(_.type)) {
-          return Option.some(_.type)
-        }
-        return Option.none()
-      })
-      const ast = Option.getOrUndefined(tag)
-      if (!ast) {
-        return acc
-      }
-      return {
-        ...acc,
-        [String((ast as SchemaAST.Literal).literal)]: (x: { _tag: string }) =>
-          x._tag === (ast as SchemaAST.Literal).literal
-      }
-    }, {} as Is<A>)
-  }
-  throw new Error("Unsupported")
+// Copied from SchemaAST.collectSentinels (marked @internal in effect).
+// Returns all { key, literal } pairs that can discriminate a union member.
+const getTagFromAST = (schema: S.Top): string => {
+  const sentinels = collectSentinelsFromAST(schema.ast)
+  const sentinel = sentinels.find((s) => s.key === "_tag")
+  if (sentinel !== undefined && typeof sentinel.literal === "string") return sentinel.literal
+  throw new Error("No _tag literal found on schema member")
 }
 
-export const makeIsAnyOf = <A extends { _tag: string }, I, R>(
-  schema: S.Codec<A, I, R>
-): IsAny<A> => {
-  if (SchemaAST.isUnion(schema.ast)) {
-    return <Keys extends A["_tag"][]>(...keys: Keys) => (a: A): a is ExtractUnion<A, ElemType<Keys>> =>
-      keys.includes(a._tag)
+function collectSentinelsFromAST(
+  ast: SchemaAST.AST
+): Array<{ key: PropertyKey; literal: SchemaAST.LiteralValue | symbol }> {
+  switch (ast._tag) {
+    case "Declaration": {
+      const s = ast.annotations?.["~sentinels"]
+      return Array.isArray(s) ? s : []
+    }
+    case "Objects":
+      return ast.propertySignatures.flatMap(
+        (ps): Array<{ key: PropertyKey; literal: SchemaAST.LiteralValue | symbol }> => {
+          const type = ps.type
+          if (!SchemaAST.isOptional(type)) {
+            if (SchemaAST.isLiteral(type)) return [{ key: ps.name, literal: type.literal }]
+            if (SchemaAST.isUniqueSymbol(type)) return [{ key: ps.name, literal: type.symbol }]
+          }
+          return []
+        }
+      )
+    case "Suspend":
+      return collectSentinelsFromAST(ast.thunk())
+    default:
+      return []
   }
-  throw new Error("Unsupported")
-}
-
-export type ExtractUnion<A extends { _tag: string }, Tags extends A["_tag"]> = Extract<A, Record<"_tag", Tags>>
-export type Is<A extends { _tag: string }> = { [K in A as K["_tag"]]: (a: A) => a is K }
-export type ElemType<A> = A extends Array<infer E> ? E : never
-export interface IsAny<A extends { _tag: string }> {
-  <Keys extends A["_tag"][]>(...keys: Keys): (a: A) => a is ExtractUnion<A, ElemType<Keys>>
 }
 
-export const taggedUnionMap = <
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  Members extends readonly (S.Top & { fields: { _tag: S.tag<string> } })[]
->(
-  self: Members
-) =>
-  self.reduce((acc, key) => {
-    // TODO: v4 migration — PropertySignatureDeclaration removed, need v4 AST traversal
-    const ast = key.fields._tag.ast as any
-    const tag = ((ast.type ?? ast) as SchemaAST.Literal).literal as string // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-member-access
-    acc[tag] = key as any
-    return acc
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  }, {} as any)
-
 export const tags = <
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  Members extends NonEmptyReadonlyArray<(S.Top & { fields: { _tag: S.tag<string> } })>
+  Members extends NonEmptyReadonlyArray<(S.Top & { readonly Type: { readonly _tag: string } })>
 >(
   self: Members
 ) =>
-  S.Literals(self.map((key) => {
-    // TODO: v4 migration — PropertySignatureDeclaration removed, need v4 AST traversal
-    const ast = key.fields._tag.ast as any
-    const tag = ((ast.type ?? ast) as SchemaAST.Literal).literal
-    return tag
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  })) as any
-
-export const ExtendTaggedUnion = <A extends { _tag: string }, I, R>(
-  schema: S.Codec<A, I, R>
-) =>
-  extendM(
-    schema,
-    (_) => ({
-      is: S.is(schema as any),
-      isA: makeIs(_ as any),
-      isAnyOf: makeIsAnyOf(_ as any) /*, map: taggedUnionMap(a) */
-    })
-  )
+  S.Literals(
+    self.map(getTagFromAST) as {
+      [Index in keyof Members]: Members[Index]["Type"]["_tag"]
+    }
+  ) as S.Literals<
+    {
+      [Index in keyof Members]: Members[Index]["Type"]["_tag"]
+    }
+  >
+
+type TaggedUnionMembers = NonEmptyReadonlyArray<
+  S.Top & { readonly Type: { readonly _tag: string } }
+>
+
+type TaggedUnionTags<Members extends TaggedUnionMembers> = S.Literals<
+  {
+    [Index in keyof Members]: Members[Index]["Type"]["_tag"]
+  }
+>
+
+type TaggedPropertyKeys<A, Members extends TaggedUnionMembers> = {
+  [K in keyof A & string]: A[K] extends Members[number]["Type"] ? K : never
+}[keyof A & string]
+
+type PropertyGuardsFor<
+  Members extends TaggedUnionMembers,
+  K extends string,
+  A
+> =
+  & {
+    readonly [M in Members[number] as `is${M["Type"]["_tag"]}`]: (
+      target: A
+    ) => target is A & { readonly [P in K]: M["Type"] }
+  }
+  & {
+    readonly isAnyOf: <const Tags extends ReadonlyArray<Members[number]["Type"]["_tag"]>>(
+      tags: Tags
+    ) => (
+      target: A
+    ) => target is A & { readonly [P in K]: Extract<Members[number]["Type"], { readonly _tag: Tags[number] }> }
+  }
+
+type PropertyGuards<
+  Members extends TaggedUnionMembers,
+  K extends string
+> =
+  & {
+    readonly [M in Members[number] as `is${M["Type"]["_tag"]}`]: <
+      T extends { readonly [P in K]: Members[number]["Type"] }
+    >(target: T) => target is T & { readonly [P in K]: M["Type"] }
+  }
+  & {
+    readonly isAnyOf: <const Tags extends ReadonlyArray<Members[number]["Type"]["_tag"]>>(
+      tags: Tags
+    ) => <T extends { readonly [P in K]: Members[number]["Type"] }>(
+      target: T
+    ) => target is T & { readonly [P in K]: Extract<Members[number]["Type"], { readonly _tag: Tags[number] }> }
+  }
+
+type TaggedUnionWithTags<Members extends TaggedUnionMembers> = S.toTaggedUnion<"_tag", Members> & {
+  readonly tags: TaggedUnionTags<Members>
+  readonly generateGuards: <K extends string>(property: K) => PropertyGuards<Members, K>
+  readonly generateGuardsFor: <A>() => <K extends TaggedPropertyKeys<A, Members>>(
+    property: K
+  ) => PropertyGuardsFor<Members, K, A>
+}
+
+const extendTaggedUnionWithTags = <Members extends TaggedUnionMembers>(
+  schema: S.Union<Members>
+): TaggedUnionWithTags<Members> =>
+  extendM(schema.pipe(S.toTaggedUnion("_tag")), (tagged) => {
+    const makeGuards = (property: string) => {
+      const result: any = {}
+      const guards: Record<string, (u: unknown) => boolean> = tagged.guards
+      for (const tag of Object.keys(guards)) {
+        const guard = guards[tag]!
+        result[`is${tag}`] = (target: any) => guard(target[property])
+      }
+      result.isAnyOf = (memberTags: Array<string>) => {
+        const check = tagged.isAnyOf(memberTags)
+        return (target: any) => check(target[property])
+      }
+      return result
+    }
+    return {
+      tags: tags(schema.members),
+      generateGuards: makeGuards,
+      generateGuardsFor: () => makeGuards
+    }
+  })
+
+export const ExtendTaggedUnion = <Members extends TaggedUnionMembers>(
+  schema: S.Union<Members>
+): TaggedUnionWithTags<Members> => extendTaggedUnionWithTags(schema)
 
 export const TaggedUnion = <
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  Members extends readonly (S.Top & { fields: { _tag: S.tag<any> } })[]
->(...a: Members) =>
-  pipe(
-    S.Union(a),
-    (_) =>
-      extendM(_, (_) => ({
-        is: S.is(_ as any),
-        isA: makeIs(_ as any),
-        isAnyOf: makeIsAnyOf(_ as any),
-        tagMap: taggedUnionMap(a),
-        tags: tags(a as any)
-      }))
-  )
+  Members extends TaggedUnionMembers
+>(...a: Members): TaggedUnionWithTags<Members> => extendTaggedUnionWithTags(S.Union(a))