feat: object and shape validation

Author: glennmichael123

src/lib/isURL.ts

@@ -85,8 +85,6 @@ export default function isURL(url: string, options?: Partial<IsURLOptions>): boo
   let protocol, auth, host, port, port_str, ipv6
   let split: string[] = []
 
-  const hostname = split.join('@')
-
   split = url.split('#')
   url = split.shift() ?? ''
 
@@ -116,13 +114,13 @@ export default function isURL(url: string, options?: Partial<IsURLOptions>): boo
   }
 
   split = url.split('/')
-  url = split.shift() ?? ''
+  const hostname = split.shift() ?? ''
 
-  if (url === '' && !options.require_host) {
+  if (hostname === '' && !options.require_host) {
     return true
   }
 
-  split = url.split('@')
+  split = hostname.split('@')
   if (split.length > 1) {
     if (options.disallow_auth) {
       return false

src/validation.ts

@@ -3,13 +3,15 @@ import type { BooleanValidator } from './validators/booleans'
 import type { DateValidator } from './validators/dates'
 import type { EnumValidator } from './validators/enums'
 import type { NumberValidator } from './validators/numbers'
+import type { ObjectValidator } from './validators/objects'
 import type { StringValidator } from './validators/strings'
 
 import { array } from './validators/arrays'
 import { boolean } from './validators/booleans'
 import { date } from './validators/dates'
 import { enum_ } from './validators/enums'
 import { number } from './validators/numbers'
+import { object } from './validators/objects'
 import { string } from './validators/strings'
 
 interface Validator {
@@ -19,6 +21,7 @@ interface Validator {
   boolean: () => BooleanValidator
   enum: <T extends string | number>(values: readonly T[]) => EnumValidator<T>
   date: () => DateValidator
+  object: <T extends Record<string, any>>() => ObjectValidator<T>
 }
 
 export const v: Validator = {
@@ -28,4 +31,5 @@ export const v: Validator = {
   boolean,
   enum: enum_,
   date,
+  object,
 }

src/validators/objects.ts

@@ -0,0 +1,81 @@
+import type { ValidationError, ValidationResult, Validator } from '../types'
+import { BaseValidator } from './base'
+
+export class ObjectValidator<T extends Record<string, any>> extends BaseValidator<T> {
+  private schema: Record<string, Validator<any>> = {}
+  private strictMode = false
+
+  constructor() {
+    super()
+    this.addRule({
+      name: 'object',
+      test: (value: unknown): value is T =>
+        typeof value === 'object' && value !== null && !Array.isArray(value),
+      message: 'Must be an object',
+    })
+  }
+
+  shape(schema: Record<string, Validator<any>>): this {
+    this.schema = schema
+    return this.addRule({
+      name: 'shape',
+      test: (value: T) => {
+        // If value is null/undefined, let the required/optional rules handle it
+        if (value === null || value === undefined)
+          return true
+
+        // In strict mode, check for extra fields
+        if (this.strictMode) {
+          const schemaKeys = new Set(Object.keys(schema))
+          const valueKeys = Object.keys(value)
+          return valueKeys.every(key => schemaKeys.has(key))
+        }
+
+        return true
+      },
+      message: 'Invalid object shape',
+    })
+  }
+
+  strict(strict = true): this {
+    this.strictMode = strict
+    return this
+  }
+
+  validate(value: T): ValidationResult {
+    const result = super.validate(value)
+
+    // If the base validation passed and we have a schema, validate each field
+    if (result.valid && Object.keys(this.schema).length > 0 && value !== null && value !== undefined) {
+      const fieldErrors: ValidationError[] = []
+
+      for (const [key, validator] of Object.entries(this.schema)) {
+        const fieldValue = value[key]
+        const fieldResult = validator.validate(fieldValue)
+
+        if (!fieldResult.valid) {
+          fieldErrors.push(
+            ...fieldResult.errors.map(error => ({
+              ...error,
+              field: key,
+              message: `${key}: ${error.message}`,
+            })),
+          )
+        }
+      }
+
+      if (fieldErrors.length > 0) {
+        return {
+          valid: false,
+          errors: fieldErrors,
+        }
+      }
+    }
+
+    return result
+  }
+}
+
+export function object<T extends Record<string, any>>(): ObjectValidator<T> {
+  return new ObjectValidator<T>()
+}

test/validation.test.ts

@@ -287,6 +287,154 @@ describe('Validation Library', () => {
     })
   })
 
+  describe('Object Validator', () => {
+    test('basic object validation', () => {
+      const validator = v.object()
+      expect(validator.test({})).toBe(true)
+      expect(validator.test({ foo: 'bar' })).toBe(true)
+      expect(validator.test(null as any)).toBe(false)
+      expect(validator.test([] as any)).toBe(false)
+      expect(validator.test('not an object' as any)).toBe(false)
+    })
+
+    test('shape validation', () => {
+      const validator = v.object().shape({
+        name: v.string().min(2),
+        age: v.number().min(18),
+        email: v.string().email(),
+      })
+
+      expect(validator.test({
+        name: 'John',
+        age: 25,
+        email: 'john@example.com',
+      })).toBe(true)
+
+      expect(validator.test({
+        name: 'J', // too short
+        age: 25,
+        email: 'john@example.com',
+      })).toBe(false)
+
+      expect(validator.test({
+        name: 'John',
+        age: 16, // too young
+        email: 'john@example.com',
+      })).toBe(false)
+
+      expect(validator.test({
+        name: 'John',
+        age: 25,
+        email: 'invalid-email', // invalid email
+      })).toBe(false)
+    })
+
+    test('nested object validation', () => {
+      const validator = v.object().shape({
+        user: v.object().shape({
+          name: v.string().min(2),
+          age: v.number().min(18),
+        }),
+        settings: v.object().shape({
+          theme: v.string(),
+          notifications: v.boolean(),
+        }),
+      })
+
+      expect(validator.test({
+        user: {
+          name: 'John',
+          age: 25,
+        },
+        settings: {
+          theme: 'dark',
+          notifications: true,
+        },
+      })).toBe(true)
+
+      expect(validator.test({
+        user: {
+          name: 'J', // too short
+          age: 25,
+        },
+        settings: {
+          theme: 'dark',
+          notifications: true,
+        },
+      })).toBe(false)
+    })
+
+    test('strict mode validation', () => {
+      const validator = v.object().shape({
+        name: v.string(),
+        age: v.number(),
+      }).strict()
+
+      expect(validator.test({
+        name: 'John',
+        age: 25,
+      })).toBe(true)
+
+      expect(validator.test({
+        name: 'John',
+        age: 25,
+        extra: 'field', // extra field not allowed in strict mode
+      })).toBe(false)
+    })
+
+    test('complex object validation', () => {
+      const validator = v.object().shape({
+        name: v.string().min(2).max(50),
+        email: v.string().email(),
+        age: v.number().min(18).integer(),
+        website: v.string().url().optional(),
+        tags: v.array<string>().each(v.string()).optional(),
+        address: v.object().shape({
+          street: v.string(),
+          city: v.string(),
+          zip: v.string(),
+        }).optional(),
+      })
+
+      expect(validator.test({
+        name: 'John Doe',
+        email: 'john@example.com',
+        age: 25,
+        website: 'https://example.com',
+        tags: ['developer', 'typescript'],
+        address: {
+          street: '123 Main St',
+          city: 'New York',
+          zip: '10001',
+        },
+      })).toBe(true)
+
+      const result = validator.validate({
+        name: 'J', // too short
+        email: 'invalid-email',
+        age: 16, // too young
+        website: 'not-a-url',
+        tags: [123], // invalid tag type
+        address: {
+          street: '123 Main St',
+          city: 'New York',
+          zip: '10001',
+        },
+      })
+
+      expect(result.valid).toBe(false)
+      expect(result.errors).toHaveLength(5)
+
+      // Check specific error messages
+      const errorMessages = result.errors.map(e => e.message)
+      expect(errorMessages).toContain('name: Must be at least 2 characters long') // name too short
+      expect(errorMessages).toContain('email: Must be a valid email address') // invalid email
+      expect(errorMessages).toContain('age: Must be at least 18') // age too young
+      expect(errorMessages).toContain('website: Must be a valid URL') // invalid URL
+      expect(errorMessages).toContain('tags: Each item in array is invalid') // invalid array item type
+    })
+  })
+
   describe('Validation Results', () => {
     test('validate returns detailed results', () => {
       const validator = v.string().min(5).max(10)