effect 4.0.0-beta.102 → 4.0.0-beta.103

package/src/SchemaParser.ts

@@ -10,12 +10,13 @@
  *
  * @since 4.0.0
  */
-import * as Arr from "./Array.ts"
 import * as Cause from "./Cause.ts"
 import * as Effect from "./Effect.ts"
 import * as Exit from "./Exit.ts"
 import { memoize } from "./Function.ts"
+import { effectIsExit } from "./internal/effect.ts"
 import * as InternalSchemaCause from "./internal/schema/cause.ts"
+import * as InternalParser from "./internal/schema/parser.ts"
 import * as Option from "./Option.ts"
 import * as Predicate from "./Predicate.ts"
 import * as Result from "./Result.ts"
@@ -169,7 +170,7 @@ export function make<S extends Schema.Constraint>(schema: S) {
  * that contain defects, interruptions, or asynchronous work at this synchronous
  * boundary throw an `Error` whose cause is the underlying `Cause`.
  *
- * @category Asserting
+ * @category guards
  * @since 3.10.0
  */
 export function is<S extends Schema.Constraint>(schema: S): <I>(input: I) => input is I & S["Type"] {
@@ -221,7 +222,7 @@ export function _issue<T>(ast: SchemaAST.AST) {
  * synchronous boundary throw an `Error` whose cause is the underlying `Cause`,
  * instead of being converted to a schema validation error.
  *
- * @category Asserting
+ * @category guards
  * @since 4.0.0
  */
 export function asserts<S extends Schema.Constraint, I>(schema: S, input: I): asserts input is I & S["Type"] {
@@ -911,18 +912,34 @@ export const encodeSync: <S extends Schema.ConstraintEncoder<unknown>>(
 const mergeParseOptions = (
   options: SchemaAST.ParseOptions,
   overrideOptions: SchemaAST.ParseOptions | undefined
-): SchemaAST.ParseOptions => overrideOptions === undefined ? options : { ...options, ...overrideOptions }
+): SchemaAST.ParseOptions => overrideOptions ? { ...options, ...overrideOptions } : options
+
+const getValue = (value: unknown): Effect.Effect<any, SchemaIssue.Issue> => {
+  if (value === InternalParser.missing) {
+    return Effect.fail(new SchemaIssue.InvalidValue())
+  }
+  return Effect.succeed(value)
+}
 
 /** @internal */
 export function run<T, R>(ast: SchemaAST.AST) {
-  const parser = recur(ast)
-  return (input: unknown, options?: SchemaAST.ParseOptions): Effect.Effect<T, SchemaIssue.Issue, R> =>
-    Effect.flatMapEager(parser(Option.some(input), options ?? SchemaAST.defaultParseOptions), (oa) => {
-      if (oa._tag === "None") {
-        return Effect.fail(new SchemaIssue.InvalidValue(oa))
-      }
-      return Effect.succeed(oa.value as T)
-    })
+  let parser: Parser
+  return (input: unknown, options?: SchemaAST.ParseOptions): Effect.Effect<T, SchemaIssue.Issue, R> => {
+    const result = (parser ??= compile(ast))(
+      input,
+      options ?? SchemaAST.defaultParseOptions
+    )
+    if (result === InternalParser.sameExit) {
+      return Effect.succeed(input) as Effect.Effect<T, SchemaIssue.Issue, R>
+    }
+    if (!effectIsExit(result)) {
+      return Effect.flatMapEager(result, getValue)
+    }
+    return (result as InternalParser.Success<unknown, SchemaIssue.Issue>)[InternalParser.args] ===
+        InternalParser.missing
+      ? getValue(InternalParser.missing)
+      : result as Effect.Effect<T, SchemaIssue.Issue, R>
+  }
 }
 
 function asPromise<T, E>(
@@ -991,102 +1008,172 @@ function asSync<T, E>(
   }
 }
 
-function mapSchemaIssueEffect<A, R>(
-  self: Effect.Effect<A, SchemaIssue.Issue, R>,
-  f: (issue: SchemaIssue.Issue) => SchemaIssue.Issue
-): Effect.Effect<A, SchemaIssue.Issue, R> {
-  return Effect.catchCause(self, (cause) => Effect.failCauseSync(() => Cause.map(cause, f)))
-}
-
 /** @internal */
 export interface Parser {
   (
-    input: Option.Option<unknown>,
+    input: unknown,
     options: SchemaAST.ParseOptions
-  ): Effect.Effect<Option.Option<unknown>, SchemaIssue.Issue, any>
+  ): Effect.Effect<unknown, SchemaIssue.Issue, any>
 }
 
-const recur = memoize(
-  (ast: SchemaAST.AST): Parser => {
-    let parser: Parser
-    const checks = ast.checks
-    const encoding = ast.encoding
-    const links = encoding
-    const len = links?.length ?? 0
-    const encodingChecks = (ast as any).encodingChecks
-    const astOptions = (checks ? checks[checks.length - 1].annotations : ast.annotations)
-      ?.["parseOptions"]
-    if (!ast.context && !encoding && !checks && !encodingChecks) {
-      return (ou, options) => {
-        parser ??= ast.getParser(recur)
-        if (astOptions) {
-          options = { ...options, ...astOptions }
-        }
-        return parser(ou, options)
-      }
+const parserCache = new WeakMap<SchemaAST.AST, Parser>()
+
+function compile(ast: SchemaAST.AST): Parser {
+  let parser = parserCache.get(ast)
+  if (!parser) {
+    parserCache.set(ast, parser = makeParser(ast))
+  }
+  return parser
+}
+
+function makeParser(ast: SchemaAST.AST): Parser {
+  const parser = ast.getParser(compile)
+  const checks = ast.checks
+  const links = ast.encoding
+  const encodingChecks = (ast as any).encodingChecks
+  const astOptions = (checks ? checks[checks.length - 1].annotations : ast.annotations)
+    ?.["parseOptions"]
+  if (!links && !checks && !encodingChecks) {
+    if (!astOptions) {
+      return parser
     }
-    return (ou, options) => {
-      if (astOptions) {
-        options = { ...options, ...astOptions }
-      }
-      let srou: Effect.Effect<Option.Option<unknown>, SchemaIssue.Issue, unknown> | undefined
-      if (links) {
-        for (let i = len - 1; i >= 0; i--) {
-          const link = links[i]
-          const to = link.to
-          const parser = recur(to)
-          srou = srou ? Effect.flatMapEager(srou, (ou) => parser(ou, options)) : parser(ou, options)
-          if (link.transformation._tag === "Transformation") {
-            const getter = link.transformation.decode
-            srou = Effect.flatMapEager(srou, (ou) => getter.run(ou, options))
-          } else {
-            srou = link.transformation.decode(srou, options)
+    return (input, options) => parser(input, mergeParseOptions(options, astOptions))
+  }
+  let encodingParsers: ReadonlyArray<Parser> | undefined
+  const parseLocal = (
+    input: unknown,
+    options: SchemaAST.ParseOptions
+  ) => {
+    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)
+              )
+            }
           }
         }
-        srou = mapSchemaIssueEffect(srou!, (issue) => new SchemaIssue.Encoding(ast, ou, issue))
+      } 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)
+              )
+            }
+          }
+          return Effect.succeed(value)
+        })
       }
