feat: node-level expected, actual, problem and message writer config (#…

…1245)

ark/attest/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@ark/attest",
-	"version": "0.34.0",
+	"version": "0.35.0",
 	"license": "MIT",
 	"author": {
 		"name": "David Blass",

ark/fast-check/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@ark/fast-check",
-	"version": "0.0.4",
+	"version": "0.0.5",
 	"license": "MIT",
 	"author": {
 		"name": "David Blass",

ark/fs/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@ark/fs",
-	"version": "0.30.0",
+	"version": "0.31.0",
 	"license": "MIT",
 	"author": {
 		"name": "David Blass",

ark/repo/scratch.ts

@@ -1,3 +1,4 @@
+import { attest } from "@ark/attest"
 import { flatMorph } from "@ark/util"
 import { ark, type } from "arktype"
 

ark/schema/__tests__/errors.test.ts

@@ -1,5 +1,11 @@
 import { attest, contextualize } from "@ark/attest"
-import { $ark, configure, rootSchema, schemaScope } from "@ark/schema"
+import {
+	$ark,
+	configure,
+	rootSchema,
+	schemaScope,
+	type ArkErrors
+} from "@ark/schema"
 
 contextualize(() => {
 	it("shallow", () => {
@@ -64,6 +70,24 @@ contextualize(() => {
 		)
 	})
 
+	it("can configure error writers at a node level", () => {
+		const customNumber = rootSchema({
+			meta: {
+				description: "custom description",
+				actual: data => `custom actual ${data}`,
+				problem: ctx => `custom problem ${ctx.expected} ${ctx.actual}`,
+				message: ctx => `custom message ${ctx.problem}`
+			},
+			domain: "number"
+		})
+
+		const out = customNumber("foo") as ArkErrors
+
+		attest(out.summary).snap(
+			"custom message custom problem custom description custom actual foo"
+		)
+	})
+
 	it("can configure errors by kind at a scope level", () => {
 		const types = schemaScope(
 			{ superSpecialString: "string" },

ark/schema/__tests__/unit.test.ts

@@ -33,7 +33,8 @@ contextualize(() => {
 		attest(t.internal.errorContext).equals({
 			code: "unit",
 			description: "7n",
-			unit: 7n
+			unit: 7n,
+			meta: {}
 		})
 		attest(t.allows(6n)).equals(false)
 		attest(t.allows(7n)).equals(true)
@@ -47,7 +48,8 @@ contextualize(() => {
 		attest(t.internal.errorContext).equals({
 			code: "unit",
 			description: "undefined",
-			unit: undefined
+			unit: undefined,
+			meta: {}
 		})
 		attest(t.allows(null)).equals(false)
 		attest(t.allows(undefined)).equals(true)
@@ -65,7 +67,8 @@ contextualize(() => {
 		attest(t.internal.errorContext).equals({
 			code: "unit",
 			description: "Symbol(status)",
-			unit: status
+			unit: status,
+			meta: {}
 		})
 		attest(t.allows(status)).equals(true)
 		attest(t.allows(Symbol("test"))).equals(false)
@@ -80,7 +83,8 @@ contextualize(() => {
 		attest(t.internal.errorContext).equals({
 			code: "unit",
 			description: "{}",
-			unit: o
+			unit: o,
+			meta: {}
 		})
 		attest(t.allows(o)).equals(true)
 		attest(t.allows(new Object())).equals(false)

ark/schema/config.ts

@@ -45,14 +45,17 @@ type NodeConfigsByKind = {
 export type NodeConfig<kind extends NodeKind = NodeKind> =
 	NodeConfigsByKind[kind]
 
-type UnknownNodeConfig = {
-	description?: DescriptionWriter
+export interface UnknownErrorWriters {
 	expected?: ExpectedWriter
 	actual?: ActualWriter
 	problem?: ProblemWriter
 	message?: MessageWriter
 }
 
+interface UnknownNodeConfig extends UnknownErrorWriters {
+	description?: DescriptionWriter
+}
+
 export type ResolvedUnknownNodeConfig = requireKeys<
 	UnknownNodeConfig,
 	"description"

ark/schema/constraint.ts

@@ -25,7 +25,7 @@ import type { NodeCompiler } from "./shared/compile.ts"
 import type { BaseNodeDeclaration } from "./shared/declare.ts"
 import { Disjoint } from "./shared/disjoint.ts"
 import {
-	compileErrorContext,
+	compileObjectLiteral,
 	constraintKeys,
 	type ConstraintKind,
 	type IntersectionContext,
@@ -98,24 +98,30 @@ export abstract class InternalPrimitiveConstraint<
 	): JsonSchema.Constrainable
 
 	traverseApply: TraverseApply<d["prerequisite"]> = (data, ctx) => {
-		if (!this.traverseAllows(data, ctx)) ctx.error(this.errorContext as never)
+		if (!this.traverseAllows(data, ctx))
+			ctx.errorFromNodeContext(this.errorContext as never)
 	}
 
 	compile(js: NodeCompiler): void {
 		if (js.traversalKind === "Allows") js.return(this.compiledCondition)
 		else {
 			js.if(this.compiledNegation, () =>
-				js.line(`${js.ctx}.error(${this.compiledErrorContext})`)
+				js.line(`${js.ctx}.errorFromNodeContext(${this.compiledErrorContext})`)
 			)
 		}
 	}
 
 	get errorContext(): d["errorContext"] {
-		return { code: this.kind, description: this.description, ...this.inner }
+		return {
+			code: this.kind,
+			description: this.description,
+			meta: this.meta,
+			...this.inner
+		}
 	}
 
 	get compiledErrorContext(): string {
-		return compileErrorContext(this.errorContext!)
+		return compileObjectLiteral(this.errorContext!)
 	}
 }
 

ark/schema/node.ts

@@ -130,6 +130,7 @@ export abstract class BaseNode<
 		(result, child) => Object.assign(result, child.referencesById),
 		{ [this.id]: this }
 	)
+	readonly compiledMeta: string = JSON.stringify(this.metaJson)
 
 	protected cacheGetter<name extends keyof this>(
 		name: name,

ark/schema/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@ark/schema",
-	"version": "0.30.0",
+	"version": "0.31.0",
 	"license": "MIT",
 	"author": {
 		"name": "David Blass",

ark/schema/parse.ts

@@ -241,7 +241,7 @@ export const createNode = (
 		metaJson = flatMorph(meta, (k, v) => [
 			k,
 			k === "examples" ? v : defaultValueSerializer(v)
-		]) as BaseMeta & dict
+		]) as never
 		json.meta = possiblyCollapse(metaJson, "description", true)
 	}
 

ark/schema/predicate.ts

@@ -7,7 +7,7 @@ import type {
 	declareNode
 } from "./shared/declare.ts"
 import {
-	compileErrorContext,
+	compileObjectLiteral,
 	implementNode,
 	type nodeImplementationOf
 } from "./shared/implement.ts"
@@ -84,18 +84,19 @@ export class PredicateNode extends BaseConstraint<Predicate.Declaration> {
 	impliedBasis = null
 
 	expression: string = this.serializedPredicate
-	traverseAllows: TraverseAllows = this.predicate
+	traverseAllows: TraverseAllows = this.predicate as never
 
 	errorContext: Predicate.ErrorContext = {
 		code: "predicate",
-		description: this.description
+		description: this.description,
+		meta: this.meta
 	}
 
-	compiledErrorContext = compileErrorContext(this.errorContext)
+	compiledErrorContext = compileObjectLiteral(this.errorContext)
 
 	traverseApply: TraverseApply = (data, ctx) => {
-		if (!this.predicate(data, ctx) && !ctx.hasError())
-			ctx.error(this.errorContext)
+		if (!this.predicate(data, ctx.external) && !ctx.hasError())
+			ctx.errorFromNodeContext(this.errorContext)
 	}
 
 	compile(js: NodeCompiler): void {
@@ -104,7 +105,7 @@ export class PredicateNode extends BaseConstraint<Predicate.Declaration> {
 			return
 		}
 		js.if(`${this.compiledNegation} && !ctx.hasError()`, () =>
-			js.line(`ctx.error(${this.compiledErrorContext})`)
+			js.line(`ctx.errorFromNodeContext(${this.compiledErrorContext})`)
 		)
 	}
 

ark/schema/roots/basis.ts

@@ -1,5 +1,5 @@
 import type { NodeCompiler } from "../shared/compile.ts"
-import { compileErrorContext } from "../shared/implement.ts"
+import { compileObjectLiteral } from "../shared/implement.ts"
 import type { TraverseApply } from "../shared/traversal.ts"
 import { BaseRoot, type InternalRootDeclaration } from "./root.ts"
 
@@ -11,22 +11,28 @@ export abstract class InternalBasis<
 	declare structure: undefined
 
 	traverseApply: TraverseApply<d["prerequisite"]> = (data, ctx) => {
-		if (!this.traverseAllows(data, ctx)) ctx.error(this.errorContext as never)
+		if (!this.traverseAllows(data, ctx))
+			ctx.errorFromNodeContext(this.errorContext as never)
 	}
 
 	get errorContext(): d["errorContext"] {
-		return { code: this.kind, description: this.description, ...this.inner }
+		return {
+			code: this.kind,
+			description: this.description,
+			meta: this.meta,
+			...this.inner
+		}
 	}
 
 	get compiledErrorContext(): string {
-		return compileErrorContext(this.errorContext!)
+		return compileObjectLiteral(this.errorContext!)
 	}
 
 	compile(js: NodeCompiler): void {
 		if (js.traversalKind === "Allows") js.return(this.compiledCondition)
 		else {
 			js.if(this.compiledNegation, () =>
-				js.line(`${js.ctx}.error(${this.compiledErrorContext})`)
+				js.line(`${js.ctx}.errorFromNodeContext(${this.compiledErrorContext})`)
 			)
 		}
 	}

ark/schema/roots/union.ts

@@ -291,7 +291,7 @@ export class UnionNode extends BaseRoot<Union.Declaration> {
 			}
 			errors.push(ctx.popBranch().error!)
 		}
-		ctx.error({ code: "union", errors })
+		ctx.errorFromNodeContext({ code: "union", errors, meta: this.meta })
 	}
 
 	compile(js: NodeCompiler): void {
@@ -350,10 +350,13 @@ export class UnionNode extends BaseRoot<Union.Declaration> {
 				`${serializedTypeOfDescriptions}[${condition}]`
 			:	`${serializedPrintable}(${condition})`
 
-		js.line(`ctx.error({
+		// TODO: should have its own error code
+		js.line(`ctx.errorFromNodeContext({
+	code: "predicate",
 	expected: ${serializedExpected},
 	actual: ${serializedActual},
-	relativePath: [${serializedPathSegments}]
+	relativePath: [${serializedPathSegments}],
+	meta: ${this.compiledMeta}
 })`)
 	}
 
@@ -373,7 +376,9 @@ export class UnionNode extends BaseRoot<Union.Declaration> {
 					)
 					.line("errors.push(ctx.popBranch().error)")
 			)
-			js.line(`ctx.error({ code: "union", errors })`)
+			js.line(
+				`ctx.errorFromNodeContext({ code: "union", errors, meta: ${this.compiledMeta} })`
+			)
 		} else {
 			this.branches.forEach(branch =>
 				js.if(`${js.invoke(branch)}`, () => js.return(true))

ark/schema/shared/declare.ts

@@ -1,4 +1,5 @@
 import type { merge, show } from "@ark/util"
+import type { UnknownErrorWriters } from "../config.ts"
 import type { nodeOfKind, reducibleKindOf } from "../kinds.ts"
 import type { Disjoint } from "./disjoint.ts"
 import type { NarrowedAttachments, NodeKind } from "./implement.ts"
@@ -8,7 +9,7 @@ type withMetaPrefixedKeys<o> = {
 	[k in keyof o as k extends string ? `meta.${k}` : never]: o[k]
 }
 
-export interface BaseMeta extends JsonSchema.Meta {
+export interface BaseMeta extends JsonSchema.Meta, UnknownErrorWriters {
 	alias?: string
 }
 
@@ -44,6 +45,7 @@ interface DeclarationInput {
 export interface BaseErrorContext<kind extends NodeKind = NodeKind> {
 	readonly description?: string
 	readonly code: kind
+	readonly meta: BaseMeta
 }
 
 export type defaultErrorContext<d extends DeclarationInput> = show<