justus 0.5.2 → 0.5.4

package/src/validators/bigint.ts

@@ -0,0 +1,147 @@
+import { assertSchema, assertValidation, ValidationError } from '../errors'
+import { AbstractValidator, makeValidatorFactory } from '../types'
+
+import type { Branding, Validator } from '../types'
+
+/* ========================================================================== */
+
+/** Constraints to validate a `bigint` with. */
+export interface BigIntConstraints {
+  /** The value for which a `bigint` must be multiple of for it to be valid */
+  multipleOf?: bigint | number,
+  /** The _inclusive_ maximum value for a valid `bigint`: `value <= maximum` */
+  maximum?: bigint | number,
+  /** The _inclusive_ minimum value for a valid `bigint`: `value >= minimum` */
+  minimum?: bigint | number,
+  /** The _exclusive_ maximum value for a valid `bigint`: `value < exclusiveMaximum` */
+  exclusiveMaximum?: bigint | number,
+  /** The _exclusive_ minimum value for a valid `bigint`: `value > exclusiveMaximum` */
+  exclusiveMinimum?: bigint | number,
+  /** Allow bigints to be parsed from strings (e.g. `123.456` or `0x0CAFE`, default: `false`) */
+  fromString?: boolean,
+  /** Allow bigints to be parsed from numbers (default: `true`) */
+  fromNumber?: boolean,
+}
+
+/** Constraints to validate a `bigint` with extra branding information. */
+export interface BrandedBigIntConstraints<B extends string> extends BigIntConstraints {
+  /** The _brand_ of the string (will generate a `__brand_${B}` type property */
+  brand: B
+}
+
+/** A `Validator` validating any `bigint`. */
+export class AnyBigIntValidator extends AbstractValidator<bigint> {
+  validate(value: unknown): bigint {
+    if (typeof value === 'number') {
+      try {
+        value = BigInt(value)
+      } catch (error) {
+        throw new ValidationError('BigInt can not be parsed from number')
+      }
+    }
+    assertValidation(typeof value === 'bigint', 'Value is not a "bigint"')
+    return value
+  }
+}
+
+/** A `Validator` validating `bigint`s with constaints. */
+export class BigIntValidator<N extends bigint = bigint> extends AbstractValidator<N, bigint> {
+  readonly fromString: boolean
+  readonly fromNumber: boolean
+  readonly exclusiveMaximum?: bigint
+  readonly exclusiveMinimum?: bigint
+  readonly maximum?: bigint
+  readonly minimum?: bigint
+  readonly multipleOf?: bigint
+  readonly brand?: string
+
+  constructor(constraints: BigIntConstraints = {}) {
+    super()
+
+    const {
+      exclusiveMaximum,
+      exclusiveMinimum,
+      maximum,
+      minimum,
+      multipleOf,
+      fromString = false,
+      fromNumber = true,
+    } = constraints
+
+    if ('brand' in constraints) this.brand = (<any> constraints).brand
+    this.fromString = fromString
+    this.fromNumber = fromNumber
+
+    const _exclusiveMaximum = exclusiveMaximum === undefined ? undefined : BigInt(exclusiveMaximum)
+    const _exclusiveMinimum = exclusiveMinimum === undefined ? undefined : BigInt(exclusiveMinimum)
+    const _maximum = maximum === undefined ? undefined : BigInt(maximum)
+    const _minimum = minimum === undefined ? undefined : BigInt(minimum)
+    const _multipleOf = multipleOf === undefined ? undefined : BigInt(multipleOf)
+
+    if ((_maximum !== undefined) && (_minimum !== undefined)) {
+      assertSchema(_maximum >= _minimum, `Constraint "minimum" (${_minimum}) is greater than "maximum" (${_maximum})`)
+    }
+
+    if ((_exclusiveMaximum !== undefined) && (_minimum !== undefined)) {
+      assertSchema(_exclusiveMaximum > _minimum,
+          `Constraint "exclusiveMaximum" (${_exclusiveMaximum}) must be greater than "minimum" (${_minimum})`)
+    }
+
+    if ((_exclusiveMinimum !== undefined) && (_maximum != undefined)) {
+      assertSchema(_maximum > _exclusiveMinimum,
+          `Constraint "maximum" (${_maximum}) must be greater than "exclusiveMinimum" (${_exclusiveMinimum})`)
+    }
+
+    if ((_exclusiveMinimum != undefined) && (_exclusiveMaximum !== undefined)) {
+      assertSchema(_exclusiveMaximum > _exclusiveMinimum,
+          `Constraint "exclusiveMaximum" (${_exclusiveMaximum}) must be greater than "exclusiveMinimum" (${_exclusiveMinimum})`)
+    }
+
+    if (_multipleOf !== undefined) {
+      assertSchema(_multipleOf > 0, `Constraint "multipleOf" (${_multipleOf}) must be greater than zero`)
+    }
+
+    this.exclusiveMaximum = _exclusiveMaximum
+    this.exclusiveMinimum = _exclusiveMinimum
+    this.maximum = _maximum
+    this.minimum = _minimum
+    this.multipleOf = _multipleOf
+  }
+
+  validate(value: unknown): N {
+    // Allow parsing from strings or numbers
+    if (((typeof value === 'string') && (this.fromString)) ||
+        ((typeof value === 'number') && (this.fromNumber))) {
+      try {
+        value = BigInt(value)
+      } catch (error) {
+        throw new ValidationError('BigInt can not be parsed from ' + typeof value)
+      }
+    }
+
+    assertValidation(typeof value === 'bigint', 'Value is not a "bigint"')
+
+    assertValidation(((this.minimum === undefined) || (value >= this.minimum)),
+        `BigInt is less than ${this.minimum}`)
+    assertValidation(((this.maximum === undefined) || (value <= this.maximum)),
+        `BigInt is greater than ${this.maximum}`)
+    assertValidation((this.exclusiveMinimum === undefined) || (value > this.exclusiveMinimum),
+        `BigInt is less than or equal to ${this.exclusiveMinimum}`)
+    assertValidation((this.exclusiveMaximum === undefined) || (value < this.exclusiveMaximum),
+        `BigInt is greater than or equal to ${this.exclusiveMaximum}`)
+    assertValidation((this.multipleOf === undefined) || (!(value % this.multipleOf)),
+        `BigInt is not a multiple of ${this.multipleOf}`)
+
+    return value as N
+  }
+}
+
+export function bigintFactory(constraints: BigIntConstraints): BigIntValidator<bigint>
+export function bigintFactory<N extends bigint>(constraints: BigIntConstraints): BigIntValidator<N>
+export function bigintFactory<B extends string>(constraints: BrandedBigIntConstraints<B>): BigIntValidator<bigint & Branding<B>>
+export function bigintFactory(constraints: BigIntConstraints): Validator<bigint> {
+  return new BigIntValidator(constraints)
+}
+
+/** Validate `bigint`s. */
+export const bigint = makeValidatorFactory(new AnyBigIntValidator(), bigintFactory)