+    }
 
-      parser ??= ast.getParser(recur)
-      const parseLocal = (localOu: Option.Option<unknown>) => {
-        let sroa = parser(localOu, options)
-
-        if (encodingChecks && !options?.disableChecks) {
-          sroa = Effect.flatMapEager(sroa, (oa) => {
-            if (Option.isSome(localOu) && Option.isSome(oa)) {
-              const issues: Array<SchemaIssue.Issue> = []
-
-              SchemaAST.collectIssues(encodingChecks, localOu.value, issues, ast, options)
-
-              if (Arr.isArrayNonEmpty(issues)) {
-                return Effect.fail(new SchemaIssue.Composite(ast, localOu, issues))
-              }
-            }
-            return Effect.succeed(oa)
-          })
+    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)
+            )
+          }
         }
-
-        if (checks && !options?.disableChecks) {
-          sroa = Effect.flatMapEager(sroa, (oa) => {
-            if (Option.isSome(oa)) {
-              const value = oa.value
-              const issues: Array<SchemaIssue.Issue> = []
-
-              SchemaAST.collectIssues(checks, value, issues, ast, options)
-
-              if (Arr.isArrayNonEmpty(issues)) {
-                return Effect.fail(new SchemaIssue.Composite(ast, oa, issues))
-              }
+      } 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)
+              )
             }
