Support Unregistered Kinds in ObjectMap (#385)

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.27.7",
+  "version": "0.27.8",
   "description": "JSONSchema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",

src/typebox.ts

@@ -1832,24 +1832,24 @@ export namespace TypeClone {
 // --------------------------------------------------------------------------
 export namespace ObjectMap {
   function Intersect(schema: TIntersect, callback: (object: TObject) => TObject) {
-    return Type.Intersect(
-      schema.allOf.map((inner) => Visit(inner, callback)),
-      { ...schema },
-    )
+    // prettier-ignore
+    return Type.Intersect(schema.allOf.map((inner) => Visit(inner, callback)), { ...schema })
   }
   function Union(schema: TUnion, callback: (object: TObject) => TObject) {
-    return Type.Union(
-      schema.anyOf.map((inner) => Visit(inner, callback)),
-      { ...schema },
-    )
+    // prettier-ignore
+    return Type.Union(schema.anyOf.map((inner) => Visit(inner, callback)), { ...schema })
   }
   function Object(schema: TObject, callback: (object: TObject) => TObject) {
     return callback(schema)
   }
   function Visit(schema: TSchema, callback: (object: TObject) => TObject): TSchema {
-    if (TypeGuard.TIntersect(schema)) return Intersect(schema, callback)
-    if (TypeGuard.TUnion(schema)) return Union(schema, callback)
-    if (TypeGuard.TObject(schema)) return Object(schema, callback)
+    // There are cases where users need to map objects with unregistered kinds. Using a TypeGuard here would
+    // prevent sub schema mapping as unregistered kinds will not pass TSchema checks. This is notable in the
+    // case of TObject where unregistered property kinds cause the TObject check to fail. As mapping is only
+    // used for composition, we use explicit checks instead.
+    if (schema[Kind] === 'Intersect') return Intersect(schema as TIntersect, callback)
+    if (schema[Kind] === 'Union') return Union(schema as TUnion, callback)
+    if (schema[Kind] === 'Object') return Object(schema as TObject, callback)
     return schema
   }
   export function Map<T = TSchema>(schema: TSchema, callback: (object: TObject) => TObject, options: SchemaOptions): T {

test/runtime/compiler/omit.ts

@@ -1,6 +1,6 @@
-import { Type } from '@sinclair/typebox'
+import { Type, Kind } from '@sinclair/typebox'
 import { Ok, Fail } from './validate'
-import { strictEqual } from 'assert'
+import { deepEqual, strictEqual } from 'assert'
 
 describe('type/compiler/Omit', () => {
   it('Should omit properties on the source schema', () => {

test/runtime/compiler/partial.ts

@@ -50,20 +50,4 @@ describe('type/compiler/Partial', () => {
     strictEqual(A.additionalProperties, false)
     strictEqual(T.additionalProperties, false)
   })
-  it('Should support partial properties of raw TUnsafe', () => {
-    // https://github.com/sinclairzx81/typebox/issues/364
-    const T = Type.Partial(Type.Object({ x: Type.Unsafe({ x: 1 }) }))
-    strictEqual(T.required, undefined)
-  })
-  it('Should not support partial properties of unknown TUnsafe', () => {
-    // https://github.com/sinclairzx81/typebox/issues/364
-    const T = Type.Partial(Type.Object({ x: Type.Unsafe({ [Kind]: 'UnknownPartialType', x: 1 }) }))
-    strictEqual(T.required![0], 'x')
-  })
-  it('Should support partial properties of custom TUnsafe', () => {
-    // https://github.com/sinclairzx81/typebox/issues/364
-    const U = TypeSystem.Type('CustomPartialType', () => true)
-    const T = Type.Partial(Type.Object({ x: U() }))
-    strictEqual(T.required, undefined)
-  })
 })

test/runtime/type/guard/index.ts

@@ -16,6 +16,9 @@ import './not'
 import './null'
 import './number'
 import './object'
+import './omit'
+import './partial'
+import './pick'
 import './promise'
 import './record'
 import './ref'

test/runtime/type/guard/omit.ts

@@ -0,0 +1,17 @@
+import { TypeGuard } from '@sinclair/typebox'
+import { Type, Kind } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('type/guard/TOmit', () => {
+  // -------------------------------------------------------------------------
+  // case: https://github.com/sinclairzx81/typebox/issues/384
+  // -------------------------------------------------------------------------
+  it('Should support TUnsafe omit properties with no Kind', () => {
+    const T = Type.Omit(Type.Object({ x: Type.Unsafe({ x: 1 }), y: Type.Number() }), ['x'])
+    Assert.deepEqual(T.required, ['y'])
+  })
+  it('Should support TUnsafe omit properties with unregistered Kind', () => {
+    const T = Type.Omit(Type.Object({ x: Type.Unsafe({ x: 1, [Kind]: 'UnknownOmitType' }), y: Type.Number() }), ['x'])
+    Assert.deepEqual(T.required, ['y'])
+  })
+})

test/runtime/type/guard/partial.ts

@@ -0,0 +1,23 @@
+import { TypeSystem } from '@sinclair/typebox/system'
+import { TypeGuard } from '@sinclair/typebox'
+import { Type, Kind } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('type/guard/TPartial', () => {
+  // -------------------------------------------------------------------------
+  // case: https://github.com/sinclairzx81/typebox/issues/364
+  // -------------------------------------------------------------------------
+  it('Should support TUnsafe partial properties with no Kind', () => {
+    const T = Type.Partial(Type.Object({ x: Type.Unsafe({ x: 1 }) }))
+    Assert.deepEqual(T.required, undefined)
+  })
+  it('Should support TUnsafe partial properties with unregistered Kind', () => {
+    const T = Type.Partial(Type.Object({ x: Type.Unsafe({ [Kind]: 'UnknownPartialType', x: 1 }) }))
+    Assert.deepEqual(T.required, undefined)
+  })
+  it('Should support TUnsafe partial properties with registered Kind', () => {
+    const U = TypeSystem.Type('CustomPartialType', () => true)
+    const T = Type.Partial(Type.Object({ x: U() }))
+    Assert.deepEqual(T.required, undefined)
+  })
+})

test/runtime/type/guard/pick.ts

@@ -0,0 +1,17 @@
+import { TypeGuard } from '@sinclair/typebox'
+import { Type, Kind } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('type/guard/TPick', () => {
+  // -------------------------------------------------------------------------
+  // case: https://github.com/sinclairzx81/typebox/issues/384
+  // -------------------------------------------------------------------------
+  it('Should support TUnsafe omit properties with no Kind', () => {
+    const T = Type.Pick(Type.Object({ x: Type.Unsafe({ x: 1 }), y: Type.Number() }), ['x'])
+    Assert.deepEqual(T.required, ['x'])
+  })
+  it('Should support TUnsafe omit properties with unregistered Kind', () => {
+    const T = Type.Pick(Type.Object({ x: Type.Unsafe({ x: 1, [Kind]: 'UnknownPickType' }), y: Type.Number() }), ['x'])
+    Assert.deepEqual(T.required, ['x'])
+  })
+})