effect 4.0.0-beta.101 → 4.0.0-beta.103

package/src/internal/schema/fromRepresentation.ts

@@ -0,0 +1,339 @@
+import * as Arr from "../../Array.ts"
+import * as Result from "../../Result.ts"
+import * as Schema from "../../Schema.ts"
+import type * as SchemaAST from "../../SchemaAST.ts"
+import type * as SchemaRepresentation from "../../SchemaRepresentation.ts"
+import { errorWithPath } from "../errors.ts"
+import * as InternalRecord from "../record.ts"
+
+type Path = ReadonlyArray<string | number>
+
+/** @internal */
+export function fromRepresentations(
+  document: SchemaRepresentation.MultiDocument,
+  revivers: ReadonlyArray<SchemaRepresentation.AnyReviver>
+): readonly [Schema.Top, ...Array<Schema.Top>] {
+  return revivePersisted(document.representations, document.references, makeReviverMap(revivers), false)
+}
+
+class ReferenceSlot {
+  body: Schema.Top | undefined
+  resolving = false
+  readonly wrapper: Schema.Top
+
+  constructor(key: string) {
+    this.wrapper = Schema.suspend(() => {
+      if (this.body === undefined) {
+        throw new Error(`Reference ${key} was evaluated before it was resolved`)
+      }
+      return this.body
+    })
+  }
+}
+
+function makeReviverMap(
+  revivers: ReadonlyArray<SchemaRepresentation.AnyReviver>
+): Map<string, SchemaRepresentation.AnyReviver> {
+  const out = new Map<string, SchemaRepresentation.AnyReviver>()
+
+  for (let index = 0; index < revivers.length; index++) {
+    const reviver = revivers[index]
+    if (out.has(reviver.id)) {
+      throw errorWithPath(`Duplicate reviver for ${reviver.id}`, ["revivers", index, "id"])
+    }
+    out.set(reviver.id, {
+      ...reviver,
+      payloadSchema: Schema.toCodecJson(reviver.payloadSchema)
+    })
+  }
+
+  return out
+}
+
+function revivePersisted(
+  representations: readonly [
+    SchemaRepresentation.Representation,
+    ...Array<SchemaRepresentation.Representation>
+  ],
+  references: SchemaRepresentation.References,
+  reviverMap: ReadonlyMap<string, SchemaRepresentation.AnyReviver>,
+  singleRoot: boolean
+): readonly [Schema.Top, ...Array<Schema.Top>] {
+  const slots = new Map<string, ReferenceSlot>()
+
+  function resolveReference(key: string, path: Path): Schema.Top {
+    let slot = slots.get(key)
+    if (slot === undefined) {
+      if (!Object.hasOwn(references, key)) {
+        throw errorWithPath(`Invalid reference ${key}`, [...path, "$ref"])
+      }
+      slot = new ReferenceSlot(key)
+      slots.set(key, slot)
+    }
+    if (slot.body !== undefined) {
+      return slot.body
+    }
+    if (slot.resolving) {
+      return slot.wrapper
+    }
+
+    slot.resolving = true
+    try {
+      slot.body = annotate(recur(references[key], ["references", key]), { identifier: key })
+      return slot.body
+    } finally {
+      slot.resolving = false
+    }
+  }
+
+  function resolveReviver<R extends SchemaRepresentation.AnyReviver>(
+    representation: SchemaRepresentation.RepresentationAnnotation,
+    path: Path
+  ): R {
+    const reviver = reviverMap.get(representation.id)
+    if (reviver === undefined) {
+      throw errorWithPath(`Missing reviver for ${representation.id}`, path)
+    }
+    return reviver as R
+  }
+
+  function decodePayload(
+    representation: SchemaRepresentation.RepresentationAnnotation,
+    reviver: SchemaRepresentation.AnyReviver,
+    path: Path
+  ): any {
+    const decoded = Schema.decodeUnknownResult(reviver.payloadSchema)(representation.payload)
+    if (Result.isFailure(decoded)) {
+      throw errorWithPath(`Invalid representation payload for ${representation.id}`, path)
+    }
+    return decoded.success
+  }
+
+  function reviveSchemas(
+    representations: ReadonlyArray<SchemaRepresentation.Representation>,
+    path: Path
+  ): ReadonlyArray<Schema.Top> {
+    return representations.map((representation, index) => recur(representation, [...path, index]))
+  }
+
+  function reviveDeclaration(
+    declaration: SchemaRepresentation.Declaration,
+    path: Path
+  ): Schema.Top {
+    const representationPath = [...path, "representation"]
+    const representation = declaration.representation
+    if (representation === undefined) {
+      throw errorWithPath("Missing representation annotation", representationPath)
+    }
+    const reviver = resolveReviver<SchemaRepresentation.DeclarationReviver<any>>(representation, representationPath)
+    const payload = decodePayload(representation, reviver, [...representationPath, "payload"])
+    const typeParameters = reviveSchemas(declaration.typeParameters, [...path, "typeParameters"])
+    const schema = reviver.revive({ payload, typeParameters, annotations: declaration.annotations })
+    return appendChecks(schema, declaration.checks, [...path, "checks"])
+  }
+
+  function reviveFilter(
+    filter: SchemaRepresentation.Filter,
+    path: Path
+  ): SchemaAST.Filter<any> {
+    const representationPath = [...path, "representation"]
+    const representation = filter.representation
+    if (representation === undefined) {
+      throw errorWithPath("Missing representation annotation", representationPath)
+    }
+    const reviver = resolveReviver<SchemaRepresentation.FilterReviver<any>>(representation, representationPath)
+    const payload = decodePayload(representation, reviver, [...representationPath, "payload"])
+    const schemas = reviveSchemas(representation.schemas ?? [], [...representationPath, "schemas"])
+    const check = reviver.revive({ payload, schemas, annotations: filter.annotations })
+    return filter.aborted ? check.abort() : check
+  }
+
+  function reviveFilterGroup(
+    group: SchemaRepresentation.FilterGroup,
+    path: Path
+  ): SchemaAST.FilterGroup<any> {
+    const representationPath = [...path, "representation"]
+    const representation = group.representation
+    if (representation === undefined) {
+      const checks = group.checks.map((check, index) => reviveCheck(check, [...path, "checks", index]))
+      return Schema.makeFilterGroup(
+        checks as [SchemaAST.Check<any>, ...Array<SchemaAST.Check<any>>],
+        group.annotations as Schema.Annotations.Filter | undefined
+      )
+    }
+
+    const reviver = resolveReviver<SchemaRepresentation.FilterGroupReviver<any>>(representation, representationPath)
+    const payload = decodePayload(representation, reviver, [...representationPath, "payload"])
+    const schemas = reviveSchemas(representation.schemas ?? [], [...representationPath, "schemas"])
+    return reviver.revive({ payload, schemas, annotations: group.annotations })
+  }
+
+  function reviveCheck(
+    check: SchemaRepresentation.Check,
+    path: Path
+  ): SchemaAST.Check<any> {
+    return check._tag === "Filter"
+      ? reviveFilter(check, path)
+      : reviveFilterGroup(check, path)
+  }
+
+  function appendChecks<S extends Schema.Top>(
+    schema: S,
+    checks: ReadonlyArray<SchemaRepresentation.Check>,
+    path: Path
+  ): S["Rebuild"] {
+    const revived = checks.map((check, index) => reviveCheck(check, [...path, index]))
+    return Arr.isArrayNonEmpty(revived) ? schema.check(...revived) : schema as S["Rebuild"]
+  }
+
+  function annotate(
+    schema: Schema.Top,
+    annotations: Schema.Annotations.Annotations | undefined
+  ): Schema.Top {
+    return annotations === undefined ? schema : schema.annotate(annotations)
+  }
+
+  function finishStructural(
+    schema: Schema.Top,
+    representation: Exclude<SchemaRepresentation.Representation, SchemaRepresentation.Reference>,
+    path: Path
+  ): Schema.Top {
+    return appendChecks(
+      annotate(schema, representation.annotations),
+      representation.checks,
+      [...path, "checks"]
+    )
+  }
+
+  function recur(
+    representation: SchemaRepresentation.Representation,
+    path: Path
+  ): Schema.Top {
+    switch (representation._tag) {
+      case "Reference":
+        return resolveReference(representation.$ref, path)
+      case "Declaration":
+        return reviveDeclaration(representation, path)
+      case "Suspend": {
+        const thunkPath = [...path, "thunk"]
+        if (representation.thunk._tag === "Reference") {
+          const key = representation.thunk.$ref
+          resolveReference(key, thunkPath)
+          const slot = slots.get(key)!
+          return annotate(slot.wrapper, representation.annotations)
+        }
+        const thunk = recur(representation.thunk, thunkPath)
+        return annotate(Schema.suspend(() => thunk), representation.annotations)
+      }
+      case "Null":
+        return finishStructural(Schema.Null, representation, path)
+      case "Undefined":
+        return finishStructural(Schema.Undefined, representation, path)
+      case "Void":
+        return finishStructural(Schema.Void, representation, path)
+      case "Never":
+        return finishStructural(Schema.Never, representation, path)
+      case "Unknown":
+        return finishStructural(Schema.Unknown, representation, path)
+      case "Any":
+        return finishStructural(Schema.Any, representation, path)
+      case "String":
+        return finishStructural(Schema.String, representation, path)
+      case "Number":
+        return finishStructural(Schema.Number, representation, path)
+      case "Boolean":
+        return finishStructural(Schema.Boolean, representation, path)
+      case "BigInt":
+        return finishStructural(Schema.BigInt, representation, path)
+      case "Symbol":
+        return finishStructural(Schema.Symbol, representation, path)
+      case "Literal":
+        return finishStructural(Schema.Literal(representation.literal), representation, path)
+      case "UniqueSymbol":
+        return finishStructural(Schema.UniqueSymbol(representation.symbol), representation, path)
+      case "ObjectKeyword":
+        return finishStructural(Schema.ObjectKeyword, representation, path)
+      case "Enum":
+        return finishStructural(
+          Schema.Enum(Object.fromEntries(representation.enums)),
+          representation,
+          path
+        )
+      case "TemplateLiteral": {
+        const parts = representation.parts.map((part, index) => recur(part, [...path, "parts", index]))
+        return finishStructural(
+          Schema.TemplateLiteral(parts as unknown as Schema.TemplateLiteral.Parts),
+          representation,
+          path
+        )
+      }
+      case "Arrays": {
+        const elements = representation.elements.map((element, index) => {
+          let schema = recur(element.type, [...path, "elements", index, "type"])
+          if (element.annotations !== undefined) {
+            schema = schema.annotateKey(element.annotations as Schema.Annotations.Key<unknown>)
+          }
+          return element.isOptional ? Schema.optionalKey(schema) : schema
+        })
+        const rest = representation.rest.map((item, index) => recur(item, [...path, "rest", index]))
+        const schema = Arr.isArrayNonEmpty(rest)
+          ? elements.length === 0 && rest.length === 1
+            ? Schema.Array(rest[0])
+            : Schema.TupleWithRest(Schema.Tuple(elements), rest)
+          : Schema.Tuple(elements)
+        return finishStructural(schema, representation, path)
+      }
+      case "Objects": {
+        const fields: Record<PropertyKey, Schema.Top> = {}
+        for (let index = 0; index < representation.propertySignatures.length; index++) {
+          const property = representation.propertySignatures[index]
+          let schema = recur(property.type, [...path, "propertySignatures", index, "type"])
+          if (property.annotations !== undefined) {
+            schema = schema.annotateKey(property.annotations as Schema.Annotations.Key<unknown>)
+          }
+          if (property.isOptional) {
+            schema = Schema.optionalKey(schema)
+          }
+          if (property.isMutable) {
+            schema = Schema.mutableKey(schema)
+          }
+          InternalRecord.assignProperty(fields, property.name, schema)
+        }
+        const records = representation.indexSignatures.map((indexSignature, index) =>
+          Schema.Record(
+            recur(indexSignature.parameter, [...path, "indexSignatures", index, "parameter"]) as Schema.Record.Key,
+            recur(indexSignature.type, [...path, "indexSignatures", index, "type"])
+          )
+        )
+        const schema = Arr.isArrayNonEmpty(records)
+          ? representation.propertySignatures.length === 0 && records.length === 1
+            ? records[0]
+            : Schema.StructWithRest(Schema.Struct(fields), records)
+          : Schema.Struct(fields)
+        return finishStructural(schema, representation, path)
+      }
+      case "Union": {
+        const members = representation.types.map((member, index) => recur(member, [...path, "types", index]))
+        return finishStructural(Schema.Union(members, { mode: representation.mode }), representation, path)
+      }
+    }
+  }
+
+  const schemas = representations.map((representation, index) =>
+    recur(representation, singleRoot ? ["representation"] : ["representations", index])
+  ) as [Schema.Top, ...Array<Schema.Top>]
+  return schemas
+}
+
+/** @internal */
+export function fromRepresentation(
+  document: SchemaRepresentation.Document,
+  revivers: ReadonlyArray<SchemaRepresentation.AnyReviver>
+): Schema.Top {
+  return revivePersisted(
+    [document.representation],
+    document.references,
+    makeReviverMap(revivers),
+    true
+  )[0]
+}

