justus 0.0.6 → 0.1.0

package/src/validators/never.ts

@@ -0,0 +1,18 @@
+import { ValidationError } from '../errors'
+import { ValidationOptions, AbstractValidator } from '../types'
+
+/** A `Validator` validating _nothing_. */
+export class NeverValidator extends AbstractValidator<never> {
+  optional: true = true
+
+  validate(value: unknown, options: ValidationOptions): never {
+    const { stripForbiddenProperties } = options
+
+    // @ts-expect-error
+    if (stripForbiddenProperties || (value === undefined)) return
+    throw new ValidationError('Forbidden property')
+  }
+}
+
+/** The `Validator` validating _nothing_. */
+export const never = new NeverValidator()

package/src/validators/number.ts

@@ -1,6 +1,5 @@
-import { Branding, Validator } from '../types'
+import { Branding, Validator, AbstractValidator, makeValidatorFactory } from '../types'
 import { assertSchema, assertValidation } from '../errors'
-import { makeTupleRestIterable } from './tuple'
 import { ValidationError } from '..'
 
 /* ========================================================================== */
@@ -42,7 +41,7 @@ export interface BrandedNumberConstraints<B extends string> extends NumberConstr
 }
 
 /** A `Validator` validating any `number`. */
-export class AnyNumberValidator extends Validator<number> {
+export class AnyNumberValidator extends AbstractValidator<number> {
   validate(value: unknown): number {
     assertValidation(typeof value == 'number', 'Value is not a "number"')
     assertValidation(! isNaN(value), 'Number is "NaN"')
@@ -51,7 +50,7 @@ export class AnyNumberValidator extends Validator<number> {
 }
 
 /** A `Validator` validating `number`s with constaints. */
-export class NumberValidator<N extends number = number> extends Validator<N> {
+export class NumberValidator<N extends number = number> extends AbstractValidator<N> {
   #isMultipleOf?: ((value: number) => boolean)
 
   readonly allowNaN: boolean
@@ -148,16 +147,13 @@ export class NumberValidator<N extends number = number> extends Validator<N> {
   }
 }
 
-const anyNumberValidator = new AnyNumberValidator()
 
-export function _number(): Validator<number>
-export function _number(constraints?: NumberConstraints): NumberValidator<number>
-export function _number<N extends number>(constraints?: NumberConstraints): NumberValidator<N>
+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> {
-  return constraints ? new NumberValidator(constraints) : anyNumberValidator
+export function _number(constraints: NumberConstraints): Validator<number> {
+  return new NumberValidator(constraints)
 }
 
 /** Validate `number`s. */
-export const number = makeTupleRestIterable(_number)
+export const number = makeValidatorFactory(new AnyNumberValidator(), _number)

package/src/validators/object.ts

@@ -4,29 +4,21 @@ import {
   TupleRestParameter,
   ValidationOptions,
   Validator,
+  AbstractValidator,
   additionalValidator,
-  modifierValidator,
-  never,
   restValidator,
   schemaValidator,
+  makeValidatorFactory,
 } from '../types'
 import { assertValidation, ValidationErrorBuilder } from '../errors'
 import { getValidator } from '../utilities'
-import { isModifier } from '../schema'
-import { makeTupleRestIterable } from './tuple'
 
 /* ========================================================================== *
  * OBJECT VALIDATOR                                                           *
  * ========================================================================== */
 
-export type ObjectProperty = {
-  validator: Validator,
-  readonly?: true,
-  optional?: true,
-}
-
 /** A `Validator` validating any `object`. */
-export class AnyObjectValidator extends Validator<Record<string, any>> {
+export class AnyObjectValidator extends AbstractValidator<Record<string, any>> {
   validate(value: unknown): Record<string, any> {
     assertValidation(typeof value == 'object', 'Value is not an "object"')
     assertValidation(value !== null, 'Value is "null"')
@@ -35,10 +27,10 @@ export class AnyObjectValidator extends Validator<Record<string, any>> {
 }
 
 /** A `Validator` validating `object`s according to a `Schema`. */
-export class ObjectValidator<S extends Schema> extends Validator<InferSchema<S>> {
+export class ObjectValidator<S extends Schema> extends AbstractValidator<InferSchema<S>> {
   readonly schema: Readonly<S>
 
-  properties = new Map<string, ObjectProperty | undefined>()
+  validators = new Map<string, Validator>()
   additionalProperties?: Validator
 
   constructor(schema: S) {
@@ -48,19 +40,7 @@ export class ObjectValidator<S extends Schema> extends Validator<InferSchema<S>>
     if (additional) this.additionalProperties = getValidator(additional)
 
     for (const key of Object.keys(properties)) {
-      const definition = properties[key]
-
-      if (definition === never) {
-        this.properties.set(key, undefined)
-      } else if (isModifier(definition)) {
-        this.properties.set(key, {
-          validator: definition[modifierValidator],
-          readonly: definition.readonly,
-          optional: definition.optional,
-        })
-      } else {
-        this.properties.set(key, { validator: getValidator(definition) })
-      }
+      this.validators.set(key, getValidator(properties[key]))
     }
 
     this.schema = schema
@@ -70,22 +50,14 @@ export class ObjectValidator<S extends Schema> extends Validator<InferSchema<S>>
     assertValidation(typeof value === 'object', 'Value is not an "object"')
     assertValidation(value !== null, 'Value is "null"')
 
-    const { stripAdditionalProperties, stripForbiddenProperties, stripOptionalNulls } = options
+    const { stripAdditionalProperties, stripOptionalNulls } = options
 
     const record: { [ k in string | number | symbol ]?: unknown } = value
     const builder = new ValidationErrorBuilder()
     const clone: Record<string, any> = {}
 
-    for (const [ key, property ] of this.properties.entries()) {
-      const { validator, optional } = property || {}
-
-      // no validator? this is "never" (forbidden)
-      if (! validator) {
-        if (record[key] === undefined) continue
-        if (stripForbiddenProperties) continue
-        builder.record('Forbidden property', key)
-        continue
-      }
+    for (const [ key, validator ] of this.validators.entries()) {
+      const optional = !! validator.optional
 
       // no value? might be optional, but definitely not validated
       if (record[key] === undefined) {
@@ -100,13 +72,14 @@ export class ObjectValidator<S extends Schema> extends Validator<InferSchema<S>>
 
       // all the rest gets validated normally
       try {
-        clone[key] = validator.validate(record[key], options)
+        const value = validator.validate(record[key], options)
+        if (! (optional && (value == undefined))) clone[key] = value
       } catch (error) {
         builder.record(error, key)
       }
     }
 
-    const additionalKeys = Object.keys(record).filter((k) => !this.properties.has(k))
+    const additionalKeys = Object.keys(record).filter((k) => !this.validators.has(k))
     const additional = this.additionalProperties
 
     if (additional) {
@@ -128,15 +101,9 @@ export class ObjectValidator<S extends Schema> extends Validator<InferSchema<S>>
   }
 }
 
-const anyObjectValidator = new AnyObjectValidator()
-
-export function _object(): Validator<Record<string, any>>
 export function _object<S extends Schema>(schema: S): S & {
   [Symbol.iterator](): Generator<TupleRestParameter<InferSchema<S>>>
-}
-export function _object(schema?: Schema): Validator<Record<string, any>> | Schema {
-  if (! schema) return anyObjectValidator
-
+} {
   const validator = new ObjectValidator(schema)
   function* iterator(): Generator<TupleRestParameter> {
     yield { [restValidator]: validator }
@@ -145,8 +112,8 @@ export function _object(schema?: Schema): Validator<Record<string, any>> | Schem
   return Object.defineProperties(schema, {
     [schemaValidator]: { value: validator, enumerable: false },
     [Symbol.iterator]: { value: iterator, enumerable: false },
-  })
+  }) as any
 }
 
 /** Validate `object`s. */
-export const object = makeTupleRestIterable(_object)
+export const object = makeValidatorFactory(new AnyObjectValidator(), _object)

package/src/validators/optional.ts

@@ -0,0 +1,30 @@
+import { AbstractValidator, Validator, ValidationOptions, Validation, InferValidation } from '../types'
+import { getValidator } from '../utilities'
+
+/**
+ * A `Validator` for _optional_ properties (that is `type | undefined`).
+ */
+export class OptionalValidator<T = any> extends AbstractValidator<T | undefined> {
+  validator: Validator<T>
+  optional: true = true
+
+  constructor(validator: Validator<T>) {
+    super()
+    this.validator = validator
+  }
+
+  validate(value: unknown, options: ValidationOptions): T | undefined {
+    if (value === undefined) return value
+    return this.validator.validate(value, options)
+  }
+}
+
+/**
+ * Ensure that the property is marked as _optional_ in the `Schema`.
+ *
+ * @param validation - A `Validation` to be marked as _optional_.
+ */
+export function optional<V extends Validation>(validation: V): OptionalValidator<InferValidation<V>> {
+  const validator = getValidator(validation)
+  return new OptionalValidator(validator)
+}

package/src/validators/string.ts

@@ -1,6 +1,5 @@
-import { Branding, Validator } from '../types'
+import { Branding, Validator, AbstractValidator, makeValidatorFactory } from '../types'
 import { assertValidation, assertSchema } from '../errors'
-import { makeTupleRestIterable } from './tuple'
 
 /** Constraints to validate a `string` with. */
 export interface StringConstraints {
@@ -19,7 +18,7 @@ export interface BrandedStringConstraints<B extends string> extends StringConstr
 }
 
 /** A `Validator` validating any `string`. */
-export class AnyStringValidator extends Validator<string> {
+export class AnyStringValidator extends AbstractValidator<string> {
   validate(value: unknown): string {
     assertValidation(typeof value == 'string', 'Value is not a "string"')
     return value
@@ -27,7 +26,7 @@ export class AnyStringValidator extends Validator<string> {
 }
 
 /** A `Validator` validating `string`s with constraints. */
-export class StringValidator<S extends string = string> extends Validator<S> {
+export class StringValidator<S extends string = string> extends AbstractValidator<S> {
   readonly maxLength: number
   readonly minLength: number
   readonly pattern?: RegExp
@@ -69,16 +68,12 @@ export class StringValidator<S extends string = string> extends Validator<S> {
   }
 }
 
-const anyStringValidator = new AnyStringValidator()
-
-export function _string(): Validator<string>
-export function _string(constraints?: StringConstraints): StringValidator<string>
-export function _string<S extends string>(constraints?: StringConstraints): StringValidator<S>
+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> {
-  return constraints ? new StringValidator(constraints) : anyStringValidator
+export function _string(constraints: StringConstraints): Validator<string> {
+  return new StringValidator(constraints)
 }
 
 /** Validate `string`s. */
-export const string = makeTupleRestIterable(_string)
+export const string = makeValidatorFactory(new AnyStringValidator(), _string)

package/src/validators/tuple.ts

@@ -1,4 +1,4 @@
-import { Tuple, InferTuple, Validator, TupleRestParameter, InferValidation, restValidator } from '../types'
+import { Tuple, InferTuple, Validator, AbstractValidator, restValidator } from '../types'
 import { ValidationOptions } from '../types'
 import { assertValidation, ValidationError } from '../errors'
 import { getValidator } from '../utilities'
@@ -7,7 +7,7 @@ import { nullValidator } from './constant'
 export interface TupleMember { single: boolean, validator: Validator }
 
 /** A `Validator` for _tuples_. */
-export class TupleValidator<T extends Tuple> extends Validator<InferTuple<T>> {
+export class TupleValidator<T extends Tuple> extends AbstractValidator<InferTuple<T>> {
   readonly members: readonly TupleMember[]
   readonly tuple: T
 
@@ -78,13 +78,3 @@ export class TupleValidator<T extends Tuple> extends Validator<InferTuple<T>> {
 export function tuple<T extends Tuple>(tuple: T): Validator<InferTuple<T>> {
   return new TupleValidator(tuple)
 }
-
-export function makeTupleRestIterable<
-  F extends () => Validator,
->(create: F): F & Iterable<TupleRestParameter<InferValidation<F>>> {
-  const validator = create()
-  ;(<any>create)[Symbol.iterator] = function* (): Generator<TupleRestParameter<InferValidation<F>>> {
-    yield { [restValidator]: validator }
-  }
-  return create as any
-}

package/src/validators/union.ts

@@ -5,6 +5,7 @@ import {
   Validation,
   ValidationOptions,
   Validator,
+  AbstractValidator,
 } from '../types'
 
 export type UnionArguments = readonly [ Validation, ...Validation[] ]
@@ -21,7 +22,7 @@ export type InferOneOfValidationType<A extends UnionArguments> =
   never
 
 /** A `Validator` validating a value as _one of_ the specified arguments. */
-export class OneOfValidator<A extends UnionArguments> extends Validator<InferOneOfValidationType<A>> {
+export class OneOfValidator<A extends UnionArguments> extends AbstractValidator<InferOneOfValidationType<A>> {
   readonly validators: readonly Validator[]
 
   constructor(args: A) {
@@ -59,7 +60,7 @@ export type InferAllOfValidationType<A extends UnionArguments> =
   never
 
 /** A `Validator` validating a value as _all of_ the specified arguments. */
-export class AllOfValidator<A extends UnionArguments> extends Validator<InferAllOfValidationType<A>> {
+export class AllOfValidator<A extends UnionArguments> extends AbstractValidator<InferAllOfValidationType<A>> {
   readonly validators: readonly Validator[]
 
   constructor(args: A) {

package/src/validators/url.ts

@@ -1,7 +1,6 @@
 import { ConstantValidator } from './constant'
 import { ValidationError, ValidationErrorBuilder } from '../errors'
-import { Schema, Validator } from '../types'
-import { makeTupleRestIterable } from './tuple'
+import { Schema, Validator, AbstractValidator, makeValidatorFactory } from '../types'
 import { ObjectValidator, ValidationOptions } from '..'
 
 const KEYS: Exclude<keyof URLConstraints, 'searchParams'>[] = [
@@ -58,7 +57,7 @@ export interface URLConstraints {
 }
 
 /** A `Validator` validating URLs and converting them to `URL` instances. */
-export class URLValidator extends Validator<URL> {
+export class URLValidator extends AbstractValidator<URL> {
   readonly href?: Validator<string>
   readonly origin?: Validator<string>
   readonly protocol?: Validator<string>
@@ -130,12 +129,9 @@ export class URLValidator extends Validator<URL> {
 
 const anyURLValidator = new URLValidator()
 
-export function _url(): URLValidator
-export function _url(constraints: URLConstraints): URLValidator
-
-export function _url(constraints?: URLConstraints): URLValidator {
-  return constraints ? new URLValidator(constraints) : anyURLValidator
+export function _url(constraints: URLConstraints): URLValidator {
+  return new URLValidator(constraints)
 }
 
 /** Validate URLs and convert them to `URL` instances. */
-export const url = makeTupleRestIterable(_url)
+export const url = makeValidatorFactory(anyURLValidator, _url)