Use standard formatting function in Config error messages, closes #5709 (#5712)

Author: gcanti

.changeset/deep-clouds-wink.md

@@ -0,0 +1,5 @@
+---
+"effect": patch
+---
+
+Use standard formatting function in Config error messages, closes #5709

packages/effect/src/Inspectable.ts

@@ -3,7 +3,7 @@
  */
 import type * as FiberRefs from "./FiberRefs.js"
 import { globalValue } from "./GlobalValue.js"
-import { hasProperty, isFunction } from "./Predicate.js"
+import * as Predicate from "./Predicate.js"
 
 /**
  * @since 2.0.0
@@ -33,7 +33,7 @@ export interface Inspectable {
 export const toJSON = (x: unknown): unknown => {
   try {
     if (
-      hasProperty(x, "toJSON") && isFunction(x["toJSON"]) &&
+      Predicate.hasProperty(x, "toJSON") && Predicate.isFunction(x["toJSON"]) &&
       x["toJSON"].length === 0
     ) {
       return x.toJSON()
@@ -46,6 +46,119 @@ export const toJSON = (x: unknown): unknown => {
   return redact(x)
 }
 
+const CIRCULAR = "[Circular]"
+
+/** @internal */
+export function formatDate(date: Date): string {
+  try {
+    return date.toISOString()
+  } catch {
+    return "Invalid Date"
+  }
+}
+
+function safeToString(input: any): string {
+  try {
+    const s = input.toString()
+    return typeof s === "string" ? s : String(s)
+  } catch {
+    return "[toString threw]"
+  }
+}
+
+/** @internal */
+export function formatPropertyKey(name: PropertyKey): string {
+  return Predicate.isString(name) ? JSON.stringify(name) : String(name)
+}
+
+/** @internal */
+export function formatUnknown(
+  input: unknown,
+  options?: {
+    readonly space?: number | string | undefined
+    readonly ignoreToString?: boolean | undefined
+  }
+): string {
+  const space = options?.space ?? 0
+  const seen = new WeakSet<object>()
+  const gap = !space ? "" : (Predicate.isNumber(space) ? " ".repeat(space) : space)
+  const ind = (d: number) => gap.repeat(d)
+
+  const wrap = (v: unknown, body: string): string => {
+    const ctor = (v as any)?.constructor
+    return ctor && ctor !== Object.prototype.constructor && ctor.name ? `${ctor.name}(${body})` : body
+  }
+
+  const ownKeys = (o: object): Array<PropertyKey> => {
+    try {
+      return Reflect.ownKeys(o)
+    } catch {
+      return ["[ownKeys threw]"]
+    }
+  }
+
+  function go(v: unknown, d = 0): string {
+    if (Array.isArray(v)) {
+      if (seen.has(v)) return CIRCULAR
+      seen.add(v)
+      if (!gap || v.length <= 1) return `[${v.map((x) => go(x, d)).join(",")}]`
+      const inner = v.map((x) => go(x, d + 1)).join(",\n" + ind(d + 1))
+      return `[\n${ind(d + 1)}${inner}\n${ind(d)}]`
+    }
+
+    if (Predicate.isDate(v)) return formatDate(v)
+
+    if (
+      !options?.ignoreToString &&
+      Predicate.hasProperty(v, "toString") &&
+      Predicate.isFunction(v["toString"]) &&
+      v["toString"] !== Object.prototype.toString &&
+      v["toString"] !== Array.prototype.toString
+    ) {
+      const s = safeToString(v)
+      if (v instanceof Error && v.cause) {
+        return `${s} (cause: ${go(v.cause, d)})`
+      }
+      return s
+    }
+
+    if (Predicate.isString(v)) return JSON.stringify(v)
+
+    if (
+      Predicate.isNumber(v) ||
+      v == null ||
+      Predicate.isBoolean(v) ||
+      Predicate.isSymbol(v)
+    ) return String(v)
+
+    if (Predicate.isBigInt(v)) return String(v) + "n"
+
+    if (v instanceof Set || v instanceof Map) {
+      if (seen.has(v)) return CIRCULAR
+      seen.add(v)
+      return `${v.constructor.name}(${go(Array.from(v), d)})`
+    }
+
+    if (Predicate.isObject(v)) {
+      if (seen.has(v)) return CIRCULAR
+      seen.add(v)
+      const keys = ownKeys(v)
+      if (!gap || keys.length <= 1) {
+        const body = `{${keys.map((k) => `${formatPropertyKey(k)}:${go((v as any)[k], d)}`).join(",")}}`
+        return wrap(v, body)
+      }
+      const body = `{\n${
+        keys.map((k) => `${ind(d + 1)}${formatPropertyKey(k)}: ${go((v as any)[k], d + 1)}`).join(",\n")
+      }\n${ind(d)}}`
+      return wrap(v, body)
+    }
+
+    return String(v)
+  }
+
+  return go(input, 0)
+}
+
 /**
  * @since 2.0.0
  */