package/src/internal/schema/parser.ts

@@ -0,0 +1,22 @@
+import * as Exit from "../../Exit.ts"
+import * as Option from "../../Option.ts"
+import { args } from "../core.ts"
+
+export const missing = Symbol()
+
+export { args }
+
+export type Success<A, E = never> = Exit.Success<A, E> & { readonly [args]: A }
+
+export const succeed = Exit.succeed as <A>(value: A) => Success<A>
+
+export const missingExit = succeed(missing)
+
+// Shared success for a present input returned unchanged. It must be resolved
+// before crossing an asynchronous or transformation boundary.
+export const sameExit: Success<unknown> = succeed(missing)
+
+export const toOption = <A>(value: A): Option.Option<A> => value === missing ? Option.none() : Option.some(value as A)
+
+export const fromOptionExit = <A>(option: Option.Option<A>): Success<A | typeof missing> =>
+  option._tag === "None" ? missingExit : succeed(option.value)

package/src/internal/schema/schema.ts

@@ -6,10 +6,50 @@ import * as SchemaAST from "../../SchemaAST.ts"
 import { SchemaError } from "../../SchemaError.ts"
 import type { Issue } from "../../SchemaIssue.ts"
 import * as SchemaParser from "../../SchemaParser.ts"
+import type * as SchemaRepresentation from "../../SchemaRepresentation.ts"
 
 /** @internal */
 export const TypeId = "~effect/Schema/Schema"
 
