fix: check type constructor arguments

src/types/ArrayType.ts

@@ -1,4 +1,4 @@
-import Type from './Type'
+import Type, { assertIsType } from './Type'
 import Validation, { IdentifierPath } from '../Validation'
 
 import {
@@ -18,6 +18,7 @@ export default class ArrayType<T> extends Type<Array<T>> {
 
   constructor(elementType: Type<T>) {
     super()
+    assertIsType(elementType, 'elementType')
     this.elementType = elementType
   }
 

src/types/BooleanLiteralType.ts

@@ -7,5 +7,8 @@ export default class BooleanLiteralType<
 
   constructor(value: T) {
     super(value)
+    if (typeof value !== 'boolean') {
+      throw new Error(`value must be a boolean`)
+    }
   }
 }

src/types/IntersectionType.ts

@@ -1,4 +1,4 @@
-import Type from './Type'
+import Type, { assertIsType } from './Type'
 import Validation, { IdentifierPath } from '../Validation'
 import RuntimeTypeErrorItem from '../errorReporting/RuntimeTypeErrorItem'
 import ObjectType from './ObjectType'
@@ -12,6 +12,9 @@ export default class IntersectionType<T> extends Type<T> {
 
   constructor(types: Type<any>[]) {
     super()
+    for (let i = 0; i < types.length; i++) {
+      assertIsType(types[i], `types[${i}]`)
+    }
     this.types = types
   }
 

src/types/MergedObjectType.ts

@@ -1,4 +1,4 @@
-import Type from './Type'
+import Type, { assertIsType } from './Type'
 import ObjectType from './ObjectType'
 import ObjectTypeProperty from './ObjectTypeProperty'
 import Validation, { IdentifierPath } from '../Validation'
@@ -12,6 +12,9 @@ export default class MergedObjectType<T extends {}> extends Type<T> {
 
   constructor(objects: Type<T>[], exact = true) {
     super()
+    for (let i = 0; i < objects.length; i++) {
+      assertIsType(objects[i], `objects[${i}]`)
+    }
     this.objects = objects
     this.exact = exact
   }

src/types/NumericLiteralType.ts

@@ -7,6 +7,9 @@ export default class NumericLiteralType<
 
   constructor(value: T) {
     super(value)
+    if (typeof value !== 'number') {
+      throw new Error(`value must be a number`)
+    }
   }
 
   toString(): string {

src/types/ObjectType.ts

@@ -25,6 +25,13 @@ export default class ObjectType<T extends {}> extends Type<T> {
     exact = true
   ) {
     super()
+    for (let i = 0; i < properties.length; i++) {
+      if (!(properties[i] instanceof ObjectTypeProperty)) {
+        throw new Error(
+          `properties[${i}] must be an instance of ObjectTypeProperty`
+        )
+      }
+    }
     this.properties = properties
     this.exact = exact
     properties.forEach(prop => (prop.__objectType = this))

src/types/ObjectTypeProperty.ts

@@ -1,4 +1,4 @@
-import Type from './Type'
+import Type, { assertIsType } from './Type'
 import Validation, { IdentifierPath } from '../Validation'
 import RuntimeTypeErrorItem from '../errorReporting/RuntimeTypeErrorItem'
 import MissingPropertyErrorItem from '../errorReporting/MissingPropertyErrorItem'
@@ -16,6 +16,15 @@ export default class ObjectTypeProperty<
 
   constructor(key: K, value: Type<V>, optional: boolean) {
     super()
+    switch (typeof key) {
+      case 'number':
+      case 'string':
+      case 'symbol':
+        break
+      default:
+        throw new Error('key must be a number, string or symbol')
+    }
+    assertIsType(value, 'value')
     this.key = key
     this.value = value
     this.optional = optional

src/types/RecordType.ts

@@ -1,4 +1,4 @@
-import Type from './Type'
+import Type, { assertIsType } from './Type'
 import Validation, { IdentifierPath } from '../Validation'
 
 import {
@@ -23,6 +23,8 @@ export default class RecordType<
 
   constructor(key: Type<K>, value: Type<V>) {
     super()
+    assertIsType(key, 'key')
+    assertIsType(value, 'value')
     this.key = key
     this.value = value
   }

src/types/StringLiteralType.ts

@@ -7,6 +7,9 @@ export default class StringLiteralType<
 
   constructor(value: T) {
     super(value)
+    if (typeof value !== 'string') {
+      throw new Error(`value must be a string`)
+    }
   }
 
   toString(): string {

src/types/SymbolLiteralType.ts

@@ -7,5 +7,8 @@ export default class SymbolLiteralType<
 
   constructor(value: T) {
     super(value)
+    if (typeof value !== 'symbol') {
+      throw new Error(`value must be symbol`)
+    }
   }
 }

src/types/TupleType.ts

@@ -1,4 +1,4 @@
-import Type from './Type'
+import Type, { assertIsType } from './Type'
 import Validation, { IdentifierPath } from '../Validation'
 import RuntimeTypeErrorItem from '../errorReporting/RuntimeTypeErrorItem'
 import InvalidLengthErrorItem from '../errorReporting/InvalidLengthErrorItem'
@@ -10,6 +10,9 @@ export default class TupleType<T extends any[]> extends Type<T> {
 
   constructor(types: { [Index in keyof T]: Type<T[Index]> }) {
     super()
+    for (let i = 0; i < types.length; i++) {
+      assertIsType(types[i], `types[${i}]`)
+    }
     this.types = types
   }
 

src/types/Type.ts

@@ -3,6 +3,11 @@ import { IdentifierPath } from '../Validation'
 import RuntimeTypeErrorItem from '../errorReporting/RuntimeTypeErrorItem'
 import RuntimeTypeError from '../errorReporting/RuntimeTypeError'
 
+export function assertIsType(x: unknown, name: string): void {
+  if (!(x instanceof Type))
+    throw new Error(`${name} must be an instance of Type`)
+}
+
 /**
  * # Type
  *

src/types/TypeAlias.ts

@@ -1,4 +1,4 @@
-import Type from './Type'
+import Type, { assertIsType } from './Type'
 import Validation, { IdentifierPath } from '../Validation'
 import {
   collectConstraintErrors,
@@ -15,6 +15,7 @@ export default class TypeAlias<T> extends Type<T> {
 
   constructor(name: string, type: Type<T>) {
     super()
+    assertIsType(type, 'type')
     this.name = name
     this.type = type
   }

src/types/UnionType.ts

@@ -1,4 +1,4 @@
-import Type from './Type'
+import Type, { assertIsType } from './Type'
 import Validation, { IdentifierPath } from '../Validation'
 import RuntimeTypeErrorItem from '../errorReporting/RuntimeTypeErrorItem'
 import InvalidTypeErrorItem from '../errorReporting/InvalidTypeErrorItem'
@@ -64,6 +64,9 @@ export default class UnionType<T> extends Type<T> {
 
   constructor(types: Type<any>[]) {
     super()
+    for (let i = 0; i < types.length; i++) {
+      assertIsType(types[i], `types[${i}]`)
+    }
     this.types = types
   }
 

test/alias.spec.ts

@@ -9,6 +9,9 @@ describe(`t.alias`, function() {
       t.alias('Foo', t.number()).addConstraint(() => undefined).hasConstraints
     ).to.be.true
   })
+  it(`requires type to be an instance of Type`, function() {
+    expect(() => t.alias('Foo', 2 as any)).to.throw()
+  })
   describe(`constraints`, function() {
     const PositiveNumberType = t
       .alias('PositiveNumber', t.number())

test/allOf.spec.ts

@@ -4,6 +4,9 @@ import dedent from 'dedent-js'
 import stringifyValue from '../src/errorReporting/stringifyValue'
 
 describe(`t.allOf`, function() {
+  it(`requires all types to be instance of Type`, function() {
+    expect(() => t.oneOf(t.null(), 2 as any)).to.throw()
+  })
   describe(`intersection of unions`, function() {
     const NumberOrNull = t.allOf(
       t.oneOf(t.number(), t.string(), t.null()),

test/array.spec.ts

@@ -3,6 +3,9 @@ import { expect } from 'chai'
 import dedent from 'dedent-js'
 
 describe(`t.array`, function() {
+  it(`requires elementType to be an instance of Type`, function() {
+    expect(() => t.array(2 as any)).to.throw()
+  })
   it(`accepts matching arrays`, function() {
     t.array(t.number()).assert([1, 2, 3])
     expect(t.array(t.number()).accepts([1, 2, 3])).to.be.true

test/boolean.spec.ts

@@ -44,6 +44,9 @@ describe(`t.boolean`, function() {
 })
 
 describe(`t.boolean(literal)`, function() {
+  it(`requires value to be a boolean`, function() {
+    expect(() => t.boolean(2 as any)).to.throw()
+  })
   it(`accepts literal value`, function() {
     t.boolean(true).assert(true)
     t.boolean(false).assert(false)

test/merge.spec.ts

@@ -3,6 +3,9 @@ import { expect } from 'chai'
 import dedent from 'dedent-js'
 
 describe(`t.merge`, function() {
+  it(`requires objectTypes to be instance of Type`, function() {
+    expect(() => t.merge(t.object({ foo: t.number() }), 2 as any)).to.throw()
+  })
   const BarAlias = t.alias('Bar', t.object({ bar: t.string() }))
   const Merged = t.merge(
     t.object({ foo: t.number() }),

test/number.spec.ts

@@ -31,6 +31,9 @@ describe(`t.number`, function() {
 })
 
 describe(`t.number(literal)`, function() {
+  it(`requires value to be a boolean`, function() {
+    expect(() => t.number('1' as any)).to.throw()
+  })
   it(`accepts literal value`, function() {
     t.number(2).assert(2)
     t.number(15).assert(15)

test/object.spec.ts

@@ -3,6 +3,10 @@ import { expect } from 'chai'
 import dedent from 'dedent-js'
 
 describe(`t.object`, function() {
+  it(`requires values to be instance of Type`, function() {
+    expect(() => t.object({ name: 2 as any })).to.throw()
+  })
+
   const Person = t.object({
     required: {
       name: t.string(),

test/oneOf.spec.ts

@@ -4,6 +4,9 @@ import dedent from 'dedent-js'
 import stringifyValue from '../src/errorReporting/stringifyValue'
 
 describe(`t.oneOf`, function() {
+  it(`requires types to be instance of Type`, function() {
+    expect(() => t.oneOf(t.object({ foo: t.number() }), 2 as any)).to.throw()
+  })
   const NumberOrString = t.oneOf(t.number(), t.string())
 
   const ObjectUnion = t.oneOf(

test/record.spec.ts

@@ -3,6 +3,12 @@ import { expect } from 'chai'
 import dedent from 'dedent-js'
 
 describe(`t.record`, function() {
+  it(`requires key to be instance of Type`, function() {
+    expect(() => t.record('hello' as any, t.number())).to.throw()
+  })
+  it(`requires value to be instance of Type`, function() {
+    expect(() => t.record(t.string('a'), 2 as any)).to.throw()
+  })
   const Numbers = t.record(
     t.oneOf(t.string('a'), t.string('b'), t.string('c')),
     t.number()

test/string.spec.ts

@@ -31,6 +31,9 @@ describe(`t.string`, function() {
 })
 
 describe(`t.string(literal)`, function() {
+  it(`requires value to be a string`, function() {
+    expect(() => t.string(1 as any)).to.throw()
+  })
   it(`accepts literal value`, function() {
     t.string('foo').assert('foo')
     t.string('').assert('')

test/symbol.spec.ts

@@ -34,6 +34,9 @@ describe(`t.symbol`, function() {
 })
 
 describe(`t.symbol(literal)`, function() {
+  it(`requires value to be a string`, function() {
+    expect(() => t.symbol('hello')).to.throw()
+  })
   const foo = Symbol('foo')
   const bar = Symbol('bar')
   it(`accepts literal value`, function() {

test/tuple.spec.ts

@@ -4,6 +4,9 @@ import dedent from 'dedent-js'
 import stringifyValue from '../src/errorReporting/stringifyValue'
 
 describe(`t.tuple`, function() {
+  it(`requires types to be instance of Type`, function() {
+    expect(() => t.tuple(t.object({ foo: t.number() }), 2 as any)).to.throw()
+  })
   const TheTuple = t.tuple(t.string(), t.number(), t.boolean())
   it(`accepts matching types`, function() {
     for (const value of [