justus 0.4.2 → 0.5.0

package/src/types.ts

@@ -49,7 +49,7 @@ export const defaultValidationOptions: Readonly<Required<ValidationOptions>> = {
  * A `Validator` is an object capable of validating a given _value_ and
  * (possibly) converting it the required type `T`.
  */
-export interface Validator<T = any> extends Iterable<TupleRestParameter<T>> {
+export interface Validator<T = any, I = T> extends Iterable<TupleRestParameter<T, I>> {
   [Symbol.justusValidator]: this
 
   optional?: boolean
@@ -58,7 +58,7 @@ export interface Validator<T = any> extends Iterable<TupleRestParameter<T>> {
   validate(value: unknown, options?: ValidationOptions | undefined): T
 
   /** Allow any `Validator` to be used as a rest parameter in `Tuple`s */
-  [Symbol.iterator](): Generator<TupleRestParameter<T>>;
+  [Symbol.iterator](): Generator<TupleRestParameter<T, I>>;
 }
 
 /**
@@ -83,8 +83,8 @@ export function makeValidatorFactory<
  * 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 Validator<T>, Iterable<TupleRestParameter<T>> {
+export abstract class AbstractValidator<T, I = T>
+implements Validator<T, I>, Iterable<TupleRestParameter<T, I>> {
   [Symbol.justusValidator] = this
 
   optional?: boolean = undefined
@@ -93,7 +93,7 @@ implements Validator<T>, Iterable<TupleRestParameter<T>> {
   abstract validate(value: unknown, options?: ValidationOptions | undefined): T
 
   /** Allow any `Validator` to be used as a rest parameter in `Tuple`s */
-  * [Symbol.iterator](): Generator<TupleRestParameter<T>> {
+  * [Symbol.iterator](): Generator<TupleRestParameter<T, I>> {
     yield { [Symbol.justusRestValidator]: this }
   }
 }
@@ -118,7 +118,7 @@ export type Validation =
  */
 export type InferValidation<V> =
   // Validators return their validation type
-  V extends Validator<infer T> ? T :
+  V extends Validator<infer T, any> ? T :
 
   // Primitives are returned as constants
   V extends undefined ? V :
@@ -133,6 +133,25 @@ export type InferValidation<V> =
   // Anyhing else can only be a schema
   InferSchema<V>
 
+/**
+ * Infer the type compatible with a `Validation`'s input.
+ */
+export type InferInput<V> =
+  // Validators return their validation type
+  V extends Validator<any, infer T> ? T :
+
+  // Primitives are returned as constants
+  V extends undefined ? V :
+  V extends boolean ? V :
+  V extends number ? V :
+  V extends string ? V :
+  V extends null ? V :
+
+  // // Tuples are inferred using their own types
+  V extends Tuple ? InferInputTuple<V> :
+
+  // // Anyhing else can only be a schema
+  InferInputSchema<V>
 
 /* ========================================================================== *
  * TUPLES                                                                     *
@@ -140,16 +159,22 @@ export type InferValidation<V> =
 
 /** Infer the type validated by a `Validation` or `TupleRestParameter` */
 export type InferValidationOrTupleRest<T> =
-  T extends TupleRestParameter<infer X> ? X :
+  T extends TupleRestParameter<infer X, any> ? X :
   T extends Validation ? InferValidation<T> :
   never
 
+/** Infer the input type for a `Validation` or `TupleRestParameter` */
+export type InferInputValidationOrTupleRest<T> =
+  T extends TupleRestParameter<any, infer X> ? X :
+  T extends Validation ? InferInput<T> :
+  never
+
 /* -------------------------------------------------------------------------- */
 
 /**
  * A `Tuple` is defined to be an array of `Validation` or `TupleRest`
  */
-export type Tuple = readonly (Validation | TupleRestParameter)[]
+export type Tuple = readonly (Validation | TupleRestParameter<any, any>)[]
 
 /**
  * The `TupleRestParameter` defines a tuple member that can occur several
@@ -164,8 +189,8 @@ export type Tuple = readonly (Validation | TupleRestParameter)[]
  * const myTuple = tuple([ number, ...nonEmptyString ])
  * ```
  */
-export type TupleRestParameter<T = any> = {
-  [Symbol.justusRestValidator] : Validator<T>
+export type TupleRestParameter<T, I> = {
+  [Symbol.justusRestValidator] : Validator<T, I>
 }
 
 /**
@@ -187,6 +212,24 @@ export type InferTuple<T> =
     never :
   never
 
+/**
+ * Infer a time compatible with a `TupleValidator`'s input.
+ */
+export type InferInputTuple<T> =
+  T extends Tuple ?
+    T extends readonly [] ? [] :
+    T extends readonly [ Validation, ...any[] ] ?
+      T extends readonly [ infer V, ...infer Rest ] ?
+        [ InferInput<V>, ...InferInputTuple<Rest> ] :
+      never :
+    T extends readonly [ ...any[], Validation ] ?
+      T extends readonly [ ...infer Rest, infer V ] ?
+        [ ...InferInputTuple<Rest>, InferInput<V> ] :
+      never :
+    T extends readonly (infer V)[] ?
+      [ ...InferInputValidationOrTupleRest<V>[] ] :
+    never :
+  never
 
 /* ========================================================================== *
  * OBJECT SCHEMAS                                                             *
@@ -237,11 +280,37 @@ export type InferSchema2<S> = {
   InferValidation<S[key]>
 }
 
+/** Infer the input type compatible with a `Schema` */
+export type InferInputSchema<S> =
+  S extends AdditionalProperties<Validator<any, infer X>> ?
+    { [ key in string ] : X } & InferInputSchema2<S> :
+    InferInputSchema2<S>
+
+/** Infer the input type of the properties described by a `Schema` */
+export type InferInputSchema2<S> = {
+  // this first part of the type infers all keys from the schema into their
+  // type, but makes *each* key optional... we'll restrict in the next part...
+  [ key in keyof S as key extends string ? key : never ] ? : InferInput<S[key]>
+} & {
+  // this second part infers *only* keys that _do not_ contain a "undefined"
+  // in their unions, and associates them with the inferred value, basically
+  // making the key *non optional*
+  [ key in keyof S as
+      key extends string ?
+        InferInput<S[key]> extends never ?
+          never :
+        undefined extends InferInput<S[key]> ?
+          never :
+          key :
+      never ] -? :
+  InferInput<S[key]>
+}
+
 /* ========================================================================== *
  * TYPE BRANDING                                                              *
  * ========================================================================== */
 
 /** Utility type to infer primitive branding according to a string */
 export type Branding<S extends string> = {
-  [ key in keyof { __brand: never } as `__brand_${S}` ] : never
+  [ brand in `__brand_${S}` ] : never
 }

package/src/utilities.ts

@@ -1,8 +1,4 @@
-import { ConstantValidator, nullValidator } from './validators/constant'
-// eslint-disable-next-line import/no-cycle
-import { ObjectValidator } from './validators/object'
-// eslint-disable-next-line import/no-cycle
-import { TupleValidator } from './validators/tuple'
+import { registry } from './registry'
 
 import type { Schema, Validation, Validator } from './types'
 
@@ -17,7 +13,7 @@ import type { Schema, Validation, Validator } from './types'
  */
 export function getValidator(validation: Validation): Validator {
   // Null is a constant
-  if (validation === null) return nullValidator
+  if (validation === null) return new (registry.get('constant'))(null)
 
   // Anything with a validor associated with
   if ((<any> validation)[Symbol.justusValidator]) {
@@ -30,14 +26,14 @@ export function getValidator(validation: Validation): Validator {
     case 'boolean':
     case 'string':
     case 'number':
-      return new ConstantValidator(validation)
+      return new (registry.get('constant'))(validation)
 
     // other objects...
     case 'object':
       // arrays are tuples
-      if (Array.isArray(validation)) return new TupleValidator(validation)
+      if (Array.isArray(validation)) return new (registry.get('tuple'))(validation)
       // any other object is a schema
-      return new ObjectValidator(validation as Schema)
+      return new (registry.get('object'))(validation as Schema)
 
     // definitely not one of our types
     default:

package/src/validators/array.ts

@@ -22,7 +22,7 @@ export interface ArrayConstraints<V extends Validation> {
 }
 
 /** Basic validator for `Array` instances. */
-export class AnyArrayValidator<T = any> extends AbstractValidator<T[]> {
+export class AnyArrayValidator<T = any> extends AbstractValidator<T[], T[]> {
   validate(value: unknown): T[] {
     assertValidation(Array.isArray(value), 'Value is not an "array"')
     return [ ...value ]

package/src/validators/constant.ts

@@ -1,4 +1,5 @@
 import { assertValidation } from '../errors'
+import { registry } from '../registry'
 import { AbstractValidator } from '../types'
 
 import type { Validator } from '../types'
@@ -23,5 +24,5 @@ export function constant<T extends string | number | boolean | null>(constant: T
   return new ConstantValidator(constant)
 }
 
-/** The `Validator` for the `null` constant. */
-export const nullValidator = new ConstantValidator(null)
+// Register our "constant" validator
+registry.set('constant', ConstantValidator)

package/src/validators/date.ts

@@ -15,7 +15,7 @@ export interface DateConstraints {
 }
 
 /** A `Validator` validating dates and converting them to `Date` instances. */
-export class DateValidator extends AbstractValidator<Date> {
+export class DateValidator extends AbstractValidator<Date, Date | string | number> {
   readonly format?: 'iso' | 'timestamp'
   readonly from?: Date
   readonly until?: Date
@@ -36,12 +36,12 @@ export class DateValidator extends AbstractValidator<Date> {
   }
 
   validate(value: unknown): Date {
-    let date: Date
-    try {
-      date = new Date(value as any)
-    } catch (error) {
-      throw new ValidationError('Value could not be converted to a "Date"')
-    }
+    const date =
+        value instanceof Date ? new Date(value.getTime()) :
+        typeof value === 'string' ? new Date(value) :
+        typeof value === 'number' ? new Date(value) :
+        undefined
+    assertValidation(!! date, 'Value could not be converted to a "Date"')
 
     if (isNaN(date.getTime())) throw new ValidationError('Invalid date')
 

package/src/validators/number.ts

@@ -53,7 +53,7 @@ export class AnyNumberValidator extends AbstractValidator<number> {
 }
 
 /** A `Validator` validating `number`s with constaints. */
-export class NumberValidator<N extends number = number> extends AbstractValidator<N> {
+export class NumberValidator<N extends number = number> extends AbstractValidator<N, number> {
   #isMultipleOf?: ((value: number) => boolean)
 
   readonly allowNaN: boolean

package/src/validators/object.ts

@@ -1,15 +1,12 @@
 import { assertValidation, ValidationErrorBuilder } from '../errors'
-// eslint-disable-next-line import/no-cycle
-import { allowAdditionalProperties } from '../schema'
-import {
-  AbstractValidator,
-  defaultValidationOptions,
-  makeValidatorFactory,
-} from '../types'
+import { registry } from '../registry'
+import { AbstractValidator, defaultValidationOptions, makeValidatorFactory } from '../types'
 import { getValidator } from '../utilities'
 
 import type {
-  InferSchema, InferValidation, Schema, TupleRestParameter, Validation, ValidationOptions,
+  InferInputSchema,
+  InferSchema, InferValidation, Schema, TupleRestParameter, Validation,
+  ValidationOptions,
   Validator,
 } from '../types'
 
@@ -27,7 +24,7 @@ export class AnyObjectValidator extends AbstractValidator<Record<string, any>> {
 }
 
 /** A `Validator` validating `object`s according to a `Schema`. */
-export class ObjectValidator<S extends Schema> extends AbstractValidator<InferSchema<S>> {
+export class ObjectValidator<S extends Schema> extends AbstractValidator<InferSchema<S>, InferInputSchema<S>> {
   readonly schema: Readonly<S>
 
   validators = new Map<string, Validator>()
@@ -118,10 +115,11 @@ export class ObjectValidator<S extends Schema> extends AbstractValidator<InferSc
 }
 
 export function objectFactory<S extends Schema>(schema: S): S & {
-  [Symbol.iterator](): Generator<TupleRestParameter<InferSchema<S>>>
+  [Symbol.iterator](): Generator<TupleRestParameter<InferSchema<S>, InferInputSchema<S>>>
 } {
   const validator = new ObjectValidator(schema)
-  function* iterator(): Generator<TupleRestParameter> {
+
+  function* iterator(): Generator<TupleRestParameter<any, any>> {
     yield { [Symbol.justusRestValidator]: validator }
   }
 
@@ -136,5 +134,8 @@ export const object = makeValidatorFactory(new AnyObjectValidator(), objectFacto
 
 /** Validate `Object`s containing only the specified elements. */
 export function objectOf<V extends Validation>(validation: V): Validator<Record<string, InferValidation<V>>> {
-  return new ObjectValidator({ ...allowAdditionalProperties(validation) })
+  return new ObjectValidator({ [Symbol.justusAdditionalValidator]: getValidator(validation) })
 }
+
+// Register our "object" validator
+registry.set('object', ObjectValidator)

package/src/validators/optional.ts

@@ -1,15 +1,16 @@
 import { AbstractValidator, defaultValidationOptions } from '../types'
 import { getValidator } from '../utilities'
 
-import type { InferValidation, Validation, ValidationOptions, Validator } from '../types'
+import type { InferInput, InferValidation, Validation, ValidationOptions, Validator } from '../types'
 
 /**
  * A `Validator` for _optional_ properties (that is `type | undefined`).
  */
 export class OptionalValidator<
   T = any, // the type of the "validation", that is the optional type to validate
+  I = T, // the _input_ type of the "validation", that is anything acceptable
   D = undefined, // the default value (or undefined)
-> extends AbstractValidator<D extends undefined ? T | undefined : T> {
+> extends AbstractValidator<D extends undefined ? T | undefined : T, I | undefined> {
   validator: Validator<T>
   defaultValue: T | undefined
 
@@ -32,8 +33,9 @@ export class OptionalValidator<
     }
   }
 
-  validate(value: unknown, options?: ValidationOptions): D extends undefined ? T | undefined : T {
-    if (value === undefined) return this.defaultValue as any // do not validate defaults!
+  validate(value: unknown, options?: ValidationOptions): D extends undefined ? T | undefined : T
+  validate(value: unknown, options?: ValidationOptions): T | undefined {
+    if (value === undefined) return this.defaultValue // do not validate defaults!
     return this.validator.validate(value, options)
   }
 }
@@ -45,15 +47,15 @@ export class OptionalValidator<
  */
 export function optional<
   V extends Validation
->(validation: V): OptionalValidator<InferValidation<V>, undefined>
+>(validation: V): OptionalValidator<InferValidation<V>, InferInput<V>, undefined>
 
 export function optional<
   V extends Validation, D,
->(validation: V, defaultValue: D): OptionalValidator<InferValidation<V>, D>
+>(validation: V, defaultValue: D): OptionalValidator<InferValidation<V>, InferInput<V>, D>
 
 export function optional<
   V extends Validation, D,
->(validation: V, defaultValue?: D): OptionalValidator<InferValidation<V>> {
+>(validation: V, defaultValue?: D): OptionalValidator<InferValidation<V>, InferInput<V>, D> {
   const validator = getValidator(validation)
   return new OptionalValidator(validator, defaultValue)
 }

package/src/validators/string.ts

@@ -28,7 +28,7 @@ export class AnyStringValidator extends AbstractValidator<string> {
 }
 
 /** A `Validator` validating `string`s with constraints. */
-export class StringValidator<S extends string = string> extends AbstractValidator<S> {
+export class StringValidator<S extends string = string, I = string> extends AbstractValidator<S, I> {
   readonly maxLength: number
   readonly minLength: number
   readonly pattern?: RegExp

package/src/validators/tuple.ts

@@ -1,15 +1,22 @@
 import { assertValidation, ValidationError } from '../errors'
+import { registry } from '../registry'
 import { AbstractValidator } from '../types'
-// eslint-disable-next-line import/no-cycle
 import { getValidator } from '../utilities'
-import { nullValidator } from './constant'
 
-import type { InferTuple, Tuple, ValidationOptions, Validator } from '../types'
+import type {
+  InferInputTuple,
+  InferTuple,
+  Tuple,
+  TupleRestParameter,
+  Validation,
+  ValidationOptions,
+  Validator,
+} from '../types'
 
 export interface TupleMember { single: boolean, validator: Validator }
 
 /** A `Validator` for _tuples_. */
-export class TupleValidator<T extends Tuple> extends AbstractValidator<InferTuple<T>> {
+export class TupleValidator<T extends Tuple> extends AbstractValidator<InferTuple<T>, InferInputTuple<T>> {
   readonly members: readonly TupleMember[]
   readonly tuple: T
 
@@ -19,7 +26,7 @@ export class TupleValidator<T extends Tuple> extends AbstractValidator<InferTupl
     const members: TupleMember[] = []
     for (const item of tuple) {
       if (item === null) { // god knows why typeof null === "object"
-        members.push({ single: true, validator: nullValidator })
+        members.push({ single: true, validator: getValidator(null) })
       } else if ((typeof item === 'object') && (Symbol.justusRestValidator in item)) {
         members.push({ single: false, validator: (<any>item)[Symbol.justusRestValidator] })
       } else {
@@ -77,6 +84,13 @@ export class TupleValidator<T extends Tuple> extends AbstractValidator<InferTupl
 }
 
 /** Validate _tuples_. */
-export function tuple<T extends Tuple>(tuple: T): Validator<InferTuple<T>> {
+export function tuple<T extends
+| readonly [ Validation | TupleRestParameter<any, any>, ...Tuple ]
+| readonly [ ...Tuple, Validation | TupleRestParameter<any, any> ]
+| readonly [ ...Tuple ] // ... this is bascially an array...
+>(tuple: T): Validator<InferTuple<T>, InferInputTuple<T>> {
   return new TupleValidator(tuple)
 }
+
+// Register our "tuple" validator
+registry.set('tuple', TupleValidator)

package/src/validators/union.ts

@@ -3,6 +3,7 @@ import { AbstractValidator } from '../types'
 import { getValidator } from '../utilities'
 
 import type {
+  InferInput,
   InferValidation,
   Validation,
   ValidationOptions,
@@ -13,11 +14,11 @@ import type {
 
 export type OneOfArguments = readonly Validation[]
 
-export type InferOneOfValidationType<A extends OneOfArguments> =
+export type InferOneOfValidation<A extends OneOfArguments> =
   A extends readonly [ infer First, ...infer Rest ] ?
     First extends Validation ?
       Rest extends OneOfArguments ?
-        InferValidation<First> | InferOneOfValidationType<Rest> :
+        InferValidation<First> | InferOneOfValidation<Rest> :
       InferValidation<First> :
     never :
   A extends readonly (infer Type)[] ?
@@ -26,8 +27,22 @@ export type InferOneOfValidationType<A extends OneOfArguments> =
     never :
   never
 
+export type InferOneOfInput<A extends OneOfArguments> =
+  A extends readonly [ infer First, ...infer Rest ] ?
+    First extends Validation ?
+      Rest extends OneOfArguments ?
+        InferInput<First> | InferOneOfValidation<Rest> :
+        InferInput<First> :
+    never :
+  A extends readonly (infer Type)[] ?
+    Type extends Validation ?
+      InferInput<Type> :
+    never :
+  never
+
 /** A `Validator` validating a value as _one of_ the specified arguments. */
-export class OneOfValidator<A extends OneOfArguments> extends AbstractValidator<InferOneOfValidationType<A>> {
+export class OneOfValidator<A extends OneOfArguments>
+  extends AbstractValidator<InferOneOfValidation<A>, InferOneOfInput<A>> {
   readonly validators: readonly Validator[]
 
   constructor(args: A) {
@@ -36,7 +51,7 @@ export class OneOfValidator<A extends OneOfArguments> extends AbstractValidator<
     assertSchema(this.validators.length > 0, 'At least one validation required in "oneOf"')
   }
 
-  validate(value: unknown, options?: ValidationOptions): InferOneOfValidationType<A> {
+  validate(value: unknown, options?: ValidationOptions): InferOneOfValidation<A> {
     const builder = new ValidationErrorBuilder()
     for (const validator of this.validators) {
       try {
@@ -45,7 +60,7 @@ export class OneOfValidator<A extends OneOfArguments> extends AbstractValidator<
         builder.record(error)
       }
     }
-    return builder.assert(value as InferOneOfValidationType<A>)
+    return builder.assert(value as InferOneOfValidation<A>)
   }
 }
 
@@ -58,17 +73,27 @@ export function oneOf<A extends OneOfArguments>(...args: A): OneOfValidator<A> {
 
 export type AllOfArguments = readonly [ Validation, ...Validation[] ]
 
-export type InferAllOfValidationType<A extends AllOfArguments> =
+export type InferAllOfValidation<A extends AllOfArguments> =
   A extends readonly [ infer First, ...infer Rest ] ?
     First extends Validation ?
       Rest extends AllOfArguments ?
-        InferValidation<First> & InferAllOfValidationType<Rest> :
+        InferValidation<First> & InferAllOfValidation<Rest> :
       InferValidation<First> :
     never :
   never
 
+export type InferAllOfInput<A extends AllOfArguments> =
+  A extends readonly [ infer First, ...infer Rest ] ?
+    First extends Validation ?
+      Rest extends AllOfArguments ?
+        InferInput<First> & InferAllOfValidation<Rest> :
+      InferInput<First> :
+    never :
+  never
+
 /** A `Validator` validating a value as _all of_ the specified arguments. */
-export class AllOfValidator<A extends AllOfArguments> extends AbstractValidator<InferAllOfValidationType<A>> {
+export class AllOfValidator<A extends AllOfArguments>
+  extends AbstractValidator<InferAllOfValidation<A>, InferAllOfInput<A>> {
   readonly validators: readonly Validator[]
 
   constructor(args: A) {
@@ -77,11 +102,11 @@ export class AllOfValidator<A extends AllOfArguments> extends AbstractValidator<
     assertSchema(this.validators.length > 0, 'At least one validation required in "allOf"')
   }
 
-  validate(value: unknown, options?: ValidationOptions): InferAllOfValidationType<A> {
+  validate(value: unknown, options?: ValidationOptions): InferAllOfValidation<A> {
     for (const validator of this.validators) {
       value = validator.validate(value, options)
     }
-    return value as InferAllOfValidationType<A>
+    return value as InferAllOfValidation<A>
   }
 }