packages/effect/src/ParseResult.ts

@@ -1873,7 +1873,7 @@ function getDefaultTypeMessage(issue: Type): string {
     return issue.message
   }
   const expected = AST.isRefinement(issue.ast) ? getRefinementExpected(issue.ast) : String(issue.ast)
-  return `Expected ${expected}, actual ${util_.formatUnknown(issue.actual)}`
+  return `Expected ${expected}, actual ${Inspectable.formatUnknown(issue.actual)}`
 }
 
 const formatTypeMessage = (issue: Type): Effect.Effect<string> =>

packages/effect/src/Pretty.ts

@@ -2,6 +2,7 @@
  * @since 3.10.0
  */
 import * as Arr from "./Array.js"
+import * as Inspectable from "./Inspectable.js"
 import * as errors_ from "./internal/schema/errors.js"
 import * as util_ from "./internal/schema/util.js"
 import * as Option from "./Option.js"
@@ -43,7 +44,7 @@ const toString = getMatcher((a) => String(a))
 
 const stringify = getMatcher((a) => JSON.stringify(a))
 
-const formatUnknown = getMatcher(util_.formatUnknown)
+const formatUnknown = getMatcher(Inspectable.formatUnknown)
 
 /**
  * @since 3.10.0
@@ -142,7 +143,7 @@ export const match: AST.Match<Pretty<any>> = {
           continue
         }
         output.push(
-          `${util_.formatPropertyKey(name)}: ${propertySignaturesTypes[i](input[name])}`
+          `${Inspectable.formatPropertyKey(name)}: ${propertySignaturesTypes[i](input[name])}`
         )
       }
       // ---------------------------------------------
@@ -156,7 +157,7 @@ export const match: AST.Match<Pretty<any>> = {
             if (Object.prototype.hasOwnProperty.call(expectedKeys, key)) {
               continue
             }
-            output.push(`${util_.formatPropertyKey(key)}: ${type(input[key])}`)
+            output.push(`${Inspectable.formatPropertyKey(key)}: ${type(input[key])}`)
           }
         }
       }

packages/effect/src/Schema.ts

@@ -29,6 +29,7 @@ import { dual, identity } from "./Function.js"
 import { globalValue } from "./GlobalValue.js"
 import * as hashMap_ from "./HashMap.js"
 import * as hashSet_ from "./HashSet.js"
+import * as Inspectable from "./Inspectable.js"
 import * as internalCause_ from "./internal/cause.js"
 import * as errors_ from "./internal/schema/errors.js"
 import * as schemaId_ from "./internal/schema/schemaId.js"
@@ -6647,8 +6648,8 @@ export const lessThanDate = <S extends Schema.Any>(
     filter((a: Date) => a < max, {
       schemaId: LessThanDateSchemaId,
       [LessThanDateSchemaId]: { max },
-      title: `lessThanDate(${util_.formatDate(max)})`,
-      description: `a date before ${util_.formatDate(max)}`,
+      title: `lessThanDate(${Inspectable.formatDate(max)})`,
+      description: `a date before ${Inspectable.formatDate(max)}`,
       ...annotations
     })
   )
@@ -6674,8 +6675,8 @@ export const lessThanOrEqualToDate = <S extends Schema.Any>(
     filter((a: Date) => a <= max, {
       schemaId: LessThanOrEqualToDateSchemaId,
       [LessThanOrEqualToDateSchemaId]: { max },
-      title: `lessThanOrEqualToDate(${util_.formatDate(max)})`,
-      description: `a date before or equal to ${util_.formatDate(max)}`,
+      title: `lessThanOrEqualToDate(${Inspectable.formatDate(max)})`,
+      description: `a date before or equal to ${Inspectable.formatDate(max)}`,
       ...annotations
     })
   )
@@ -6699,8 +6700,8 @@ export const greaterThanDate = <S extends Schema.Any>(
     filter((a: Date) => a > min, {
       schemaId: GreaterThanDateSchemaId,
       [GreaterThanDateSchemaId]: { min },
-      title: `greaterThanDate(${util_.formatDate(min)})`,
-      description: `a date after ${util_.formatDate(min)}`,
+      title: `greaterThanDate(${Inspectable.formatDate(min)})`,
+      description: `a date after ${Inspectable.formatDate(min)}`,
       ...annotations
     })
   )
@@ -6726,8 +6727,8 @@ export const greaterThanOrEqualToDate = <S extends Schema.Any>(
     filter((a: Date) => a >= min, {
       schemaId: GreaterThanOrEqualToDateSchemaId,
       [GreaterThanOrEqualToDateSchemaId]: { min },
-      title: `greaterThanOrEqualToDate(${util_.formatDate(min)})`,
-      description: `a date after or equal to ${util_.formatDate(min)}`,
+      title: `greaterThanOrEqualToDate(${Inspectable.formatDate(min)})`,
+      description: `a date after or equal to ${Inspectable.formatDate(min)}`,
       ...annotations
     })
   )
@@ -6752,8 +6753,8 @@ export const betweenDate = <S extends Schema.Any>(
     filter((a: Date) => a <= max && a >= min, {
       schemaId: BetweenDateSchemaId,
       [BetweenDateSchemaId]: { max, min },
-      title: `betweenDate(${util_.formatDate(min)}, ${util_.formatDate(max)})`,
-      description: `a date between ${util_.formatDate(min)} and ${util_.formatDate(max)}`,
+      title: `betweenDate(${Inspectable.formatDate(min)}, ${Inspectable.formatDate(max)})`,
+      description: `a date between ${Inspectable.formatDate(min)} and ${Inspectable.formatDate(max)}`,
       ...annotations
     })
   )
@@ -6822,7 +6823,7 @@ export class DateFromString extends transform(
   {
     strict: true,
     decode: (i) => new Date(i),
-    encode: (a) => util_.formatDate(a)
+    encode: (a) => Inspectable.formatDate(a)
   }
 ).annotations({ identifier: "DateFromString" }) {}
 
@@ -6885,7 +6886,8 @@ export class DateTimeUtcFromSelf extends declare(
 const decodeDateTimeUtc = <A extends dateTime.DateTime.Input>(input: A, ast: AST.AST) =>
   ParseResult.try({
     try: () => dateTime.unsafeMake(input),
-    catch: () => new ParseResult.Type(ast, input, `Unable to decode ${util_.formatUnknown(input)} into a DateTime.Utc`)
+    catch: () =>
+      new ParseResult.Type(ast, input, `Unable to decode ${Inspectable.formatUnknown(input)} into a DateTime.Utc`)
   })
 
 /**
@@ -8847,7 +8849,7 @@ export const TaggedError = <Self = never>(identifier?: string) =>
       get() {
         return `{ ${
           Reflect.ownKeys(fields)
-            .map((p: any) => `${util_.formatPropertyKey(p)}: ${util_.formatUnknown((this)[p])}`)
+            .map((p: any) => `${Inspectable.formatPropertyKey(p)}: ${Inspectable.formatUnknown((this)[p])}`)
             .join(", ")
         } }`
       },
@@ -9112,7 +9114,9 @@ const makeClass = <Fields extends Struct.Fields>(
     Object.defineProperty(klass.prototype, "toString", {
       value() {
         return `${identifier}({ ${
-          Reflect.ownKeys(fields).map((p: any) => `${util_.formatPropertyKey(p)}: ${util_.formatUnknown(this[p])}`)
+          Reflect.ownKeys(fields).map((p: any) =>
+            `${Inspectable.formatPropertyKey(p)}: ${Inspectable.formatUnknown(this[p])}`
+          )
             .join(", ")
         } })`
       },

packages/effect/src/SchemaAST.ts

@@ -7,6 +7,7 @@ import type { Effect } from "./Effect.js"
 import type { Equivalence } from "./Equivalence.js"
 import { dual, identity } from "./Function.js"
 import { globalValue } from "./GlobalValue.js"
+import * as Inspectable from "./Inspectable.js"
 import * as errors_ from "./internal/schema/errors.js"
 import * as util_ from "./internal/schema/util.js"
 import * as Number from "./Number.js"
@@ -533,7 +534,7 @@ export class Literal implements Annotated {
    * @since 3.10.0
    */
   toString() {
-    return Option.getOrElse(getExpected(this), () => util_.formatUnknown(this.literal))
+    return Option.getOrElse(getExpected(this), () => Inspectable.formatUnknown(this.literal))
   }
   /**
    * @since 3.10.0
@@ -577,7 +578,7 @@ export class UniqueSymbol implements Annotated {
    * @since 3.10.0
    */
   toString() {
-    return Option.getOrElse(getExpected(this), () => util_.formatUnknown(this.symbol))
+    return Option.getOrElse(getExpected(this), () => Inspectable.formatUnknown(this.symbol))
   }
   /**
    * @since 3.10.0
@@ -2968,7 +2969,7 @@ const formatKeyword = (ast: AST): string => Option.getOrElse(getExpected(ast), (
 function getBrands(ast: Annotated): string {
   return Option.match(getBrandAnnotation(ast), {
     onNone: () => "",
-    onSome: (brands) => brands.map((brand) => ` & Brand<${util_.formatUnknown(brand)}>`).join("")
+    onSome: (brands) => brands.map((brand) => ` & Brand<${Inspectable.formatUnknown(brand)}>`).join("")
   })
 }