justus 0.5.3 → 0.5.4

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}`)