effect 4.0.0-rc.112 → 4.0.0-rc.113

package/src/internal/schema/toEncoderXml.ts

@@ -0,0 +1,110 @@
+import * as Effect from "../../Effect.ts"
+import { format } from "../../Formatter.ts"
+import type * as Schema from "../../Schema.ts"
+import * as SchemaParser from "../../SchemaParser.ts"
+import * as InternalAnnotations from "./annotations.ts"
+import * as InternalToCodec from "./toCodec.ts"
+
+interface XmlEncoderOptions {
+  readonly rootName?: string | undefined
+  readonly arrayItemName?: string | undefined
+  readonly pretty?: boolean | undefined
+  readonly indent?: string | undefined
+  readonly sortKeys?: boolean | undefined
+}
+
+/** @internal */
+export function toEncoderXml<T, RE>(
+  codec: Schema.ConstraintCodec<T, unknown, unknown, RE>,
+  options?: XmlEncoderOptions
+) {
+  const rootName = InternalAnnotations.resolveIdentifier(codec.ast) ?? InternalAnnotations.resolveTitle(codec.ast)
+  const serialize = SchemaParser.encodeEffect(InternalToCodec.toCodecStringTree(codec))
+  return (value: T) =>
+    serialize(value).pipe(Effect.map((stringTree) => stringTreeToXml(stringTree, { rootName, ...options })))
+}
+
+function stringTreeToXml(value: Schema.StringTree, options: XmlEncoderOptions): string {
+  const rootName = options.rootName ?? "root"
+  const arrayItemName = options.arrayItemName ?? "item"
+  const pretty = options.pretty ?? true
+  const indent = options.indent ?? "  "
+  const sortKeys = options.sortKeys ?? true
+
+  const seen = new Set<object>()
+  const lines: Array<string> = []
+
+  recur(rootName, value, 0)
+  return lines.join(pretty ? "\n" : "")
+
+  function push(depth: number, text: string): void {
+    lines.push(pretty ? indent.repeat(depth) + text : text)
+  }
+
+  function recur(tagName: string, node: Schema.StringTree, depth: number, originalNameForMeta?: string): void {
+    const { attrs, safe } = xml.tagInfo(tagName, originalNameForMeta)
+
+    if (node === undefined) {
+      push(depth, `<${safe}${attrs}/>`)
+    } else if (typeof node === "string") {
+      push(depth, `<${safe}${attrs}>${xml.escapeText(node)}</${safe}>`)
+    } else if (typeof node !== "object" || node === null) {
+      push(depth, `<${safe}${attrs}>${xml.escapeText(format(node))}</${safe}>`)
+    } else {
+      if (seen.has(node)) throw new globalThis.Error("Cycle detected while serializing to XML.", { cause: node })
+      seen.add(node)
+      try {
+        if (globalThis.Array.isArray(node)) {
+          if (node.length === 0) {
+            push(depth, `<${safe}${attrs}/>`)
+            return
+          }
+          push(depth, `<${safe}${attrs}>`)
+          for (const item of node) recur(arrayItemName, item, depth + 1)
+          push(depth, `</${safe}>`)
+          return
+        }
+
+        const object = node as Record<string, Schema.StringTree>
+        const keys = Object.keys(object)
+        if (sortKeys) keys.sort()
+
+        if (keys.length === 0) {
+          push(depth, `<${safe}${attrs}/>`)
+          return
+        }
+
+        push(depth, `<${safe}${attrs}>`)
+        for (const key of keys) {
+          recur(xml.parseTagName(key).safe, object[key], depth + 1, key)
+        }
+        push(depth, `</${safe}>`)
+      } finally {
+        seen.delete(node)
+      }
+    }
+  }
+}
+
+const xml = {
+  escapeText(value: string): string {
+    return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;")
+  },
+  escapeAttribute(value: string): string {
+    return value.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;").replace(/>/g, "&gt;")
+  },
+  parseTagName(name: string): { safe: string; changed: boolean } {
+    const original = name
+    let safe = name
+    if (!/^[A-Za-z_]/.test(safe)) safe = "_" + safe
+    safe = safe.replace(/[^A-Za-z0-9._-]/g, "_")
+    if (/^xml/i.test(safe)) safe = "_" + safe
+    return { safe, changed: safe !== original }
+  },
+  tagInfo(name: string, original?: string): { safe: string; attrs: string } {
+    const { changed, safe } = xml.parseTagName(name)
+    const needsMeta = changed || (original && original !== name)
+    const attrs = needsMeta ? ` data-name="${xml.escapeAttribute(original ?? name)}"` : ""
+    return { safe, attrs }
+  }
+}

package/src/internal/schema/toEquivalence.ts

