Composite Evaluate (#349)

Author: sinclairzx81

changelog/0.26.2.md

@@ -0,0 +1,38 @@
+## [0.26.2](https://www.npmjs.com/package/@sinclair/typebox/v/0.26.2)
+
+Updates:
+
+- [331](https://github.com/sinclairzx81/typebox/pull/349) Revert 0.25.0 Intersect logic for Composite
+
+Notes:
+
+This PR reverts the logic on Type.Composite back to 0.25.0 Type.Intersect due to excessive type instantiation issues. On 0.26.0, Type.Composite attempted to take a union for overlapping properties, however due to the sophistication required to type map the unions for overlapping properties, this has resulted in type instantiation problems for some users upgrading to 0.26.0.
+
+As such, 0.26.2 reverts back to the 0.25.0 interpretation, but applies type mappings more inline with TS's interpretation of an overlapping varying property types. In the examples below, the type `C` is the evaluated type for Type.Composite. Note that TS will not union for overlapping properties and instead evaluate `never`. The 0.26.2 implementation falls inline with this evaluation.
+
+```typescript
+{ // evaluation case 1: non-varying
+  type T = { a: number } & { a: number }
+
+  type C = {[K in keyof T]: T[K] }  // type C = { a: number }
+}
+
+{ // evaluation case 2: varying
+  type T = { a: number } & { a: string }
+
+  type C = {[K in keyof T]: T[K] }  // type C = { a: never }
+}
+
+{ // evaluation case 3: single optional
+  type T = { a?: number } & { a: number }
+
+  type C = {[K in keyof T]: T[K] }  // type C = { a: number }
+}
+
+{ // evaluation case 4: all optional
+  type T = { a?: number } & { a?: number }
+
+  type C = {[K in keyof T]: T[K] }  // type C = { a: number | undefined }
+}
+```
+Note: the Type.Composite is intended to be a temporary type which can be replaced with a more general `Type.Mapped` in future revisions of TypeBox. As the infrastructure to support mapped types does not exist, users can use Type.Composite to partially replicate mapped type evaluation for composited object types only.

package.json

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

readme.md

@@ -229,13 +229,13 @@ The following table lists the Standard TypeBox types. These types are fully comp
 │                                │                             │                                │
 ├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
 │ const T = Type.Null()          │ type T = null               │ const T = {                    │
-│                                │                             │    type: 'null'                │
+│                                │                             │   type: 'null'                 │
 │                                │                             │ }                              │
 │                                │                             │                                │
 ├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
 │ const T = Type.Literal(42)     │ type T = 42                 │ const T = {                    │
-│                                │                             │    const: 42,                  │
-│                                │                             │    type: 'number'              │
+│                                │                             │   const: 42,                   │
+│                                │                             │   type: 'number'               │
 │                                │                             │ }                              │
 │                                │                             │                                │
 ├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
@@ -326,19 +326,16 @@ The following table lists the Standard TypeBox types. These types are fully comp
 │                                │                             │                                │
 ├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
 │ const T = Type.Composite([     │ type T = {                  │ const T = {                    │
-│   Type.Object({                │   x: number | string        │   type: 'object',              │
-│     x: Type.Number()           │   y: number                 │   properties: {                │
-│   }),                          │ }                           │     x: {                       │
-│   Type.Object({                │                             │       anyOf: [                 │
-│     x: Type.String()           │                             │         { type: 'number' },    │
-│     y: Type.Number()           │                             │         { type: 'string' }     │
-│   })                           │                             │       ]                        │
-│ ])                             │                             │     },                         │
-│                                │                             │     y: {                       │
+│   Type.Object({                │   x: number                 │   type: 'object',              │
+│     x: Type.Number()           │   y: number                 │   required: ['x', 'y'],        │
+│   }),                          │ }                           │   properties: {                │
+│   Type.Object({                │                             │     x: {                       │
+│     y: Type.Number()           │                             │       type: 'number'           │
+│   })                           │                             │     },                         │
+│ ])                             │                             │     y: {                       │
 │                                │                             │       type: 'number'           │
 │                                │                             │     }                          │
-│                                │                             │   },                           │
-│                                │                             │   required: ['x', 'y']         │
+│                                │                             │   }                            │
 │                                │                             │ }                              │
 │                                │                             │                                │
 ├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤

src/typebox.ts

