chore: implement custom messagaes

Author: glennmichael123

examples/field-messages.ts

@@ -0,0 +1,44 @@
+import { MessageProvider, setMessagesProvider, v } from '../src'
+
+// Set up custom messages with field-specific overrides
+setMessagesProvider(new MessageProvider({
+  // Global messages
+  'required': 'The {{ field }} field is required',
+  'email': 'Please provide a valid email address',
+  'min': 'Must be at least {min} characters',
+  'max': 'Must be at most {max} characters',
+
+  // Field-specific messages
+  'username.required': 'Please choose a username for your account',
+  'username.min': 'Username must be at least {min} characters long',
+  'username.max': 'Username cannot exceed {max} characters',
+  'email.required': 'Email address is required to create your account',
+  'password.required': 'A password is required for your account',
+  'password.min': 'Password must be at least {min} characters for security',
+}))
+
+// Create a user validator
+const userValidator = v.object().shape({
+  username: v.string().min(3).max(20).required(),
+  email: v.string().email().required(),
+  password: v.string().min(8).required(),
+})
+
+// Test validation with field-specific messages
+const invalidUser = {
+  username: 'ab', // Too short
+  email: 'invalid-email',
+  password: '123', // Too short
+}
+
+const result = userValidator.validate(invalidUser)
+
+if (!result.valid) {
+  console.error('Validation errors:')
+  Object.entries(result.errors).forEach(([field, errors]) => {
+    console.error(`${field}:`)
+    errors.forEach((error: any) => {
+      console.error(`  - ${error.message}`)
+    })
+  })
+}

src/index.ts

@@ -1,7 +1,8 @@
 export * from './config'
 // Export validator library
 export { default as validator } from './lib'
+export * from './messages'
 export * from './types'
-export { v } from './validation'
 
+export { v } from './validation'
 export * from './validators'

src/messages.ts

@@ -0,0 +1,108 @@
+export interface MessageProviderType {
+  getMessage: (rule: string, field?: string, params?: Record<string, any>) => string
+  setMessage: (rule: string, message: string, field?: string) => void
+  setMessages: (messages: Record<string, string>) => void
+}
+
+export class MessageProvider implements MessageProviderType {
+  private messages: Map<string, string> = new Map()
+
+  constructor(messages?: Record<string, string>) {
+    if (messages) {
+      this.setMessages(messages)
+    }
+  }
+
+  getMessage(rule: string, field?: string, params?: Record<string, any>): string {
+    let message: string | undefined
+
+    // First try field-specific message
+    if (field) {
+      const fieldSpecificKey = `${field}.${rule}`
+      message = this.messages.get(fieldSpecificKey)
+    }
+
+    // Fall back to general rule message
+    if (!message) {
+      message = this.messages.get(rule)
+    }
+
+    // Fall back to default message
+    if (!message) {
+      message = this.getDefaultMessage(rule)
+    }
+
+    // Replace parameters in the message
+    if (params) {
+      message = this.replaceParams(message, params)
+    }
+
+    return message
+  }
+
+  setMessage(rule: string, message: string, field?: string): void {
+    const key = field ? `${field}.${rule}` : rule
+    this.messages.set(key, message)
+  }
+
+  setMessages(messages: Record<string, string>): void {
+    Object.entries(messages).forEach(([key, message]) => {
+      this.messages.set(key, message)
+    })
+  }
+
+  private getDefaultMessage(rule: string): string {
+    const defaults: Record<string, string> = {
+      required: 'This field is required',
+      string: 'Must be a string',
+      number: 'Must be a number',
+      integer: 'Must be an integer',
+      float: 'Must be a float',
+      boolean: 'Must be a boolean',
+      array: 'Must be an array',
+      object: 'Must be an object',
+      email: 'Must be a valid email address',
+      url: 'Must be a valid URL',
+      min: 'Must be at least {min}',
+      max: 'Must be at most {max}',
+      length: 'Must be exactly {length}',
+      matches: 'Must match pattern {pattern}',
+      equals: 'Must be equal to {value}',
+      alphanumeric: 'Must only contain letters and numbers',
+      alpha: 'Must only contain letters',
+      numeric: 'Must only contain numbers',
+      positive: 'Must be positive',
+      negative: 'Must be negative',
+      date: 'Must be a valid date',
+      datetime: 'Must be a valid datetime',
+      time: 'Must be a valid time',
+      timestamp: 'Must be a valid timestamp',
+      unix: 'Must be a valid Unix timestamp',
+      json: 'Must be valid JSON',
+      enum: 'Must be one of: {values}',
+      custom: 'Validation failed',
+    }
+
+    return defaults[rule] || 'Validation failed'
+  }
+
+  private replaceParams(message: string, params: Record<string, any>): string {
+    return message.replace(/\{([^}]+)\}/g, (_, key) => {
+      const value = key.split('.').reduce((obj: any, k: string) => obj?.[k], params)
+      return value !== undefined ? String(value) : `{${key}}`
+    })
+  }
+}
+
+// Global messages provider instance
+let _globalMessagesProvider: MessageProviderType = new MessageProvider()
+
+// Function to set the global messages provider
+export function setMessagesProvider(provider: MessageProvider): void {
+  _globalMessagesProvider = provider
+}
+
+// Function to get the current messages provider
+export function getMessagesProvider(): MessageProviderType {
+  return _globalMessagesProvider
+}

