@rbl-dev/validator-ts 1.0.1 → 1.2.0

package/dist/Validator.js

@@ -1,10 +1,31 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Validator = void 0;
+const AfterDateRule_js_1 = require("./rules/AfterDateRule.js");
+const AlphaNumRule_js_1 = require("./rules/AlphaNumRule.js");
+const AlphaRule_js_1 = require("./rules/AlphaRule.js");
+const ArrayRule_js_1 = require("./rules/ArrayRule.js");
+const BeforeDateRule_js_1 = require("./rules/BeforeDateRule.js");
+const BetweenRule_js_1 = require("./rules/BetweenRule.js");
+const BooleanRule_js_1 = require("./rules/BooleanRule.js");
+const ConfirmedRule_js_1 = require("./rules/ConfirmedRule.js");
+const DateFormatRule_js_1 = require("./rules/DateFormatRule.js");
+const DateRule_js_1 = require("./rules/DateRule.js");
 const EmailRule_js_1 = require("./rules/EmailRule.js");
+const ImageRule_js_1 = require("./rules/ImageRule.js");
+const IntegerRule_js_1 = require("./rules/IntegerRule.js");
 const MaxRule_js_1 = require("./rules/MaxRule.js");
+const MimesRule_js_1 = require("./rules/MimesRule.js");
 const MinRule_js_1 = require("./rules/MinRule.js");
+const NullableRule_js_1 = require("./rules/NullableRule.js");
+const NumericRule_js_1 = require("./rules/NumericRule.js");
+const RegexRule_js_1 = require("./rules/RegexRule.js");
+const RequiredIfRule_js_1 = require("./rules/RequiredIfRule.js");
 const RequiredRule_js_1 = require("./rules/RequiredRule.js");
