fix: records, test intersections and unions

Author: jedwards1211

src/index.ts

@@ -9,8 +9,8 @@ import UndefinedLiteralType from './types/UndefinedLiteralType'
 import NumberType from './types/NumberType'
 import NumericLiteralType from './types/NumericLiteralType'
 import ObjectType from './types/ObjectType'
-import ObjectTypeIndexer from './types/ObjectTypeIndexer'
 import ObjectTypeProperty from './types/ObjectTypeProperty'
+import RecordType from './types/RecordType'
 import StringLiteralType from './types/StringLiteralType'
 import StringType from './types/StringType'
 import SymbolLiteralType from './types/SymbolLiteralType'
@@ -34,8 +34,8 @@ export {
   NumberType,
   NumericLiteralType,
   ObjectType,
-  ObjectTypeIndexer,
   ObjectTypeProperty,
+  RecordType,
   StringLiteralType,
   StringType,
   SymbolLiteralType,
@@ -149,27 +149,27 @@ export const object = <S extends Record<string | number | symbol, unknown>>({
           Boolean(getOptional(type))
         )
     ),
-    [],
     exact
   ) as any
 
 type Properties = Record<string | number | symbol, Type<any>>
 
 export function simpleObject<Required extends Properties>(
-  required: Required
+  required: Required,
+  { exact }: { exact?: boolean } = {}
 ): ObjectType<{ [K in keyof Required]: Required[K]['__type'] }> {
   return new ObjectType(
     [...Object.entries(required || [])].map(
       ([key, type]) => new ObjectTypeProperty(key, type as Type<any>, false)
-    )
+    ),
+    exact
   ) as any
 }
 
 export const record = <K extends string | number | symbol, V>(
   key: Type<K>,
   value: Type<V>
-): ObjectType<Record<K, V>> =>
-  new ObjectType([], [new ObjectTypeIndexer('key', key, value)]) as any
+): RecordType<K, V> => new RecordType(key, value)
 
 export const tuple = <T extends []>(
   ...types: { [Index in keyof T]: Type<T[Index]> }

src/intersection.spec.ts

@@ -0,0 +1,58 @@
+import * as t from './'
+import { expect } from 'chai'
+import dedent from 'dedent-js'
+import typeOf from './errorReporting/typeOf'
+
+describe(`t.intersection`, function() {
+  const ObjectIntersection = t.intersection(
+    t.simpleObject({ foo: t.number() }, { exact: false }),
+    t.simpleObject({ bar: t.string() }, { exact: false })
+  )
+  it(`accepts valid values`, function() {
+    for (const value of [
+      { foo: 2, bar: 'hello' },
+      { foo: -5, bar: 'world' },
+    ]) {
+      ObjectIntersection.assert(value)
+      expect(ObjectIntersection.accepts(value)).to.be.true
+    }
+  })
+  it(`rejects invalid values`, function() {
+    expect(() => ObjectIntersection.assert({ foo: 3 })).to.throw(
+      t.RuntimeTypeError,
+      dedent`
+          Value must have property: bar
+          
+          Expected: {
+            bar: string
+          }
+          
+          Actual Value: {
+            "foo": 3
+          }
+          
+          Actual Type: {
+            foo: number
+          }`
+    )
+    expect(ObjectIntersection.accepts({ foo: 3 })).to.be.false
+    expect(() => ObjectIntersection.assert({ bar: 'hello' })).to.throw(
+      t.RuntimeTypeError,
+      dedent`
+          Value must have property: foo
+          
+          Expected: {
+            foo: number
+          }
+          
+          Actual Value: {
+            "bar": "hello"
+          }
+          
+          Actual Type: {
+            bar: string
+          }`
+    )
+    expect(ObjectIntersection.accepts({ bar: 'hello' })).to.be.false
+  })
+})

src/object.spec.ts

@@ -48,7 +48,7 @@ describe(`t.object`, function() {
     )
   })
   it(`rejects everything else`, function() {
-    for (const value of [true, 'foo', undefined, 2, []]) {
+    for (const value of [true, 'foo', null, undefined, 2, []]) {
       expect(Person.accepts(value)).to.be.false
       expect(() => Person.assert(value)).to.throw(
         t.RuntimeTypeError,

src/record.spec.ts

@@ -0,0 +1,44 @@
+import * as t from './'
+import { expect } from 'chai'
+import dedent from 'dedent-js'
+import typeOf from './errorReporting/typeOf'
+
+describe(`t.record`, function() {
+  const Numbers = t.record(t.string(), t.number())
+  it(`accepts matching records`, function() {
+    for (const value of [{ a: 1 }, { a: 1, b: 2 }]) {
+      Numbers.assert(value)
+      expect(Numbers.accepts(value)).to.be.true
+    }
+  })
+  it(`rejects values that don't match`, function() {
+    const value = { a: 'one' }
+    expect(() => Numbers.assert(value, '', ['value'])).to.throw(
+      t.RuntimeTypeError,
+      dedent`
+        value.a must be a number
+        
+        Expected: number
+        
+        Actual Value: "one"
+        
+        Actual Type: string`
+    )
+  })
+  it(`rejects everything else`, function() {
+    for (const value of [true, 'foo', null, undefined, 2, []]) {
+      expect(Numbers.accepts(value)).to.be.false
+      expect(() => Numbers.assert(value)).to.throw(
+        t.RuntimeTypeError,
+        dedent`
+        Value must be an object
+
+        Expected: Record<string, number>
+
+        Actual Value: ${JSON.stringify(value)}
+
+        Actual Type: ${typeOf(value)}`
+      )
+    }
+  })
+})

src/ref.spec.ts

@@ -61,9 +61,9 @@ describe(`t.ref`, function() {
         node.left.right should not contain the key: bar
 
         Expected: {
-          value: any;
-          left?: Node;
-          right?: Node;
+          value: any
+          left?: Node
+          right?: Node
         }
         
         Actual Value: {

src/types/IntersectionType.ts

@@ -1,6 +1,4 @@
 import Type from './Type'
-
-import { Property } from './ObjectType'
 import Validation, { ErrorTuple, IdentifierPath } from '../Validation'
 
 export default class IntersectionType<T> extends Type<T> {
@@ -24,40 +22,6 @@ export default class IntersectionType<T> extends Type<T> {
     }
   }
 
-  /**
-   * Get a property with the given name, or undefined if it does not exist.
-   */
-  getProperty<K extends string | number | symbol>(
-    key: K
-  ): Property<K, any> | null | undefined {
-    const { types } = this
-    const { length } = types
-    for (let i = length - 1; i >= 0; i--) {
-      const type: any = types[i]
-      if (typeof type.getProperty === 'function') {
-        const prop = type.getProperty(key)
-        if (prop) {
-          return prop
-        }
-      }
-    }
-  }
-
-  /**
-   * Determine whether a property with the given name exists.
-   */
-  hasProperty(key: string): boolean {
-    const { types } = this
-    const { length } = types
-    for (let i = 0; i < length; i++) {
-      const type: any = types[i]
-      if (typeof type.hasProperty === 'function' && type.hasProperty(key)) {
-        return true
-      }
-    }
-    return false
-  }
-
   accepts(input: any): boolean {
     const { types } = this
     const { length } = types

src/types/ObjectType.ts

@@ -1,11 +1,6 @@
 import Type from './Type'
 
 import ObjectTypeProperty from './ObjectTypeProperty'
-import ObjectTypeIndexer from './ObjectTypeIndexer'
-
-export type Property<K extends string | number | symbol, V> =
-  | ObjectTypeProperty<K, V>
-  | ObjectTypeIndexer<K, V>
 
 import getErrorMessage from '../getErrorMessage'
 import Validation, { ErrorTuple, IdentifierPath } from '../Validation'
@@ -23,17 +18,14 @@ import { keyToString } from '../errorReporting/typeOf'
 export default class ObjectType<T extends {}> extends Type<T> {
   typeName = 'ObjectType'
   readonly properties: ObjectTypeProperty<keyof T, any>[]
-  readonly indexers: ObjectTypeIndexer<any, any>[]
   readonly exact: boolean
 
   constructor(
     properties: ObjectTypeProperty<keyof T, any>[] = [],
-    indexers: ObjectTypeIndexer<any, any>[] = [],
     exact = true
   ) {
     super()
     this.properties = properties
-    this.indexers = indexers
     this.exact = exact
     properties.forEach(prop => (prop.__objectType = this))
   }
@@ -58,15 +50,7 @@ export default class ObjectType<T extends {}> extends Type<T> {
     }
     validation.startCycle(this, input)
 
-    if (this.indexers.length > 0) {
-      if (input instanceof Object && Array.isArray(input)) {
-        yield [path, getErrorMessage('ERR_EXPECT_OBJECT'), this]
-        return
-      }
-      yield* collectErrorsWithIndexers(this, validation, path, input)
-    } else {
-      yield* collectErrorsWithoutIndexers(this, validation, path, input)
-    }
+    yield* collectErrorsWithoutIndexers(this, validation, path, input)
     if (this.exact) {
       yield* collectErrorsExact(this, validation, path, input)
     }
@@ -86,11 +70,7 @@ export default class ObjectType<T extends {}> extends Type<T> {
     startValidationCycle(this, input)
 
     let result
-    if (this.indexers.length > 0) {
-      result = acceptsWithIndexers(this, input)
-    } else {
-      result = acceptsWithoutIndexers(this, input)
-    }
+    result = acceptsWithoutIndexers(this, input)
     if (result && this.exact) {
       result = acceptsExact(this, input)
     }
@@ -99,7 +79,7 @@ export default class ObjectType<T extends {}> extends Type<T> {
   }
 
   toString(): string {
-    const { properties, indexers } = this
+    const { properties } = this
     if (inToStringCycle(this)) {
       return '$Cycle<Record<string, any>>'
     }
@@ -108,45 +88,11 @@ export default class ObjectType<T extends {}> extends Type<T> {
     for (let i = 0; i < properties.length; i++) {
       body.push(properties[i].toString())
     }
-    for (let i = 0; i < indexers.length; i++) {
-      body.push(indexers[i].toString())
-    }
     endToStringCycle(this)
     return `{\n${indent(body.join('\n'))}\n}`
   }
 }
 
-function acceptsWithIndexers(
-  type: ObjectType<any>,
-  input: Record<string, any>
-): boolean {
-  const { properties, indexers } = type
-  const seen = []
-  for (let i = 0; i < properties.length; i++) {
-    const property = properties[i]
-    if (!property.accepts(input)) {
-      return false
-    }
-    seen.push(property.key)
-  }
-  loop: for (const key in input) {
-    if (seen.indexOf(key) !== -1) {
-      continue
-    }
-    const value = (input as any)[key]
-    for (let i = 0; i < indexers.length; i++) {
-      const indexer = indexers[i]
-      if (indexer.acceptsKey(key) && indexer.acceptsValue(value)) {
-        continue loop
-      }
-    }
-
-    // if we got this far the key / value did not accepts any indexers.
-    return false
-  }
-  return true
-}
-
 function acceptsWithoutIndexers(
   type: ObjectType<any>,
   input: Record<string, any>
@@ -175,36 +121,6 @@ function acceptsExact(
   return true
 }
 
-function* collectErrorsWithIndexers(
-  type: ObjectType<any>,
-  validation: Validation<any>,
-  path: IdentifierPath,
-  input: Record<string, any>
-): Generator<ErrorTuple, void, void> {
-  const { properties, indexers } = type
-  const seen = []
-  for (let i = 0; i < properties.length; i++) {
-    const property = properties[i]
-    yield* property.errors(validation, path, input)
-    seen.push(property.key)
-  }
-  loop: for (const key in input) {
-    if (seen.indexOf(key) !== -1) {
-      continue
-    }
-    const value = (input as any)[key]
-    for (let i = 0; i < indexers.length; i++) {
-      const indexer = indexers[i]
-      if (indexer.acceptsKey(key) && indexer.acceptsValue(value)) {
-        continue loop
-      }
-    }
-
-    // if we got this far the key / value was not accepted by any indexers.
-    yield [path.concat(key), getErrorMessage('ERR_NO_INDEXER'), type]
-  }
-}
-
 function* collectErrorsWithoutIndexers(
   type: ObjectType<any>,
   validation: Validation<any>,