-            return Effect.succeed(oa)
+          }
+          return Effect.succeed(value)
+        })
+      }
+    }
+
+    return result
+  }
+  if (!links) {
+    return astOptions
+      ? (input, options) => parseLocal(input, mergeParseOptions(options, astOptions))
+      : parseLocal
+  }
+  return (
+    input: unknown,
+    options: SchemaAST.ParseOptions
+  ) => {
+    if (astOptions) {
+      options = mergeParseOptions(options, astOptions)
+    }
+    const parsers = encodingParsers ??= links.map((link) => compile(link.to))
+    let current = input
+    let result = parsers[parsers.length - 1](input, options)
+    for (let i = links.length - 1; i >= 0; i--) {
+      const transformation = links[i].transformation
+      let transformed: Effect.Effect<Option.Option<unknown>, SchemaIssue.Issue, unknown>
+      if (effectIsExit(result) && result._tag === "Success") {
+        const optional = InternalParser.toOption(
+          result === InternalParser.sameExit
+            ? current
+            : (result as InternalParser.Success<unknown, SchemaIssue.Issue>)[InternalParser.args]
+        )
+        transformed = transformation._tag === "Transformation"
+          ? transformation.decode.run(optional, options)
+          : transformation.decode(InternalParser.succeed(optional), options)
+      } else if (transformation._tag === "Transformation") {
+        transformed = Effect.flatMapEager(
+          result,
+          (value) => transformation.decode.run(InternalParser.toOption(value), options)
+        )
+      } else {
+        transformed = transformation.decode(
+          Effect.mapEager(result, InternalParser.toOption),
+          options
+        )
+      }
+      result = effectIsExit(transformed) && transformed._tag === "Success"
+        ? InternalParser.fromOptionExit(
+          (transformed as InternalParser.Success<Option.Option<unknown>, SchemaIssue.Issue>)[InternalParser.args]
+        )
+        : Effect.flatMapEager(transformed, InternalParser.fromOptionExit)
+      if (i !== 0) {
+        const next = parsers[i - 1]
+        if ((result as Exit.Exit<unknown, unknown>)._tag === "Success") {
+          current = (result as InternalParser.Success<unknown, SchemaIssue.Issue>)[InternalParser.args]
+          result = next(current, options)
+        } else {
+          result = Effect.flatMapEager(result, (value) => {
+            const nextResult = next(value, options)
+            return nextResult === InternalParser.sameExit ? InternalParser.succeed(value) : nextResult
           })
         }
-
-        return sroa
       }
-
-      const sroa = srou ? Effect.flatMapEager(srou, parseLocal) : parseLocal(ou)
-
-      return sroa
     }
+    if ((result as Exit.Exit<unknown, unknown>)._tag === "Success") {
+      const value = (result as InternalParser.Success<unknown, SchemaIssue.Issue>)[InternalParser.args]
+      const local = parseLocal(value, options)
+      return local === InternalParser.sameExit ? result : local
+    }
+    result = Effect.catchCause(
+      result,
+      (cause) => Effect.failCauseSync(() => Cause.map(cause, (issue) => new SchemaIssue.Encoding(ast, issue)))
+    )
+    return Effect.flatMapEager(result, (value) => {
+      const local = parseLocal(value, options)
+      return local === InternalParser.sameExit ? InternalParser.succeed(value) : local
+    })
   }
-)
+}

package/src/SchemaRepresentation.ts

@@ -487,17 +487,6 @@ export interface MultiDocument {
   readonly references: References
 }
 
