effect 4.0.5 → 4.0.7

package/src/internal/schema/fromRepresentation.ts

@@ -18,7 +18,8 @@ export function fromRepresentations(
   return revivePersisted(document.representations, document.references, makeReviverMap(revivers), false)
 }
 
-class ReferenceSlot {
+/** @internal */
+export class ReferenceSlot {
   body: Schema.Top | undefined
   resolving = false
   readonly wrapper: Schema.Top

package/src/internal/schema/interpreter.ts

@@ -22,6 +22,17 @@ const flatMapTransformation = (
   result === InternalParser.sameExit ? f(current) : Effect.flatMapEager(result, f)
 
 function compileTransformation(transformation: SchemaAST.Link["transformation"]): ApplyTransformation {
+  const apply = compileTransformationUnsafe(transformation)
+  return (result, current, options) => {
+    try {
+      return apply(result, current, options)
+    } catch (error) {
+      return Effect.die(error)
+    }
+  }
+}
+
+function compileTransformationUnsafe(transformation: SchemaAST.Link["transformation"]): ApplyTransformation {
   if (transformation._tag === "Middleware") {
     return (result, current, options) => {
       const transformed = result === InternalParser.sameExit
@@ -143,63 +154,65 @@ export function compile(
     return parser
   }
   let encodingParsers: ReadonlyArray<Parser> | undefined
-  const parseChecks = (
-    input: unknown,
-    options: SchemaAST.ParseOptions
-  ) => {
+  const parseChecks: Parser = (input, options) => {
+    // Keep lazy child compilation outside the callback exception boundary.
     let result = parser(input, options)
-    if (encodingChecks && !options.disableChecks) {
-      if (effectIsExit(result)) {
-        if (result._tag === "Success") {
-          const output = result === InternalParser.sameExit
-            ? input
-            : (result as InternalParser.Success<unknown, SchemaIssue.Issue>)[InternalParser.args]
-          if (input !== InternalParser.missing && output !== InternalParser.missing) {
-            const issues = SchemaAST.collectIssues(encodingChecks, input, undefined, ast, options)
-            if (issues) {
-              result = Effect.fail(new SchemaIssue.Composite(ast, issues, input, options))
+    try {
+      if (encodingChecks && !options.disableChecks) {
+        if (effectIsExit(result)) {
+          if (result._tag === "Success") {
+            const output = result === InternalParser.sameExit
+              ? input
+              : (result as InternalParser.Success<unknown, SchemaIssue.Issue>)[InternalParser.args]
+            if (input !== InternalParser.missing && output !== InternalParser.missing) {
+              const issues = SchemaAST.collectIssues(encodingChecks, input, undefined, ast, options)
+              if (issues) {
+                result = Effect.fail(new SchemaIssue.Composite(ast, issues, input, options))
+              }
             }
           }
-        }
-      } else {
-        result = Effect.flatMap(result, (value) => {
-          if (input !== InternalParser.missing && value !== InternalParser.missing) {
-            const issues = SchemaAST.collectIssues(encodingChecks, input, undefined, ast, options)
-            if (issues) {
-              return Effect.fail(new SchemaIssue.Composite(ast, issues, input, options))
+        } else {
+          result = Effect.flatMap(result, (value) => {
+            if (input !== InternalParser.missing && value !== InternalParser.missing) {
+              const issues = SchemaAST.collectIssues(encodingChecks, input, undefined, ast, options)
+              if (issues) {
+                return Effect.fail(new SchemaIssue.Composite(ast, issues, input, options))
+              }
             }
-          }
-          return Effect.succeed(value)
-        })
+            return Effect.succeed(value)
+          })
+        }
       }
-    }
 
-    if (checks && !options.disableChecks) {
-      if (effectIsExit(result)) {
-        if (result._tag === "Success") {
-          const value = result === InternalParser.sameExit
-            ? input
-            : (result as InternalParser.Success<unknown, SchemaIssue.Issue>)[InternalParser.args]
-          if (value === InternalParser.missing) return result
-          const issues = SchemaAST.collectIssues(checks, value, undefined, ast, options)
-          if (issues) {
-            result = Effect.fail(new SchemaIssue.Composite(ast, issues, value, options))
-          }
-        }
-      } else {
-        result = Effect.flatMap(result, (value) => {
-          if (value !== InternalParser.missing) {
+      if (checks && !options.disableChecks) {
+        if (effectIsExit(result)) {
+          if (result._tag === "Success") {
+            const value = result === InternalParser.sameExit
+              ? input
+              : (result as InternalParser.Success<unknown, SchemaIssue.Issue>)[InternalParser.args]
+            if (value === InternalParser.missing) return result
             const issues = SchemaAST.collectIssues(checks, value, undefined, ast, options)
             if (issues) {
-              return Effect.fail(new SchemaIssue.Composite(ast, issues, value, options))
+              result = Effect.fail(new SchemaIssue.Composite(ast, issues, value, options))
             }
           }
-          return Effect.succeed(value)
-        })
+        } else {
+          result = Effect.flatMap(result, (value) => {
+            if (value !== InternalParser.missing) {
+              const issues = SchemaAST.collectIssues(checks, value, undefined, ast, options)
+              if (issues) {
+                return Effect.fail(new SchemaIssue.Composite(ast, issues, value, options))
+              }
+            }
+            return Effect.succeed(value)
+          })
+        }
       }
-    }
 
-    return result
+      return result
+    } catch (error) {
+      return Effect.die(error)
+    }
   }
   const parseLocal = specialize === undefined ? parseChecks : specialize(parseChecks)
   if (!links) {

package/src/internal/schema/standardSchema.ts

@@ -53,18 +53,31 @@ export function toStandardSchemaV1<S extends Schema.ConstraintDecoder<unknown>>(
       })
     })
   }
-  if (Object.hasOwn(self, "~standard")) {
-    const out = self as any
-    if ("validate" in out["~standard"]) return out
-    Object.assign(out["~standard"], { validate })
-    return out
+  return attach(self, { validate })
+}
+
+function attach(self: any, members: object): any {
+  const standard = {
+    version: 1,
+    vendor: "effect",
+    // Only an own adapter describes `self`; an inherited one describes a parent class.
+    ...(Object.hasOwn(self, "~standard") ? self["~standard"] : undefined),
+    ...members
   }
-  return Object.assign(self, {
+  // A bound function preserves construction; private static brands are not copied.
+  const out = typeof self === "function"
+    ? Function.prototype.bind.call(self, undefined)
+    : Object.create(Object.getPrototypeOf(self))
+  return Object.defineProperties(out, {
+    ...Object.getOwnPropertyDescriptors(self),
+    // Initialize a class's lazy AST with the original constructor as its receiver.
+    ast: { value: self.ast, enumerable: true, configurable: true },
     "~standard": {
-      version: 1,
-      vendor: "effect",
-      validate
-    } as const
+      value: standard,
+      writable: true,
+      enumerable: true,
+      configurable: true
+    }
   })
 }
 
@@ -81,14 +94,14 @@ function toBaseStandardJSONSchemaV1(
 ): JsonSchema.JsonSchema {
   const doc2020_12 = toJsonSchemaDocument(ast)
   if (target === "draft-2020-12") {
-    const schema = doc2020_12.schema
+    const schema: JsonSchema.JsonSchema = { $schema: JsonSchema.META_SCHEMA_URI_DRAFT_2020_12, ...doc2020_12.schema }
     if (Object.keys(doc2020_12.definitions).length > 0) {
       schema.$defs = doc2020_12.definitions
     }
     return schema
   } else if (target === "draft-07") {
     const doc07 = JsonSchema.toDocumentDraft07(doc2020_12)
-    const schema = doc07.schema
+    const schema: JsonSchema.JsonSchema = { $schema: JsonSchema.META_SCHEMA_URI_DRAFT_07, ...doc07.schema }
     if (Object.keys(doc07.definitions).length > 0) {
       schema.definitions = doc07.definitions
     }
@@ -101,25 +114,14 @@ function toBaseStandardJSONSchemaV1(
 export function toStandardJSONSchemaV1<S extends Schema.Constraint>(
   self: S
 ): StandardJSONSchemaV1<S["Encoded"], S["Type"]> & S {
-  const jsonSchema: StandardJSONSchemaV1.Props<S["Encoded"], S["Type"]>["jsonSchema"] = {
-    input(options) {
-      return toBaseStandardJSONSchemaV1(self.ast, options.target)
-    },
-    output(options) {
-      return toBaseStandardJSONSchemaV1(SchemaAST.toType(self.ast), options.target)
-    }
-  }
-  if (Object.hasOwn(self, "~standard")) {
-    const out = self as any
-    if ("jsonSchema" in out["~standard"]) return out
-    Object.assign(out["~standard"], { jsonSchema })
-    return out
-  }
-  return Object.assign(self, {
-    "~standard": {
-      version: 1,
-      vendor: "effect",
-      jsonSchema
-    } as const
+  return attach(self, {
+    jsonSchema: {
+      input(options) {
+        return toBaseStandardJSONSchemaV1(self.ast, options.target)
+      },
+      output(options) {
+        return toBaseStandardJSONSchemaV1(SchemaAST.toType(self.ast), options.target)
+      }
+    } satisfies StandardJSONSchemaV1.Converter
   })
 }

package/src/internal/schema/toCodeDocument.ts

@@ -26,7 +26,7 @@ function renderEmittableAnnotation(input: unknown): string | undefined {
   ) return format(input)
   if (typeof input === "symbol") {
     const key = globalThis.Symbol.keyFor(input)
-    return key === undefined ? undefined : `Symbol.for(${format(key)})`
+    return key === undefined ? undefined : `globalThis.Symbol.for(${format(key)})`
   }
   if (typeof input !== "object") return undefined
   if (Array.isArray(input)) {
@@ -48,7 +48,12 @@ function renderEmittableAnnotation(input: unknown): string | undefined {
   return entries.length === 0 ? "{}" : `{ ${entries.join(", ")} }`
 }
 
-const canonicalFiniteCheck = `Schema.isFinite().annotate({ "expected": "a finite number" })`
+// Leading checks that turn a bare `Schema.Number` into a built-in schema.
+const canonicalNumberChecks: Record<string, string> = {
+  [`Schema.isFinite().annotate({ "expected": "a finite number" })`]: "Schema.Finite",
+  ["Schema.isInt()"]: "Schema.Int",
+  [`Schema.isInt().annotate({ "expected": "an integer" })`]: "Schema.Int"
+}
 
 function renderAnnotations(
   annotations: Schema.Annotations.Annotations | undefined
@@ -225,7 +230,7 @@ export function toCodeDocument(
   const artifacts: Array<SchemaRepresentation.Artifact> = []
   const sorted = topologicalSort(document.references)
   const sanitizedReferences = new Map<string, string>()
-  const uniqueIdentifiers = new Set<string>()
+  const uniqueIdentifiers = new Set<string>(["Schema"])
   let compilingRecursiveDefinition = false
   let explicitSuspendDepth = 0
 
@@ -284,8 +289,8 @@ export function toCodeDocument(
       identifier,
       code: makeCode(
         key === undefined
-          ? `Symbol(${description === undefined ? "" : format(description)})`
-          : `Symbol.for(${format(key)})`,
+          ? `globalThis.Symbol(${description === undefined ? "" : format(description)})`
+          : `globalThis.Symbol.for(${format(key)})`,
         `typeof ${identifier}`
       )
     })
@@ -345,8 +350,8 @@ export function toCodeDocument(
       const check = representation.checks[index]
       const compiledCheck = compileCheck(check, [...path, "checks", index])
       // Only collapse a bare number's leading canonical check.
-      runtime = runtime === "Schema.Number" && compiledCheck === canonicalFiniteCheck
-        ? "Schema.Finite"
+      runtime = runtime === "Schema.Number" && Object.hasOwn(canonicalNumberChecks, compiledCheck)
+        ? canonicalNumberChecks[compiledCheck]
         : `${runtime}.check(${compiledCheck})`
     }
     return makeCode(runtime, base.Type)

package/src/internal/schema/toCodec.ts

@@ -1,8 +1,10 @@
-import { memoize } from "../../Function.ts"
+import { identity, memoize, memoizeIdempotent } from "../../Function.ts"
+import * as Option from "../../Option.ts"
 import * as Predicate from "../../Predicate.ts"
 import type * as PublicSchema from "../../Schema.ts"
 import * as SchemaAST from "../../SchemaAST.ts"
 import * as SchemaGetter from "../../SchemaGetter.ts"
+import * as SchemaParser from "../../SchemaParser.ts"
 import * as InternalTransformation from "../../SchemaTransformation.ts"
 import * as InternalMake from "./make.ts"
 
@@ -12,12 +14,29 @@ export function toCodecJson<S extends PublicSchema.Constraint>(schema: S): Publi
 }
 
 /** @internal */
-export const toCodecJsonAST = SchemaAST.applyToSelfOrLastLinkEncodingIdempotent((ast) => {
-  const out = toCodecJsonASTStep(ast, toCodecJsonAST)
-  const context = ast.context
-  if (out === ast || context === undefined) return out
-  return SchemaAST.replaceContextLastLink(out, withoutConstructorDefault(context))
-})
+export const toCodecJsonAST = makeCodecDerivation(toCodecJsonASTStep)
+
+function makeCodecDerivation(
+  step: (ast: SchemaAST.AST, recur: (ast: SchemaAST.AST) => SchemaAST.AST) => SchemaAST.AST,
+  options?: { readonly stopAt?: (link: SchemaAST.Link) => boolean }
+): (ast: SchemaAST.AST) => SchemaAST.AST {
+  // Derive each body once, independently of its own context. Child contexts remain part of the body.
+  const deriveBody = memoize((owner: SchemaAST.AST) => {
+    const body = SchemaAST.replaceContext(owner, undefined)
+    const out = step(body, recur)
+    return out === body ? null : out
+  })
+  // Follow existing encodings before sharing bodies: their encoded forms may differ.
+  const recur = SchemaAST.applyToSelfOrLastLinkEncodingIdempotent((ast) => {
+    const derived = deriveBody(SchemaAST.getContextOwner(ast))
+    if (derived === null) return ast
+    const out = SchemaAST.replaceContext(derived, ast.context)
+    return ast.context === undefined ?
+      out :
+      SchemaAST.replaceContextLastLink(out, withoutConstructorDefault(ast.context))
+  }, options)
+  return recur
+}
 
 function withoutConstructorDefault(context: SchemaAST.Context): SchemaAST.Context {
   return context.constructorDefault === undefined ?
@@ -255,15 +274,10 @@ const arrayFromSingleTransformation = new InternalTransformation.Transformation(
 const isCodecArrayFromSingleLink = (link: SchemaAST.Link): boolean =>
   link.transformation === arrayFromSingleTransformation
 
-const toCodecStringTreeAST = SchemaAST.applyToSelfOrLastLinkEncodingIdempotent((ast) => {
-  const out = toCodecStringTreeASTStep(ast, toCodecStringTreeAST, (ast) => {
+const toCodecStringTreeAST = makeCodecDerivation((ast, recur) =>
+  toCodecStringTreeASTStep(ast, recur, (ast) => {
     throw new globalThis.Error("Missing structural codec for StringTree", { cause: ast })
-  })
-  if (out !== ast && ast.context !== undefined) {
-    return SchemaAST.replaceContextLastLink(out, withoutConstructorDefault(ast.context))
-  }
-  return out
-}, { stopAt: isCodecArrayFromSingleLink })
+  }), { stopAt: isCodecArrayFromSingleLink })
 
 const toArrayFromSingleInputElement = (ast: SchemaAST.AST): SchemaAST.AST =>
   SchemaAST.isOptional(ast) ? SchemaAST.optionalKey(SchemaAST.unknown) : SchemaAST.unknown
@@ -291,6 +305,111 @@ const toCodecArrayFromSingleAST = SchemaAST.applyToSelfOrLastLinkEncodingIdempot
   return out
 }, { stopAt: isCodecArrayFromSingleLink })
 
+/** @internal */
+export function toCodecGoJson<S extends PublicSchema.Constraint>(
+  schema: S
+): PublicSchema.toCodecGoJson<S> {
+  return InternalMake.make(toCodecGoJsonAST(schema.ast), { schema })
+}
+
+// Keep the canonical member first to preserve accepted nulls and union branch
+// selection. Added members (`never`, `[]`, `{}`) do not widen the decoded type.
+const toCodecGoJsonAST = memoizeIdempotent((ast: SchemaAST.AST): SchemaAST.AST =>
+  nilAsEmptyAtEncoded(goNilAST(toCodecJsonAST(ast)))
+)
+
+const goNilAST: (ast: SchemaAST.AST) => SchemaAST.AST = SchemaAST.applyToSelfOrLastLinkEncodingIdempotent((ast) => {
+  switch (ast._tag) {
+    case "Objects":
+      return ast.recur((type) => nilAsMissingOrEmptyAtEncoded(goNilAST(type)), identity)
+    case "Arrays":
+      return ast.recur((type) => nilAsEmptyAtEncoded(goNilAST(type)))
+    case "Declaration":
+    case "Union":
+    case "Suspend":
+      return ast.recur(goNilAST)
+  }
+  return ast
+})
+
+const nilAsMissingOrEmptyAtEncoded = SchemaAST.applyToSelfOrLastLinkEncoding((ast) =>
+  SchemaAST.isOptional(ast) ? nilAsMissingAtEncoded(ast) : nilAsEmptyAtEncoded(ast)
+)
+
+const nilAsMissingAtEncoded: (ast: SchemaAST.AST) => SchemaAST.AST = SchemaAST.applyToSelfOrLastLinkEncoding(
+  (ast) => {
+    if (SchemaAST.isSuspend(ast)) return ast.recur(nilAsMissingAtEncoded)
+    if (isGoNil(ast) || acceptsNull(ast)) return ast
+    return orNull(ast, decodeNull(SchemaAST.never, nullAsMissing))
+  }
+)
+
+// Only a plain `Schema.Array` or `Schema.Record` can be a Go slice or map, so
+// tuples, non-empty arrays, and structs keep rejecting `null`. The empty value
+// still has to pass the collection's checks.
+const nilAsEmptyAtEncoded: (ast: SchemaAST.AST) => SchemaAST.AST = SchemaAST.applyToSelfOrLastLinkEncoding((ast) => {
+  if (SchemaAST.isSuspend(ast)) return ast.recur(nilAsEmptyAtEncoded)
+  if (SchemaAST.isArrays(ast) && ast.elements.length === 0 && ast.rest.length === 1) {
+    return orNull(ast, decodeNull(SchemaAST.replaceChecks(emptyArray, ast.checks), nullAsEmptyArray))
+  }
+  if (SchemaAST.isObjects(ast) && ast.propertySignatures.length === 0 && ast.indexSignatures.length > 0) {
+    return orNull(ast, decodeNull(SchemaAST.replaceChecks(emptyRecord, ast.checks), nullAsEmptyRecord))
+  }
+  return ast
+})
+
+// Only skips the `null` member when the schema certainly accepts `null`, to
+// keep the JSON Schema tidy. Suspended schemas are not resolved, so recursive
+// definitions stay lazy.
+function acceptsNull(ast: SchemaAST.AST): boolean {
+  const encoded = SchemaAST.getLastEncoding(ast)
+  switch (encoded._tag) {
+    case "Union":
+      return encoded.checks === undefined && encoded.types.some(acceptsNull)
+    case "Null":
+    case "Unknown":
+    case "Any":
+    case "Declaration":
+      return SchemaParser.is(InternalMake.make(SchemaAST.replaceContext(encoded, undefined)))(null)
+  }
+  return false
+}
+
+function orNull(ast: SchemaAST.AST, member: SchemaAST.AST): SchemaAST.AST {
+  return SchemaAST.replaceContext(new SchemaAST.Union([SchemaAST.replaceContext(ast, undefined), member]), ast.context)
+}
+
+const nullTo = (decode: SchemaGetter.Getter<unknown, null>) =>
+  new InternalTransformation.Transformation(
+    decode,
+    SchemaGetter.forbidden<null, unknown>(() => "Go nil values are never encoded")
+  )
+
+const nullAsMissing = nullTo(SchemaGetter.transformOptional<unknown, null>(() => Option.none()))
+
+const nullAsEmptyArray = nullTo(SchemaGetter.transform<unknown, null>(() => []))
+
+const nullAsEmptyRecord = nullTo(SchemaGetter.transform<unknown, null>(() => ({})))
+
+const emptyArray = new SchemaAST.Arrays(false, [], [])
+
+const emptyRecord = SchemaAST.record(SchemaAST.string, SchemaAST.never)
+
+function decodeNull(
+  to: SchemaAST.AST,
+  transformation: InternalTransformation.Transformation<unknown, null>
+): SchemaAST.AST {
+  return SchemaAST.decodeTo(SchemaAST.null, to, transformation)
+}
+
+// A union this codec already built, so applying it again changes nothing.
+function isGoNil(ast: SchemaAST.AST): boolean {
+  if (!SchemaAST.isUnion(ast)) return false
+  const transformation = ast.types[ast.types.length - 1].encoding?.[0].transformation
+  return transformation === nullAsMissing || transformation === nullAsEmptyArray ||
+    transformation === nullAsEmptyRecord
+}
+
 function toCodecArrayFromSingleASTStep(ast: SchemaAST.AST): SchemaAST.AST {
   return ast._tag === "Declaration" || ast._tag === "Arrays" || ast._tag === "Objects" || ast._tag === "Union" ||
       ast._tag === "Suspend"

package/src/internal/schema/toFormatter.ts

@@ -110,9 +110,9 @@ export function toFormatter<T>(ast: SchemaAST.AST, options?: {
             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_]) =>
+              const entries = globalThis.Array.from(map.entries()).map(([key_, value_]) =>
                 `${key(key_)} => ${value(value_)}`
-              )
+              ).sort()
               return `ReadonlyMap(${size}) { ${entries.join(", ")} }`
             }
           }
@@ -121,7 +121,7 @@ export function toFormatter<T>(ast: SchemaAST.AST, options?: {
             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_)}`)
+              const entries = HashMap.toEntries(map).map(([key_, value_]) => `${key(key_)} => ${value(value_)}`).sort()
               return `HashMap(${size}) { ${entries.join(", ")} }`
             }
           }
@@ -130,7 +130,7 @@ export function toFormatter<T>(ast: SchemaAST.AST, options?: {
             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)}`)
+              const values = globalThis.Array.from(set.values()).map((item) => `${value(item)}`).sort()
               return `ReadonlySet(${size}) { ${values.join(", ")} }`
             }
           }
@@ -139,7 +139,7 @@ export function toFormatter<T>(ast: SchemaAST.AST, options?: {
             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)}`)
+              const values = globalThis.Array.from(set).map((item) => `${value(item)}`).sort()
               return `HashSet(${size}) { ${values.join(", ")} }`
             }
           }
@@ -148,7 +148,7 @@ export function toFormatter<T>(ast: SchemaAST.AST, options?: {
             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)}`)
+              const values = globalThis.Array.from(chunk).map((item) => `${value(item)}`)
               return `Chunk(${size}) { ${values.join(", ")} }`
             }
           }