chore: implement more types

Author: glennmichael123

src/types/base.ts

@@ -75,6 +75,10 @@ export type ValidationNames = 'base' |
   'float' |
   'decimal' |
   'time' |
-  'smallint'
+  'smallint' |
+  'integer' |
+  'json' |
+  'blob' |
+  'binary'
 
 export type Infer<T> = T extends Validator<infer U> ? U : never

src/types/binary.ts

@@ -0,0 +1,6 @@
+import type { BinaryValidator } from '../validators/binary'
+import type { LengthValidator, Validator } from './base'
+
+export interface BinaryValidatorType extends Validator<string>, LengthValidator<BinaryValidator> {
+  custom: (fn: (value: string) => boolean, message: string) => BinaryValidator
+}

src/types/blob.ts

@@ -0,0 +1,6 @@
+import type { BlobValidator } from '../validators/blob'
+import type { LengthValidator, Validator } from './base'
+
+export interface BlobValidatorType extends Validator<string>, LengthValidator<BlobValidator> {
+  custom: (fn: (value: string) => boolean, message: string) => BlobValidator
+}

src/types/index.ts

@@ -1,10 +1,14 @@
 import type { ArrayValidatorType } from './array'
+import type { BinaryValidatorType } from './binary'
+import type { BlobValidatorType } from './blob'
 import type { BooleanValidatorType } from './boolean'
 import type { CustomValidatorType } from './custom'
 import type { DatetimeValidatorType, DateValidatorType } from './date'
 import type { DecimalValidatorType } from './decimal'
 import type { EnumValidatorType } from './enum'
 import type { FloatValidatorType } from './float'
+import type { IntegerValidatorType } from './integer'
+import type { JsonValidatorType } from './json'
 import type { BigintValidatorType, NumberValidatorType } from './number'
 import type { ObjectValidatorType } from './object'
 import type { PasswordValidatorType } from './password'
@@ -19,16 +23,19 @@ export * from './array'
 
 // Base types
 export * from './base'
+export * from './binary'
+export * from './blob'
 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 './integer'
+export * from './json'
 export * from './number'
-
 export * from './object'
 // Options types
 export * from './options'
@@ -60,6 +67,10 @@ export interface ValidationInstance {
   decimal: () => DecimalValidatorType
   time: () => TimeValidatorType
   smallint: () => SmallintValidatorType
+  integer: () => IntegerValidatorType
+  json: () => JsonValidatorType
+  blob: () => BlobValidatorType
+  binary: () => BinaryValidatorType
 }
 
 export type ValidationType = {

src/types/integer.ts

@@ -0,0 +1,7 @@
+import type { IntegerValidator } from '../validators/integer'
+import type { NumberValidatorType } from './number'
+
+export interface IntegerValidatorType extends NumberValidatorType {
+  // IntegerValidator inherits all methods from NumberValidatorType
+  // but ensures the value is an integer
+}

src/types/json.ts

@@ -0,0 +1,6 @@
+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
+}

src/validation.ts

@@ -1,13 +1,17 @@
 import type { ValidationInstance } from './types'
 import { array } from './validators/arrays'
 import { bigint } from './validators/bigint'
+import { binary } from './validators/binary'
+import { blob } from './validators/blob'
 import { boolean } from './validators/booleans'
 import { custom } from './validators/custom'
 import { date } from './validators/dates'
 import { datetime } from './validators/datetimes'
 import { decimal } from './validators/decimal'
 import { enum_ } from './validators/enums'
 import { float } from './validators/float'
+import { integer } from './validators/integer'
+import { json } from './validators/json'
 import { number } from './validators/numbers'
 import { object } from './validators/objects'
 import { password } from './validators/password'
@@ -39,4 +43,8 @@ export const v: ValidationInstance = {
   decimal,
   time,
   smallint,
+  integer,
+  json,
+  blob,
+  binary,
 }

src/validators/binary.ts

@@ -0,0 +1,62 @@
+import type { BinaryValidatorType, ValidationNames } from '../types'
+import { BaseValidator } from './base'
+
+export class BinaryValidator extends BaseValidator<string> implements BinaryValidatorType {
+  public name: ValidationNames = 'binary'
+
+  constructor() {
+    super()
+    this.addRule({
+      name: 'binary',
+      test: (value: unknown): value is string => {
+        if (typeof value !== 'string') {
+          return false
+        }
+        // Basic binary validation - could be base64 encoded data or hex string
+        // This is a simple check, could be enhanced based on specific requirements
+        return value.length > 0
+      },
+      message: 'Must be a valid binary string',
+    })
+  }
+
+  min(min: number): this {
+    return this.addRule({
+      name: 'min',
+      test: (value: string) => value.length >= min,
+      message: 'Must be at least {min} characters',
+      params: { min },
+    })
+  }
+
+  max(max: number): this {
+    return this.addRule({
+      name: 'max',
+      test: (value: string) => value.length <= max,
+      message: 'Must be at most {max} characters',
+      params: { max },
+    })
+  }
+
+  length(length: number): this {
+    return this.addRule({
+      name: 'length',
+      test: (value: string) => value.length === length,
+      message: 'Must be exactly {length} characters',
+      params: { length },
+    })
+  }
+
+  custom(fn: (value: string) => boolean, message: string): this {
+    return this.addRule({
+      name: 'custom',
+      test: fn,
+      message,
+    })
+  }
+}
+
+// Export a function to create binary validators
+export function binary(): BinaryValidator {
+  return new BinaryValidator()
+}

src/validators/blob.ts

@@ -0,0 +1,62 @@
+import type { BlobValidatorType, ValidationNames } from '../types'
+import { BaseValidator } from './base'
+
+export class BlobValidator extends BaseValidator<string> implements BlobValidatorType {
+  public name: ValidationNames = 'blob'
+
+  constructor() {
+    super()
+    this.addRule({
+      name: 'blob',
+      test: (value: unknown): value is string => {
+        if (typeof value !== 'string') {
+          return false
+        }
+        // Basic blob validation - could be base64 encoded data
+        // This is a simple check, could be enhanced based on specific requirements
+        return value.length > 0
+      },
+      message: 'Must be a valid blob string',
+    })
+  }
+
+  min(min: number): this {
+    return this.addRule({
+      name: 'min',
+      test: (value: string) => value.length >= min,
+      message: 'Must be at least {min} characters',
+      params: { min },
+    })
+  }
+
+  max(max: number): this {
+    return this.addRule({
+      name: 'max',
+      test: (value: string) => value.length <= max,
+      message: 'Must be at most {max} characters',
+      params: { max },
+    })
+  }
+
+  length(length: number): this {
+    return this.addRule({
+      name: 'length',
+      test: (value: string) => value.length === length,
+      message: 'Must be exactly {length} characters',
+      params: { length },
+    })
+  }
+
+  custom(fn: (value: string) => boolean, message: string): this {
+    return this.addRule({
+      name: 'custom',
+      test: fn,
+      message,
+    })
+  }
+}
+
+// Export a function to create blob validators
+export function blob(): BlobValidator {
+  return new BlobValidator()
+}

src/validators/index.ts

@@ -1,11 +1,15 @@
 export * from './arrays'
+export * from './binary'
+export * from './blob'
 export * from './booleans'
 export * from './custom'
 export * from './dates'
 export * from './datetimes'
 export * from './decimal'
 export * from './enums'
 export * from './float'
+export * from './integer'
+export * from './json'
 export * from './numbers'
 export * from './objects'
 export * from './password'