feat: implement password validation

Author: glennmichael123

src/types.ts

@@ -7,6 +7,7 @@ import type { DatetimeValidator } from './validators/datetimes'
 import type { EnumValidator } from './validators/enums'
 import type { NumberValidator } from './validators/numbers'
 import type { ObjectValidator } from './validators/objects'
+import type { PasswordValidator } from './validators/password'
 import type { StringValidator } from './validators/strings'
 import type { TimestampValidator } from './validators/timestamps'
 import type { UnixValidator } from './validators/unix'
@@ -259,4 +260,5 @@ export interface ValidationInstance {
   custom: <T>(validationFn: (value: T) => boolean, message: string) => CustomValidator<T>
   timestamp: () => TimestampValidator
   unix: () => UnixValidator
+  password: () => PasswordValidator
 }

src/validation.ts

@@ -7,6 +7,7 @@ import { datetime } from './validators/datetimes'
 import { enum_ } from './validators/enums'
 import { number } from './validators/numbers'
 import { object } from './validators/objects'
+import { password } from './validators/password'
 import { string } from './validators/strings'
 import { timestamp } from './validators/timestamps'
 import { unix } from './validators/unix'
@@ -23,4 +24,5 @@ export const v: ValidationInstance = {
   custom,
   timestamp,
   unix,
+  password,
 }

src/validators/password.ts

@@ -0,0 +1,83 @@
+import isAlphanumeric from '../lib/isAlphanumeric'
+import { BaseValidator } from './base'
+
+export class PasswordValidator extends BaseValidator<string> {
+  constructor() {
+    super()
+    this.addRule({
+      name: 'string',
+      test: (value: unknown): value is string => typeof value === 'string',
+      message: 'Must be a string',
+    })
+  }
+
+  matches(confirmPassword: string): this {
+    return this.addRule({
+      name: 'matches',
+      test: (value: string) => value === confirmPassword,
+      message: 'Passwords must match',
+    })
+  }
+
+  minLength(length: number = 8): this {
+    return this.addRule({
+      name: 'minLength',
+      test: (value: string) => value.length >= length,
+      message: 'Password must be at least {length} characters long',
+      params: { length },
+    })
+  }
+
+  maxLength(length: number = 128): this {
+    return this.addRule({
+      name: 'maxLength',
+      test: (value: string) => value.length <= length,
+      message: 'Password must be at most {length} characters long',
+      params: { length },
+    })
+  }
+
+  hasUppercase(): this {
+    return this.addRule({
+      name: 'hasUppercase',
+      test: (value: string) => /[A-Z]/.test(value),
+      message: 'Password must contain at least one uppercase letter',
+    })
+  }
+
+  hasLowercase(): this {
+    return this.addRule({
+      name: 'hasLowercase',
+      test: (value: string) => /[a-z]/.test(value),
+      message: 'Password must contain at least one lowercase letter',
+    })
+  }
+
+  hasNumbers(): this {
+    return this.addRule({
+      name: 'hasNumbers',
+      test: (value: string) => /[0-9]/.test(value),
+      message: 'Password must contain at least one number',
+    })
+  }
+
+  hasSpecialCharacters(): this {
+    return this.addRule({
+      name: 'hasSpecialCharacters',
+      test: (value: string) => /[!@#$%^&*(),.?":{}|<>]/.test(value),
+      message: 'Password must contain at least one special character',
+    })
+  }
+
+  alphanumeric(): this {
+    return this.addRule({
+      name: 'alphanumeric',
+      test: (value: string) => isAlphanumeric(value),
+      message: 'Password must only contain letters and numbers',
+    })
+  }
+}
+
+export function password(): PasswordValidator {
+  return new PasswordValidator()
+}

test/validation.test.ts

@@ -54,6 +54,84 @@ describe('Validation Library', () => {
     })
   })
 
+  describe('Password Validator', () => {
+    test('basic password validation', () => {
+      const validator = v.password()
+      expect(validator.test('password123')).toBe(true)
+      expect(validator.test('')).toBe(true)
+      expect(validator.test(123 as any)).toBe(false)
+    })
+
+    test('password matching validation', () => {
+      const originalPassword = 'MySecureP@ss123'
+      const validator = v.password().matches(originalPassword)
+      expect(validator.test(originalPassword)).toBe(true)
+      expect(validator.test('DifferentP@ss123')).toBe(false)
+    })
+
+    test('password length validation', () => {
+      const validator = v.password().minLength(8).maxLength(20)
+      expect(validator.test('Secure123')).toBe(true)
+      expect(validator.test('Short1')).toBe(false)
+      expect(validator.test('ThisPasswordIsWayTooLongToBeValid123')).toBe(false)
+    })
+
+    test('password character requirements', () => {
+      const validator = v.password()
+        .hasUppercase()
+        .hasLowercase()
+        .hasNumbers()
+        .hasSpecialCharacters()
+
+      // Valid password with all requirements
+      expect(validator.test('MySecureP@ss123')).toBe(true)
+
+      // Missing uppercase
+      expect(validator.test('mysecurep@ss123')).toBe(false)
+
+      // Missing lowercase
+      expect(validator.test('MYSECUREP@SS123')).toBe(false)
+
+      // Missing numbers
+      expect(validator.test('MySecureP@ssword')).toBe(false)
+
+      // Missing special characters
+      expect(validator.test('MySecurePass123')).toBe(false)
+    })
+
+    test('comprehensive password validation with multiple rules', () => {
+      const validator = v.password()
+        .minLength(8)
+        .maxLength(20)
+        .hasUppercase()
+        .hasLowercase()
+        .hasNumbers()
+        .hasSpecialCharacters()
+
+      const result = validator.validate('weak')
+      expect(result.valid).toBe(false)
+      expect(result.errors.length).toBeGreaterThan(0)
+
+      // Check specific error messages
+      const errorMessages = result.errors.map(e => e.message)
+      expect(errorMessages).toContain('Password must be at least 8 characters long')
+      expect(errorMessages).toContain('Password must contain at least one uppercase letter')
+      expect(errorMessages).toContain('Password must contain at least one number')
+      expect(errorMessages).toContain('Password must contain at least one special character')
+
+      // Test a valid password
+      const validResult = validator.validate('MySecureP@ss123')
+      expect(validResult.valid).toBe(true)
+      expect(validResult.errors).toHaveLength(0)
+    })
+
+    test('alphanumeric password validation', () => {
+      const validator = v.password().alphanumeric()
+      expect(validator.test('Password123')).toBe(true)
+      expect(validator.test('Password@123')).toBe(false)
+    })
+  })
+
   describe('Number Validator', () => {
     test('basic number validation', () => {
       const validator = v.number()