effect 4.0.0-beta.4 → 4.0.0-beta.41

package/src/SchemaAST.ts

@@ -434,6 +434,12 @@ export interface ParseOptions {
    * default: "none"
    */
   readonly propertyOrder?: "none" | "original" | undefined
+
+  /**
+   * Whether to disable checks while still applying defaults and
+   * transformations.
+   */
+  readonly disableChecks?: boolean | undefined
 }
 
 /** @internal */
@@ -594,7 +600,7 @@ export class Declaration extends Base {
   }
   /** @internal */
   getExpected(): string {
-    const expected = this.annotations?.identifier ?? this.annotations?.expected
+    const expected = this.annotations?.expected
     if (typeof expected === "string") return expected
     return "<Declaration>"
   }
@@ -651,7 +657,7 @@ export class Undefined extends Base {
     return fromConst(this, undefined)
   }
   /** @internal */
-  encodeToNull(): AST {
+  toCodecJson(): AST {
     return replaceEncoding(this, [undefinedToNull])
   }
   /** @internal */
@@ -697,7 +703,7 @@ export class Void extends Base {
     return fromConst(this, undefined)
   }
   /** @internal */
-  encodeToNull(): AST {
+  toCodecJson(): AST {
     return replaceEncoding(this, [undefinedToNull])
   }
   /** @internal */
@@ -1455,19 +1461,20 @@ export class Arrays extends Base {
         // handle post rest elements
         // ---------------------------------------------
         for (let j = 0; j < tail.length; j++) {
-          if (len < i + 1) {
+          const index = i + j
+          if (len < index) {
             continue
           } else {
             const tailj = tail[j]
             const keyAnnotations = tailj.ast.context?.annotations
-            const eff = tailj.parser(Option.some(input[i]), options)
+            const eff = tailj.parser(Option.some(input[index]), options)
             const exit = effectIsExit(eff) ? eff : yield* Effect.exit(eff)
             if (exit._tag === "Failure") {
               const issueRest = Cause.findError(exit.cause)
               if (Result.isFailure(issueRest)) {
                 return yield* exit
               }
-              const issue = new Issue.Pointer([i], issueRest.success)
+              const issue = new Issue.Pointer([index], issueRest.success)
               if (errorsAllOption) {
                 if (issues) issues.push(issue)
                 else issues = [issue]
@@ -1475,9 +1482,9 @@ export class Arrays extends Base {
                 return yield* Effect.fail(new Issue.Composite(ast, oinput, [issue]))
               }
             } else if (exit.value._tag === "Some") {
-              output[i] = exit.value.value
+              output[index] = exit.value.value
             } else {
-              const issue = new Issue.Pointer([i], new Issue.MissingKey(keyAnnotations))
+              const issue = new Issue.Pointer([index], new Issue.MissingKey(keyAnnotations))
               if (errorsAllOption) {
                 if (issues) issues.push(issue)
                 else issues = [issue]
@@ -2027,7 +2034,7 @@ type Type =
 /** @internal */
 export type Sentinel = {
   readonly key: PropertyKey
-  readonly literal: LiteralValue
+  readonly literal: LiteralValue | symbol
 }
 
 function getCandidateTypes(ast: AST): ReadonlyArray<Type> {
@@ -2080,28 +2087,33 @@ function getCandidateTypes(ast: AST): ReadonlyArray<Type> {
 }
 
 /** @internal */
-export function collectSentinels(ast: AST): Array<Sentinel> | undefined {
+export function collectSentinels(ast: AST): Array<Sentinel> {
   switch (ast._tag) {
+    default:
+      return []
     case "Declaration": {
       const s = ast.annotations?.["~sentinels"]
-      return Array.isArray(s) && s.length ? s : undefined
+      return Array.isArray(s) ? s : []
     }
-    case "Objects": {
-      const v = ast.propertySignatures.flatMap((ps) =>
-        isLiteral(ps.type) && !isOptional(ps.type)
-          ? [{ key: ps.name, literal: ps.type.literal }]
-          : []
-      )
-      return v.length ? v : undefined
-    }
-    case "Arrays": {
-      const v = ast.elements.flatMap((e, i) =>
-        isLiteral(e) && !isOptional(e)
+    case "Objects":
+      return ast.propertySignatures.flatMap((ps): Array<Sentinel> => {
+        const type = ps.type
+        if (!isOptional(type)) {
+          if (isLiteral(type)) {
+            return [{ key: ps.name, literal: type.literal }]
+          }
+          if (isUniqueSymbol(type)) {
+            return [{ key: ps.name, literal: type.symbol }]
+          }
+        }
+        return []
+      })
+    case "Arrays":
+      return ast.elements.flatMap((e, i) => {
+        return isLiteral(e) && !isOptional(e)
           ? [{ key: i, literal: e.literal }]
           : []
-      )
-      return v.length ? v : undefined
-    }
+      })
     case "Suspend":
       return collectSentinels(ast.thunk())
   }
@@ -2109,7 +2121,7 @@ export function collectSentinels(ast: AST): Array<Sentinel> | undefined {
 
 type CandidateIndex = {
   byType?: { [K in Type]?: Array<AST> }
-  bySentinel?: Map<PropertyKey, Map<LiteralValue, Array<AST>>>
+  bySentinel?: Map<PropertyKey, Map<LiteralValue | symbol, Array<AST>>>
   otherwise?: { [K in Type]?: Array<AST> }
 }
 
@@ -2131,7 +2143,7 @@ function getIndex(types: ReadonlyArray<AST>): CandidateIndex {
     idx.byType ??= {}
     for (const t of types) (idx.byType[t] ??= []).push(a)
 
-    if (sentinels?.length) { // discriminated variants
+    if (sentinels.length > 0) { // discriminated variants
       idx.bySentinel ??= new Map()
       for (const { key, literal } of sentinels) {
         let m = idx.bySentinel.get(key)
@@ -2388,9 +2400,9 @@ export function memoizeThunk<A>(f: () => A): () => A {
  *   readonly children: ReadonlyArray<Category>
  * }
  *
- * const Category: Schema.Schema<Category> = Schema.Struct({
+ * const Category = Schema.Struct({
  *   name: Schema.String,
- *   children: Schema.Array(Schema.suspend(() => Category))
+ *   children: Schema.Array(Schema.suspend((): Schema.Codec<Category> => Category))
  * })
  *
  * // The recursive branch is a Suspend node
@@ -2639,6 +2651,11 @@ export function replaceContext<A extends AST>(ast: A, context: Context | undefin
   })
 }
 
+/** @internal */
+export function getLastEncoding(ast: AST): AST {
+  return ast.encoding ? getLastEncoding(ast.encoding[ast.encoding.length - 1].to) : ast
+}
+
 /** @internal */
 export function annotate<A extends AST>(ast: A, annotations: Schema.Annotations.Annotations): A {
   if (ast.checks) {
@@ -3195,10 +3212,7 @@ export const bigIntString = appendChecks(string, [isStringBigInt()])
 
 const bigIntToString = new Link(
   bigIntString,
-  new Transformation.Transformation(
-    Getter.transform(globalThis.BigInt),
-    Getter.String()
-  )
+  Transformation.bigintFromString
 )
 
 const REGEXP_PATTERN = "Symbol\\((.*)\\)"
@@ -3358,3 +3372,128 @@ export const resolveTitle: (ast: AST) => string | undefined = InternalAnnotation
  * @since 4.0.0
  */
 export const resolveDescription: (ast: AST) => string | undefined = InternalAnnotations.resolveDescription
+
+/**
+ * Returns true if the value is a JSON value.
+ *
+ * When a cyclic reference is detected, returns false.
+ *
+ * @internal
+ */
+export function isJson(u: unknown): u is Schema.Json {
+  const seen = new Set<unknown>()
+  return recur(u)
+
+  function recur(u: unknown): boolean {
+    if (u === null || typeof u === "string" || typeof u === "boolean") {
+      return true
+    }
+    if (typeof u === "number") {
+      return globalThis.Number.isFinite(u)
+    }
+    if (typeof u !== "object" || u === undefined) {
+      return false
+    }
+    if (seen.has(u)) {
+      return false
+    }
+    seen.add(u)
+    if (Array.isArray(u)) {
+      return u.every(recur)
+    }
+    return Object.keys(u).every((key) => recur((u as Record<string, unknown>)[key]))
+  }
+}
+
+/** @internal */
+export const Json = new Declaration(
+  [],
+  () => (input, ast) =>
+    isJson(input) ?
+      Effect.succeed(input) :
+      Effect.fail(new Issue.InvalidType(ast, Option.some(input))),
+  {
+    typeConstructor: {
+      _tag: "effect/Json"
+    },
+    generation: {
+      runtime: `Schema.Json`,
+      Type: `Schema.Json`
+    },
+    expected: "JSON value",
+    toCodecJson: () => new Link(unknown, Transformation.passthrough())
+  }
+)
+
+/** @internal */
+export const MutableJson = annotate(Json, {
+  typeConstructor: {
+    _tag: "effect/MutableJson"
+  },
+  generation: {
+    runtime: `Schema.MutableJson`,
+    Type: `Schema.MutableJson`
+  }
+})
+
+/** @internal */
+export const unknownToNull = new Link(
+  null_,
+  new Transformation.Transformation(
+    Getter.passthrough(),
+    Getter.transform(() => null)
+  )
+)
+
+/** @internal */
+export const unknownToJson = new Link(
+  Json,
+  Transformation.passthrough()
+)
+
+/**
+ * Returns true if the value is a StringTree value.
+ *
+ * When a cyclic reference is detected, returns false.
+ *
+ * @internal
+ */
+export function isStringTree(u: unknown): u is Schema.StringTree {
+  const seen = new Set<unknown>()
+  return recur(u)
+
+  function recur(u: unknown): boolean {
+    if (u === undefined || typeof u === "string") {
+      return true
+    }
+    if (typeof u !== "object" || u === null) {
+      return false
+    }
+    if (seen.has(u)) {
+      return false
+    }
+    seen.add(u)
+    if (Array.isArray(u)) {
+      return u.every(recur)
+    }
+    return Object.keys(u).every((key) => recur((u as Record<string, unknown>)[key]))
+  }
+}
+
+const StringTree = new Declaration(
+  [],
+  () => (input, ast) =>
+    isStringTree(input) ?
+      Effect.succeed(input) :
+      Effect.fail(new Issue.InvalidType(ast, Option.some(input))),
+  {
+    expected: "StringTree",
+    toCodecStringTree: () => new Link(unknown, Transformation.passthrough())
+  }
+)
+
+/** @internal */
+export const unknownToStringTree = new Link(
+  StringTree,
+  Transformation.passthrough()
+)

package/src/SchemaGetter.ts

@@ -86,11 +86,9 @@
  */
 import * as DateTime from "./DateTime.ts"
 import * as Effect from "./Effect.ts"
-import * as Base64 from "./encoding/Base64.ts"
-import * as Base64Url from "./encoding/Base64Url.ts"
-import * as Hex from "./encoding/Hex.ts"
+import * as Encoding from "./Encoding.ts"
 import * as Option from "./Option.ts"
-import { Class } from "./Pipeable.ts"
+import * as Pipeable from "./Pipeable.ts"
 import * as Predicate from "./Predicate.ts"
 import * as Result from "./Result.ts"
 import type * as Schema from "./Schema.ts"
@@ -136,7 +134,7 @@ import * as Str from "./String.ts"
  * @category model
  * @since 4.0.0
  */
-export class Getter<out T, in E, R = never> extends Class {
+export class Getter<out T, in E, R = never> extends Pipeable.Class {
   readonly run: (
     input: Option.Option<E>,
     options: AST.ParseOptions
@@ -1218,7 +1216,7 @@ export function split<E extends string>(options?: {
  * @since 4.0.0
  */
 export function encodeBase64<E extends Uint8Array | string>(): Getter<string, E> {
-  return transform(Base64.encode)
+  return transform(Encoding.encodeBase64)
 }
 
 /**
@@ -1244,7 +1242,7 @@ export function encodeBase64<E extends Uint8Array | string>(): Getter<string, E>
  * @since 4.0.0
  */
 export function encodeBase64Url<E extends Uint8Array | string>(): Getter<string, E> {
-  return transform(Base64Url.encode)
+  return transform(Encoding.encodeBase64Url)
 }
 
 /**
@@ -1269,7 +1267,7 @@ export function encodeBase64Url<E extends Uint8Array | string>(): Getter<string,
  * @since 4.0.0
  */
 export function encodeHex<E extends Uint8Array | string>(): Getter<string, E> {
-  return transform(Hex.encode)
+  return transform(Encoding.encodeHex)
 }
 
 /**
@@ -1297,7 +1295,7 @@ export function encodeHex<E extends Uint8Array | string>(): Getter<string, E> {
 export function decodeBase64<E extends string>(): Getter<Uint8Array, E> {
   return transformOrFail((input) =>
     Result.mapError(
-      Base64.decode(input),
+      Encoding.decodeBase64(input),
       (e) => new Issue.InvalidValue(Option.some(input), { message: e.message })
     ).asEffect()
   )
@@ -1327,7 +1325,7 @@ export function decodeBase64<E extends string>(): Getter<Uint8Array, E> {
  */
 export function decodeBase64String<E extends string>(): Getter<string, E> {
   return transformOrFail((input) =>
-    Result.match(Base64.decodeString(input), {
+    Result.match(Encoding.decodeBase64String(input), {
       onFailure: (e) => Effect.fail(new Issue.InvalidValue(Option.some(input), { message: e.message })),
       onSuccess: Effect.succeed
     })
@@ -1358,7 +1356,7 @@ export function decodeBase64String<E extends string>(): Getter<string, E> {
  */
 export function decodeBase64Url<E extends string>(): Getter<Uint8Array, E> {
   return transformOrFail((input) =>
-    Result.match(Base64Url.decode(input), {
+    Result.match(Encoding.decodeBase64Url(input), {
       onFailure: (e) => Effect.fail(new Issue.InvalidValue(Option.some(input), { message: e.message })),
       onSuccess: Effect.succeed
     })
@@ -1389,7 +1387,7 @@ export function decodeBase64Url<E extends string>(): Getter<Uint8Array, E> {
  */
 export function decodeBase64UrlString<E extends string>(): Getter<string, E> {
   return transformOrFail((input) =>
-    Result.match(Base64Url.decodeString(input), {
+    Result.match(Encoding.decodeBase64UrlString(input), {
       onFailure: (e) => Effect.fail(new Issue.InvalidValue(Option.some(input), { message: e.message })),
       onSuccess: Effect.succeed
     })
@@ -1420,7 +1418,7 @@ export function decodeBase64UrlString<E extends string>(): Getter<string, E> {
  */
 export function decodeHex<E extends string>(): Getter<Uint8Array, E> {
   return transformOrFail((input) =>
-    Result.match(Hex.decode(input), {
+    Result.match(Encoding.decodeHex(input), {
       onFailure: (e) => Effect.fail(new Issue.InvalidValue(Option.some(input), { message: e.message })),
       onSuccess: Effect.succeed
     })
@@ -1451,7 +1449,7 @@ export function decodeHex<E extends string>(): Getter<Uint8Array, E> {
  */
 export function decodeHexString<E extends string>(): Getter<string, E> {
   return transformOrFail((input) =>
-    Result.match(Hex.decodeString(input), {
+    Result.match(Encoding.decodeHexString(input), {
       onFailure: (e) => Effect.fail(new Issue.InvalidValue(Option.some(input), { message: e.message })),
       onSuccess: Effect.succeed
     })
@@ -1484,10 +1482,10 @@ export function decodeHexString<E extends string>(): Getter<string, E> {
  */
 export function dateTimeUtcFromInput<E extends DateTime.DateTime.Input>(): Getter<DateTime.Utc, E> {
   return transformOrFail((input) => {
-    const dt = DateTime.make(input)
-    return dt
-      ? Effect.succeed(DateTime.toUtc(dt))
-      : Effect.fail(new Issue.InvalidValue(Option.some(input), { message: "Invalid DateTime input" }))
+    return Option.match(DateTime.make(input), {
+      onNone: () => Effect.fail(new Issue.InvalidValue(Option.some(input), { message: "Invalid DateTime input" })),
+      onSome: (dt) => Effect.succeed(DateTime.toUtc(dt))
+    })
   })
 }
 
@@ -1519,7 +1517,7 @@ export function dateTimeUtcFromInput<E extends DateTime.DateTime.Input>(): Gette
  * @category FormData
  * @since 4.0.0
  */
-export function decodeFormData(): Getter<Schema.TreeObject<string | Blob>, FormData> {
+export function decodeFormData(): Getter<Schema.TreeRecord<string | Blob>, FormData> {
   return transform((input) => makeTreeRecord(Array.from(input.entries())))
 }
 
@@ -1596,7 +1594,7 @@ export function encodeFormData(): Getter<FormData, unknown> {
  * @category URLSearchParams
  * @since 4.0.0
  */
-export function decodeURLSearchParams(): Getter<Schema.TreeObject<string>, URLSearchParams> {
+export function decodeURLSearchParams(): Getter<Schema.TreeRecord<string>, URLSearchParams> {
   return transform((input) => makeTreeRecord(Array.from(input.entries())))
 }
 
@@ -1701,7 +1699,7 @@ function bracketPathToTokens(bracketPath: string): Array<string | number> {
  */
 export function makeTreeRecord<A>(
   bracketPathEntries: ReadonlyArray<readonly [bracketPath: string, value: A]>
-): Schema.TreeObject<A> {
+): Schema.TreeRecord<A> {
   const out: any = {}
   bracketPathEntries.forEach(([key, value]) => {
     const tokens = bracketPathToTokens(key)