Value.Clean inconsistent behavior with Type.Codec and Type.Union

[joshuaavalon]

I was writing code using Type.Codec for serializing json request and response.
However, I found out under some cases, Value.Clean is not removing the value when it is using with Type.Codec and Type.Union.

In the example code, I expect schema3 and schema4 should return the same values.

Example Code

import { Type } from "typebox";
import { Compile } from "typebox/compile";

const schema1 = Type.Codec(Type.String()).Decode(s => Number.parseInt(s)).Encode(s => s.toString());
const schema2 = Type.Options(Type.Object({ a: Type.Ref("schema1") }), { $id: "schema2" });
const schema3 = Type.Object({ data: Type.Union([Type.Ref("schema2"), Type.Null()]) });
const schema4 = Type.Object({ data: Type.Ref("schema2") });

function main(): void {
  const a1 = Compile({ schema1, schema2 }, schema3);
  console.log(a1.Clean({ data: { a: 1, b: 2 } })); // { data: { a: 1, b: 2 } }

  const a2 = Compile({ schema1, schema2 }, schema4);
  console.log(a2.Clean({ data: { a: 1, b: 2 } })); // { data: { a: 1 } }
}

main();

Version

typebox: 1.0.61

[joshuaavalon]

After some more investigation, I think the problem is caused by the following lines

typebox/src/value/codec/from-union.ts

Lines 56 to 63 in 05a360d

	function Encode(direction: string, context: TProperties, type: TUnion, value: unknown): unknown {
	let exterior = Callback(direction, context, type, value)
	for (const schema of type.anyOf) {
	const variant = FromType(direction, context, schema, Clone(exterior))
	if(!Check(context, schema, variant)) continue
	return variant
	}
	return exterior

It seems to related to #1477 .

[sinclairzx81]

@joshuaavalon Hi, sorry for the delay on this one.

There has been quite a few changes here since this issue was posted, but TB still returns the same result. The issue is actually quite complex when considering both Codec + Clean, but the core issue is somewhat tied to Clean. I have simplified the code a bit to try and get the better picture of things.

Target is Mismatched through Union

Here is the original example with the target as String (A). We see a { a: 1, b: 2 } result specifically for the Union path via (C). The reason we see { a: 1, b: 2 } for this is because the Union path needs some way to identify a successful Clean result (for each variant of the Union). Because the target type (A) is String, and the argument { a: 1 } is a Number, the Clean operation terminates because it couldn't find a successful match (and Union needs at least one)

import { Clean } from 'typebox/value'
import Type from 'typebox'

const A = Type.String() // <--- String Here
const B = Type.Object({ a: Type.Ref("A") })
const C = Type.Object({ data: Type.Union([Type.Ref("B"), Type.Null()]) })
const D = Type.Object({ data: Type.Ref("B") })

console.log(Clean({ A, B }, C, { data: { a: 1, b: 2 } })) // { data: { a: 1, b: 2 } }
                                                          // |
                                                          // +-- Unable to find matching clean variant
                                                          
console.log(Clean({ A, B }, D, { data: { a: 1, b: 2 } })) // { data: { a: 1 } }

We can fix this by making the target a Number

import { Clean } from 'typebox/value'
import Type from 'typebox'

const A = Type.Number() // <--- Number Here
const B = Type.Object({ a: Type.Ref("A") })
const C = Type.Object({ data: Type.Union([Type.Ref("B"), Type.Null()]) })
const D = Type.Object({ data: Type.Ref("B") })

console.log(Clean({ A, B }, C, { data: { a: 1, b: 2 } })) // { data: { a: 1 } }
console.log(Clean({ A, B }, D, { data: { a: 1, b: 2 } })) // { data: { a: 1 } }

But it's not exactly ideal in the Codec case.

---

I am not sure there is much I can do to fix this specifically, not without changing the behavior of Clean (or Check). As the target type is mismatched, there just isn't a way to proceed through the Union.

One possible path might be to relax property value checks for Clean (only checking the Key, not the Value), but that may be too breaking for the standard Clean, but is worth considering none the less, but wouldn't be something I could implement on the 1.x line unfortunately.

---

I will close up this issue as non-actionable for now. But will include a review tag to investigate relaxing Clean checks at a later time.

Thanks for reporting tho, and sorry about the delay.
Cheers
S