+const RequiredUnlessRule_js_1 = require("./rules/RequiredUnlessRule.js");
+const SameRule_js_1 = require("./rules/SameRule.js");
+const SometimesRule_js_1 = require("./rules/SometimesRule.js");
+const StringRule_js_1 = require("./rules/StringRule.js");
 const data_1 = require("./utils/data");
 class Validator {
     data;
@@ -86,10 +107,18 @@ class Validator {
         this.errors = {};
         const validationPromises = [];
         for (const [attribute, attributeRules] of Object.entries(this.normalizedRules)) {
-            // 🚀 Fix: Dynamically locate deeply nested object keys using dot notation
             const value = (0, data_1.dataGet)(this.data, attribute);
             const isEmpty = value === undefined || value === null || value === '';
-            // We handle bails in an isolation chain block per field
+            const hasSometimes = attributeRules.includes('sometimes');
+            const isMissing = value === undefined;
+            if (hasSometimes && isMissing) {
+                continue;
+            }
+            const hasNullable = attributeRules.includes('nullable');
+            const isNullValue = value === undefined || value === null || value === '';
+            if (hasNullable && isNullValue) {
+                continue;
+            }
             validationPromises.push((async () => {
                 let shouldBail = false;
                 for (const rawRule of attributeRules) {
@@ -139,6 +168,16 @@ class Validator {
         for (const [attribute, attributeRules] of Object.entries(this.normalizedRules)) {
             const value = (0, data_1.dataGet)(this.data, attribute);
             const isEmpty = value === undefined || value === null || value === '';
+            const hasSometimes = attributeRules.includes('sometimes');
+            const isMissing = value === undefined;
+            if (hasSometimes && isMissing) {
+                continue;
+            }
+            const hasNullable = attributeRules.includes('nullable');
+            const isNullValue = value === undefined || value === null || value === '';
+            if (hasNullable && isNullValue) {
+                continue;
+            }
             let shouldBail = false;
             for (const rawRule of attributeRules) {
                 if (rawRule === 'bail') {
@@ -193,6 +232,70 @@ class Validator {
             return new MinRule_js_1.MinRule(parseInt(params[0], 10));
         if (ruleName === 'max')
             return new MaxRule_js_1.MaxRule(parseInt(params[0], 10));
+        if (ruleName === 'string')
+            return new StringRule_js_1.StringRule();
+        if (ruleName === 'numeric')
+            return new NumericRule_js_1.NumericRule();
+        if (ruleName === 'integer')
+            return new IntegerRule_js_1.IntegerRule();
+        if (ruleName === 'boolean')
+            return new BooleanRule_js_1.BooleanRule();
+        if (ruleName === 'array')
+            return new ArrayRule_js_1.ArrayRule();
+        if (ruleName === 'nullable')
+            return new NullableRule_js_1.NullableRule();
+        if (ruleName === 'between') {
+            return new BetweenRule_js_1.BetweenRule(parseInt(params[0], 10), parseInt(params[1], 10));
+        }
+        if (ruleName === 'confirmed') {
+            return new ConfirmedRule_js_1.ConfirmedRule(this.data);
+        }
+        if (ruleName === 'same') {
+            return new SameRule_js_1.SameRule(params[0], this.data);
+        }
+        if (ruleName === 'date')
+            return new DateRule_js_1.DateRule();
+        if (ruleName === 'after')
+            return new AfterDateRule_js_1.AfterDateRule(paramString);
+        if (ruleName === 'before')
+            return new BeforeDateRule_js_1.BeforeDateRule(paramString);
+        if (ruleName === 'date_format')
+            return new DateFormatRule_js_1.DateFormatRule(paramString);
+        if (ruleName === 'sometimes')
+            return new SometimesRule_js_1.SometimesRule();
+        if (ruleName === 'required_if') {
+            const [anotherField, targetValue] = params;
+            return new RequiredIfRule_js_1.RequiredIfRule(anotherField, targetValue, this.data);
+        }
+        if (ruleName === 'required_unless') {
+            const [anotherField, targetValue] = params;
+            return new RequiredUnlessRule_js_1.RequiredUnlessRule(anotherField, targetValue, this.data);
+        }
+        if (ruleName === 'image')
+            return new ImageRule_js_1.ImageRule();
+        if (ruleName === 'mimes')
+            return new MimesRule_js_1.MimesRule(params);
+        if (ruleName === 'alpha')
+            return new AlphaRule_js_1.AlphaRule();
+        if (ruleName === 'alpha_num')
+            return new AlphaNumRule_js_1.AlphaNumRule();
+        if (ruleName === 'regex') {
+            let pattern = paramString;
+            let flags = '';
+            if (paramString.startsWith('/') &&
+                paramString.lastIndexOf('/') > 0) {
+                const lastSlash = paramString.lastIndexOf('/');
+                pattern = paramString.slice(1, lastSlash);
+                flags = paramString.slice(lastSlash + 1);
+            }
+            return new RegexRule_js_1.RegexRule(new RegExp(pattern, flags));
+        }
+        if (ruleName === 'unique' || ruleName === 'exists') {
+            if (!Validator.extensions[ruleName]) {
+                throw new Error(`The "${ruleName}" rule requires a database bridge. Please register one via Validator.extend('${ruleName}', ...) in your application bootstrapper.`);
+            }
+            return Validator.extensions[ruleName](params);
+        }
         if (Validator.extensions[ruleName]) {
             return Validator.extensions[ruleName](params);
         }

package/dist/contracts/Validation.d.ts

@@ -3,3 +3,6 @@ export interface ValidationRule {
     validate(attribute: string, value: unknown, fail: FailCallback): void;
 }
 export type CustomRuleClosureFactory = (params: string[]) => ValidationRule;
+export interface ImplicitRule extends ValidationRule {
+    isImplicit: true;
+}

package/dist/index.d.ts

@@ -1,8 +1,25 @@
 export * from './contracts/Validation';
+export * from './rules/AfterDateRule';
+export * from './rules/AlphaNumRule';
+export * from './rules/AlphaRule';
+export * from './rules/ArrayRule';
+export * from './rules/BeforeDateRule';
+export * from './rules/BooleanRule';
+export * from './rules/DateFormatRule';
+export * from './rules/DateRule';
 export * from './rules/EmailRule';
+export * from './rules/ExistsRule';
+export * from './rules/ImageRule';
+export * from './rules/IntegerRule';
 export * from './rules/MaxRule';
+export * from './rules/MimesRule';
 export * from './rules/MinRule';
+export * from './rules/NullableRule';
+export * from './rules/NumericRule';
+export * from './rules/RegexRule';
 export * from './rules/RequiredRule';
+export * from './rules/StringRule';
+export * from './rules/UniqueRule';
 import { Validator } from './Validator';
 export * from './integrations/react';
 export * from './integrations/vue';

package/dist/index.js

@@ -15,10 +15,27 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./contracts/Validation"), exports);
+__exportStar(require("./rules/AfterDateRule"), exports);
+__exportStar(require("./rules/AlphaNumRule"), exports);
+__exportStar(require("./rules/AlphaRule"), exports);
+__exportStar(require("./rules/ArrayRule"), exports);
+__exportStar(require("./rules/BeforeDateRule"), exports);
+__exportStar(require("./rules/BooleanRule"), exports);
+__exportStar(require("./rules/DateFormatRule"), exports);
+__exportStar(require("./rules/DateRule"), exports);
 __exportStar(require("./rules/EmailRule"), exports);
+__exportStar(require("./rules/ExistsRule"), exports);
+__exportStar(require("./rules/ImageRule"), exports);
+__exportStar(require("./rules/IntegerRule"), exports);
 __exportStar(require("./rules/MaxRule"), exports);
+__exportStar(require("./rules/MimesRule"), exports);
 __exportStar(require("./rules/MinRule"), exports);
+__exportStar(require("./rules/NullableRule"), exports);
+__exportStar(require("./rules/NumericRule"), exports);
+__exportStar(require("./rules/RegexRule"), exports);
 __exportStar(require("./rules/RequiredRule"), exports);
+__exportStar(require("./rules/StringRule"), exports);
+__exportStar(require("./rules/UniqueRule"), exports);
 const Validator_1 = require("./Validator");
 __exportStar(require("./integrations/react"), exports);
 __exportStar(require("./integrations/vue"), exports);

package/dist/rules/AfterDateRule.d.ts

@@ -0,0 +1,6 @@
+import { FailCallback, ValidationRule } from '../contracts/Validation';
+export declare class AfterDateRule implements ValidationRule {
+    private targetDateString;
+    constructor(targetDateString: string);
+    validate(attribute: string, value: unknown, fail: FailCallback): void;
+}

package/dist/rules/AfterDateRule.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AfterDateRule = void 0;
+class AfterDateRule {
+    targetDateString;
+    constructor(targetDateString) {
+        this.targetDateString = targetDateString;
+    }
+    validate(attribute, value, fail) {
+        const valueTime = Date.parse(String(value));
+        const targetTime = Date.parse(this.targetDateString);
+        if (isNaN(targetTime)) {
+            throw new Error(`The validation boundary date "${this.targetDateString}" is invalid.`);
+        }
+        if (isNaN(valueTime) || valueTime <= targetTime) {
+            fail(`The :attribute must be a date after ${this.targetDateString}.`);
+        }
+    }
+}
+exports.AfterDateRule = AfterDateRule;

package/dist/rules/AlphaNumRule.d.ts

@@ -0,0 +1,4 @@
+import { FailCallback, ValidationRule } from '../contracts/Validation';
+export declare class AlphaNumRule implements ValidationRule {
+    validate(attribute: string, value: unknown, fail: FailCallback): void;
+}

package/dist/rules/AlphaNumRule.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AlphaNumRule = void 0;
+class AlphaNumRule {
+    validate(attribute, value, fail) {
+        const stringValue = String(value);
+        if (!/^[A-Za-z0-9]+$/.test(stringValue)) {
+            fail(`The :attribute must only contain letters and numbers.`);
+        }
+    }
+}
+exports.AlphaNumRule = AlphaNumRule;

package/dist/rules/AlphaRule.d.ts

@@ -0,0 +1,4 @@
+import { FailCallback, ValidationRule } from '../contracts/Validation';
+export declare class AlphaRule implements ValidationRule {
+    validate(attribute: string, value: unknown, fail: FailCallback): void;
+}

package/dist/rules/AlphaRule.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AlphaRule = void 0;
+class AlphaRule {
+    validate(attribute, value, fail) {
+        if (typeof value !== 'string' || !/^[A-Za-z]+$/.test(value)) {
+            fail(`The :attribute must only contain letters.`);
+        }
+    }
+}
+exports.AlphaRule = AlphaRule;

package/dist/rules/ArrayRule.d.ts

@@ -0,0 +1,4 @@
+import { FailCallback, ValidationRule } from '../contracts/Validation';
+export declare class ArrayRule implements ValidationRule {
+    validate(attribute: string, value: unknown, fail: FailCallback): void;
+}

package/dist/rules/ArrayRule.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ArrayRule = void 0;
+class ArrayRule {
+    validate(attribute, value, fail) {
+        if (!Array.isArray(value)) {
+            fail(`The :attribute must be an array.`);
+        }
+    }
+}
+exports.ArrayRule = ArrayRule;

package/dist/rules/BeforeDateRule.d.ts

@@ -0,0 +1,6 @@
+import { FailCallback, ValidationRule } from '../contracts/Validation';
+export declare class BeforeDateRule implements ValidationRule {
+    private targetDateString;
+    constructor(targetDateString: string);
+    validate(attribute: string, value: unknown, fail: FailCallback): void;
+}

package/dist/rules/BeforeDateRule.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BeforeDateRule = void 0;
+class BeforeDateRule {
+    targetDateString;
+    constructor(targetDateString) {
+        this.targetDateString = targetDateString;
+    }
+    validate(attribute, value, fail) {
+        const valueTime = Date.parse(String(value));
+        const targetTime = Date.parse(this.targetDateString);
+        if (isNaN(targetTime)) {
+            throw new Error(`The validation boundary date "${this.targetDateString}" is invalid.`);
+        }
+        if (isNaN(valueTime) || valueTime >= targetTime) {
+            fail(`The :attribute must be a date before ${this.targetDateString}.`);
+        }
+    }
+}
+exports.BeforeDateRule = BeforeDateRule;

package/dist/rules/BetweenRule.d.ts

@@ -0,0 +1,7 @@
+import { FailCallback, ValidationRule } from '../contracts/Validation';
+export declare class BetweenRule implements ValidationRule {
+    private min;
+    private max;
+    constructor(min: number, max: number);
+    validate(attribute: string, value: unknown, fail: FailCallback): void;
+}

package/dist/rules/BetweenRule.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BetweenRule = void 0;
+class BetweenRule {
+    min;
+    max;
+    constructor(min, max) {
+        this.min = min;
+        this.max = max;
+    }
+    validate(attribute, value, fail) {
+        let size;
+        if (Array.isArray(value)) {
+            size = value.length;
+        }
+        else if (typeof value === 'number') {
+            size = value;
+        }
+        else if (typeof value === 'string') {
+            // If it looks numeric, treat it as a number; otherwise, check character length
+            size =
+                !isNaN(Number(value)) && value.trim() !== ''
+                    ? Number(value)
+                    : [...value].length;
+        }
+        else {
+            return; // Skip unsupported types gracefully
+        }
+        if (size < this.min || size > this.max) {
+            fail(`The :attribute must be between ${this.min} and ${this.max}.`);
+        }
+    }
+}
+exports.BetweenRule = BetweenRule;

package/dist/rules/BooleanRule.d.ts

@@ -0,0 +1,4 @@
+import { FailCallback, ValidationRule } from '../contracts/Validation';
+export declare class BooleanRule implements ValidationRule {
+    validate(attribute: string, value: unknown, fail: FailCallback): void;
+}

package/dist/rules/BooleanRule.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BooleanRule = void 0;
+class BooleanRule {
+    validate(attribute, value, fail) {
+        const acceptable = [true, false, 1, 0, '1', '0', 'true', 'false'];
+        if (!acceptable.includes(value)) {
+            fail(`The :attribute field must be true or false.`);
+        }
+    }
+}
+exports.BooleanRule = BooleanRule;

package/dist/rules/ConfirmedRule.d.ts

@@ -0,0 +1,6 @@
+import { FailCallback, ValidationRule } from '../contracts/Validation';
+export declare class ConfirmedRule implements ValidationRule {
+    private allData;
+    constructor(allData: Record<string, unknown>);
+    validate(attribute: string, value: unknown, fail: FailCallback): void;
+}

package/dist/rules/ConfirmedRule.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConfirmedRule = void 0;
+class ConfirmedRule {
+    allData;
+    // We accept the full root data object via the constructor
+    constructor(allData) {
+        this.allData = allData;
+    }
+    validate(attribute, value, fail) {
+        const confirmationField = `${attribute}_confirmation`;
+        const confirmationValue = this.allData[confirmationField];
+        if (value !== confirmationValue) {
+            fail(`The :attribute confirmation does not match.`);
+        }
+    }
+}
+exports.ConfirmedRule = ConfirmedRule;

package/dist/rules/DateFormatRule.d.ts

@@ -0,0 +1,6 @@
+import { FailCallback, ValidationRule } from '../contracts/Validation';
+export declare class DateFormatRule implements ValidationRule {
+    private format;
+    constructor(format: string);
+    validate(attribute: string, value: unknown, fail: FailCallback): void;
+}

package/dist/rules/DateFormatRule.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DateFormatRule = void 0;
+class DateFormatRule {
+    format;
+    constructor(format) {
+        this.format = format;
+    }
+    validate(attribute, value, fail) {
+        if (typeof value !== 'string') {
+            fail(`The :attribute does not match the format ${this.format}.`);
+            return;
+        }
+        // 🚀 Clean token isolation using exact character boundary maps
+        let regexString = this.format
+            .replace(/[-/\\^$*+?.()|[\]{}]/g, '\\$&') // 1. Escape layout boundaries first
+            .replace(/d/g, '(0[1-9]|[12]\\d|3[01])') // 2. Replace 'd' BEFORE injecting matching '\\d' tokens
+            .replace(/Y/g, '\\d{4}') // 3. Replace 'Y' (4-digit Year)
+            .replace(/m/g, '(0[1-9]|1[0-2])') // 4. Replace 'm' (2-digit Month)
+            .replace(/H/g, '(0\\d|1\\d|2[0-3])') // 5. Replace 'H' (24-Hour)
+            .replace(/i/g, '[0-5]\\d') // 6. Replace 'i' (Minutes)
+            .replace(/s/g, '[0-5]\\d'); // 7. Replace 's' (Seconds)
+        const strictRegex = new RegExp(`^${regexString}$`);
+        if (!strictRegex.test(value)) {
+            fail(`The :attribute does not match the format ${this.format}.`);
+        }
+    }
+}
+exports.DateFormatRule = DateFormatRule;

package/dist/rules/DateRule.d.ts

@@ -0,0 +1,4 @@
+import { FailCallback, ValidationRule } from '../contracts/Validation';
+export declare class DateRule implements ValidationRule {
+    validate(attribute: string, value: unknown, fail: FailCallback): void;
+}

package/dist/rules/DateRule.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DateRule = void 0;
+class DateRule {
+    validate(attribute, value, fail) {
+        if (value instanceof Date && !isNaN(value.getTime())) {
+            return;
+        }
+        if (typeof value !== 'string' && typeof value !== 'number') {
+            fail(`The :attribute is not a valid date.`);
+            return;
+        }
+        const timestamp = Date.parse(String(value));
+        if (isNaN(timestamp)) {
+            fail(`The :attribute is not a valid date.`);
+        }
+    }
+}
+exports.DateRule = DateRule;

package/dist/rules/ExistsRule.d.ts

@@ -0,0 +1,8 @@
+import { FailCallback, ValidationRule } from '../contracts/Validation';
+export declare abstract class ExistsRule implements ValidationRule {
+    protected table: string;
+    protected column: string;
+    constructor(table: string, column: string);
+    abstract existsInDatabase(table: string, column: string, value: unknown): Promise<boolean>;
+    validate(attribute: string, value: unknown, fail: FailCallback): Promise<void>;
+}

package/dist/rules/ExistsRule.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExistsRule = void 0;
+class ExistsRule {
+    table;
+    column;
+    constructor(table, column) {
+        this.table = table;
+        this.column = column;
+    }
+    async validate(attribute, value, fail) {
+        if (value === undefined || value === null || value === '')
+            return;
+        const exists = await this.existsInDatabase(this.table, this.column, value);
+        if (!exists) {
+            fail(`The selected :attribute is invalid.`);
+        }
+    }
+}
+exports.ExistsRule = ExistsRule;

package/dist/rules/ImageRule.d.ts

@@ -0,0 +1,4 @@
+import { FailCallback, ValidationRule } from '../contracts/Validation';
+export declare class ImageRule implements ValidationRule {
+    validate(attribute: string, value: unknown, fail: FailCallback): void;
+}

package/dist/rules/ImageRule.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImageRule = void 0;
+class ImageRule {
+    validate(attribute, value, fail) {
+        const allowedExtensions = [
+            'jpeg',
+            'jpg',
+            'png',
+            'bmp',
+            'gif',
+            'svg',
+            'webp',
+        ];
+        let filename = '';
+        if (typeof value === 'string') {
+            filename = value;
+        }
+        else if (value && typeof value === 'object' && 'name' in value) {
+            filename = String(value.name);
+        }
+        else {
+            fail(`The :attribute must be an image.`);
+            return;
+        }
+        const extension = filename.split('.').pop()?.toLowerCase() || '';
+        if (!allowedExtensions.includes(extension)) {
+            fail(`The :attribute must be an image.`);
+        }
+    }
+}
+exports.ImageRule = ImageRule;

package/dist/rules/IntegerRule.d.ts

@@ -0,0 +1,4 @@
+import { FailCallback, ValidationRule } from '../contracts/Validation';
+export declare class IntegerRule implements ValidationRule {
+    validate(attribute: string, value: unknown, fail: FailCallback): void;
+}

package/dist/rules/IntegerRule.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IntegerRule = void 0;
+class IntegerRule {
+    validate(attribute, value, fail) {
+        const num = Number(value);
+        const isInteger = !isNaN(num) && Number.isInteger(num) && String(value).trim() !== '';
+        if (!isInteger) {
+            fail(`The :attribute must be an integer.`);
+        }
+    }
+}
+exports.IntegerRule = IntegerRule;

package/dist/rules/MimesRule.d.ts

@@ -0,0 +1,6 @@
+import { FailCallback, ValidationRule } from '../contracts/Validation';
+export declare class MimesRule implements ValidationRule {
+    private allowedExtensions;
+    constructor(allowedExtensions: string[]);
+    validate(attribute: string, value: unknown, fail: FailCallback): void;
+}

package/dist/rules/MimesRule.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MimesRule = void 0;
+class MimesRule {
+    allowedExtensions;
+    constructor(allowedExtensions) {
+        this.allowedExtensions = allowedExtensions;
+    }
+    validate(attribute, value, fail) {
+        let filename = '';
+        if (typeof value === 'string') {
+            filename = value;
+        }
+        else if (value && typeof value === 'object' && 'name' in value) {
+            filename = String(value.name);
+        }
+        else {
+            fail(`The :attribute must be a file of type: ${this.allowedExtensions.join(', ')}.`);
+            return;
+        }
+        const extension = filename.split('.').pop()?.toLowerCase() || '';
+        if (!this.allowedExtensions
+            .map((ext) => ext.toLowerCase())
+            .includes(extension)) {
+            fail(`The :attribute must be a file of type: ${this.allowedExtensions.join(', ')}.`);
+        }
+    }
+}
+exports.MimesRule = MimesRule;

package/dist/rules/NullableRule.d.ts

@@ -0,0 +1,4 @@
+import { FailCallback, ValidationRule } from '../contracts/Validation';
+export declare class NullableRule implements ValidationRule {
+    validate(attribute: string, value: unknown, fail: FailCallback): void;
+}

package/dist/rules/NullableRule.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NullableRule = void 0;
+class NullableRule {
+    validate(attribute, value, fail) { }
+}
+exports.NullableRule = NullableRule;

package/dist/rules/NumericRule.d.ts

@@ -0,0 +1,4 @@
+import { FailCallback, ValidationRule } from '../contracts/Validation';
+export declare class NumericRule implements ValidationRule {
+    validate(attribute: string, value: unknown, fail: FailCallback): void;
+}

package/dist/rules/NumericRule.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NumericRule = void 0;
+class NumericRule {
+    validate(attribute, value, fail) {
+        // Allows pure numbers or numeric strings (like "123" or "45.6")
+        const isNumeric = (typeof value === 'number' && !isNaN(value)) ||
+            (typeof value === 'string' &&
+                value.trim() !== '' &&
+                !isNaN(Number(value)));
+        if (!isNumeric) {
+            fail(`The :attribute must be a number.`);
+        }
+    }
+}
+exports.NumericRule = NumericRule;

package/dist/rules/RegexRule.d.ts

@@ -0,0 +1,6 @@
+import { FailCallback, ValidationRule } from '../contracts/Validation';
+export declare class RegexRule implements ValidationRule {
+    private pattern;
+    constructor(pattern: RegExp);
+    validate(attribute: string, value: unknown, fail: FailCallback): void;
+}

package/dist/rules/RegexRule.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RegexRule = void 0;
+class RegexRule {
+    pattern;
+    constructor(pattern) {
+        this.pattern = pattern;
+    }
+    validate(attribute, value, fail) {
+        const stringValue = String(value);
+        if (!this.pattern.test(stringValue)) {
+            fail(`The :attribute format is invalid.`);
+        }
+    }
+}
+exports.RegexRule = RegexRule;

package/dist/rules/RequiredIfRule.d.ts

@@ -0,0 +1,9 @@
+import { FailCallback, ImplicitRule } from '../contracts/Validation';
+export declare class RequiredIfRule implements ImplicitRule {
+    private anotherField;
+    private targetValue;
+    private allData;
+    isImplicit: true;
+    constructor(anotherField: string, targetValue: string, allData: Record<string, unknown>);
+    validate(attribute: string, value: unknown, fail: FailCallback): void;
+}

package/dist/rules/RequiredIfRule.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RequiredIfRule = void 0;
+const data_1 = require("../utils/data");
+class RequiredIfRule {
+    anotherField;
+    targetValue;
+    allData;
+    isImplicit = true; // Must be implicit to run when the field is missing
+    constructor(anotherField, targetValue, allData) {
+        this.anotherField = anotherField;
+        this.targetValue = targetValue;
+        this.allData = allData;
+    }
+    validate(attribute, value, fail) {
+        const actualValue = (0, data_1.dataGet)(this.allData, this.anotherField);
+        // Cast comparison value to string to ensure fluid loose matching (handles numbers/booleans)
+        if (String(actualValue) === this.targetValue) {
+            if (value === undefined || value === null || value === '') {
+                fail(`The :attribute field is required when ${this.anotherField} is ${this.targetValue}.`);
+            }
+        }
+    }
+}
+exports.RequiredIfRule = RequiredIfRule;

package/dist/rules/RequiredUnlessRule.d.ts

@@ -0,0 +1,9 @@
+import { FailCallback, ImplicitRule } from '../contracts/Validation';
+export declare class RequiredUnlessRule implements ImplicitRule {
+    private anotherField;
+    private targetValue;
+    private allData;
+    isImplicit: true;
+    constructor(anotherField: string, targetValue: string, allData: Record<string, unknown>);
+    validate(attribute: string, value: unknown, fail: FailCallback): void;
+}

package/dist/rules/RequiredUnlessRule.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RequiredUnlessRule = void 0;
+const data_1 = require("../utils/data");
+class RequiredUnlessRule {
+    anotherField;
+    targetValue;
+    allData;
+    isImplicit = true;
+    constructor(anotherField, targetValue, allData) {
+        this.anotherField = anotherField;
+        this.targetValue = targetValue;
+        this.allData = allData;
+    }
+    validate(attribute, value, fail) {
+        const actualValue = (0, data_1.dataGet)(this.allData, this.anotherField);
+        if (String(actualValue) !== this.targetValue) {
+            if (value === undefined || value === null || value === '') {
+                fail(`The :attribute field is required unless ${this.anotherField} is ${this.targetValue}.`);
+            }
+        }
+    }
+}
+exports.RequiredUnlessRule = RequiredUnlessRule;

package/dist/rules/SameRule.d.ts

@@ -0,0 +1,7 @@
+import { FailCallback, ValidationRule } from '../contracts/Validation';
+export declare class SameRule implements ValidationRule {
+    private otherField;
+    private allData;
+    constructor(otherField: string, allData: Record<string, unknown>);
+    validate(attribute: string, value: unknown, fail: FailCallback): void;
+}

package/dist/rules/SameRule.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SameRule = void 0;
+const data_1 = require("../utils/data");
+class SameRule {
+    otherField;
+    allData;
+    constructor(otherField, allData) {
+        this.otherField = otherField;
+        this.allData = allData;
+    }
+    validate(attribute, value, fail) {
+        // Uses our dot-notation utility helper to grab the comparison value safely
+        const otherValue = (0, data_1.dataGet)(this.allData, this.otherField);
+        if (value !== otherValue) {
+            fail(`The :attribute and ${this.otherField} must match.`);
+        }
+    }
+}
+exports.SameRule = SameRule;

package/dist/rules/SometimesRule.d.ts

@@ -0,0 +1,4 @@
+import { FailCallback, ValidationRule } from '../contracts/Validation';
+export declare class SometimesRule implements ValidationRule {
+    validate(attribute: string, value: unknown, fail: FailCallback): void;
+}

package/dist/rules/SometimesRule.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SometimesRule = void 0;
+class SometimesRule {
+    validate(attribute, value, fail) { }
+}
+exports.SometimesRule = SometimesRule;

package/dist/rules/StringRule.d.ts

@@ -0,0 +1,4 @@
+import { FailCallback, ValidationRule } from '../contracts/Validation';
+export declare class StringRule implements ValidationRule {
+    validate(attribute: string, value: unknown, fail: FailCallback): void;
+}

package/dist/rules/StringRule.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StringRule = void 0;
+class StringRule {
+    validate(attribute, value, fail) {
+        if (typeof value !== 'string') {
+            fail(`The :attribute must be a string.`);
+        }
+    }
+}
+exports.StringRule = StringRule;

package/dist/rules/UniqueRule.d.ts

@@ -0,0 +1,8 @@
+import { FailCallback, ValidationRule } from '../contracts/Validation';
+export declare abstract class UniqueRule implements ValidationRule {
+    protected table: string;
+    protected column: string;
+    constructor(table: string, column: string);
+    abstract isUnique(table: string, column: string, value: unknown): Promise<boolean>;
+    validate(attribute: string, value: unknown, fail: FailCallback): Promise<void>;
+}

package/dist/rules/UniqueRule.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UniqueRule = void 0;
+class UniqueRule {
+    table;
+    column;
+    constructor(table, column) {
+        this.table = table;
+        this.column = column;
+    }
+    async validate(attribute, value, fail) {
+        if (value === undefined || value === null || value === '')
+            return;
+        const unique = await this.isUnique(this.table, this.column, value);
+        if (!unique) {
+            fail(`The :attribute has already been taken.`);
+        }
+    }
+}
+exports.UniqueRule = UniqueRule;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@rbl-dev/validator-ts",
-	"version": "1.0.1",
+	"version": "1.2.0",
 	"description": "A Laravel-inspired class-based pipe validator for TypeScript applications.",
 	"main": "dist/index.js",
 	"types": "dist/index.d.ts",