Add Not in rule

Author: Armnajafi

src/Validator.ts

@@ -24,6 +24,7 @@ import { LowercaseRule } from './rules/LowercaseRule';
 import { JsonRule } from './rules/JsonRule';
 import { AlphaRule } from './rules/AlphaRule';
 import { InRule } from './rules/InRule';
+import { NotInRule } from './rules/NotInRule';
 
 
 export class Validator {
@@ -50,7 +51,8 @@ export class Validator {
     lowercase: new LowercaseRule(),
     json: new JsonRule(),
     alpha: new AlphaRule(),
-    in: new InRule()
+    in: new InRule(),
+    not_in: new NotInRule()
   };
 
   constructor(private locale: string = 'en') {}

src/locales/en.json

@@ -18,5 +18,6 @@
     "lowercase": "The {field} field must be lowercase.",
     "json": "The {field} field must be a valid JSON string.",
     "alpha": "The {field} field must contain only alphabetic characters.",
-    "in": "The {field} field must be one of: {values}."
+    "in": "The {field} field must be one of: {values}.",
+    "not_in": "The {field} field must not be one of: {values}."
 }

src/locales/fa.json

@@ -12,6 +12,7 @@
     "lowercase": "فیلد {field} باید با حروف کوچک باشد.",
     "json": "فیلد {field} باید یک رشته JSON معتبر باشد.",
     "alpha": "فیلد {field} باید فقط شامل حروف الفبا باشد.",
-    "in": "فیلد {field} باید یکی از مقادیر {values} باشد."
+    "in": "فیلد {field} باید یکی از مقادیر {values} باشد.",
+    "not_in": "فیلد {field} نباید یکی از مقادیر {values} باشد."
 }
 

src/rules/NotInRule.ts

@@ -0,0 +1,62 @@
+import { ValidationRule } from './ValidationRule';
+
+export class NotInRule implements ValidationRule {
+  private defaultMessage = '';
+  private customMessage?: string;
+  
+  setDefaultMessage(message: string) {
+    this.defaultMessage = message;
+  }
+  
+  setCustomMessage(message: string) {
+    this.customMessage = message;
+  }
+  
+  validate(value: any, params: any, field: string, inputs: Record<string, any>): string | null {
+    // Skip validation if value is empty
+    if (value === undefined || value === null || value === '') {
+      return null;
+    }
+    
+    // Parse parameters
+    let disallowedValues: string[] = [];
+    let strictMode = false;
+    
+    if (typeof params === 'string') {
+      // Format: "value1,value2,value3" or "value1,value2,value3,strict"
+      const paramsArray = params.split(',');
+      
+      // Check if the last parameter is "strict"
+      if (paramsArray.length > 0 && paramsArray[paramsArray.length - 1].trim().toLowerCase() === 'strict') {
+        strictMode = true;
+        disallowedValues = paramsArray.slice(0, -1);
+      } else {
+        disallowedValues = paramsArray;
+      }
+    } else if (Array.isArray(params)) {
+      // Format: ["value1", "value2", "value3"] or ["value1", "value2", "value3", "strict"]
+      if (params.length > 0 && params[params.length - 1] === 'strict') {
+        strictMode = true;
+        disallowedValues = params.slice(0, -1).map(String);
+      } else {
+        disallowedValues = params.map(String);
+      }
+    } else {
+      return 'Invalid parameters for not_in rule';
+    }
+    
+    // Check if the value is NOT in the disallowed values list
+    const isInvalid = strictMode
+      ? disallowedValues.some(disallowedValue => disallowedValue === String(value) && typeof disallowedValue === typeof value)
+      : disallowedValues.some(disallowedValue => String(disallowedValue) === String(value));
+    
+    if (isInvalid) {
+      const msg = this.customMessage || this.defaultMessage;
+      return msg
+        .replace('{field}', field)
+        .replace('{values}', disallowedValues.join(', '));
+    }
+    
+    return null;
+  }
+}