justus 0.5.3 → 0.5.5

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,
@@ -160,12 +160,12 @@ export class NumberValidator<N extends number = number> extends AbstractValidato
   }
 }
 
-export function numberFactory(constraints: NumberConstraints): NumberValidator<number>
-export function numberFactory<N extends number>(constraints: NumberConstraints): NumberValidator<N>
-export function numberFactory<B extends string>(constraints: BrandedNumberConstraints<B>): NumberValidator<number & Branding<B>>
-export function numberFactory(constraints: NumberConstraints): Validator<number> {
+export function numberValidatorFactory(constraints: NumberConstraints): NumberValidator<number>
+export function numberValidatorFactory<N extends number>(constraints: NumberConstraints): NumberValidator<N>
+export function numberValidatorFactory<B extends string>(constraints: BrandedNumberConstraints<B>): NumberValidator<number & Branding<B>>
+export function numberValidatorFactory(constraints: NumberConstraints): Validator<number> {
   return new NumberValidator(constraints)
 }
 
 /** Validate `number`s. */
-export const number = makeValidatorFactory(new AnyNumberValidator(), numberFactory)
+export const number = makeValidatorFactory(new AnyNumberValidator(), numberValidatorFactory)

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)
       }
@@ -114,7 +115,7 @@ export class ObjectValidator<S extends Schema> extends AbstractValidator<InferSc
   }
 }
 
-export function objectFactory<S extends Schema>(schema: S): S & {
+export function objectValidatorFactory<S extends Schema>(schema: S): S & {
   [Symbol.iterator](): Generator<TupleRestParameter<InferSchema<S>, InferInputSchema<S>>>
 } {
   const validator = new ObjectValidator(schema)
@@ -130,11 +131,11 @@ export function objectFactory<S extends Schema>(schema: S): S & {
 }
 
 /** Validate `object`s. */
-export const object = makeValidatorFactory(new AnyObjectValidator(), objectFactory)
+export const object = makeValidatorFactory(new AnyObjectValidator(), objectValidatorFactory)
 
 /** Validate `Object`s containing only the specified elements. */
 export function objectOf<V extends Validation>(validation: V): Validator<Record<string, InferValidation<V>>> {
-  return new ObjectValidator({ [Symbol.justusAdditionalValidator]: getValidator(validation) })
+  return new ObjectValidator<any>({ [Symbol.justusAdditionalValidator]: getValidator(validation) })
 }
 
 // Register our "object" validator

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}`)
@@ -70,12 +70,12 @@ export class StringValidator<S extends string = string, I = string> extends Abst
   }
 }
 
-export function stringFactory(constraints: StringConstraints): StringValidator<string>
-export function stringFactory<S extends string>(constraints: StringConstraints): StringValidator<S>
-export function stringFactory<B extends string>(constraints: BrandedStringConstraints<B>): StringValidator<string & Branding<B>>
-export function stringFactory(constraints: StringConstraints): Validator<string> {
+export function stringValidatorFactory(constraints: StringConstraints): StringValidator<string>
+export function stringValidatorFactory<S extends string>(constraints: StringConstraints): StringValidator<S>
+export function stringValidatorFactory<B extends string>(constraints: BrandedStringConstraints<B>): StringValidator<string & Branding<B>>
+export function stringValidatorFactory(constraints: StringConstraints): Validator<string> {
   return new StringValidator(constraints)
 }
 
 /** Validate `string`s. */
-export const string = makeValidatorFactory(new AnyStringValidator(), stringFactory)
+export const string = makeValidatorFactory(new AnyStringValidator(), stringValidatorFactory)

package/src/validators/union.ts

@@ -31,7 +31,7 @@ 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> | InferOneOfInput<Rest> :
         InferInput<First> :
     never :
   A extends readonly (infer Type)[] ?
@@ -86,7 +86,7 @@ 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> & InferAllOfInput<Rest> :
       InferInput<First> :
     never :
   never