package/src/validators/boolean.ts

@@ -25,7 +25,7 @@ export class BooleanValidator extends AbstractValidator<boolean> {
 
   validate(value: unknown): boolean {
     // Allow parsing from strings
-    if ((typeof value == 'string') && (this.fromString)) {
+    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')

package/src/validators/constant.ts

@@ -5,7 +5,7 @@ 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> {
+export class ConstantValidator<T extends string | number | boolean | bigint | null> extends AbstractValidator<T> {
   readonly constant: T
 
   constructor(constant: T) {
@@ -14,13 +14,14 @@ export class ConstantValidator<T extends string | number | boolean | null> exten
   }
 
   validate(value: unknown): T {
-    assertValidation(value === this.constant, `Value does not match constant "${this.constant}"`)
+    const extra = this.constant === null ? '' : ` (${typeof this.constant})`
+    assertValidation(value === this.constant, `Value does not match constant "${this.constant}"${extra}`)
     return value as T
   }
 }
 
 /** Validate _constants_. */
-export function constant<T extends string | number | boolean | null>(constant: T): Validator<T> {
+export function constant<T extends string | number | boolean | bigint | null>(constant: T): Validator<T> {
   return new ConstantValidator(constant)
 }
 

package/src/validators/never.ts

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

package/src/validators/number.ts

@@ -46,7 +46,7 @@ export interface BrandedNumberConstraints<B extends string> extends NumberConstr
 /** A `Validator` validating any `number`. */
 export class AnyNumberValidator extends AbstractValidator<number> {
   validate(value: unknown): number {
-    assertValidation(typeof value == 'number', 'Value is not a "number"')
+    assertValidation(typeof value === 'number', 'Value is not a "number"')
     assertValidation(! isNaN(value), 'Number is "NaN"')
     return value
   }
@@ -131,13 +131,13 @@ export class NumberValidator<N extends number = number> extends AbstractValidato
 
   validate(value: unknown): N {
     // Allow parsing from strings
-    if ((typeof value == 'string') && (this.fromString)) {
+    if ((typeof value === 'string') && (this.fromString)) {
       const parsed = +`${value}`
       assertValidation(! isNaN(parsed), 'Number can not be parsed from string')
       value = parsed
     }
 
-    assertValidation(typeof value == 'number', 'Value is not a "number"')
+    assertValidation(typeof value === 'number', 'Value is not a "number"')
 
     if (isNaN(value)) {
       assertValidation(this.allowNaN, 'Number is "NaN"')
@@ -147,10 +147,10 @@ export class NumberValidator<N extends number = number> extends AbstractValidato
     assertValidation(value >= this.minimum, `Number is less than ${this.minimum}`)
     assertValidation(value <= this.maximum, `Number is greater than ${this.maximum}`)
 
-    assertValidation((this.exclusiveMinimum == undefined) || (value > this.exclusiveMinimum),
+    assertValidation((this.exclusiveMinimum === undefined) || (value > this.exclusiveMinimum),
         `Number is less than or equal to ${this.exclusiveMinimum}`)
 
-    assertValidation((this.exclusiveMaximum == undefined) || (value < this.exclusiveMaximum),
+    assertValidation((this.exclusiveMaximum === undefined) || (value < this.exclusiveMaximum),
         `Number is greater than or equal to ${this.exclusiveMaximum}`)
 
     assertValidation(this.#isMultipleOf ? this.#isMultipleOf(value) : true,

package/src/validators/object.ts

@@ -1,6 +1,6 @@
 import { assertValidation, ValidationErrorBuilder } from '../errors'
 import { registry } from '../registry'
-import { AbstractValidator, defaultValidationOptions, makeValidatorFactory } from '../types'
+import { AbstractValidator, makeValidatorFactory } from '../types'
 import { getValidator } from '../utilities'
 
 import type {
@@ -17,7 +17,7 @@ import type {
 /** A `Validator` validating any `object`. */
 export class AnyObjectValidator extends AbstractValidator<Record<string, any>> {
   validate(value: unknown): Record<string, any> {
-    assertValidation(typeof value == 'object', 'Value is not an "object"')
+    assertValidation(typeof value === 'object', 'Value is not an "object"')
     assertValidation(value !== null, 'Value is "null"')
     return value
   }
@@ -43,11 +43,11 @@ export class ObjectValidator<S extends Schema> extends AbstractValidator<InferSc
     this.schema = schema
   }
 
-  validate(value: unknown, options: ValidationOptions = defaultValidationOptions): InferSchema<S> {
+  validate(value: unknown, options: ValidationOptions = {}): InferSchema<S> {
     assertValidation(typeof value === 'object', 'Value is not an "object"')
     assertValidation(value !== null, 'Value is "null"')
 
-    const { stripAdditionalProperties, stripOptionalNulls } = options
+    const { stripAdditionalProperties, stripOptionalNulls, partialValidation } = options
 
     const record: { [ k in string | number | symbol ]?: unknown } = value
     const builder = new ValidationErrorBuilder()
@@ -63,19 +63,20 @@ export class ObjectValidator<S extends Schema> extends AbstractValidator<InferSc
       }
 
       // if we have no value, then we have few possibilities:
+      // - we are performing a partial validation, so we ignore
       // - the (optional) validator provides a valid value
       // - the validator is optional, so we can simply ignore
       // - the validator is not optional, so the property is missing
       if (original === undefined) {
+        if (partialValidation) continue
         try {
           // try to validate, the validator _might_ be giving us a value
           const validated = validator.validate(original, options)
           // put the validated value in the clone, unless optional and undefined
-          if (! (optional && (validated == undefined))) clone[key] = validated
+          if (! (optional && (validated === undefined))) clone[key] = validated
         } catch (error) {
           if (optional) continue // original was undefined, so we can skip!
           builder.record('Required property missing', key)
-          // builder.record(error, key) // double error!
         }
 
         continue
@@ -85,7 +86,7 @@ export class ObjectValidator<S extends Schema> extends AbstractValidator<InferSc
       try {
         const validated = validator.validate(original, options)
         // put the validated value in the clone, unless optional and undefined
-        if (! (optional && (validated == undefined))) clone[key] = validated
+        if (! (optional && (validated === undefined))) clone[key] = validated
       } catch (error) {
         builder.record(error, key)
       }

package/src/validators/optional.ts

@@ -1,4 +1,4 @@
-import { AbstractValidator, defaultValidationOptions } from '../types'
+import { AbstractValidator } from '../types'
 import { getValidator } from '../utilities'
 
 import type { InferInput, InferValidation, Validation, ValidationOptions, Validator } from '../types'
@@ -27,7 +27,7 @@ export class OptionalValidator<
     }
 
     try {
-      this.defaultValue = validator.validate(defaultValue, defaultValidationOptions)
+      this.defaultValue = validator.validate(defaultValue, {})
     } catch (cause) {
       throw new TypeError('Default value does not match validator', { cause })
     }

package/src/validators/string.ts

@@ -22,7 +22,7 @@ export interface BrandedStringConstraints<B extends string> extends StringConstr
 /** A `Validator` validating any `string`. */
 export class AnyStringValidator extends AbstractValidator<string> {
   validate(value: unknown): string {
-    assertValidation(typeof value == 'string', 'Value is not a "string"')
+    assertValidation(typeof value === 'string', 'Value is not a "string"')
     return value
   }
 }
@@ -55,7 +55,7 @@ export class StringValidator<S extends string = string, I = string> extends Abst
   }
 
   validate(value: unknown): S {
-    assertValidation(typeof value == 'string', 'Value is not a "string"')
+    assertValidation(typeof value === 'string', 'Value is not a "string"')
 
     assertValidation(value.length >= this.minLength,
         `String must have a minimum length of ${this.minLength}`)