effect 4.0.0-beta.3 → 4.0.0-beta.30

package/src/SchemaAST.ts

@@ -594,7 +594,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 +651,7 @@ export class Undefined extends Base {
     return fromConst(this, undefined)
   }
   /** @internal */
-  encodeToNull(): AST {
+  toCodecJson(): AST {
     return replaceEncoding(this, [undefinedToNull])
   }
   /** @internal */
@@ -697,7 +697,7 @@ export class Void extends Base {
     return fromConst(this, undefined)
   }
   /** @internal */
-  encodeToNull(): AST {
+  toCodecJson(): AST {
     return replaceEncoding(this, [undefinedToNull])
   }
   /** @internal */
@@ -1455,19 +1455,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 +1476,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 +2028,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 +2081,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 +2115,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 +2137,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)
@@ -2639,6 +2645,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 +3206,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 +3366,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
     })
@@ -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)

package/src/SchemaParser.ts

@@ -53,6 +53,17 @@ export function makeEffect<S extends Schema.Top>(schema: S) {
   }
 }
 
+/**
+ * @category Constructing
+ * @since 4.0.0
+ */
+export function makeOption<S extends Schema.Top>(schema: S) {
+  const parser = makeEffect(schema)
+  return (input: S["~type.make.in"], options?: Schema.MakeOptions): Option.Option<S["Type"]> => {
+    return Exit.getSuccess(Effect.runSyncExit(parser(input, options) as any))
+  }
+}
+
 /**
  * @category Constructing
  * @since 4.0.0

package/src/SchemaRepresentation.ts

@@ -1698,7 +1698,8 @@ export type Reviver<T> = (declaration: Declaration, recur: (representation: Repr
 
 /**
  * Default {@link Reviver} for {@link toSchema} that handles built-in Effect
- * types (Option, Result, Redacted, Cause, Exit, ReadonlyMap, ReadonlySet,
+ * types (Option, Result, Redacted, Cause, Exit, ReadonlyMap, HashMap,
+ * ReadonlySet,
  * Date, Duration, URL, RegExp, etc.).
  *
  * - Pass as `options.reviver` to {@link toSchema} to reconstruct schemas that
@@ -1716,42 +1717,66 @@ export const toSchemaDefaultReviver: Reviver<Schema.Top> = (s, recur) => {
   if (Predicate.isObject(typeConstructor) && typeof typeConstructor._tag === "string") {
     const typeParameters = s.typeParameters.map(recur)
     switch (typeConstructor._tag) {
-      case "effect/Option":
-        return Schema.Option(typeParameters[0])
-      case "effect/Result":
-        return Schema.Result(typeParameters[0], typeParameters[1])
-      case "effect/Redacted":
-        return Schema.Redacted(typeParameters[0])
-      case "effect/Cause/Failure":
-        return Schema.CauseFailure(typeParameters[0], typeParameters[1])
-      case "effect/Cause":
-        return Schema.Cause(typeParameters[0], typeParameters[1])
+      // built-in types
+      case "Date":
+        return Schema.Date
       case "Error":
         return Schema.Error
-      case "effect/Exit":
-        return Schema.Exit(typeParameters[0], typeParameters[1], typeParameters[2])
+      case "ErrorWithStack":
+        return Schema.ErrorWithStack
+      case "File":
+        return Schema.File
+      case "FormData":
+        return Schema.FormData
       case "ReadonlyMap":
         return Schema.ReadonlyMap(typeParameters[0], typeParameters[1])
       case "ReadonlySet":
         return Schema.ReadonlySet(typeParameters[0])
       case "RegExp":
         return Schema.RegExp
+      case "Uint8Array":
+        return Schema.Uint8Array
       case "URL":
         return Schema.URL
-      case "File":
-        return Schema.File
-      case "Date":
-        return Schema.Date
-      case "effect/Duration":
-        return Schema.Duration
-      case "FormData":
-        return Schema.FormData
       case "URLSearchParams":
         return Schema.URLSearchParams
-      case "Uint8Array":
-        return Schema.Uint8Array
-      case "DateTime.Utc":
+      // effect types
+      case "effect/Option":
+        return Schema.Option(typeParameters[0])
+      case "effect/Result":
+        return Schema.Result(typeParameters[0], typeParameters[1])
+      case "effect/Redacted":
+        return Schema.Redacted(typeParameters[0])
+      case "effect/DateTime.TimeZone":
+        return Schema.TimeZone
+      case "effect/DateTime.TimeZone.Named":
+        return Schema.TimeZoneNamed
+      case "effect/DateTime.TimeZone.Offset":
+        return Schema.TimeZoneOffset
+      case "effect/DateTime.Utc":
         return Schema.DateTimeUtc
+      case "effect/DateTime.Zoned":
+        return Schema.DateTimeZoned
+      case "effect/BigDecimal":
+        return Schema.BigDecimal
+      case "effect/Chunk":
+        return Schema.Chunk(typeParameters[0])
+      case "effect/Cause":
+        return Schema.Cause(typeParameters[0], typeParameters[1])
+      case "effect/Cause/Failure":
+        return Schema.CauseReason(typeParameters[0], typeParameters[1])
+      case "effect/Duration":
+        return Schema.Duration
+      case "effect/Exit":
+        return Schema.Exit(typeParameters[0], typeParameters[1], typeParameters[2])
+      case "effect/Json":
+        return Schema.Json
+      case "effect/MutableJson":
+        return Schema.MutableJson
+      case "effect/HashMap":
+        return Schema.HashMap(typeParameters[0], typeParameters[1])
+      case "effect/HashSet":
+        return Schema.HashSet(typeParameters[0])
     }
   }
 }