justus 0.0.7 → 0.1.1

package/src/dts-generator.ts

@@ -1,22 +1,32 @@
 import ts from 'typescript'
 import {
   AllOfValidator,
+  any,
   AnyArrayValidator,
   AnyNumberValidator,
   AnyObjectValidator,
   AnyStringValidator,
   AnyValidator,
+  array,
   ArrayValidator,
   assertSchema,
+  boolean,
   BooleanValidator,
   ConstantValidator,
+  date,
   DateValidator,
   getValidator,
+  NeverValidator,
+  number,
   NumberValidator,
+  object,
   ObjectValidator,
   OneOfValidator,
+  OptionalValidator,
+  string,
   StringValidator,
   TupleValidator,
+  url,
   URLValidator,
   Validation,
   Validator,
@@ -42,14 +52,13 @@ type ValidatorConstructor<V extends Validator = Validator> = { // <T = any> = {
  * ========================================================================== */
 
 /** Registry of all `Validator` constructors and related `TypeGenerator`s. */
-const generators = new Map<Function, TypeGenerator<any>>()
+const generators = new Map<Function | Validator, TypeGenerator<any>>()
 
 /** Register a `TypeGenerator` function for a `Validator`. */
 export function registerTypeGenerator<V extends Validator>(
-    validator: ValidatorConstructor<V>,
+    validator: V | ValidatorConstructor<V>,
     generator: TypeGenerator<V>,
 ): void {
-  assertSchema(validator.prototype instanceof Validator, 'Not a `Validator` class')
   generators.set(validator, generator)
 }
 
@@ -84,7 +93,7 @@ export function generateTypes(validations: Record<string, Validation>): string {
 
     // Create a type alias declaration with the name of the export
     const modifiers = [ ts.factory.createModifier(ts.SyntaxKind.ExportKeyword) ]
-    const decl = ts.factory.createTypeAliasDeclaration(undefined, modifiers, name, [], type)
+    const decl = ts.factory.createTypeAliasDeclaration(modifiers, name, [], type)
     types.push(decl)
   }
 
@@ -107,7 +116,7 @@ function generateTypeNode(
   const reference = references.get(validator)
   if (reference) return ts.factory.createTypeReferenceNode(reference)
 
-  const generator = generators.get(validator.constructor)
+  const generator = generators.get(validator) || generators.get(validator.constructor)
   assertSchema(!! generator, `Type generator for "${validator.constructor.name}" not found`)
   return generator(validator, references)
 }
@@ -125,15 +134,13 @@ const stringType = ts.factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword)
 const undefinedType = ts.factory.createKeywordTypeNode(ts.SyntaxKind.UndefinedKeyword)
 const recordType = ts.factory.createMappedTypeNode(
     undefined, // readonly
-    ts.factory.createTypeParameterDeclaration('key', stringType),
+    ts.factory.createTypeParameterDeclaration([], 'key', stringType),
     undefined, // name type
     undefined, // question token
     anyType, // type of the mapped key
     undefined) // members
 
-// Modifiers and tokens
-
-const readonlyKeyword = [ ts.factory.createModifier(ts.SyntaxKind.ReadonlyKeyword) ]
+// "Optional" modifier (the "?" token )
 const optionalKeyword = ts.factory.createToken(ts.SyntaxKind.QuestionToken)
 
 
@@ -147,9 +154,19 @@ registerTypeGenerator(AnyNumberValidator, () => numberType)
 registerTypeGenerator(AnyObjectValidator, () => recordType)
 registerTypeGenerator(AnyStringValidator, () => stringType)
 registerTypeGenerator(BooleanValidator, () => booleanType)
+registerTypeGenerator(NeverValidator, () => neverType)
 registerTypeGenerator(DateValidator, () => ts.factory.createTypeReferenceNode('Date'))
 registerTypeGenerator(URLValidator, () => ts.factory.createTypeReferenceNode('URL'))
 
+registerTypeGenerator(any, () => anyType)
+registerTypeGenerator(array, () => anyArrayType)
+registerTypeGenerator(number, () => numberType)
+registerTypeGenerator(object, () => recordType)
+registerTypeGenerator(string, () => stringType)
+registerTypeGenerator(boolean, () => booleanType)
+registerTypeGenerator(date, () => ts.factory.createTypeReferenceNode('Date'))
+registerTypeGenerator(url, () => ts.factory.createTypeReferenceNode('URL'))
+
 /* ========================================================================== */
 
 // Complex generator functions...
@@ -180,6 +197,11 @@ registerTypeGenerator(NumberValidator, (validator: NumberValidator) => {
   return ts.factory.createIntersectionTypeNode([ numberType, literal ])
 })
 
+registerTypeGenerator(OptionalValidator, (validator: OptionalValidator, references) => {
+  const type = generateTypeNode(validator.validator, references)
+  return ts.factory.createUnionTypeNode([ type, undefinedType ])
+})
+
 registerTypeGenerator(StringValidator, (validator: StringValidator) => {
   if (! validator.brand) return stringType
 
@@ -245,15 +267,15 @@ registerTypeGenerator(OneOfValidator, (validator, references) => {
 registerTypeGenerator(ObjectValidator, (validator, references) => {
   const properties: ts.PropertySignature[] = []
 
-  for (const [ key, property ] of validator.properties.entries()) {
-    const { validator, readonly, optional } = property || { optional: true }
-    const type = validator ? generateTypeNode(validator, references) : neverType
+  for (const [ key, valueValidator ] of validator.validators.entries()) {
+    const type = generateTypeNode(valueValidator, references)
+    const optional = valueValidator.optional
 
     const signature = ts.factory.createPropertySignature(
-          readonly ? readonlyKeyword : undefined,
-          key,
-          optional ? optionalKeyword : undefined,
-          type)
+        undefined,
+        key,
+        optional ? optionalKeyword : undefined,
+        type)
 
     properties.push(signature)
   }
@@ -264,7 +286,7 @@ registerTypeGenerator(ObjectValidator, (validator, references) => {
 
     const extra = ts.factory.createMappedTypeNode(
         undefined, // readonly
-        ts.factory.createTypeParameterDeclaration('key', stringType),
+        ts.factory.createTypeParameterDeclaration([], 'key', stringType),
         undefined, // name type
         undefined, // question token
         optionalPropertyType, // (type | undefined)

package/src/index.ts

@@ -12,11 +12,13 @@ export * from './utilities'
 export { allOf, oneOf, AllOfValidator, InferAllOfValidationType, InferOneOfValidationType, OneOfValidator, UnionArguments } from './validators/union'
 export { any, AnyValidator } from './validators/any'
 export { _array, array, arrayOf, AnyArrayValidator, ArrayConstraints, ArrayValidator } from './validators/array'
-export { boolean, BooleanValidator } from './validators/boolean'
+export { _boolean, boolean, BooleanConstraints, BooleanValidator } from './validators/boolean'
 export { constant, ConstantValidator } from './validators/constant'
 export { _date, date, DateConstraints, DateValidator } from './validators/date'
+export { never, NeverValidator } from './validators/never'
 export { _number, number, AnyNumberValidator, BrandedNumberConstraints, NumberConstraints, NumberValidator } from './validators/number'
-export { _object, object, AnyObjectValidator, ObjectProperty, ObjectValidator } from './validators/object'
+export { _object, object, AnyObjectValidator, ObjectValidator } from './validators/object'
+export { optional, OptionalValidator } from './validators/optional'
 export { _string, string, AnyStringValidator, BrandedStringConstraints, StringConstraints, StringValidator } from './validators/string'
 export { tuple, TupleMember, TupleValidator } from './validators/tuple'
 export { _url, url, URLConstraints, URLValidator } from './validators/url'

package/src/schema.ts

@@ -3,15 +3,10 @@ import { getValidator } from './utilities'
 
 import {
   AdditionalProperties,
-  CombinedModifier,
   InferValidation,
-  Modifier,
-  OptionalModifier,
-  ReadonlyModifier,
   Validation,
   Validator,
   additionalValidator,
-  modifierValidator,
 } from './types'
 
 /* ========================================================================== *
@@ -28,7 +23,7 @@ export function _allowAdditionalProperties(options?: Validation | boolean): Addi
   if (options === false) return { [additionalValidator]: false }
   if (options === true) return { [additionalValidator]: any }
 
-  return { [additionalValidator]: getValidator(options) }
+  return { [additionalValidator]: options ? getValidator(options) : any }
 }
 
 /**
@@ -44,69 +39,3 @@ export const allowAdditionalProperties = _allowAdditionalProperties as
   typeof _allowAdditionalProperties & AdditionalProperties<Validator<any>>
 
 allowAdditionalProperties[additionalValidator] = any
-
-/* ========================================================================== *
- * SCHEMA KEYS MODIFIERS                                                      *
- * ========================================================================== */
-
-export type CombineModifiers<M1 extends Modifier, M2 extends Modifier> =
-  M1 extends ReadonlyModifier ?
-    M2 extends ReadonlyModifier<infer V> ? ReadonlyModifier<V> :
-    M2 extends OptionalModifier<infer V> ? CombinedModifier<V> :
-    never :
-  M1 extends OptionalModifier ?
-    M2 extends ReadonlyModifier<infer V> ? CombinedModifier<V> :
-    M2 extends OptionalModifier<infer V> ? OptionalModifier<V> :
-    never :
-  never
-
-/* -------------------------------------------------------------------------- */
-
-/** Type guard for `Modifier` instances */
-export function isModifier(what: any): what is Modifier<any> {
-  return (what && (typeof what === 'object') && (modifierValidator in what))
-}
-
-/* -------------------------------------------------------------------------- */
-
-/**
- * Ensure that the property is marked as _read only_ in the `Schema`.
- *
- * @param validation - A `Validation` to be marked as _read only_.
- */
-export function readonly(): ReadonlyModifier<any>
-export function readonly<V extends Validation>(validation: V): ReadonlyModifier<Validator<InferValidation<V>>>
-export function readonly<M extends Modifier>(modifier: M): CombineModifiers<ReadonlyModifier, M>
-
-export function readonly(options?: Modifier | Validation): Modifier {
-  const { [modifierValidator]: validation = any, optional = false } =
-    isModifier(options) ? options : { [modifierValidator]: options }
-
-  const validator = getValidator(validation)
-
-  return optional ?
-    { [modifierValidator]: validator, optional, readonly: true } :
-    { [modifierValidator]: validator, readonly: true }
-}
-
-/* -------------------------------------------------------------------------- */
-
-/**
- * Ensure that the property is marked as _optional_ in the `Schema`.
- *
- * @param validation - A `Validation` to be marked as _optional_.
- */
-export function optional(): OptionalModifier<any>
-export function optional<V extends Validation>(validation: V): OptionalModifier<Validator<InferValidation<V>>>
-export function optional<M extends Modifier>(modifier: M): CombineModifiers<OptionalModifier, M>
-
-export function optional(options?: Modifier<any> | Validation): Modifier<any> {
-  const { [modifierValidator]: validation = any, readonly = false } =
-    isModifier(options) ? options : { [modifierValidator]: options }
-
-  const validator = getValidator(validation)
-
-  return readonly ?
-    { [modifierValidator]: validator, readonly, optional: true } :
-    { [modifierValidator]: validator, optional: true }
-}

package/src/types.ts

@@ -2,21 +2,18 @@
  * SYMBOLS IDENTIFYING SPECIAL FUNCTIONALITIES                                *
  * ========================================================================== */
 
+/** A symbol indicating that an instance is (in fact) a `Validator`. */
+export const isValidator = Symbol.for('justus.isValidator')
+
 /** A symbol indicating the `Validator` for a `Tuple`'s rest parameter. */
 export const restValidator = Symbol.for('justus.restValidator')
 
 /** A symbol indicating the `Validator` for a `Schema`. */
 export const schemaValidator = Symbol.for('justus.schemaValidator')
 
-/** A symbol indicating the `Validator` for a `Modifier`. */
-export const modifierValidator = Symbol.for('justus.modifierValidator')
-
 /** A symbol indicating the `Validator` for a `Schema`'s additional properties. */
 export const additionalValidator = Symbol.for('justus.additionalValidator')
 
-/** A symbol indicating that a `Schema` property is _forbidden_. */
-export const never = Symbol.for('justus.never')
-
 /* ========================================================================== *
  * BASIC VALIDATION TYPES                                                     *
  * ========================================================================== */
@@ -37,7 +34,45 @@ export interface ValidationOptions {
  * A `Validator` is an object capable of validating a given _value_ and
  * (possibly) converting it the required type `T`.
  */
-export abstract class Validator<T = any> implements Iterable<TupleRestParameter<T>> {
+export interface Validator<T = any> extends Iterable<TupleRestParameter<T>> {
+  [isValidator]: true
+
+  optional?: boolean
+
+  /** Validate a _value_ and optionally convert it to the required `Type` */
+  validate(value: unknown, options: ValidationOptions): T
+
+  /** Allow any `Validator` to be used as a rest parameter in `Tuple`s */
+  [Symbol.iterator](): Generator<TupleRestParameter<T>>;
+}
+
+/**
+ * Create a validator "factory", that is a function that when invoked will
+ * create a new `Validator` according to the parameters specified. This function
+ * will also implement the `Validator` interface itself, using the `Validator`
+ * supplied as the first parameter.
+ */
+export function makeValidatorFactory<
+  V extends Validator,
+  F extends (...args: any[]) => Validator,
+>(validator: V, factory: F): F & V {
+  return Object.assign(factory, {
+    optional: validator.optional,
+    validate: validator.validate.bind(validator),
+    [Symbol.iterator]: validator[Symbol.iterator].bind(validator),
+    [isValidator]: true,
+  }) as F & V
+}
+
+/**
+ * A `Validator` is an object capable of validating a given _value_ and
+ * (possibly) converting it the required type `T`.
+ */
+export abstract class AbstractValidator<T = any> implements Iterable<TupleRestParameter<T>> {
+  [isValidator]: true = true
+
+  optional?: boolean = undefined
+
   /** Validate a _value_ and optionally convert it to the required `Type` */
   abstract validate(value: unknown, options: ValidationOptions): T
 
@@ -58,7 +93,7 @@ export abstract class Validator<T = any> implements Iterable<TupleRestParameter<
  * * Either `null`, a `boolean`, a `number` or a `string` for constants
  */
 export type Validation =
-  (() => Validator) | Validator | // Validator instances or their creators
+  Validator | // Validator instances
   Tuple | Schema | // Tuples or schemas (arrays, objects)
   null | boolean | number | string // Primitives, mapped as constants
 
@@ -69,33 +104,6 @@ export type InferValidation<V> =
   // Let `InferValidationType<T>` be liberal in the type it accepts and check
   // here whether it extends `Validation`
   V extends Validation ?
-
-    // `Validation` can be a function returning a `Validator`, here we need to
-    // extract the return value of its _zero-arguments_ overload
-    V extends {
-      (...args: infer A0): Validator<infer R0>;
-      (...args: infer A1): Validator<infer R1>;
-      (...args: infer A2): Validator<infer R2>;
-      (...args: infer A3): Validator<infer R3>;
-      (...args: infer A4): Validator<infer R4>;
-      (...args: infer A5): Validator<infer R5>;
-      (...args: infer A6): Validator<infer R6>;
-      (...args: infer A7): Validator<infer R7>;
-      (...args: infer A8): Validator<infer R8>;
-      (...args: infer A9): Validator<infer R9>;
-    } ?
-      A0 extends [] ? R0 :
-      A1 extends [] ? R1 :
-      A2 extends [] ? R2 :
-      A3 extends [] ? R3 :
-      A4 extends [] ? R4 :
-      A5 extends [] ? R5 :
-      A6 extends [] ? R6 :
-      A7 extends [] ? R7 :
-      A8 extends [] ? R8 :
-      A9 extends [] ? R9 :
-      never :
-
     // Validators return their validation type
     V extends Validator<infer T> ? T :
 
@@ -175,7 +183,7 @@ export type InferTuple<T> =
  * how they should be validated.
  */
 export interface Schema {
-  [ key: string ] : Validation | Modifier | typeof never
+  [ key: string ] : Validation
   [ additionalValidator ]?: Validator | false
 }
 
@@ -187,118 +195,23 @@ export interface AdditionalProperties<V extends Validator | false> {
   [ additionalValidator ]: V
 }
 
-/* -------------------------------------------------------------------------- */
-
-/**
- * A `Modifier` marks a `Schema` property either _read only_ and/or _optional_.
- */
-export interface Modifier<V extends Validator = Validator> {
-  [ modifierValidator ]: V
-  readonly?: true,
-  optional?: true,
-}
-
-/**
- * Mark a `Schema` property as _read only_.
- */
-export interface ReadonlyModifier<V extends Validator = Validator> extends Modifier<V> {
-  readonly: true,
-}
-
-/**
- * Mark a `Schema` property as _optional_.
- */
-export interface OptionalModifier<V extends Validator = Validator> extends Modifier<V> {
-  optional: true,
-}
-
-/**
- * Mark a `Schema` property as both _optional_ and _read only_.
- */
-export interface CombinedModifier<V extends Validator = Validator>
-  extends ReadonlyModifier<V>, OptionalModifier<V>, Modifier<V> {
-  optional: true,
-  readonly: true,
-}
-
 /* ========================================================================== *
  * INFER OBJECT TYPE FROM SCHEMA                                              *
  * ========================================================================== */
 
 /** Infer the type validated by a `Schema` */
 export type InferSchema<S extends Schema> =
-  InferReadonlyModifiers<S> &
-  InferOptionalModifiers<S> &
-  InferCombinedModifiers<S> &
-  ( S extends AdditionalProperties<Validator<infer V>> ?
-      Record<string, V | undefined> &
-      InferNever<S> &
-      InferRequired<S> :
-    InferRequired<S> )
-
-/* -------------------------------------------------------------------------- */
-
-/** Infer the type of keys associated with `Validation`s */
-export type InferRequired<S extends Schema> = {
-  [ key in keyof S as
-      key extends string ?
-        S[key] extends Validation ? key :
-        never :
-      never
-  ] :
-    S[key] extends Validation ? InferValidation<S[key]> :
-    never
-}
-
-/* -------------------------------------------------------------------------- */
-
-/** Infer the type of _read only_ `Schema` properties  */
-export type InferReadonlyModifiers<S extends Schema> = {
-  readonly [ key in keyof S as
-    key extends string ?
-      S[key] extends OptionalModifier<Validator> ? never :
-      S[key] extends ReadonlyModifier<Validator> ? key :
-      never :
-    never
-  ] :
-    S[key] extends ReadonlyModifier<infer V> ? InferValidation<V> : never
-}
-
-/** Infer the type of _optional_ `Schema` properties  */
-export type InferOptionalModifiers<S extends Schema> = {
-  [ key in keyof S as
-    key extends string ?
-      S[key] extends ReadonlyModifier<Validator> ? never :
-      S[key] extends OptionalModifier<Validator> ? key :
-      never :
-    never
-  ] ? :
-    S[key] extends OptionalModifier<infer V> ? InferValidation<V> : never
-}
-
-/** Infer the type of  _read only_ **and** _optional_ `Schema` properties  */
-export type InferCombinedModifiers<S extends Schema> = {
-  readonly [ key in keyof S as
-    key extends string ?
-      S[key] extends CombinedModifier ? key :
-      never :
-    never
-  ] ? :
-    S[key] extends CombinedModifier<infer V> ? InferValidation<V> : never
-}
-
-/* -------------------------------------------------------------------------- */
-
-/** Ensure that we properly type `never` properties */
-export type InferNever<S extends Schema> =
-  { [ key in keyof S as
-      key extends string ?
-        S[key] extends typeof never ? key :
-        never :
-      never
-    ] : never
+  S extends AdditionalProperties<Validator<infer V>> ?
+    { [ key in string ] : V | undefined } & InferSchema2<S> :
+    InferSchema2<S>
+
+/** Infer the property types described by a `Schema` */
+export type InferSchema2<S extends Schema> =
+  { [ key in keyof S as key extends string ? key : never ]:
+    InferValidation<S[key]>
   }
 
+
 /* ========================================================================== *
  * TYPE BRANDING                                                              *
  * ========================================================================== */

package/src/utilities.ts

@@ -1,6 +1,5 @@
-import { any } from './validators/any'
 import { ConstantValidator, nullValidator } from './validators/constant'
-import { Schema, schemaValidator, Validation, Validator } from './types'
+import { isValidator, Schema, schemaValidator, Validation, Validator } from './types'
 import { TupleValidator } from './validators/tuple'
 import { ObjectValidator } from './validators/object'
 
@@ -13,13 +12,12 @@ import { ObjectValidator } from './validators/object'
  *
  * When `validation` is `undefined` it will return a `Validator<any>`,
  */
-export function getValidator(validation?: Validation): Validator {
-  // Undefined maps to `any`, null is a constant
-  if (validation === undefined) return any
+export function getValidator(validation: Validation): Validator {
+  // Null is a constant
   if (validation === null) return nullValidator
 
-  // Validator instances are simply returned
-  if (validation instanceof Validator) return validation
+  // Validator instance (either object or function)
+  if ((<any> validation)[isValidator] === true) return validation as Validator
 
   // Other types
   switch (typeof validation) {
@@ -29,10 +27,6 @@ export function getValidator(validation?: Validation): Validator {
     case 'number':
       return new ConstantValidator(validation)
 
-    // validator generator
-    case 'function':
-      return validation()
-
     // other objects...
     case 'object':
       // pre-compiled schema with validator

package/src/validators/any.ts

@@ -1,7 +1,7 @@
-import { Validator } from '../types'
+import { AbstractValidator } from '../types'
 
 /** A `Validator` validating _anything_. */
-export class AnyValidator extends Validator<any> {
+export class AnyValidator extends AbstractValidator<any> {
   validate(value: unknown): any {
     return value
   }

package/src/validators/array.ts

@@ -1,8 +1,7 @@
 import { assertSchema, assertValidation, ValidationErrorBuilder } from '../errors'
-import { InferValidation, Validation, ValidationOptions, Validator } from '../types'
+import { InferValidation, Validation, ValidationOptions, AbstractValidator, Validator, makeValidatorFactory } from '../types'
 import { getValidator } from '../utilities'
 import { any } from './any'
-import { makeTupleRestIterable } from './tuple'
 
 /* ========================================================================== *
  * ARRAYS VALIDATION                                                           *
@@ -21,7 +20,7 @@ export interface ArrayConstraints<V extends Validation> {
 }
 
 /** Basic validator for `Array` instances. */
-export class AnyArrayValidator<T = any> extends Validator<T[]> {
+export class AnyArrayValidator<T = any> extends AbstractValidator<T[]> {
   validate(value: unknown, options: ValidationOptions): T[] {
     void options
     assertValidation(Array.isArray(value), 'Value is not an "array"')
@@ -30,7 +29,7 @@ export class AnyArrayValidator<T = any> extends Validator<T[]> {
 }
 
 /** A validator for `Array` instances with constraints. */
-export class ArrayValidator<T> extends Validator<T[]> {
+export class ArrayValidator<T> extends AbstractValidator<T[]> {
   readonly maxItems: number
   readonly minItems: number
   readonly uniqueItems: boolean
@@ -87,22 +86,15 @@ export class ArrayValidator<T> extends Validator<T[]> {
   }
 }
 
-const anyArrayValidator = new AnyArrayValidator()
-
 /* -------------------------------------------------------------------------- */
 
-export function _array(): Validator<any[]>
-export function _array<V extends Validation>(constraints: ArrayConstraints<V>): ArrayValidator<InferValidation<V>>
-
-export function _array(options?: ArrayConstraints<Validation>): Validator<any[]> {
-  if (! options) return anyArrayValidator
-
-  const items = getValidator(options.items)
-  return new ArrayValidator({ ...options, items })
+export function _array<V extends Validation>(constraints: ArrayConstraints<V>): ArrayValidator<InferValidation<V>> {
+  const items = constraints.items ? getValidator(constraints.items) : any
+  return new ArrayValidator({ ...constraints, items })
 }
 
 /** Validate `Array`s. */
-export const array = makeTupleRestIterable(_array)
+export const array = makeValidatorFactory(new AnyArrayValidator(), _array)
 
 /** Validate `Array`s containing only the specified elements. */
 export function arrayOf<V extends Validation>(validation: V): ArrayValidator<InferValidation<V>> {

package/src/validators/boolean.ts

@@ -1,13 +1,45 @@
-import { Validator } from '../types'
+import { AbstractValidator, makeValidatorFactory } from '../types'
 import { assertValidation } from '../errors'
 
+/** Constraints to validate a `boolean` with. */
+export interface BooleanConstraints {
+  /**
+   * Allow booleans to be parsed from strings (default: `false`).
+   *
+   * The string in question _MUST_ be either `true` or `false`, and will be
+   * compared regardless of case.
+   */
+  fromString?: boolean,
+}
+
+
 /** A `Validator` validating `boolean`s. */
-export class BooleanValidator extends Validator<boolean> {
+export class BooleanValidator extends AbstractValidator<boolean> {
+  readonly fromString: boolean
+
+  constructor(constraints: BooleanConstraints = {}) {
+    super()
+    const { fromString = false } = constraints
+    this.fromString = fromString
+  }
+
   validate(value: unknown): boolean {
+    // Allow parsing from strings
+    if ((typeof value == 'string') && (this.fromString)) {
+      const string = value.toLowerCase()
+      const parsed = string === 'true' ? true : string === 'false' ? false : undefined
+      assertValidation(parsed !== undefined, 'Boolean can not be parsed from string')
+      value = parsed
+    }
+
     assertValidation(typeof value === 'boolean', 'Value is not a "boolean"')
     return value
   }
 }
 
+export function _boolean(constraints: BooleanConstraints): BooleanValidator {
+  return new BooleanValidator(constraints)
+}
+
 /** The `Validator` for `boolean`s. */
-export const boolean = new BooleanValidator()
+export const boolean = makeValidatorFactory(new BooleanValidator(), _boolean)

package/src/validators/constant.ts

@@ -1,8 +1,8 @@
-import { Validator } from '../types'
+import { AbstractValidator, Validator } from '../types'
 import { assertValidation } from '../errors'
 
 /** A `Validator` for _constants_. */
-export class ConstantValidator<T extends string | number | boolean | null> extends Validator<T> {
+export class ConstantValidator<T extends string | number | boolean | null> extends AbstractValidator<T> {
   readonly constant: T
 
   constructor(constant: T) {