chore: implement smallint

Author: glennmichael123

src/types/base.ts

@@ -74,6 +74,7 @@ export type ValidationNames = 'base' |
   'timestampTz' |
   'float' |
   'decimal' |
-  'time'
+  'time' |
+  'smallint'
 
 export type Infer<T> = T extends Validator<infer U> ? U : never

src/types/index.ts

@@ -8,6 +8,7 @@ import type { FloatValidatorType } from './float'
 import type { BigintValidatorType, NumberValidatorType } from './number'
 import type { ObjectValidatorType } from './object'
 import type { PasswordValidatorType } from './password'
+import type { SmallintValidatorType } from './smallint'
 // Re-export ValidationInstance type
 import type { StringValidatorType, TextValidatorType } from './string'
 import type { TimeValidatorType } from './time'
@@ -22,14 +23,17 @@ export * from './boolean'
 export * from './custom'
 export * from './date'
 export * from './decimal'
+export * from './decimal'
 export * from './enum'
 export * from './float'
+export * from './float'
 export * from './number'
+
 export * from './object'
 // Options types
 export * from './options'
-
 export * from './password'
+export * from './smallint'
 // Validator types
 export * from './string'
 export * from './time'
@@ -55,6 +59,7 @@ export interface ValidationInstance {
   float: () => FloatValidatorType
   decimal: () => DecimalValidatorType
   time: () => TimeValidatorType
+  smallint: () => SmallintValidatorType
 }
 
 export type ValidationType = {

src/types/smallint.ts

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

src/validation.ts

@@ -11,6 +11,7 @@ import { float } from './validators/float'
 import { number } from './validators/numbers'
 import { object } from './validators/objects'
 import { password } from './validators/password'
+import { smallint } from './validators/smallint'
 import { string } from './validators/strings'
 import { text } from './validators/text'
 import { time } from './validators/time'
@@ -37,4 +38,5 @@ export const v: ValidationInstance = {
   float,
   decimal,
   time,
+  smallint,
 }

src/validators/index.ts

@@ -9,6 +9,7 @@ export * from './float'
 export * from './numbers'
 export * from './objects'
 export * from './password'
+export * from './smallint'
 export * from './strings'
 export * from './time'
 export * from './timestamps'

src/validators/smallint.ts

@@ -0,0 +1,92 @@
+import type { SmallintValidatorType, ValidationNames } from '../types'
+import isDivisibleBy from '../lib/isDivisibleBy'
+import isInt from '../lib/isInt'
+import { BaseValidator } from './base'
+
+export class SmallintValidator extends BaseValidator<number> implements SmallintValidatorType {
+  public name: ValidationNames = 'smallint'
+
+  constructor() {
+    super()
+    this.addRule({
+      name: 'smallint',
+      test: (value: unknown): value is number => {
+        if (typeof value !== 'number' || Number.isNaN(value)) {
+          return false
+        }
+        // Check if it's an integer
+        if (!isInt(String(value), {})) {
+          return false
+        }
+        // Check if it's within smallint range (-32,768 to 32,767)
+        return value >= -32768 && value <= 32767
+      },
+      message: 'Must be a valid smallint (-32,768 to 32,767)',
+    })
+  }
+
+  min(min: number): this {
+    return this.addRule({
+      name: 'min',
+      test: (value: number) => value >= min,
+      message: 'Must be at least {min}',
+      params: { min },
+    })
+  }
+
+  max(max: number): this {
+    return this.addRule({
+      name: 'max',
+      test: (value: number) => value <= max,
+      message: 'Must be at most {max}',
+      params: { max },
+    })
+  }
+
+  length(length: number): this {
+    return this.addRule({
+      name: 'length',
+      test: (value: number) => value.toString().length === length,
+      message: 'Must be exactly {length} digits',
+      params: { length },
+    })
+  }
+
+  positive(): this {
+    return this.addRule({
+      name: 'positive',
+      test: (value: number) => value > 0,
+      message: 'Must be a positive number',
+    })
+  }
+
+  negative(): this {
+    return this.addRule({
+      name: 'negative',
+      test: (value: number) => value < 0,
+      message: 'Must be a negative number',
+    })
+  }
+
+  divisibleBy(divisor: number): this {
+    return this.addRule({
+      name: 'divisibleBy',
+      test: (value: number) => 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 smallint validators
+export function smallint(): SmallintValidator {
+  return new SmallintValidator()
+}