fix: tests

Author: glennmichael123

src/types/base.ts

@@ -22,7 +22,7 @@ export interface ValidationResult {
 
 export interface ValidationRule<T> {
   name: string
-  test: (value: T) => boolean
+  test: (value: T | null | undefined) => boolean
   message: string
   params?: Record<string, any>
 }
@@ -31,7 +31,7 @@ export interface Validator<T> {
   name: ValidationNames
   isRequired: boolean
   getRules: () => ValidationRule<T>[]
-  test: (value: T) => boolean
+  test: (value: T | null | undefined) => boolean
   validate: (value: T | undefined | null) => ValidationResult
   required: () => this
   optional: () => this

src/types/decimal.ts

@@ -12,5 +12,5 @@ export interface DecimalValidatorType extends Validator<number>, LengthValidator
   positive: () => DecimalValidator
   negative: () => DecimalValidator
   divisibleBy: (divisor: number) => DecimalValidator
-  custom: (fn: (value: number) => boolean, message: string) => DecimalValidator
+  custom: (fn: (value: number | null | undefined) => boolean, message: string) => DecimalValidator
 }

src/types/float.ts

@@ -13,5 +13,5 @@ export interface FloatValidatorType extends Validator<number>, LengthValidator<F
   positive: () => FloatValidator
   negative: () => FloatValidator
   divisibleBy: (divisor: number) => FloatValidator
-  custom: (fn: (value: number) => boolean, message: string) => FloatValidator
+  custom: (fn: (value: number | null | undefined) => boolean, message: string) => FloatValidator
 }

src/types/json.ts

@@ -1,6 +1,5 @@
-import type { JsonValidator } from '../validators/json'
 import type { LengthValidator, Validator } from './base'
 
-export interface JsonValidatorType extends Validator<string>, LengthValidator<JsonValidator> {
-  custom: (fn: (value: string) => boolean, message: string) => JsonValidator
+export interface JsonValidatorType extends Validator<string>, LengthValidator<any> {
+  custom: (fn: (value: string | null | undefined) => boolean, message: string) => any
 }

src/types/number.ts

@@ -19,7 +19,7 @@ export interface NumberValidatorType extends Validator<number>, LengthValidator<
   positive: () => NumberValidator
   negative: () => NumberValidator
   divisibleBy: (divisor: number) => NumberValidator
-  custom: (fn: (value: number) => boolean, message: string) => NumberValidator
+  custom: (fn: (value: number | null | undefined) => boolean, message: string) => NumberValidator
 }
 
 export interface BigintValidatorType extends Validator<bigint> {

src/types/smallint.ts

@@ -5,5 +5,5 @@ export interface SmallintValidatorType extends Validator<number>, LengthValidato
   positive: () => SmallintValidator
   negative: () => SmallintValidator
   divisibleBy: (divisor: number) => SmallintValidator
-  custom: (fn: (value: number) => boolean, message: string) => SmallintValidator
+  custom: (fn: (value: number | null | undefined) => boolean, message: string) => SmallintValidator
 }

src/types/string.ts

@@ -81,7 +81,7 @@ export interface StringValidatorType extends Validator<string>, LengthValidator<
   alphanumeric: () => StringValidator
   alpha: () => StringValidator
   numeric: () => StringValidator
-  custom: (fn: (value: string) => boolean, message: string) => StringValidator
+  custom: (fn: (value: string | null | undefined) => boolean, message: string) => StringValidator
 }
 
 export interface TextValidatorType extends StringValidatorType {}

src/types/time.ts

@@ -5,5 +5,5 @@ export interface TimeValidatorType extends Validator<string> {
   min: (min: string) => TimeValidator
   max: (max: string) => TimeValidator
   length: (length: number) => TimeValidator
-  custom: (fn: (value: string) => boolean, message: string) => TimeValidator
+  custom: (fn: (value: string | null | undefined) => boolean, message: string) => TimeValidator
 }

src/validators/base.ts

