justus 0.1.5 → 0.2.0

package/src/types.ts

@@ -22,12 +22,21 @@ export const additionalValidator = Symbol.for('justus.additionalValidator')
  * Options to be using while validating.
  */
 export interface ValidationOptions {
-  /** Strip additional, undeclared properties from objects */
-  readonly stripAdditionalProperties: boolean,
-  /** Strip `null`s from an object when associated with an optional key */
-  readonly stripOptionalNulls: boolean,
-  /** Ignore and strip forbidden (`never`) properties from objects */
-  readonly stripForbiddenProperties: boolean,
+  /** Strip additional, undeclared properties from objects (default: `false`) */
+  stripAdditionalProperties?: boolean,
+  /** Strip `null`s from an object when associated with an optional key (default: `false`) */
+  stripOptionalNulls?: boolean,
+  /** Ignore and strip forbidden (`never`) properties from objects (default: `false`) */
+  stripForbiddenProperties?: boolean,
+}
+
+/**
+ * Default validation options.
+ */
+export const defaultValidationOptions: Readonly<Required<ValidationOptions>> = {
+  stripAdditionalProperties: false,
+  stripForbiddenProperties: false,
+  stripOptionalNulls: false,
 }
 
 /**
@@ -40,7 +49,7 @@ export interface Validator<T = any> extends Iterable<TupleRestParameter<T>> {
   optional?: boolean
 
   /** Validate a _value_ and optionally convert it to the required `Type` */
-  validate(value: unknown, options: ValidationOptions): 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>>;
@@ -68,13 +77,14 @@ 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 Iterable<TupleRestParameter<T>> {
+export abstract class AbstractValidator<T = any>
+implements Validator<T>, 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
+  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>> {
@@ -101,23 +111,21 @@ export type Validation =
  * Infer the type returned by a `Validation` when validating.
  */
 export type InferValidation<V> =
-  // Let `InferValidationType<T>` be liberal in the type it accepts and check
-  // here whether it extends `Validation`
-  V extends Validation ?
-    // Validators return their validation type
-    V extends Validator<infer T> ? T :
-
-    // Tuples and schemas are inferred using their own types
-    V extends Tuple ? InferTuple<V> :
-    V extends Schema ? InferSchema<V> :
-
-    // Primitives are returned as constants
-    V extends boolean ? V :
-    V extends number ? V :
-    V extends string ? V :
-    V extends null ? V :
-    never :
-  never
+  // Validators return their validation type
+  V extends Validator<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 ? InferTuple<V> :
+
+  // Anyhing else can only be a schema
+  InferSchema<V>
 
 
 /* ========================================================================== *
@@ -200,17 +208,28 @@ export interface AdditionalProperties<V extends Validator | false> {
  * ========================================================================== */
 
 /** Infer the type validated by a `Schema` */
-export type InferSchema<S extends Schema> =
+export type InferSchema<S> =
   S extends AdditionalProperties<Validator<infer V>> ?
     { [ key in string ] : V } & 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]>
-  }
-
+export type InferSchema2<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 ] ? : InferValidation<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 ?
+        undefined extends InferValidation<S[key]> ?
+          never :
+          key :
+      never ] -? :
+  InferValidation<S[key]>
+}
 
 /* ========================================================================== *
  * TYPE BRANDING                                                              *

package/src/utilities.ts

@@ -1,7 +1,11 @@
+import { isValidator, schemaValidator } from './types'
 import { ConstantValidator, nullValidator } from './validators/constant'
-import { isValidator, Schema, schemaValidator, Validation, Validator } from './types'
-import { TupleValidator } from './validators/tuple'
+// 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 type { Schema, Validation, Validator } from './types'
 
 /* ========================================================================== *
  * UTILITY FUNCTIONS                                                          *

package/src/validators/array.ts

@@ -1,8 +1,10 @@
 import { assertSchema, assertValidation, ValidationErrorBuilder } from '../errors'
-import { InferValidation, Validation, ValidationOptions, AbstractValidator, Validator, makeValidatorFactory } from '../types'
+import { AbstractValidator, makeValidatorFactory } from '../types'
 import { getValidator } from '../utilities'
 import { any } from './any'
 
+import type { InferValidation, Validation, ValidationOptions, Validator } from '../types'
+
 /* ========================================================================== *
  * ARRAYS VALIDATION                                                           *
  * ========================================================================== */
