chore: implement double validation

Author: glennmichael123

src/types/double.ts

@@ -0,0 +1,9 @@
+import type { DoubleValidator } from '../validators/double'
+import type { LengthValidator, Validator } from './base'
+
+export interface DoubleValidatorType extends Validator<number>, LengthValidator<DoubleValidator> {
+  positive: () => DoubleValidator
+  negative: () => DoubleValidator
+  divisibleBy: (divisor: number) => DoubleValidator
+  custom: (fn: (value: number | null | undefined) => boolean, message: string) => DoubleValidator
+}

src/types/index.ts

@@ -5,6 +5,7 @@ import type { BooleanValidatorType } from './boolean'
 import type { CustomValidatorType } from './custom'
 import type { DatetimeValidatorType, DateValidatorType } from './date'
 import type { DecimalValidatorType } from './decimal'
+import type { DoubleValidatorType } from './double'
 import type { EnumValidatorType } from './enum'
 import type { FloatValidatorType } from './float'
 import type { IntegerValidatorType } from './integer'
@@ -29,8 +30,8 @@ export * from './boolean'
 export * from './custom'
 export * from './date'
 export * from './decimal'
+export * from './double'
 export * from './enum'
-export * from './float'
 
 export * from './float'
 export * from './integer'
@@ -64,6 +65,7 @@ export interface ValidationInstance {
   unix: () => UnixValidatorType
   password: () => PasswordValidatorType
   float: () => FloatValidatorType
+  double: () => DoubleValidatorType
   decimal: () => DecimalValidatorType
   time: () => TimeValidatorType
   smallint: () => SmallintValidatorType

src/validators/double.ts

@@ -0,0 +1,115 @@
+import type { DoubleValidatorType, ValidationNames } from '../types'
+import isDivisibleBy from '../lib/isDivisibleBy'
+import { NumberValidator } from './numbers'
+
+export class DoubleValidator extends NumberValidator implements DoubleValidatorType {
+  public name: ValidationNames = 'float'
+
+  constructor() {
+    super()
+    // Override the base number validation to ensure it's a float
+    // Remove the existing number rule and add our own
+    this.rules = this.rules.filter(rule => rule.name !== 'number')
+    this.addRule({
+      name: 'double',
+      test: (value: unknown): value is number => {
+        // First check if it's a number
+        if (typeof value !== 'number' || Number.isNaN(value)) {
+          return false
+        }
+        // All numbers in JavaScript are floats, including Infinity
+        return true
+      },
+      message: 'Must be a valid float number',
+    })
+  }
+
+  min(min: number): this {
+    return this.addRule({
+      name: 'min',
+      test: (value: number) => {
+        if (typeof value !== 'number')
+          return false
+        return value >= min
+      },
+      message: 'Must be at least {min}',
+      params: { min },
+    })
+  }
+
+  max(max: number): this {
+    return this.addRule({
+      name: 'max',
+      test: (value: number) => {
+        if (typeof value !== 'number')
+          return false
+        return value <= max
+      },
+      message: 'Must be at most {max}',
+      params: { max },
+    })
+  }
+
+  length(length: number): this {
+    return this.addRule({
+      name: 'length',
+      test: (value: number) => {
+        if (typeof value !== 'number')
+          return false
+        return value.toString().length === length
+      },
+      message: 'Must be exactly {length} digits',
+      params: { length },
+    })
+  }
+
+  positive(): this {
+    return this.addRule({
+      name: 'positive',
+      test: (value: number) => {
+        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) => {
+        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) => {
+        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 {
+    return this.addRule({
+      name: 'custom',
+      test: fn,
+      message,
+    })
+  }
+}
+
+// Export a function to create float validators
+export function float(): DoubleValidator {
+  return new DoubleValidator()
+}

src/validators/float.ts

@@ -11,7 +11,7 @@ export class FloatValidator extends NumberValidator implements FloatValidatorTyp
     // Remove the existing number rule and add our own
     this.rules = this.rules.filter(rule => rule.name !== 'number')
     this.addRule({
-      name: 'number',
+      name: 'float',
       test: (value: unknown): value is number => {
         // First check if it's a number
         if (typeof value !== 'number' || Number.isNaN(value)) {

src/validators/integer.ts

@@ -10,7 +10,7 @@ export class IntegerValidator extends NumberValidator implements IntegerValidato
     // Remove the existing number rule and add our own
     this.rules = this.rules.filter(rule => rule.name !== 'number')
     this.addRule({
-      name: 'number',
+      name: 'integer',
       test: (value: number) => {
         // First check if it's a number
         if (typeof value !== 'number' || Number.isNaN(value) || !Number.isFinite(value)) {