@@ -30,18 +30,17 @@ export abstract class BaseValidator<T> implements Validator<T> {
   validate(value: T | undefined | null): ValidationResult {
     const errors: ValidationError[] = []
 
-    if ((value === undefined || value === null || value === '')) {
-      if (!this.isRequired) {
-        return this.isPartOfShape
-          ? { valid: true, errors: {} }
-          : { valid: true, errors: [] }
-      }
-      else {
-        const error = { message: 'This field is required' }
-        return this.isPartOfShape
-          ? { valid: false, errors: { [this.fieldName]: [error] } }
-          : { valid: false, errors: [error] }
-      }
+    if (!this.isRequired && (value === undefined || value === null || value === '')) {
+      return this.isPartOfShape
+        ? { valid: true, errors: {} }
+        : { valid: true, errors: [] }
+    }
+
+    if (this.isRequired && (value === undefined || value === null || value === '')) {
+      const error = { message: 'This field is required' }
+      return this.isPartOfShape
+        ? { valid: false, errors: { [this.fieldName]: [error] } }
+        : { valid: false, errors: [error] }
     }
 
     for (const rule of this.rules) {
@@ -69,7 +68,7 @@ export abstract class BaseValidator<T> implements Validator<T> {
     return this.rules
   }
 
-  test(value: T): boolean {
+  test(value: T | null | undefined): boolean {
     return this.validate(value).valid
   }
 

src/validators/decimal.ts

@@ -29,7 +29,11 @@ export class DecimalValidator extends NumberValidator implements DecimalValidato
   min(min: number): this {
     return this.addRule({
       name: 'min',
-      test: (value: number) => value >= min,
+      test: (value: number | null | undefined) => {
+        if (typeof value !== 'number')
+          return false
+        return value >= min
+      },
       message: 'Must be at least {min}',
       params: { min },
     })
@@ -38,7 +42,11 @@ export class DecimalValidator extends NumberValidator implements DecimalValidato
   max(max: number): this {
     return this.addRule({
       name: 'max',
-      test: (value: number) => value <= max,
+      test: (value: number | null | undefined) => {
+        if (typeof value !== 'number')
+          return false
+        return value <= max
+      },
       message: 'Must be at most {max}',
       params: { max },
     })
@@ -47,7 +55,11 @@ export class DecimalValidator extends NumberValidator implements DecimalValidato
   length(length: number): this {
     return this.addRule({
       name: 'length',
-      test: (value: number) => value.toString().length === length,
+      test: (value: number | null | undefined) => {
+        if (typeof value !== 'number')
+          return false
+        return value.toString().length === length
+      },
       message: 'Must be exactly {length} digits',
       params: { length },
     })
@@ -56,35 +68,59 @@ export class DecimalValidator extends NumberValidator implements DecimalValidato
   positive(): this {
     return this.addRule({
       name: 'positive',
-      test: (value: number) => value > 0,
+      test: (value: number | null | undefined) => {
+        if (typeof value !== 'number')
+          return false
+        return value > 0
+      },
       message: 'Must be a positive number',
     })
   }
 
   negative(): this {
     return this.addRule({
       name: 'negative',
-      test: (value: number) => value < 0,
+      test: (value: number | null | undefined) => {
+        if (typeof value !== 'number')
+          return false
+        return value < 0
+      },
       message: 'Must be a negative number',
     })
   }
 
   divisibleBy(divisor: number): this {
     return this.addRule({
       name: 'divisibleBy',
-      test: (value: number) => isDivisibleBy(String(value), divisor),
+      test: (value: number | null | undefined) => {
+        if (typeof value !== 'number')
+          return false
+        return isDivisibleBy(String(value), divisor)
+      },
       message: 'Must be divisible by {divisor}',
       params: { divisor },
     })
   }
 
-  custom(fn: (value: number) => boolean, message: string): this {
+  custom(fn: (value: number | null | undefined) => boolean, message: string): this {
     return this.addRule({
       name: 'custom',
       test: fn,
       message,
     })
   }
+
+  validate(value: number | undefined | null): any {
+    // Only allow actual numbers
+    if (typeof value !== 'number' || Number.isNaN(value)) {
+      const error = { message: 'This field is required' }
+      return this.isPartOfShape
+        ? { valid: false, errors: { [this.fieldName]: [error] } }
+        : { valid: false, errors: [error] }
+    }
+    // Otherwise, use the base validation
+    return super.validate(value)
+  }
 }
 
 // Export a function to create decimal validators