+/** @internal */
+export function makeDeclarationReviver<P>(
+  id: string,
+  payloadSchema: Schema.Decoder<P>,
+  revive: SchemaRepresentation.DeclarationReviver<P>["revive"]
+): SchemaRepresentation.DeclarationReviver<P> {
+  return {
+    id,
+    payloadSchema,
+    revive
+  }
+}
+
+/** @internal */
+export function makeFilterReviver<P>(
+  id: string,
+  payloadSchema: Schema.Decoder<P>,
+  revive: SchemaRepresentation.FilterReviver<P>["revive"]
+): SchemaRepresentation.FilterReviver<P> {
+  return {
+    id,
+    payloadSchema,
+    revive
+  }
+}
+
+/** @internal */
+export function makeFilterGroupReviver<P>(
+  id: string,
+  payloadSchema: Schema.Decoder<P>,
+  revive: SchemaRepresentation.FilterGroupReviver<P>["revive"]
+): SchemaRepresentation.FilterGroupReviver<P> {
+  return {
+    id,
+    payloadSchema,
+    revive
+  }
+}
+
 const SchemaProto = {
   [TypeId]: TypeId,
   pipe() {
@@ -28,10 +68,11 @@ const SchemaProto = {
 
 /** @internal */
 export function make<S extends Schema.Constraint>(ast: S["ast"], options?: object): S {
-  const self = Object.create(SchemaProto)
-  if (options) {
-    Object.assign(self, options)
-  }
+  function Schema() {}
+  const self = Object.defineProperties(
+    Object.setPrototypeOf(Schema, SchemaProto),
+    Object.getOwnPropertyDescriptors({ ...options })
+  )
   self.ast = ast
   self.rebuild = (ast: SchemaAST.AST) => make(ast, options)
   const makeEffect = SchemaParser.makeEffect(self)
@@ -51,45 +92,3 @@ export function fromIssueEffect<A, R>(
     (cause) => Effect.failCauseSync(() => Cause.map(cause, (issue) => new SchemaError(issue)))
   )
 }
-
-/** @internal */
-export const jsonReorder = makeReorder(getJsonPriority)
-
-function getJsonPriority(ast: SchemaAST.AST): number {
-  switch (ast._tag) {
-    case "BigInt":
-    case "Symbol":
-    case "UniqueSymbol":
-      return 0
-    default:
-      return 1
-  }
-}
-
-/** @internal */
-export function makeReorder(getPriority: (ast: SchemaAST.AST) => number) {
-  return (types: ReadonlyArray<SchemaAST.AST>): ReadonlyArray<SchemaAST.AST> => {
-    // Create a map of original indices for O(1) lookup
-    const indexMap = new Map<SchemaAST.AST, number>()
-    for (let i = 0; i < types.length; i++) {
-      indexMap.set(SchemaAST.toEncoded(types[i]), i)
-    }
-
-    // Create a sorted copy of the types array
-    const sortedTypes = [...types].sort((a, b) => {
-      a = SchemaAST.toEncoded(a)
-      b = SchemaAST.toEncoded(b)
-      const pa = getPriority(a)
-      const pb = getPriority(b)
-      if (pa !== pb) return pa - pb
-      // If priorities are equal, maintain original order (stable sort)
-      return indexMap.get(a)! - indexMap.get(b)!
-    })
-
-    // Check if order changed by comparing arrays
-    const orderChanged = sortedTypes.some((ast, index) => ast !== types[index])
-
-    if (!orderChanged) return types
-    return sortedTypes
-  }
-}

package/src/internal/schema/{arbitrary.ts → toArbitrary.ts}

@@ -13,6 +13,7 @@ import * as Struct from "../../Struct.ts"
 import type * as FastCheck from "../../testing/FastCheck.ts"
 import * as UndefinedOr from "../../UndefinedOr.ts"
 import { errorWithPath } from "../errors.ts"
+import * as InternalRecord from "../record.ts"
 import * as InternalAnnotations from "./annotations.ts"
 
 const arbitraryMemoMap = new WeakMap<SchemaAST.AST, LazyArbitraryWithContext<any>>()
@@ -131,8 +132,7 @@ const combiner: Combiner.Combiner<any> = Struct.makeCombiner({
   noInfinity: or,
   noNaN: or,
   patterns: concat,
-  unique: or,
-  valid: or
+  unique: or
 }, {
   omitKeyWhen: Predicate.isUndefined
 })
@@ -288,7 +288,7 @@ function objectWithOptionalCount(
     const out: Record<PropertyKey, any> = {}
     for (const name of orderedNames) {
       if (keep.has(name)) {
-        out[name] = base[name]
+        InternalRecord.assignProperty(out, name, base[name])
       }
     }
     return out
@@ -403,10 +403,8 @@ function reportChecks(report: MutableReport, checks: SchemaAST.Checks | undefine
         visit(child, nextCovered)
       }
     } else if (!nextCovered) {
-      const meta = check.annotations?.meta
-      const description = typeof meta === "object" && meta !== null && "_tag" in meta && typeof meta._tag === "string"
-        ? meta._tag
-        : check.annotations?.identifier ?? check.annotations?.expected
+      const description = check.annotations?.representation?.id ?? check.annotations?.identifier ??
+        check.annotations?.expected
       report.warnings.push({ _tag: "OpaqueFilter", path, ...(description === undefined ? {} : { description }) })
     }
   }
@@ -773,7 +771,7 @@ function base(ast: SchemaAST.AST, path: ReadonlyArray<PropertyKey>): LazyArbitra
             return undefined
           }
           requiredKeys.push(name)
-          pss[name] = out
+          InternalRecord.assignProperty(pss, name, out)
         }
         let optionalCount = Math.max(0, (ctx.constraint?.minLength ?? 0) - requiredKeys.length)
         for (const [name, out] of optionals) {
@@ -782,7 +780,7 @@ function base(ast: SchemaAST.AST, path: ReadonlyArray<PropertyKey>): LazyArbitra
           }
           optionalCount--
           requiredKeys.push(name)
-          pss[name] = out
+          InternalRecord.assignProperty(pss, name, out)
         }
         if (optionalCount > 0 && ast.indexSignatures.length === 0) {
           return undefined
@@ -828,7 +826,7 @@ function base(ast: SchemaAST.AST, path: ReadonlyArray<PropertyKey>): LazyArbitra
           } else {
             requiredKeys.push(name)
           }
-          pss[name] = arbitrary(fc, reset, recursionStack)
+          InternalRecord.assignProperty(pss, name, arbitrary(fc, reset, recursionStack))
         }
         // When property-count constraints must be satisfied by selecting
         // optional keys (no index signatures are available to fill the gap),