@@ -1,3 +1,4 @@
+import type * as Cause from "../../Cause.ts"
 import * as Equal from "../../Equal.ts"
 import * as Equivalence from "../../Equivalence.ts"
 import { memoize } from "../../Function.ts"
@@ -26,6 +27,7 @@ function recur(ast: SchemaAST.AST, path: ReadonlyArray<PropertyKey>): Equivalenc
     case "Never":
       return Equivalence.strictEqual()
     case "Declaration":
+      return declarationEquivalence(ast, path)
     case "Null":
     case "Undefined":
     case "Void":
@@ -156,3 +158,77 @@ function recur(ast: SchemaAST.AST, path: ReadonlyArray<PropertyKey>): Equivalenc
     }
   }
 }
+
+function declarationEquivalence(
+  ast: SchemaAST.Declaration,
+  path: ReadonlyArray<PropertyKey>
+): Equivalence.Equivalence<any> {
+  const representation = (ast.annotations as Schema.Annotations.Declaration<any> | undefined)?.representation
+  if (representation === undefined) return Equal.equals
+  switch (representation.id) {
+    case "effect/schema/Option": {
+      const [value] = declarationTypeParameters(ast, path)
+      return (a, b) => a._tag === b._tag && (a._tag === "None" || value(a.value, b.value))
+    }
+    case "effect/schema/Result": {
+      const [success, failure] = declarationTypeParameters(ast, path)
+      return (a, b) =>
+        a._tag === b._tag &&
+        (a._tag === "Success" ? success(a.success, b.success) : failure(a.failure, b.failure))
+    }
+    case "effect/schema/CauseReason": {
+      const [error, defect] = declarationTypeParameters(ast, path)
+      return causeReasonEquivalence(error, defect)
+    }
+    case "effect/schema/Cause": {
+      const [error, defect] = declarationTypeParameters(ast, path)
+      return causeEquivalence(error, defect)
+    }
+    case "effect/schema/Exit": {
+      const [value, error, defect] = declarationTypeParameters(ast, path)
+      const cause = causeEquivalence(error, defect)
+      return (a, b) => a._tag === b._tag && (a._tag === "Success" ? value(a.value, b.value) : cause(a.cause, b.cause))
+    }
+    case "effect/schema/ReadonlyMap": {
+      const [key, value] = declarationTypeParameters(ast, path)
+      return Equal.makeCompareMap(key, value)
+    }
+    case "effect/schema/ReadonlySet":
+      return Equal.makeCompareSet(declarationTypeParameters(ast, path)[0])
+    case "effect/schema/RegExp":
+      return (a: globalThis.RegExp, b: globalThis.RegExp) => a.source === b.source && a.flags === b.flags
+    case "effect/schema/URL":
+      return (a: globalThis.URL, b: globalThis.URL) => a.toString() === b.toString()
+    default:
+      return Equal.equals
+  }
+}
+
+function declarationTypeParameters(ast: SchemaAST.Declaration, path: ReadonlyArray<PropertyKey>) {
+  return ast.typeParameters.map((parameter) => recur(parameter, path))
+}
+
+function causeReasonEquivalence<E>(
+  error: Equivalence.Equivalence<E>,
+  defect: Equivalence.Equivalence<unknown>
+): Equivalence.Equivalence<Cause.Reason<E>> {
+  return (a, b) => {
+    if (a._tag !== b._tag) return false
+    switch (a._tag) {
+      case "Fail":
+        return error(a.error, (b as Cause.Fail<E>).error)
+      case "Die":
+        return defect(a.defect, (b as Cause.Die).defect)
+      case "Interrupt":
+        return a.fiberId === (b as Cause.Interrupt).fiberId
+    }
+  }
+}
+
+function causeEquivalence<E>(
+  error: Equivalence.Equivalence<E>,
+  defect: Equivalence.Equivalence<unknown>
+): Equivalence.Equivalence<Cause.Cause<E>> {
+  const reasons = Equivalence.Array(causeReasonEquivalence(error, defect))
+  return (a, b) => reasons(a.reasons, b.reasons)
+}

package/src/internal/schema/toFormatter.ts