src/types/base.ts

@@ -51,9 +51,9 @@ export interface ValidationConfig {
 }
 
 export interface LengthValidator<T> {
-  min: (length: number) => T
-  max: (length: number) => T
-  length: (length: number) => T
+  min: (length: number, message?: string) => T
+  max: (length: number, message?: string) => T
+  length: (length: number, message?: string) => T
 }
 
 export type ValidationNames = 'base' |

src/validators/base.ts

@@ -1,4 +1,5 @@
 import type { ValidationError, ValidationErrorMap, ValidationNames, ValidationResult, ValidationRule, Validator } from '../types'
+import { getMessagesProvider } from '../messages'
 
 export abstract class BaseValidator<T> implements Validator<T> {
   protected rules: ValidationRule<T>[] = []
@@ -22,6 +23,11 @@ export abstract class BaseValidator<T> implements Validator<T> {
     return this
   }
 
+  setFieldName(fieldName: string): this {
+    this.fieldName = fieldName
+    return this
+  }
+
   protected addRule(rule: ValidationRule<T>): this {
     this.rules.push(rule)
     return this
@@ -37,17 +43,19 @@ export abstract class BaseValidator<T> implements Validator<T> {
     }
 
     if (this.isRequired && (value === undefined || value === null || value === '')) {
-      const error = { message: 'This field is required' }
+      const messagesProvider = getMessagesProvider()
+      const message = messagesProvider.getMessage('required', this.fieldName)
+      const error = { message }
       return this.isPartOfShape
         ? { valid: false, errors: { [this.fieldName]: [error] } }
         : { valid: false, errors: [error] }
     }
 
     for (const rule of this.rules) {
       if (!rule.test(value)) {
-        errors.push({
-          message: this.formatMessage(rule.message, rule.params ?? {}),
-        })
+        const messagesProvider = getMessagesProvider()
+        const message = messagesProvider.getMessage(rule.name, this.fieldName, rule.params)
+        errors.push({ message })
       }
     }
 
@@ -71,11 +79,4 @@ export abstract class BaseValidator<T> implements Validator<T> {
   test(value: T): boolean {
     return this.validate(value).valid
   }
-
-  private formatMessage(message: string, params: Record<string, any>): string {
-    return message.replace(/\{([^}]+)\}/g, (_, key) => {
-      const value = key.split('.').reduce((obj: any, k: string) => obj?.[k], params)
-      return value !== undefined ? String(value) : `{${key}}`
-    })
-  }
 }

src/validators/objects.ts

@@ -25,7 +25,7 @@ export class ObjectValidator<T extends Record<string, any>> extends BaseValidato
   shape(schema: Record<string, Validator<any>>): this {
     this.schema = Object.entries(schema).reduce((acc, [key, validator]) => {
       if (validator instanceof BaseValidator) {
-        acc[key] = validator.setIsPartOfShape(true)
+        acc[key] = validator.setIsPartOfShape(true).setFieldName(key)
       }
       else {
         acc[key] = validator

src/validators/strings.ts

@@ -26,8 +26,8 @@ export class StringValidator extends BaseValidator<string> implements StringVali
           return false
         return value.length >= length
       },
-      message: 'Must be at least {length} characters long',
-      params: { length },
+      message: 'Must be at least {min} characters long',
+      params: { min: length },
     })
   }
 
@@ -39,8 +39,8 @@ export class StringValidator extends BaseValidator<string> implements StringVali
           return false
         return value.length <= length
       },
-      message: 'Must be at most {length} characters long',
-      params: { length },
+      message: 'Must be at most {max} characters long',
+      params: { max: length },
     })
   }