@@ -21,8 +23,7 @@ export interface ArrayConstraints<V extends Validation> {
 
 /** Basic validator for `Array` instances. */
 export class AnyArrayValidator<T = any> extends AbstractValidator<T[]> {
-  validate(value: unknown, options: ValidationOptions): T[] {
-    void options
+  validate(value: unknown): T[] {
     assertValidation(Array.isArray(value), 'Value is not an "array"')
     return [ ...value ]
   }
@@ -55,7 +56,7 @@ export class ArrayValidator<T> extends AbstractValidator<T[]> {
     this.uniqueItems = uniqueItems
   }
 
-  validate(value: unknown, options: ValidationOptions): T[] {
+  validate(value: unknown, options?: ValidationOptions): T[] {
     assertValidation(Array.isArray(value), 'Value is not an "array"')
 
     assertValidation(value.length >= this.minItems,
@@ -88,7 +89,7 @@ export class ArrayValidator<T> extends AbstractValidator<T[]> {
 
 /* -------------------------------------------------------------------------- */
 
-export function _array<V extends Validation>(constraints: ArrayConstraints<V>): ArrayValidator<InferValidation<V>> {
+function _array<V extends Validation>(constraints: ArrayConstraints<V>): ArrayValidator<InferValidation<V>> {
   const items = constraints.items ? getValidator(constraints.items) : any
   return new ArrayValidator({ ...constraints, items })
 }

package/src/validators/boolean.ts

@@ -1,5 +1,5 @@
-import { AbstractValidator, makeValidatorFactory } from '../types'
 import { assertValidation } from '../errors'
+import { AbstractValidator, makeValidatorFactory } from '../types'
 
 /** Constraints to validate a `boolean` with. */
 export interface BooleanConstraints {
@@ -37,7 +37,7 @@ export class BooleanValidator extends AbstractValidator<boolean> {
   }
 }
 
-export function _boolean(constraints: BooleanConstraints): BooleanValidator {
+function _boolean(constraints: BooleanConstraints): BooleanValidator {
   return new BooleanValidator(constraints)
 }
 

package/src/validators/constant.ts

@@ -1,5 +1,7 @@
-import { AbstractValidator, Validator } from '../types'
 import { assertValidation } from '../errors'
+import { AbstractValidator } from '../types'
+
+import type { Validator } from '../types'
 
 /** A `Validator` for _constants_. */
 export class ConstantValidator<T extends string | number | boolean | null> extends AbstractValidator<T> {

package/src/validators/date.ts

@@ -64,7 +64,7 @@ export class DateValidator extends AbstractValidator<Date> {
   }
 }
 
-export function _date(constraints: DateConstraints): DateValidator {
+function _date(constraints: DateConstraints): DateValidator {
   return new DateValidator(constraints)
 }
 

package/src/validators/never.ts

@@ -1,11 +1,13 @@
 import { ValidationError } from '../errors'
-import { ValidationOptions, AbstractValidator } from '../types'
+import { AbstractValidator, defaultValidationOptions } from '../types'
+
+import type { ValidationOptions } from '../types'
 
 /** A `Validator` validating _nothing_. */
 export class NeverValidator extends AbstractValidator<never> {
   optional: true = true
 
-  validate(value: unknown, options: ValidationOptions): never {
+  validate(value: unknown, options: ValidationOptions = defaultValidationOptions): never {
     const { stripForbiddenProperties } = options
 
     // @ts-expect-error

package/src/validators/number.ts

@@ -1,6 +1,7 @@
-import { Branding, Validator, AbstractValidator, makeValidatorFactory } from '../types'
-import { assertSchema, assertValidation } from '../errors'
-import { ValidationError } from '..'
+import { assertSchema, assertValidation, ValidationError } from '../errors'
+import { AbstractValidator, makeValidatorFactory } from '../types'
+
+import type { Branding, Validator } from '../types'
 
 /* ========================================================================== */
 
@@ -160,10 +161,10 @@ export class NumberValidator<N extends number = number> extends AbstractValidato
 }
 
 
-export function _number(constraints: NumberConstraints): NumberValidator<number>
-export function _number<N extends number>(constraints: NumberConstraints): NumberValidator<N>
-export function _number<B extends string>(constraints: BrandedNumberConstraints<B>): NumberValidator<number & Branding<B>>
-export function _number(constraints: NumberConstraints): Validator<number> {
+function _number(constraints: NumberConstraints): NumberValidator<number>
+function _number<N extends number>(constraints: NumberConstraints): NumberValidator<N>
+function _number<B extends string>(constraints: BrandedNumberConstraints<B>): NumberValidator<number & Branding<B>>
+function _number(constraints: NumberConstraints): Validator<number> {
   return new NumberValidator(constraints)
 }
 

package/src/validators/object.ts

@@ -1,20 +1,20 @@
+import { assertValidation, ValidationErrorBuilder } from '../errors'
+// eslint-disable-next-line import/no-cycle
+import { allowAdditionalProperties } from '../schema'
 import {
-  InferSchema,
-  Schema,
-  TupleRestParameter,
-  ValidationOptions,
-  Validator,
   AbstractValidator,
   additionalValidator,
+  defaultValidationOptions,
+  makeValidatorFactory,
   restValidator,
   schemaValidator,
-  makeValidatorFactory,
-  Validation,
-  InferValidation,
 } from '../types'
-import { assertValidation, ValidationErrorBuilder } from '../errors'
 import { getValidator } from '../utilities'
-import { allowAdditionalProperties } from '../schema'
+
+import type {
+  InferSchema, InferValidation, Schema, TupleRestParameter, Validation, ValidationOptions,
+  Validator,
+} from '../types'
 
 /* ========================================================================== *
  * OBJECT VALIDATOR                                                           *
@@ -49,7 +49,7 @@ export class ObjectValidator<S extends Schema> extends AbstractValidator<InferSc
     this.schema = schema
   }
 
-  validate(value: unknown, options: ValidationOptions): InferSchema<S> {
+  validate(value: unknown, options: ValidationOptions = defaultValidationOptions): InferSchema<S> {
     assertValidation(typeof value === 'object', 'Value is not an "object"')
     assertValidation(value !== null, 'Value is "null"')
 
@@ -120,7 +120,7 @@ export class ObjectValidator<S extends Schema> extends AbstractValidator<InferSc
   }
 }
 
-export function _object<S extends Schema>(schema: S): S & {
+function _object<S extends Schema>(schema: S): S & {
   [Symbol.iterator](): Generator<TupleRestParameter<InferSchema<S>>>
 } {
   const validator = new ObjectValidator(schema)

package/src/validators/optional.ts

@@ -1,6 +1,8 @@
-import { AbstractValidator, InferValidation, Validation, ValidationOptions, Validator } from '../types'
+import { AbstractValidator, defaultValidationOptions } from '../types'
 import { getValidator } from '../utilities'
 
+import type { InferValidation, Validation, ValidationOptions, Validator } from '../types'
+
 /**
  * A `Validator` for _optional_ properties (that is `type | undefined`).
  */
@@ -10,7 +12,6 @@ export class OptionalValidator<
 > extends AbstractValidator<D extends undefined ? T | undefined : T> {
   validator: Validator<T>
   defaultValue: T | undefined
-  optional: D extends undefined ? true : false
 
   constructor(validator: Validator<T>)
   constructor(validator: Validator<T>, defaultValue: D)
@@ -25,17 +26,13 @@ export class OptionalValidator<
     }
 
     try {
-      this.defaultValue = validator.validate(defaultValue, {
-        stripAdditionalProperties: false,
-        stripForbiddenProperties: false,
-        stripOptionalNulls: false,
-      })
+      this.defaultValue = validator.validate(defaultValue, defaultValidationOptions)
     } catch (cause) {
       throw new TypeError('Default value does not match validator', { cause })
     }
   }
 
-  validate(value: unknown, options: ValidationOptions): D extends undefined ? T | undefined : T {
+  validate(value: unknown, options?: ValidationOptions): D extends undefined ? T | undefined : T {
     if (value === undefined) return this.defaultValue as any // do not validate defaults!
     return this.validator.validate(value, options)
   }

package/src/validators/string.ts

@@ -1,5 +1,7 @@
-import { Branding, Validator, AbstractValidator, makeValidatorFactory } from '../types'
-import { assertValidation, assertSchema } from '../errors'
+import { assertSchema, assertValidation } from '../errors'
+import { AbstractValidator, makeValidatorFactory } from '../types'
+
+import type { Branding, Validator } from '../types'
 
 /** Constraints to validate a `string` with. */
 export interface StringConstraints {
@@ -68,10 +70,10 @@ export class StringValidator<S extends string = string> extends AbstractValidato
   }
 }
 
-export function _string(constraints: StringConstraints): StringValidator<string>
-export function _string<S extends string>(constraints: StringConstraints): StringValidator<S>
-export function _string<B extends string>(constraints: BrandedStringConstraints<B>): StringValidator<string & Branding<B>>
-export function _string(constraints: StringConstraints): Validator<string> {
+function _string(constraints: StringConstraints): StringValidator<string>
+function _string<S extends string>(constraints: StringConstraints): StringValidator<S>
+function _string<B extends string>(constraints: BrandedStringConstraints<B>): StringValidator<string & Branding<B>>
+function _string(constraints: StringConstraints): Validator<string> {
   return new StringValidator(constraints)
 }
 

package/src/validators/tuple.ts

@@ -1,9 +1,11 @@
-import { Tuple, InferTuple, Validator, AbstractValidator, restValidator } from '../types'
-import { ValidationOptions } from '../types'
 import { assertValidation, ValidationError } from '../errors'
+import { AbstractValidator, restValidator } 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'
+
 export interface TupleMember { single: boolean, validator: Validator }
 
 /** A `Validator` for _tuples_. */
@@ -29,7 +31,7 @@ export class TupleValidator<T extends Tuple> extends AbstractValidator<InferTupl
     this.tuple = tuple
   }
 
-  validate(value: unknown, options: ValidationOptions): InferTuple<T> {
+  validate(value: unknown, options?: ValidationOptions): InferTuple<T> {
     assertValidation(Array.isArray(value), 'Value is not an "array"')
 
     // Empty tuples

package/src/validators/union.ts

@@ -1,11 +1,13 @@
 import { assertSchema, ValidationErrorBuilder } from '../errors'
-import {
-  AbstractValidator, InferValidation,
+import { AbstractValidator } from '../types'
+import { getValidator } from '../utilities'
+
+import type {
+  InferValidation,
   Validation,
   ValidationOptions,
   Validator,
 } from '../types'
-import { getValidator } from '../utilities'
 
 /* -------------------------------------------------------------------------- */
 
@@ -34,7 +36,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): InferOneOfValidationType<A> {
     const builder = new ValidationErrorBuilder()
     for (const validator of this.validators) {
       try {
@@ -75,7 +77,7 @@ 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): InferAllOfValidationType<A> {
     for (const validator of this.validators) {
       value = validator.validate(value, options)
     }

package/src/validators/url.ts

@@ -1,7 +1,10 @@
-import { ConstantValidator } from './constant'
 import { ValidationError, ValidationErrorBuilder } from '../errors'
-import { Schema, Validator, AbstractValidator, makeValidatorFactory } from '../types'
-import { ObjectValidator, ValidationOptions } from '..'
+import { AbstractValidator, makeValidatorFactory } from '../types'
+import { ConstantValidator } from './constant'
+import { ObjectValidator } from './object'
+
+import type { ValidationOptions } from '..'
+import type { Schema, Validator } from '../types'
 
 const KEYS: Exclude<keyof URLConstraints, 'searchParams'>[] = [
   'href',
@@ -127,11 +130,9 @@ export class URLValidator extends AbstractValidator<URL> {
   }
 }
 
-const anyURLValidator = new URLValidator()
-
-export function _url(constraints: URLConstraints): URLValidator {
+function _url(constraints: URLConstraints): URLValidator {
   return new URLValidator(constraints)
 }
 
 /** Validate URLs and convert them to `URL` instances. */
-export const url = makeValidatorFactory(anyURLValidator, _url)
+export const url = makeValidatorFactory(new URLValidator(), _url)