@@ -0,0 +1,230 @@
+import type * as Cause from "../../Cause.ts"
+import * as Chunk from "../../Chunk.ts"
+import type * as Exit from "../../Exit.ts"
+import type { Formatter } from "../../Formatter.ts"
+import { format, formatPropertyKey } from "../../Formatter.ts"
+import * as HashMap from "../../HashMap.ts"
+import * as HashSet from "../../HashSet.ts"
+import * as Option from "../../Option.ts"
+import * as Result from "../../Result.ts"
+import type * as Schema from "../../Schema.ts"
+import * as SchemaAST from "../../SchemaAST.ts"
+import * as SchemaParser from "../../SchemaParser.ts"
+import * as InternalAnnotations from "./annotations.ts"
+
+function causeReasonToFormatter<E>(error: Formatter<E>, defect: Formatter<unknown>) {
+  return (reason: Cause.Reason<E>) => {
+    switch (reason._tag) {
+      case "Fail":
+        return `Fail(${error(reason.error)})`
+      case "Die":
+        return `Die(${defect(reason.defect)})`
+      case "Interrupt":
+        return "Interrupt"
+    }
+  }
+}
+
+function causeToFormatter<E>(error: Formatter<E>, defect: Formatter<unknown>) {
+  const causeReason = causeReasonToFormatter(error, defect)
+  return (cause: Cause.Cause<E>) => `Cause([${cause.reasons.map(causeReason).join(", ")}])`
+}
+
+/** @internal */
+export function toFormatter<T>(ast: SchemaAST.AST, options?: {
+  readonly onBefore?:
+    | ((ast: SchemaAST.AST, recur: (ast: SchemaAST.AST) => Formatter<any>) => Formatter<any> | undefined)
+    | undefined
+}): Formatter<T> {
+  return recur(ast)
+
+  function recur(ast: SchemaAST.AST): Formatter<any> {
+    const annotation = InternalAnnotations.resolve(ast)?.["toFormatter"]
+    if (typeof annotation === "function") {
+      return annotation(SchemaAST.isDeclaration(ast) ? ast.typeParameters.map(recur) : [])
+    }
+    if (options?.onBefore) {
+      const onBefore = options.onBefore(ast, recur)
+      if (onBefore !== undefined) {
+        return onBefore
+      }
+    }
+    return on(ast)
+  }
+
+  function on(ast: SchemaAST.AST): Formatter<any> {
+    switch (ast._tag) {
+      default:
+        return format
+      case "Never":
+        return () => "never"
+      case "Void":
+        return () => "void"
+      case "Declaration": {
+        const representation = (ast.annotations as Schema.Annotations.Declaration<any> | undefined)?.representation
+        if (representation === undefined) return format
+        const typeParameters = ast.typeParameters.map(recur)
+        switch (representation.id) {
+          case "effect/schema/Option": {
+            const [value] = typeParameters
+            return Option.match({
+              onNone: () => "none()",
+              onSome: (value_) => `some(${value(value_)})`
+            })
+          }
+          case "effect/schema/Result": {
+            const [success, failure] = typeParameters
+            return Result.match({
+              onSuccess: (value) => `success(${success(value)})`,
+              onFailure: (error) => `failure(${failure(error)})`
+            })
+          }
+          case "effect/schema/CauseReason":
+            return causeReasonToFormatter(typeParameters[0], typeParameters[1])
+          case "effect/schema/Cause":
+            return causeToFormatter(typeParameters[0], typeParameters[1])
+          case "effect/schema/Exit": {
+            const [value, error, defect] = typeParameters
+            const cause = causeToFormatter(error, defect)
+            return (exit: Exit.Exit<unknown, unknown>) => {
+              switch (exit._tag) {
+                case "Success":
+                  return `Exit.Success(${value(exit.value)})`
+                case "Failure":
+                  return `Exit.Failure(${cause(exit.cause)})`
+              }
+            }
+          }
+          case "effect/schema/ReadonlyMap": {
+            const [key, value] = typeParameters
+            return (map: globalThis.ReadonlyMap<unknown, unknown>) => {
+              const size = map.size
+              if (size === 0) return "ReadonlyMap(0) {}"
+              const entries = globalThis.Array.from(map.entries()).sort().map(([key_, value_]) =>
+                `${key(key_)} => ${value(value_)}`
+              )
+              return `ReadonlyMap(${size}) { ${entries.join(", ")} }`
+            }
+          }
+          case "effect/schema/HashMap": {
+            const [key, value] = typeParameters
+            return (map: HashMap.HashMap<unknown, unknown>) => {
+              const size = HashMap.size(map)
+              if (size === 0) return "HashMap(0) {}"
+              const entries = HashMap.toEntries(map).sort().map(([key_, value_]) => `${key(key_)} => ${value(value_)}`)
+              return `HashMap(${size}) { ${entries.join(", ")} }`
+            }
+          }
+          case "effect/schema/ReadonlySet": {
+            const [value] = typeParameters
+            return (set: globalThis.ReadonlySet<unknown>) => {
+              const size = set.size
+              if (size === 0) return "ReadonlySet(0) {}"
+              const values = globalThis.Array.from(set.values()).sort().map((item) => `${value(item)}`)
+              return `ReadonlySet(${size}) { ${values.join(", ")} }`
+            }
+          }
+          case "effect/schema/HashSet": {
+            const [value] = typeParameters
+            return (set: HashSet.HashSet<unknown>) => {
+              const size = HashSet.size(set)
+              if (size === 0) return "HashSet(0) {}"
+              const values = globalThis.Array.from(set).sort().map((item) => `${value(item)}`)
+              return `HashSet(${size}) { ${values.join(", ")} }`
+            }
+          }
+          case "effect/schema/Chunk": {
+            const [value] = typeParameters
+            return (chunk: Chunk.Chunk<unknown>) => {
+              const size = Chunk.size(chunk)
+              if (size === 0) return "Chunk(0) {}"
+              const values = globalThis.Array.from(chunk).sort().map((item) => `${value(item)}`)
+              return `Chunk(${size}) { ${values.join(", ")} }`
+            }
+          }
+          default:
+            return format
+        }
+      }
+      case "Arrays": {
+        const elements = ast.elements.map((element) => recur(element))
+        const rest = ast.rest.map(recur)
+        return (value) => {
+          const out: Array<string> = []
+          let i = 0
+          for (; i < elements.length; i++) {
+            if (value.length < i + 1) {
+              if (SchemaAST.isOptional(ast.elements[i])) {
+                continue
+              }
+            } else {
+              out.push(elements[i](value[i]))
+            }
+          }
+          if (rest.length > 0) {
+            const [head, ...tail] = rest
+            for (; i < value.length - tail.length; i++) {
+              out.push(head(value[i]))
+            }
+            for (let j = 0; j < tail.length; j++) {
+              out.push(tail[j](value[i + j]))
+            }
+          }
+          return "[" + out.join(", ") + "]"
+        }
+      }
+      case "Objects": {
+        const propertySignatures = ast.propertySignatures.map((signature) => recur(signature.type))
+        const indexSignatures = ast.indexSignatures.map((signature) => recur(signature.type))
+        if (ast.propertySignatures.length === 0 && ast.indexSignatures.length === 0) {
+          return format
+        }
+        return (value) => {
+          const out: Array<string> = []
+          const visited = new Set<PropertyKey>()
+          for (let i = 0; i < propertySignatures.length; i++) {
+            const signature = ast.propertySignatures[i]
+            const name = signature.name
+            visited.add(name)
+            if (SchemaAST.isOptional(signature.type) && !Object.hasOwn(value, name)) {
+              continue
+            }
+            out.push(`${formatPropertyKey(name)}: ${propertySignatures[i](value[name])}`)
+          }
+          for (let i = 0; i < indexSignatures.length; i++) {
+            const keys = SchemaAST.getIndexSignatureKeys(value, ast.indexSignatures[i].parameter)
+            for (const key of keys) {
+              if (visited.has(key)) {
+                continue
+              }
+              visited.add(key)
+              out.push(`${formatPropertyKey(key)}: ${indexSignatures[i](value[key])}`)
+            }
+          }
+          return out.length > 0 ? "{ " + out.join(", ") + " }" : "{}"
+        }
+      }
+      case "Union": {
+        const types = SchemaAST.toType(ast).types
+        const getCandidates = (value: any) => SchemaAST.getCandidates(value, types)
+        const compiled = new Map(
+          types.map((candidate, i) => [candidate, [SchemaParser._is(candidate), recur(ast.types[i])] as const] as const)
+        )
+        return (value) => {
+          const candidates = getCandidates(value)
+          for (let i = 0; i < candidates.length; i++) {
+            const [is, formatter] = compiled.get(candidates[i])!
+            if (is(value)) {
+              return formatter(value)
+            }
+          }
+          return format(value)
+        }
+      }
+      case "Suspend": {
+        const get = SchemaAST.memoizeThunk(() => recur(ast.thunk()))
+        return (value) => get()(value)
+      }
+    }
+  }
+}

package/src/internal/schema/toIso.ts

@@ -0,0 +1,20 @@
+import * as Optic from "../../Optic.ts"
+import type * as Schema from "../../Schema.ts"
+import * as SchemaParser from "../../SchemaParser.ts"
+import * as InternalToCodec from "./toCodec.ts"
+
+/** @internal */
+export function toIso<S extends Schema.Constraint>(schema: S): Optic.Iso<S["Type"], S["Iso"]> {
+  const serializer = InternalToCodec.toCodecIso(schema)
+  return Optic.makeIso(SchemaParser.encodeSync(serializer), SchemaParser.decodeSync(serializer))
+}
+
+/** @internal */
+export function toIsoSource<S extends Schema.Constraint>(_: S): Optic.Iso<S["Type"], S["Type"]> {
+  return Optic.id()
+}
+
+/** @internal */
+export function toIsoFocus<S extends Schema.Constraint>(_: S): Optic.Iso<S["Iso"], S["Iso"]> {
+  return Optic.id()
+}