Version 1.0.41 (#1416)

* Repair: Support Sub Schema Refine Recovery

* ChangeLog

* Version

Author: sinclairzx81

changelog/1.0.0.md

@@ -3,6 +3,8 @@
 ---
 
 ### Version Updates
+- [Revision 1.0.41](https://github.com/sinclairzx81/typebox/pull/1416)
+  - Support Sub Schema Value Recovery on Repair
 - [Revision 1.0.40](https://github.com/sinclairzx81/typebox/pull/1415)
   - Support Top Level Value Recovery on Repair
 - [Revision 1.0.39](https://github.com/sinclairzx81/typebox/pull/1411)

src/value/repair/from-type.ts

@@ -30,6 +30,8 @@ THE SOFTWARE.
 
 import { Guard, GlobalsGuard } from '../../guard/index.ts'
 import * as T from '../../type/index.ts'
+import { Check } from '../check/index.ts'
+import { Create } from '../create/index.ts'
 
 import { FromArray } from './from-array.ts'
 import { FromBase } from './from-base.ts'
@@ -73,15 +75,35 @@ function AssertRepairableType(context: T.TProperties, type: T.TSchema, value: un
   }
 }
 // ------------------------------------------------------------------
+// FinalizeRepair
+//
+// When a type includes the ~refine modifier, a post-repair validation
+// check must be performed to ensure the repaired value satisfies the
+// refine constraint. This logic is implemented as part of FromType to
+// ensure the post-refine validation check is handled outside of
+// sub-schema constraint checking (i.e., at the top level).
+//
+// ------------------------------------------------------------------
+function FinalizeRepair(context: T.TProperties, type: T.TSchema, repaired: unknown): unknown {
+  return T.IsRefine(type) 
+    ? Check(context, type, repaired) 
+      ? repaired 
+      : Create(context, type) 
+    : repaired
+}
+// ------------------------------------------------------------------
 // FromType
 // ------------------------------------------------------------------
 export function FromType(context: T.TProperties, type: T.TSchema, value: unknown): unknown {
-  // Intercept Base
-  if (T.IsBase(type)) return FromBase(context, type, value)
-  // Standard Repair
+  // Base Repair
+  if (T.IsBase(type)) {
+    const repaired = FromBase(context, type, value)
+    return FinalizeRepair(context, type, repaired)
+  }
+  // Schema Repair
   AssertRepairableValue(context, type, value)
   AssertRepairableType(context, type, value)
-  return (
+  const repaired = (
     T.IsArray(type) ? FromArray(context, type, value) :
     T.IsEnum(type) ? FromEnum(context, type, value) :
     T.IsIntersect(type) ? FromIntersect(context, type, value) :
@@ -93,4 +115,5 @@ export function FromType(context: T.TProperties, type: T.TSchema, value: unknown
     T.IsUnion(type) ? FromUnion(context, type, value) :
     FromUnknown(context, type, value)
   )
+  return FinalizeRepair(context, type, repaired)
 }

src/value/repair/repair.ts

@@ -32,8 +32,6 @@ import { Arguments } from '../../system/arguments/index.ts'
 import type { TProperties, TSchema, Static } from '../../type/index.ts'
 import { FromType } from './from-type.ts'
 import { Assert } from '../assert/index.ts'
-import { Check } from '../check/index.ts'
-import { Create } from '../create/index.ts'
 
 /**
  * Repairs a value to match the provided type. This function is intended for data migration 
@@ -70,7 +68,6 @@ export function Repair(...args: unknown[]): unknown {
     2: (type, value) => [{}, type, value],
   })
   const repaired = FromType(context, type, value)
-  const checked = Check(context, type, repaired) ? repaired : Create(context, type)
-  Assert(context, type, checked) // ensure correct
-  return checked
+  Assert(context, type, repaired)
+  return repaired
 }

tasks.ts

@@ -8,7 +8,7 @@ import { Range } from './task/range/index.ts'
 import { Metrics } from './task/metrics/index.ts'
 import { Task } from 'tasksmith'
 
-const Version = '1.0.40'
+const Version = '1.0.41'
 
 // ------------------------------------------------------------------
 // Build

test/typebox/runtime/value/repair/~refine.ts

@@ -13,7 +13,7 @@ Test('Should Refine 1', () => {
       greater: Type.Integer({ default: 10 }),
       smaller: Type.Integer({ default: 5 })
     }),
-    (data) => data.greater > data.smaller
+    (value) => value.greater > value.smaller
   )
   const R = Value.Repair(T, { greater: 3, smaller: 7 })
   Assert.IsEqual(R, {
@@ -32,7 +32,7 @@ Test('Should Refine 2', () => {
         smaller: 5
       }
     }),
-    (data) => data.greater > data.smaller
+    (value) => value.greater > value.smaller
   )
   const R = Value.Repair(T, { greater: 3, smaller: 7 })
   Assert.IsEqual(R, {
@@ -51,11 +51,45 @@ Test('Should Refine 3', () => {
         smaller: 50
       }
     }),
-    (data) => data.greater > data.smaller
+    (value) => value.greater > value.smaller
   )
   const R = Value.Repair(T, { greater: 3, smaller: 7 })
   Assert.IsEqual(R, {
     greater: 100,
     smaller: 50
   })
 })
+// ------------------------------------------------------------------
+// Coverage (Fall through case for when post refine-checks pass)
+// ------------------------------------------------------------------
+Test('Should Refine 4', () => {
+  const T = Type.Refine(
+    Type.Object({
+      greater: Type.Integer({ default: 10 }),
+      smaller: Type.Integer({ default: 5 })
+    }),
+    (value) => value.greater > value.smaller
+  )
+  const R = Value.Repair(T, { greater: 10, smaller: 5 })
+  Assert.IsEqual(R, {
+    greater: 10,
+    smaller: 5
+  })
+})
+// ------------------------------------------------------------------
+// https://github.com/sinclairzx81/typebox/issues/1414#issuecomment-3420056090
+// ------------------------------------------------------------------
+Test('Should Refine 5', () => {
+  const T = Type.Object({
+    bounds: Type.Refine(
+      Type.Object({
+        max: Type.Integer({ default: 10 }),
+        min: Type.Integer({ default: 5 })
+      }),
+      (value) => value.max > value.min
+    ),
+    otherData: Type.String({ default: '' })
+  })
+  const R = Value.Repair(T, { bounds: { max: 10, min: 15 }, otherData: 'keep this' })
+  Assert.IsEqual(R, { bounds: { max: 10, min: 5 }, otherData: 'keep this' })
+})