-/**
- * Live schemas reconstructed from a multi-document.
- *
- * @category models
- * @since 4.0.0
- */
-export interface SchemaMultiDocument {
-  readonly schemas: readonly [Schema.Top, ...Array<Schema.Top>]
-  readonly definitions: Readonly<Record<string, Schema.Top>>
-}
-
 /**
  * Reviver for a declaration.
  *
@@ -713,27 +702,6 @@ export function toRepresentations(
   return InternalToRepresentation.toRepresentations(asts)
 }
 
-/**
- * Converts live schemas and their named definitions to a shared representation document.
- *
- * **When to use**
- *
- * Use when schemas with shared or unreachable definitions must be passed to representation compilers such as `toCodeDocument`.
- *
- * **Gotchas**
- *
- * Every schema is projected to its encoded side. Definitions are preserved even when no root reaches them.
- *
- * @see {@link toRepresentations} for converting AST roots without an explicit definition map
- * @see {@link toCodeDocument} for generating code from the result
- *
- * @category constructors
- * @since 4.0.0
- */
-export function fromSchemaMultiDocument(document: SchemaMultiDocument): MultiDocument {
-  return InternalToRepresentation.fromSchemaMultiDocument(document)
-}
-
 /**
  * Wraps a single representation document as a multi-document with one root.
  *
@@ -1120,6 +1088,20 @@ export function fromJsonMultiDocument(input: Schema.Json): MultiDocument {
  *
  * Revivers are resolved locally by `id`; none are installed implicitly. Reviver results are used directly, and exceptions raised by a reviver pass through unchanged.
  *
+ * **Example** (Restoring a persisted schema)
+ *
+ * ```ts import.meta.vitest
+ * import { Schema, SchemaRepresentation } from "effect"
+ *
+ * const document = SchemaRepresentation.toRepresentation(Schema.Struct({ name: Schema.String }).ast)
+ * const persisted = SchemaRepresentation.toJson(document)
+ * const restored = SchemaRepresentation.fromJson(persisted)
+ * const schema = SchemaRepresentation.fromRepresentation(restored, { revivers: [] })
+ * const Person = Schema.make<Schema.Codec<{ readonly name: string }>>(schema.ast)
+ *
+ * Schema.decodeUnknownSync(Person)({ name: "Ada" }) // => { name: "Ada" }
+ * ```
+ *
  * @see {@link fromJson} for decoding a persisted document
  * @see {@link fromRepresentations} for multiple roots sharing references
  *
@@ -1134,15 +1116,15 @@ export function fromRepresentation(
 }
 
 /**
- * Reconstructs multiple runtime schemas and their shared definitions from a representation multi-document.
+ * Reconstructs multiple runtime schemas from a representation multi-document.
  *
  * **When to use**
  *
- * Use when every root and named definition must be rebuilt in one shared reference environment.
+ * Use when multiple roots must be rebuilt in one shared reference environment.
  *
  * **Gotchas**
  *
- * Every definition is revived, including definitions not reachable from a root. Revivers are resolved locally by `id`; none are installed implicitly.
+ * Only references reachable from a root are revived. Revivers are resolved locally by `id`; none are installed implicitly.
  *
  * @see {@link fromJsonMultiDocument} for decoding a persisted multi-document
  * @see {@link fromRepresentation} for a single root
@@ -1153,7 +1135,7 @@ export function fromRepresentation(
 export function fromRepresentations(
   document: MultiDocument,
   options: { readonly revivers: ReadonlyArray<AnyReviver> }
-): SchemaMultiDocument {
+): readonly [Schema.Top, ...Array<Schema.Top>] {
   return InternalFromRepresentation.fromRepresentations(document, options.revivers)
 }
 
@@ -1186,14 +1168,14 @@ export function fromJsonSchemaDocument(
  *
  * **When to use**
  *
- * Use when multiple imported roots must preserve shared definitions, aliases, and recursion.
+ * Use when multiple imported roots share reachable definitions, aliases, or recursion.
  *
  * **Gotchas**
  *
- * Every definition is translated, including definitions that no root references. Callback results are used directly, and exceptions raised by a callback pass through unchanged.
+ * Only definitions reachable from a root are translated. Callback results are used directly, and exceptions raised by a callback pass through unchanged.
  *
  * @see {@link fromJsonSchemaDocument} for a single root
- * @see {@link fromSchemaMultiDocument} for converting the result to a representation document
+ * @see {@link toRepresentations} for converting the returned schema ASTs to a representation document
  *
  * @category constructors
  * @since 4.0.0
@@ -1201,6 +1183,6 @@ export function fromJsonSchemaDocument(
 export function fromJsonSchemaMultiDocument(
   document: JsonSchema.MultiDocument<"draft-2020-12">,
   options?: FromJsonSchemaOptions
-): SchemaMultiDocument {
+): readonly [Schema.Top, ...Array<Schema.Top>] {
   return InternalFromJsonSchemaDocument.fromJsonSchemaMultiDocument(document, options)
 }