Version 1.1.19 (#1566)

* Improved Intersect Encode and Decode Handling

* ChangeLog

* Version

Author: sinclairzx81

changelog/1.1.0.md

@@ -3,6 +3,8 @@
 ---
 
 ### Version Updates
+- [Revision 1.1.19](https://github.com/sinclairzx81/typebox/pull/1566)
+  - Improved Intersect Encode and Decode Handling
 - [Revision 1.1.18](https://github.com/sinclairzx81/typebox/pull/1565)
   - Use Explicit Static Return Type Annotation for Value Functions
 - [Revision 1.1.17](https://github.com/sinclairzx81/typebox/pull/1564)

src/value/codec/from-intersect.ts

@@ -32,28 +32,53 @@ import { Guard } from '../../guard/index.ts'
 import { type TIntersect, type TProperties } from '../../type/index.ts'
 import { FromType } from './from-type.ts'
 import { Callback } from './callback.ts'
+import { Clone } from '../clone/index.ts'
+import { Clean } from '../clean/index.ts'
 
+// ------------------------------------------------------------------
+// MergeInteriors
+//
+// Merges all interior operand results into a single object. Each
+// subsequent operand's properties override those of prior operands.
+//
+// ------------------------------------------------------------------
+function MergeInteriors(interiors: Record<PropertyKey, unknown>[]): unknown {
+  return interiors.reduce((results, interior) => ({ ...results, ...interior }), {})
+}
+// ------------------------------------------------------------------
+// NonMatchingInterior
+//
+// Used when Intersect operands do not all produce Objects. Returns
+// the first interior result that differs from the original value,
+// indicating a Codec has transformed the data. If no operand
+// produced a change, defaults to the first interior result.
+//
+// ------------------------------------------------------------------
+function NonMatchingInterior(value: unknown, interiors: unknown[]) {
+  for (const interior of interiors) if (!Guard.IsDeepEqual(value, interior)) return interior
+  return value // value-unchanged
+}
 // ------------------------------------------------------------------
 // Decode
 // ------------------------------------------------------------------
 function Decode(direction: string, context: TProperties, type: TIntersect, value: unknown): unknown {
-  for (const schema of type.allOf) {
-    value = FromType(direction, context, schema, value)
-  }
-  return Callback(direction, context, type, value)
+  if (Guard.IsEqual(type.allOf.length, 0)) return Callback(direction, context, type, value)
+  const interiors = type.allOf.map((schema) => FromType(direction, context, schema, Clean(schema, Clone(value))))
+  const structural = interiors.every((result) => Guard.IsObject(result))
+  const exterior = structural ? MergeInteriors(interiors) : NonMatchingInterior(value, interiors)
+  return Callback(direction, context, type, exterior)
 }
 // ------------------------------------------------------------------
 // Encode
 // ------------------------------------------------------------------
 function Encode(direction: string, context: TProperties, type: TIntersect, value: unknown): unknown {
-  let exterior = Callback(direction, context, type, value)
-  for (const schema of type.allOf) {
-    exterior = FromType(direction, context, schema, exterior)
-  }
-  return exterior
+  if (Guard.IsEqual(type.allOf.length, 0)) return Callback(direction, context, type, value)
+  const exterior = Callback(direction, context, type, value)
+  const interiors = type.allOf.map((schema) => FromType(direction, context, schema, Clean(schema, Clone(exterior))))
+  const structural = interiors.every((result) => Guard.IsObject(result))
+  if (structural) return MergeInteriors(interiors)
+  return NonMatchingInterior(exterior, interiors)
 }
 export function FromIntersect(direction: string, context: TProperties, type: TIntersect, value: unknown): unknown {
-  return Guard.IsEqual(direction, 'Decode')
-    ? Decode(direction, context, type, value)
-    : Encode(direction, context, type, value)
+  return Guard.IsEqual(direction, 'Decode') ? Decode(direction, context, type, value) : Encode(direction, context, type, value)
 }

tasks.ts

@@ -9,7 +9,7 @@ import { Metrics } from './task/metrics/index.ts'
 import { Spec } from './task/spec/index.ts'
 import { Task } from 'tasksmith'
 
-const Version = '1.1.18'
+const Version = '1.1.19'
 
 // ------------------------------------------------------------------
 // Build

test/typebox/runtime/value/codec/intersect.ts

@@ -53,7 +53,7 @@ Test('Should Intersect 3', () => {
   Assert.IsEqual(D, '1')
   Assert.IsEqual(E, 1)
 })
-Test('Should Intersect 3', () => {
+Test('Should Intersect 4', () => {
   const NumberToString = Type.Codec(Type.Number())
     .Decode((value) => value.toString())
     .Encode((value) => parseFloat(value))
@@ -67,8 +67,137 @@ Test('Should Intersect 3', () => {
 // ------------------------------------------------------------------
 // Illogical
 // ------------------------------------------------------------------
-Test('Should Intersect 4', () => {
+Test('Should Intersect 5', () => {
   const T = Type.Intersect([Type.Array(Type.Null()), Type.Number()])
   Assert.Throws(() => Value.Decode(T, 1))
   Assert.Throws(() => Value.Encode(T, [null]))
 })
+// ------------------------------------------------------------------
+// Intersect Operand Should Not Break Subsequent Operands
+//
+// https://github.com/sinclairzx81/typebox/issues/1466
+// ------------------------------------------------------------------
+Test('Should Intersect 6', () => {
+  let C = 0
+  const T = Type.Codec(Type.Object({
+    L: Type.String(),
+    R: Type.String()
+  }))
+    .Decode((encoded) => (`${encoded.L}:${encoded.R}`))
+    .Encode((decoded) => {
+      C = C + 1
+      const [L, R] = decoded.split(':') as [string, string]
+      return { L, R }
+    })
+  const S = Type.Intersect([
+    Type.Object({ id: T }),
+    Type.Object({ id: T })
+  ])
+  const D = Value.Decode(S, { id: { L: 'L', R: 'R' } })
+  const E = Value.Encode(S, D)
+  // Expect Multiple Calls Per Operand
+  Assert.IsEqual(C, 2)
+  Assert.IsEqual(D, { id: 'L:R' })
+  Assert.IsEqual(E, { id: { L: 'L', R: 'R' } })
+})
+// ------------------------------------------------------------------
+// Intersect With Outer Codec
+//
+// Verifies the outer Intersect-level Codec is applied after merging
+// interiors on Decode, and before on Encode.
+// ------------------------------------------------------------------
+Test('Should Intersect 7', () => {
+  const T = Type.Codec(Type.Intersect([
+    Type.Object({ x: Type.Number() }),
+    Type.Object({ y: Type.Number() })
+  ]))
+    .Decode((value) => ({ ...value, decoded: true }))
+    .Encode(({ decoded: _, ...rest }) => rest)
+
+  const D = Value.Decode(T, { x: 1, y: 2 })
+  const E = Value.Encode(T, D)
+  Assert.IsEqual(D, { x: 1, y: 2, decoded: true })
+  Assert.IsEqual(E, { x: 1, y: 2 })
+})
+// ------------------------------------------------------------------
+// Intersect Key Override
+//
+// Verifies that when two operands produce the same key, the latter
+// operand's value wins on merge.
+// ------------------------------------------------------------------
+Test('Should Intersect 8', () => {
+  const Increment = Type.Codec(Type.Number())
+    .Decode((value) => value + 1)
+    .Encode((value) => value - 1)
+
+  const T = Type.Intersect([
+    Type.Object({ n: Type.Number() }),
+    Type.Object({ n: Increment })
+  ])
+  const D = Value.Decode(T, { n: 1 })
+  const E = Value.Encode(T, D)
+  Assert.IsEqual(D, { n: 2 }) // latter operand wins
+  Assert.IsEqual(E, { n: 1 })
+})
+// ------------------------------------------------------------------
+// Empty Intersect
+//
+// Verifies that an Intersect with no operands decodes and encodes
+// without error, returning an empty object.
+// ------------------------------------------------------------------
+Test('Should Intersect 9', () => {
+  const T = Type.Intersect([])
+  const D = Value.Decode(T, {})
+  const E = Value.Encode(T, D)
+  Assert.IsEqual(D, {})
+  Assert.IsEqual(E, {})
+})
+// ------------------------------------------------------------------
+// Empty Intersect
+//
+// Verifies that an empty Intersect returns the original value
+// unchanged for both Decode and Encode.
+// ------------------------------------------------------------------
+Test('Should Intersect 10', () => {
+  const T = Type.Intersect([])
+  const D = Value.Decode(T, 42)
+  const E = Value.Encode(T, 42)
+  Assert.IsEqual(D, 42)
+  Assert.IsEqual(E, 42)
+})
+// ------------------------------------------------------------------
+// Primitive With No Transformation
+//
+// Verifies that when no operand transforms the value,
+// NonMatchingInterior correctly falls back to the first result.
+// ------------------------------------------------------------------
+Test('Should Intersect 11', () => {
+  const T = Type.Intersect([Type.Number(), Type.Number()])
+  const D = Value.Decode(T, 42)
+  const E = Value.Encode(T, 42)
+  Assert.IsEqual(D, 42)
+  Assert.IsEqual(E, 42)
+})
+// ------------------------------------------------------------------
+// Nested Intersect
+//
+// Verifies that codec transformation composes correctly when
+// Intersect types are nested inside one another.
+// ------------------------------------------------------------------
+Test('Should Intersect 12', () => {
+  const NumberToString = Type.Codec(Type.Number())
+    .Decode((value) => value.toString())
+    .Encode((value) => parseFloat(value))
+
+  const Inner = Type.Intersect([
+    Type.Object({ x: NumberToString })
+  ])
+  const Outer = Type.Intersect([
+    Inner,
+    Type.Object({ y: NumberToString })
+  ])
+  const D = Value.Decode(Outer, { x: 1, y: 2 })
+  const E = Value.Encode(Outer, D)
+  Assert.IsEqual(D, { x: '1', y: '2' })
+  Assert.IsEqual(E, { x: 1, y: 2 })
+})