fix: types and test cases

Author: glennmichael123

src/messages.ts

@@ -1,6 +1,6 @@
 export interface MessageProviderType {
-  getMessage: (rule: string, field?: string, params?: Record<string, any>) => string
-  setMessage: (rule: string, message: string, field?: string) => void
+  getMessage: (ruleName: string, customMessage?: string, field?: string, params?: Record<string, any>) => string
+  setMessage: (ruleName: string, message: string, field?: string) => void
   setMessages: (messages: Record<string, string>) => void
 }
 
@@ -13,30 +13,35 @@ export class MessageProvider implements MessageProviderType {
     }
   }
 
-  getMessage(rule: string, field?: string, params?: Record<string, any>): string {
+  getMessage(ruleName: string, ruleMessage?: string, field?: string, params?: Record<string, any>): string {
     let message: string | undefined
 
     // First try field-specific message
     if (field) {
-      const fieldSpecificKey = `${field}.${rule}`
+      const fieldSpecificKey = `${field}.${ruleName}`
       message = this.messages.get(fieldSpecificKey)
     }
 
     // Fall back to general rule message
     if (!message) {
-      message = this.messages.get(rule)
+      message = this.messages.get(ruleName)
     }
 
-    // Fall back to default message
-    if (!message) {
-      message = this.getDefaultMessage(rule)
+    // Fall back to rule-specific message (from addRule)
+    if (!message && ruleMessage) {
+      message = ruleMessage
     }
 
     // Replace parameters in the message
-    if (params) {
+    if (message && params) {
       message = this.replaceParams(message, params)
     }
 
+    // Fall back to default message
+    if (!message) {
+      message = this.getDefaultMessage(ruleName)
+    }
+
     return message
   }
 

src/types/number.ts

@@ -23,6 +23,8 @@ export interface NumberValidatorType extends Validator<number>, LengthValidator<
 
 export interface BigintValidatorType extends Validator<bigint> {
   min: (min: bigint) => BigintValidatorType
+  max: (max: bigint) => BigintValidatorType
+  length: (length: number) => BigintValidatorType
   positive: () => BigintValidatorType
   negative: () => BigintValidatorType
   divisibleBy: (divisor: bigint) => BigintValidatorType

src/validators/base.ts

@@ -44,7 +44,7 @@ export abstract class BaseValidator<T> implements Validator<T> {
 
     if (this.isRequired && (value === undefined || value === null || value === '')) {
       const messagesProvider = getCustomMessages()
-      const message = messagesProvider.getMessage('required', this.fieldName)
+      const message = messagesProvider.getMessage('required', undefined, this.fieldName)
       const error = { message }
       return this.isPartOfShape
         ? { valid: false, errors: { [this.fieldName]: [error] } }
@@ -54,7 +54,7 @@ export abstract class BaseValidator<T> implements Validator<T> {
     for (const rule of this.rules) {
       if (!rule.test(value)) {
         const messagesProvider = getCustomMessages()
-        const message = messagesProvider.getMessage(rule.name, this.fieldName, rule.params)
+        const message = messagesProvider.getMessage(rule.name, rule.message, this.fieldName, rule.params)
         errors.push({ message })
       }
     }

src/validators/bigint.ts

@@ -31,6 +31,15 @@ export class BigintValidator extends BaseValidator<bigint> implements BigintVali
     })
   }
 
+  length(length: number): BigintValidatorType {
+    return this.addRule({
+      name: 'length',
+      test: (value: bigint) => value.toString().length === length,
+      message: 'Must be {length} digits',
+      params: { length },
+    })
+  }
+
   positive(): BigintValidatorType {
     return this.addRule({
       name: 'positive',

test/validators/numbers.test.ts

@@ -231,7 +231,7 @@ describe('NumberValidator', () => {
       expect(result.valid).toBe(false)
       expect(Array.isArray(result.errors)).toBe(true)
       if (Array.isArray(result.errors)) {
-        expect(result.errors[0].message).toContain('at least 10')
+        expect(result.errors[0].message).toContain('Must be at least')
       }
     })
 

test/validators/password.test.ts

@@ -161,6 +161,7 @@ describe('PasswordValidator', () => {
 
       if (!result.valid && Array.isArray(result.errors)) {
         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')