@@ -168,21 +168,14 @@ export type TInstanceType<T extends TConstructor<TSchema[], TSchema>> = T['retur
 // --------------------------------------------------------------------------
 // TComposite
 // --------------------------------------------------------------------------
-export type TCompositeUnion<Left extends TSchema, Right extends TSchema> = Ensure<TUnion<[Left, Right]>>
-// note: we need to take the left and right as the accumulator is assigned for multiple composite property sets with missing properties.
-export type TCompositeUnionLeft<T extends TObject, Acc extends TProperties> = {
-  [K in keyof T['properties']]: K extends keyof Acc ? TCompositeUnion<T['properties'][K], Acc[K]> : T['properties'][K]
+export type TCompositeEvaluateArray<T extends readonly TSchema[], P extends unknown[]> = { [K in keyof T]: T[K] extends TSchema ? Static<T[K], P> : never }
+export type TCompositeArray<T extends readonly TObject[]> = { [K in keyof T]: T[K] extends TObject<infer P> ? P : {} }
+export type TCompositeProperties<I extends unknown, T extends readonly any[]> = Evaluate<T extends [infer A, ...infer B] ? TCompositeProperties<I & A, B> : I extends object ? I : {}>
+export interface TComposite<T extends TObject[] = TObject[]> extends TObject {
+  [Hint]: 'Composite' // Hint is required to differentiate between object | intersection on pick, omit, required, partial and keyof
+  static: Evaluate<TCompositeProperties<unknown, TCompositeEvaluateArray<T, this['params']>>>
+  properties: TCompositeProperties<unknown, TCompositeArray<T>>
 }
-export type TCompositeUnionRight<T extends TObject, Acc extends TProperties> = {
-  [K in keyof Acc]: K extends keyof T['properties'] ? TCompositeUnion<T['properties'][K], Acc[K]> : Acc[K]
-}
-export type TCompositeUnionObject<T extends TObject, Acc extends TProperties> = Evaluate<TCompositeUnionLeft<T, Acc> & TCompositeUnionRight<T, Acc>>
-// prettier-ignore
-export type TCompositeProperties<T extends TObject[], Acc extends TProperties> = 
-  T extends [...infer L, infer R] ? TCompositeProperties<Assert<L, TObject[]>, TCompositeUnionObject<Assert<R, TObject>, Acc>> :
-  T extends [] ? Acc :
-  never
-export type TComposite<T extends TObject[] = TObject[]> = Ensure<TObject<TCompositeProperties<T, {}>>>
 // --------------------------------------------------------------------------
 // TConstructor
 // --------------------------------------------------------------------------
@@ -275,6 +268,7 @@ export interface IntersectOptions extends SchemaOptions {
   unevaluatedProperties?: TUnevaluatedProperties
 }
 export type TIntersectStatic<T extends TSchema[], P extends unknown[]> = TupleToIntersect<{ [K in keyof T]: Static<Assert<T[K], TSchema>, P> }>
+
 export interface TIntersect<T extends TSchema[] = TSchema[]> extends TSchema, IntersectOptions {
   [Kind]: 'Intersect'
   type?: 'object'
@@ -292,6 +286,7 @@ export type TKeyOfTuple<T extends TSchema> = {
   : never
 // prettier-ignore
 export type TKeyOf<T extends TSchema = TSchema> = (
+  T extends TComposite ? TKeyOfTuple<T> :
   T extends TIntersect ? TKeyOfTuple<T> :
   T extends TUnion     ? TKeyOfTuple<T> :
   T extends TObject    ? TKeyOfTuple<T> :
@@ -312,7 +307,7 @@ export interface TLiteral<T extends TLiteralValue = TLiteralValue> extends TSche
 export interface TNever extends TSchema {
   [Kind]: 'Never'
   static: never
-  allOf: [{ type: 'boolean'; const: false }, { type: 'boolean'; const: true }]
+  not: {}
 }
 // --------------------------------------------------------------------------
 // TNot
@@ -381,6 +376,7 @@ export type TOmitArray<T extends TSchema[], K extends keyof any> = Assert<{ [K2
 export type TOmitProperties<T extends TProperties, K extends keyof any> = Evaluate<Assert<Omit<T, K>, TProperties>>
 // prettier-ignore
 export type TOmit<T extends TSchema, K extends keyof any> = 
+  T extends TComposite<infer S> ? TComposite<TOmitArray<S, K>> :
   T extends TIntersect<infer S> ? TIntersect<TOmitArray<S, K>> : 
   T extends TUnion<infer S> ? TUnion<TOmitArray<S, K>> : 
   T extends TObject<infer S> ? TObject<TOmitProperties<S, K>> : 
@@ -392,6 +388,7 @@ export type TParameters<T extends TFunction> = TTuple<T['parameters']>
 // --------------------------------------------------------------------------
 // TPartial
 // --------------------------------------------------------------------------
+export type TPartialObjectArray<T extends TObject[]> = Assert<{ [K in keyof T]: TPartial<Assert<T[K], TObject>> }, TObject[]>
 export type TPartialArray<T extends TSchema[]> = Assert<{ [K in keyof T]: TPartial<Assert<T[K], TSchema>> }, TSchema[]>
 // prettier-ignore
 export type TPartialProperties<T extends TProperties> = Evaluate<Assert<{
@@ -402,7 +399,8 @@ export type TPartialProperties<T extends TProperties> = Evaluate<Assert<{
     TOptional<T[K]>
 }, TProperties>>
 // prettier-ignore
-export type TPartial<T extends TSchema> = 
+export type TPartial<T extends TSchema> =  
+  T extends TComposite<infer S> ? TComposite<TPartialArray<S>> :
   T extends TIntersect<infer S> ? TIntersect<TPartialArray<S>> : 
   T extends TUnion<infer S>     ? TUnion<TPartialArray<S>> : 
   T extends TObject<infer S>    ? TObject<TPartialProperties<S>> : 
@@ -420,11 +418,11 @@ export type TPickProperties<T extends TProperties, K extends keyof any> =
   }): never
 // prettier-ignore
 export type TPick<T extends TSchema, K extends keyof any> = 
+  T extends TComposite<infer S> ? TComposite<TPickArray<S, K>> :
   T extends TIntersect<infer S> ? TIntersect<TPickArray<S, K>> : 
   T extends TUnion<infer S> ? TUnion<TPickArray<S, K>> : 
   T extends TObject<infer S> ? TObject<TPickProperties<S, K>> :
   T
-
 // --------------------------------------------------------------------------
 // TPromise
 // --------------------------------------------------------------------------
@@ -489,6 +487,7 @@ export type TRequiredProperties<T extends TProperties> = Evaluate<Assert<{
 }, TProperties>>
 // prettier-ignore
 export type TRequired<T extends TSchema> = 
+  T extends TComposite<infer S> ? TComposite<TRequiredArray<S>> : 
   T extends TIntersect<infer S> ? TIntersect<TRequiredArray<S>> : 
   T extends TUnion<infer S>     ? TUnion<TRequiredArray<S>> : 
   T extends TObject<infer S>    ? TObject<TRequiredProperties<S>> : 
@@ -1845,15 +1844,41 @@ export class StandardTypeBuilder extends TypeBuilder {
   public Boolean(options: SchemaOptions = {}): TBoolean {
     return this.Create({ ...options, [Kind]: 'Boolean', type: 'boolean' })
   }
-  /** `[Standard]` Creates a Composite object type that will union any overlapping properties of the given object array */
-  public Composite<T extends TObject[]>(schemas: [...T], options?: ObjectOptions): TComposite<T> {
-    const properties = {} as TProperties
-    for (const object of schemas) {
-      for (const [key, property] of globalThis.Object.entries(object.properties)) {
-        properties[key] = key in properties ? this.Union([properties[key], property]) : TypeClone.Clone(property, {})
+  /** `[Standard]` Creates a Composite object type. */
+  public Composite<T extends TObject[]>(objects: [...T], options?: ObjectOptions): TComposite<T> {
+    const isOptionalAll = (objects: TObject[], key: string) => objects.every((object) => !(key in object.properties) || IsOptional(object.properties[key]))
+    const IsOptional = (schema: TSchema) => TypeGuard.TOptional(schema) || TypeGuard.TReadonlyOptional(schema)
+    const [required, optional] = [new Set<string>(), new Set<string>()]
+    for (const object of objects) {
+      for (const key of globalThis.Object.getOwnPropertyNames(object.properties)) {
+        if (isOptionalAll(objects, key)) optional.add(key)
+      }
+    }
+    for (const object of objects) {
+      for (const key of globalThis.Object.getOwnPropertyNames(object.properties)) {
+        if (!optional.has(key)) required.add(key)
       }
     }
-    return this.Object(properties, options) as TComposite<T>
+    const properties = {} as Record<keyof any, any>
+    for (const object of objects) {
+      for (const [key, schema] of Object.entries(object.properties)) {
+        const property = TypeClone.Clone(schema, {})
+        if (!optional.has(key)) delete property[Modifier]
+        if (key in properties) {
+          const left = TypeExtends.Extends(properties[key], property) !== TypeExtendsResult.False
+          const right = TypeExtends.Extends(property, properties[key]) !== TypeExtendsResult.False
+          if (!left && !right) properties[key] = Type.Never()
+          if (!left && right) properties[key] = property
+        } else {
+          properties[key] = property
+        }
+      }
+    }
+    if (required.size > 0) {
+      return this.Create({ ...options, [Kind]: 'Object', [Hint]: 'Composite', type: 'object', properties, required: [...required] })
+    } else {
+      return this.Create({ ...options, [Kind]: 'Object', [Hint]: 'Composite', type: 'object', properties })
+    }
   }
   /** `[Standard]` Creates a Enum type */
   public Enum<T extends Record<string, string | number>>(item: T, options: SchemaOptions = {}): TEnum<T> {

test/runtime/compiler/composite.ts

@@ -1,4 +1,4 @@
-import { Type, Static } from '@sinclair/typebox'
+import { Type } from '@sinclair/typebox'
 import { Ok, Fail } from './validate'
 
 describe('type/compiler/Composite', () => {
@@ -13,33 +13,45 @@ describe('type/compiler/Composite', () => {
     const B = Type.Partial(Type.Object({ b: Type.Number() }))
     const P = Type.Composite([A, B], { additionalProperties: false })
     Ok(P, { a: 1, b: 2 })
+    Ok(P, { a: 1 })
+    Ok(P, { b: 1 })
+    Ok(P, {})
+    Fail(P, { a: 1, b: 2, c: 3 })
+    Fail(P, { c: 1 })
   })
   it('Should compose with overlapping same type', () => {
     const A = Type.Object({ a: Type.Number() })
     const B = Type.Object({ a: Type.Number() })
     const P = Type.Composite([A, B])
     Ok(P, { a: 1 })
-    Fail(P, { a: 'hello' })
-    Fail(P, {})
+    Fail(P, { a: '1' })
   })
-  it('Should compose with overlapping varying type', () => {
+  it('Should not compose with overlapping varying type', () => {
     const A = Type.Object({ a: Type.Number() })
     const B = Type.Object({ a: Type.String() })
     const T = Type.Composite([A, B])
-    Ok(T, { a: 1 })
-    Ok(T, { a: 'hello' })
+    Fail(T, { a: 1 })
+    Fail(T, { a: 'hello' })
     Fail(T, {})
   })
   it('Should compose with deeply nest overlapping varying type', () => {
+    const A = Type.Object({ a: Type.Number() })
+    const B = Type.Object({ b: Type.String() })
+    const C = Type.Object({ c: Type.Boolean() })
+    const D = Type.Object({ d: Type.Null() })
+    const T = Type.Composite([A, B, C, D])
+    Ok(T, { a: 1, b: 'hello', c: true, d: null })
+  })
+  it('Should not compose with deeply nest overlapping varying type', () => {
     const A = Type.Object({ a: Type.Number() })
     const B = Type.Object({ a: Type.String() })
     const C = Type.Object({ a: Type.Boolean() })
     const D = Type.Object({ a: Type.Null() })
     const T = Type.Composite([A, B, C, D])
-    Ok(T, { a: 1 })
-    Ok(T, { a: 'hello' })
-    Ok(T, { a: false })
-    Ok(T, { a: null })
+    Fail(T, { a: 1 })
+    Fail(T, { a: 'hello' })
+    Fail(T, { a: false })
+    Fail(T, { a: null })
     Fail(T, { a: [] })
     Fail(T, {})
   })
@@ -61,13 +73,12 @@ describe('type/compiler/Composite', () => {
     Ok(P, { x: 1, y: 1 })
     Fail(P, { x: 1, y: 1, z: 1 })
   })
-
   it('Should compose nested object properties', () => {
     const A = Type.Object({ x: Type.Object({ x: Type.Number() }) })
-    const B = Type.Object({ x: Type.Object({ x: Type.String() }) })
+    const B = Type.Object({ y: Type.Object({ x: Type.String() }) })
     const T = Type.Composite([A, B])
-    Ok(T, { x: { x: 1 } })
-    Ok(T, { x: { x: 'hello' } })
-    Fail(T, { x: { x: false } })
+    Ok(T, { x: { x: 1 }, y: { x: '' } })
+    Fail(T, { x: { x: '1' }, y: { x: '' } })
+    Fail(T, { x: { x: 1 }, y: { x: 1 } })
   })
 })