ts-prorm-orm 1.1.0

package/dist/validators/validator.js

@@ -0,0 +1,911 @@
+"use strict";
+/**
+ * Validator System for the TypeScript ORM
+ * Provides comprehensive validation methods and utilities
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Validator = exports.ValidationError = void 0;
+exports.registerValidatorModel = registerValidatorModel;
+exports.unregisterValidatorModel = unregisterValidatorModel;
+exports.getValidatorModel = getValidatorModel;
+exports.validate = validate;
+exports.validateField = validateField;
+exports.validateAsync = validateAsync;
+exports.validateFieldAsync = validateFieldAsync;
+exports.createValidationError = createValidationError;
+exports.getValidatorsForDataType = getValidatorsForDataType;
+const operators_1 = require("../models/operators");
+// ==================== Validation Error ====================
+/**
+ * Custom validation error class that extends Error
+ * Contains an array of validation error items
+ */
+class ValidationError extends Error {
+    constructor(message = 'Validation error', errors = []) {
+        super(message);
+        this.name = 'PrormValidationError';
+        this.errors = errors;
+        // Maintains proper stack trace for where error was thrown (V8 engines)
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, ValidationError);
+        }
+    }
+    /**
+     * Add an error to the validation errors array
+     */
+    addError(error) {
+        this.errors.push(error);
+    }
+    /**
+     * Check if there are any validation errors
+     */
+    hasErrors() {
+        return this.errors.length > 0;
+    }
+    /**
+     * Get errors for a specific field
+     */
+    getErrorsForField(path) {
+        return this.errors.filter((error) => error.path === path);
+    }
+}
+exports.ValidationError = ValidationError;
+/**
+ * Registry mapping a model name to a live model class reference.
+ *
+ * Validators run inside `src/validators/**` and, by design, have no
+ * built-in access to a live `Prorm` instance or model classes. To let
+ * `isUnique` perform a real `findOne` uniqueness check without validators
+ * importing `src/models/model.ts` (which would create a circular
+ * dependency: model.ts -> validators -> model.ts), model classes must be
+ * registered here - typically when a model is defined/initialized.
+ *
+ * NOTE: as of this fix, nothing in `src/models/model.ts` calls
+ * `registerValidatorModel` yet. Until it does, `isUnique`/`isUniqueAsync`
+ * cannot resolve a `model: 'SomeModelName'` string reference and will fall
+ * back to a safe no-op (see `isUniqueAsync` below). Callers can work around
+ * this today by passing a live model class directly as `options.model`
+ * instead of a string name.
+ */
+const modelRegistry = new Map();
+/**
+ * Register a live model class so `isUnique`/`isUniqueAsync` validators can
+ * resolve a `model: 'SomeModelName'` string reference to a real class with
+ * a working `findOne`.
+ */
+function registerValidatorModel(name, model) {
+    modelRegistry.set(name, model);
+}
+/**
+ * Remove a previously registered model reference.
+ */
+function unregisterValidatorModel(name) {
+    modelRegistry.delete(name);
+}
+/**
+ * Look up a registered model reference by name.
+ */
+function getValidatorModel(name) {
+    return modelRegistry.get(name);
+}
+// ==================== Validator Class ====================
+/**
+ * Validator class with built-in validation methods
+ * Provides comprehensive validation for various data types
+ */
+class Validator {
+    /**
+     * Check if value is a valid email address
+     */
+    static isEmail(value) {
+        if (value === null || value === undefined || value === '') {
+            return true; // Use notEmpty for required fields
+        }
+        const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+        return emailRegex.test(String(value));
+    }
+    /**
+     * Check if value is a valid URL
+     */
+    static isUrl(value) {
+        if (value === null || value === undefined || value === '') {
+            return true;
+        }
+        try {
+            new URL(String(value));
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Check if value is a valid IP address (IPv4 or IPv6)
+     */
+    static isIP(value) {
+        if (value === null || value === undefined || value === '') {
+            return true;
+        }
+        const ipValue = String(value);
+        // IPv4
+        const ipv4Regex = /^(\d{1,3}\.){3}\d{1,3}$/;
+        if (ipv4Regex.test(ipValue)) {
+            const parts = ipValue.split('.');
+            return parts.every((part) => {
+                const num = parseInt(part, 10);
+                return num >= 0 && num <= 255;
+            });
+        }
+        // IPv6
+        const ipv6Regex = /^([\da-f]{1,4}:){7}[\da-f]{1,4}$/i;
+        return ipv6Regex.test(ipValue);
+    }
+    /**
+     * Check if value contains only alphabetic characters
+     */
+    static isAlpha(value) {
+        if (value === null || value === undefined || value === '') {
+            return true;
+        }
+        const alphaRegex = /^[a-zA-Z]+$/;
+        return alphaRegex.test(String(value));
+    }
+    /**
+     * Check if value contains only alphanumeric characters
+     */
+    static isAlphanumeric(value) {
+        if (value === null || value === undefined || value === '') {
+            return true;
+        }
+        const alphanumericRegex = /^[a-zA-Z0-9]+$/;
+        return alphanumericRegex.test(String(value));
+    }
+    /**
+     * Check if value contains only numeric characters
+     */
+    static isNumeric(value) {
+        if (value === null || value === undefined || value === '') {
+            return true;
+        }
+        const numericRegex = /^[0-9]+$/;
+        return numericRegex.test(String(value));
+    }
+    /**
+     * Check if value is an integer
+     */
+    static isInt(value) {
+        if (value === null || value === undefined || value === '') {
+            return true;
+        }
+        if (typeof value === 'number') {
+            return Number.isInteger(value);
+        }
+        const intRegex = /^-?\d+$/;
+        return intRegex.test(String(value));
+    }
+    /**
+     * Check if value is a floating-point number
+     */
+    static isFloat(value) {
+        if (value === null || value === undefined || value === '') {
+            return true;
+        }
+        if (typeof value === 'number') {
+            return !isNaN(value);
+        }
+        return !isNaN(parseFloat(String(value)));
+    }
+    /**
+     * Check if value is a decimal number
+     */
+    static isDecimal(value) {
+        if (value === null || value === undefined || value === '') {
+            return true;
+        }
+        const decimalRegex = /^\d+\.\d+$/;
+        return decimalRegex.test(String(value));
+    }
+    /**
+     * Check if value is a boolean
+     */
+    static isBoolean(value) {
+        if (value === null || value === undefined || value === '') {
+            return true;
+        }
+        if (typeof value === 'boolean') {
+            return true;
+        }
+        if (typeof value === 'string') {
+            const lower = value.toLowerCase();
+            return lower === 'true' || lower === 'false' || lower === '1' || lower === '0';
+        }
+        return typeof value === 'number' && (value === 0 || value === 1);
+    }
+    /**
+     * Check if value is a valid date
+     */
+    static isDate(value) {
+        if (value === null || value === undefined || value === '') {
+            return true;
+        }
+        if (value instanceof Date) {
+            return !isNaN(value.getTime());
+        }
+        const date = new Date(String(value));
+        return !isNaN(date.getTime());
+    }
+    /**
+     * Check if value is a valid time string (HH:MM or HH:MM:SS)
+     */
+    static isTime(value) {
+        if (value === null || value === undefined || value === '') {
+            return true;
+        }
+        const timeRegex = /^([01]?[0-9]|2[0-3]):([0-5][0-9])(:([0-5][0-9]))?$/;
+        return timeRegex.test(String(value));
+    }
+    /**
+     * Check if value is a valid date string (ISO 8601)
+     */
+    static isDateString(value) {
+        if (value === null || value === undefined || value === '') {
+            return true;
+        }
+        const dateStr = String(value);
+        const isoDateRegex = /^\d{4}-\d{2}-\d{2}(T\d{2}:\d{2}:\d{2}(\.\d{3})?(Z|[+-]\d{2}:\d{2})?)?$/;
+        return isoDateRegex.test(dateStr) && Validator.isDate(value);
+    }
+    /**
+     * Check if value is a valid UUID (version 1, 4, 5)
+     */
+    static isUUID(value) {
+        if (value === null || value === undefined || value === '') {
+            return true;
+        }
+        const uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+        return uuidRegex.test(String(value));
+    }
+    /**
+     * Check if value is valid JSON
+     */
+    static isJSON(value) {
+        if (value === null || value === undefined || value === '') {
+            return true;
+        }
+        if (typeof value === 'object' && value !== null) {
+            try {
+                JSON.stringify(value);
+                return true;
+            }
+            catch {
+                return false;
+            }
+        }
+        try {
+            JSON.parse(String(value));
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Check if value is empty (null, undefined, or empty string)
+     */
+    static isEmpty(value) {
+        if (value === null || value === undefined) {
+            return true;
+        }
+        if (typeof value === 'string') {
+            return value.trim() === '';
+        }
+        if (Array.isArray(value)) {
+            return value.length === 0;
+        }
+        return false;
+    }
+    /**
+     * Check if value is not empty
+     */
+    static notEmpty(value) {
+        return !Validator.isEmpty(value);
+    }
+    /**
+     * Check if string length is within bounds
+     * @param value - The value to check
+     * @param len - Single number for exact length, or [min, max] tuple
+     */
+    static len(value, len) {
+        if (value === null || value === undefined) {
+            return true;
+        }
+        const strValue = String(value);
+        const strLen = strValue.length;
+        if (typeof len === 'number') {
+            return strLen === len;
+        }
+        const [min, max] = len;
+        if (max !== undefined) {
+            return strLen >= min && strLen <= max;
+        }
+        return strLen >= min;
+    }
+    /**
+     * Check if numeric value is >= minimum
+     */
+    static min(value, minVal) {
+        if (value === null || value === undefined || value === '') {
+            return true;
+        }
+        const num = typeof value === 'number' ? value : parseFloat(String(value));
+        return !isNaN(num) && num >= minVal;
+    }
+    /**
+     * Check if numeric value is <= maximum
+     */
+    static max(value, maxVal) {
+        if (value === null || value === undefined || value === '') {
+            return true;
+        }
+        const num = typeof value === 'number' ? value : parseFloat(String(value));
+        return !isNaN(num) && num <= maxVal;
+    }
+    /**
+     * Check if numeric value is within range
+     */
+    static range(value, range) {
+        const [min, max] = range;
+        return Validator.min(value, min) && Validator.max(value, max);
+    }
+    /**
+     * Check if value is in the allowed list
+     */
+    static isIn(value, values) {
+        if (value === null || value === undefined) {
+            return true;
+        }
+        return values.includes(value);
+    }
+    /**
+     * Check if value is not in the disallowed list
+     */
+    static notIn(value, values) {
+        if (value === null || value === undefined) {
+            return true;
+        }
+        return !values.includes(value);
+    }
+    /**
+     * Synchronous uniqueness check.
+     *
+     * A real uniqueness check requires an async database query, which cannot
+     * be performed from a synchronous function. This method exists only for
+     * backwards compatibility with call sites that still use the
+     * synchronous `validate()`/`validateField()` entry points; it always
+     * returns `true` (never fails validation) and logs a warning so silent
+     * false-passes are visible.
+     *
+     * Prefer `Validator.isUniqueAsync()` (via `validateAsync()`/
+     * `validateFieldAsync()`) wherever a real database uniqueness check is
+     * required.
+     */
+    static isUnique(value, options) {
+        if (value === null || value === undefined) {
+            return true;
+        }
+        if (typeof console !== 'undefined' && console.warn) {
+            console.warn('[Validator.isUnique] Synchronous uniqueness checks cannot query the database and ' +
+                'always pass. Use Validator.isUniqueAsync (via validateAsync/validateFieldAsync) for ' +
+                `a real uniqueness check${options?.field ? ` on field "${options.field}"` : ''}.`);
+        }
+        return true;
+    }
+    /**
+     * Check if value is unique by performing a real database lookup via
+     * `Model.findOne()`.
+     *
+     * @param value - The value to check for uniqueness
+     * @param options.model - Either a model name registered via
+     *   `registerValidatorModel()`, or a live model reference (any object
+     *   exposing an async `findOne({ where })` method, e.g. a Model class).
+     * @param options.field - The column/attribute name to check. Defaults to
+     *   the field the rule was declared on when used via `validateAsync`.
+     * @param options.where - Extra where conditions to scope the lookup
+     *   (e.g. multi-column uniqueness, soft-delete scoping).
+     * @param options.exclude - Primary-key (or other) conditions identifying
+     *   the current instance, so an update does not fail uniqueness against
+     *   itself. Each entry is turned into a `{ [Op.ne]: value }` condition.
+     */
+    static async isUniqueAsync(value, options) {
+        if (value === null || value === undefined) {
+            return true;
+        }
+        if (!options || !options.field) {
+            // Without knowing which column to check, there is nothing to query.
+            return true;
+        }
+        const modelRef = typeof options.model === 'string' ? modelRegistry.get(options.model) : options.model;
+        if (!modelRef || typeof modelRef.findOne !== 'function') {
+            // No live model reference available (e.g. model not registered).
+            // Fail open rather than silently rejecting otherwise-valid data.
+            return true;
+        }
+        const where = {
+            [options.field]: value,
+            ...(options.where ?? {}),
+        };
+        if (options.exclude) {
+            for (const [key, excludeValue] of Object.entries(options.exclude)) {
+                if (excludeValue !== undefined && excludeValue !== null) {
+                    where[key] = { [operators_1.Op.ne]: excludeValue };
+                }
+            }
+        }
+        const existing = await modelRef.findOne({ where });
+        return existing === null || existing === undefined;
+    }
+    /**
+     * Check if value equals the expected value
+     */
+    static equals(value, expected) {
+        if (value === null || value === undefined) {
+            return expected === null || expected === undefined;
+        }
+        return value === expected;
+    }
+    /**
+     * Check if value does not equal the expected value
+     */
+    static notEquals(value, expected) {
+        return !Validator.equals(value, expected);
+    }
+    /**
+     * Check if value matches a regular expression
+     */
+    static matches(value, pattern) {
+        if (value === null || value === undefined || value === '') {
+            return true;
+        }
+        const regex = typeof pattern === 'string' ? new RegExp(pattern) : pattern;
+        return regex.test(String(value));
+    }
+    /**
+     * Check if value does not match a regular expression
+     */
+    static notMatches(value, pattern) {
+        return !Validator.matches(value, pattern);
+    }
+    // Additional useful validators
+    /**
+     * Check if value is a valid credit card number (Luhn algorithm)
+     */
+    static isCreditCard(value) {
+        if (value === null || value === undefined || value === '') {
+            return true;
+        }
+        const card = String(value).replace(/\s+/g, '');
+        if (!/^\d{13,19}$/.test(card)) {
+            return false;
+        }
+        // Luhn algorithm
+        let sum = 0;
+        let isEven = false;
+        for (let i = card.length - 1; i >= 0; i--) {
+            let digit = parseInt(card[i], 10);
+            if (isEven) {
+                digit *= 2;
+                if (digit > 9) {
+                    digit -= 9;
+                }
+            }
+            sum += digit;
+            isEven = !isEven;
+        }
+        return sum % 10 === 0;
+    }
+    /**
+     * Check if value is a valid postal code
+     */
+    static isPostalCode(value, locale = 'US') {
+        if (value === null || value === undefined || value === '') {
+            return true;
+        }
+        const postalCode = String(value);
+        const patterns = {
+            US: /^\d{5}(-\d{4})?$/,
+            CA: /^[A-Z]\d[A-Z]\s?\d[A-Z]\d$/i,
+            UK: /^[A-Z]{1,2}\d{1,2}[A-Z]?\s?\d[A-Z]{2}$/i,
+            DE: /^\d{5}$/,
+            FR: /^\d{5}$/,
+            JP: /^\d{3}-?\d{4}$/,
+        };
+        const pattern = patterns[locale.toUpperCase()] || /^.+$/;
+        return pattern.test(postalCode);
+    }
+    /**
+     * Check if value is a valid phone number
+     */
+    static isMobilePhone(value, locale = 'en-US') {
+        if (value === null || value === undefined || value === '') {
+            return true;
+        }
+        const phone = String(value).replace(/[\s\-\(\)]/g, '');
+        const patterns = {
+            'en-US': /^(\+1)?\d{10}$/,
+            'en-GB': /^(\+44)?\d{10}$/,
+            'de-DE': /^(\+49)?\d{10,11}$/,
+            'fr-FR': /^(\+33)?\d{9}$/,
+            'jp-JP': /^(\+81)?\d{9,10}$/,
+        };
+        const pattern = patterns[locale.toLowerCase()] || /^\+?\d{7,15}$/;
+        return pattern.test(phone);
+    }
+    /**
+     * Check if value is a valid hexadecimal color
+     */
+    static isHexColor(value) {
+        if (value === null || value === undefined || value === '') {
+            return true;
+        }
+        const hexColorRegex = /^#?([a-fA-F0-9]{6}|[a-fA-F0-9]{3})$/;
+        return hexColorRegex.test(String(value));
+    }
+    /**
+     * Check if string contains only lowercase characters
+     */
+    static isLowercase(value) {
+        if (value === null || value === undefined || value === '') {
+            return true;
+        }
+        return String(value) === String(value).toLowerCase();
+    }
+    /**
+     * Check if string contains only uppercase characters
+     */
+    static isUppercase(value) {
+        if (value === null || value === undefined || value === '') {
+            return true;
+        }
+        return String(value) === String(value).toUpperCase();
+    }
+}
+exports.Validator = Validator;
+// ==================== Validate Function ====================
+/**
+ * Validator method map for dynamic method lookup
+ */
+const validatorMethods = {
+    isEmail: Validator.isEmail,
+    isUrl: Validator.isUrl,
+    isIP: Validator.isIP,
+    isAlpha: Validator.isAlpha,
+    isAlphanumeric: Validator.isAlphanumeric,
+    isNumeric: Validator.isNumeric,
+    isInt: Validator.isInt,
+    isFloat: Validator.isFloat,
+    isDecimal: Validator.isDecimal,
+    isBoolean: Validator.isBoolean,
+    isDate: Validator.isDate,
+    isTime: Validator.isTime,
+    isDateString: Validator.isDateString,
+    isUUID: Validator.isUUID,
+    isJSON: Validator.isJSON,
+    isEmpty: Validator.isEmpty,
+    notEmpty: Validator.notEmpty,
+    isIn: (value, ...args) => Validator.isIn(value, args),
+    notIn: (value, ...args) => Validator.notIn(value, args),
+    isUnique: (value, ...args) => Validator.isUnique(value, args[0]),
+    equals: Validator.equals,
+    notEquals: Validator.notEquals,
+    matches: (value, ...args) => Validator.matches(value, args[0]),
+    notMatches: (value, ...args) => Validator.notMatches(value, args[0]),
+    isCreditCard: Validator.isCreditCard,
+    isPostalCode: (value, ...args) => Validator.isPostalCode(value, args[0]),
+    isMobilePhone: (value, ...args) => Validator.isMobilePhone(value, args[0]),
+    isHexColor: Validator.isHexColor,
+    isLowercase: Validator.isLowercase,
+    isUppercase: Validator.isUppercase,
+};
+/**
+ * Get error message for a validation rule
+ */
+function getErrorMessage(rule, field, ruleValue, customMessage) {
+    if (customMessage) {
+        return customMessage;
+    }
+    const messages = {
+        isEmail: 'Invalid email address',
+        isUrl: 'Invalid URL',
+        isIP: 'Invalid IP address',
+        isAlpha: 'Must contain only letters',
+        isAlphanumeric: 'Must contain only letters and numbers',
+        isNumeric: 'Must contain only numbers',
+        isInt: 'Must be an integer',
+        isFloat: 'Must be a number',
+        isDecimal: 'Must be a decimal number',
+        isBoolean: 'Must be a boolean',
+        isDate: 'Invalid date',
+        isTime: 'Invalid time format',
+        isDateString: 'Invalid date string',
+        isUUID: 'Invalid UUID',
+        isJSON: 'Invalid JSON',
+        isEmpty: 'Cannot be empty',
+        notEmpty: 'Cannot be empty',
+        isIn: `Must be one of: ${Array.isArray(ruleValue) ? ruleValue.join(', ') : ruleValue}`,
+        notIn: `Must not be one of: ${Array.isArray(ruleValue) ? ruleValue.join(', ') : ruleValue}`,
+        isUnique: 'Value must be unique',
+        equals: `Must equal ${ruleValue}`,
+        notEquals: `Must not equal ${ruleValue}`,
+        matches: 'Does not match required pattern',
+        notMatches: 'Must not match the pattern',
+        len: `Length must be ${Array.isArray(ruleValue) ? `${ruleValue[0]}-${ruleValue[1]}` : ruleValue}`,
+        min: `Must be at least ${ruleValue}`,
+        max: `Must be at most ${ruleValue}`,
+        range: `Must be between ${Array.isArray(ruleValue) ? ruleValue.join(' and ') : ruleValue}`,
+        isCreditCard: 'Invalid credit card number',
+        isPostalCode: 'Invalid postal code',
+        isMobilePhone: 'Invalid phone number',
+        isHexColor: 'Invalid hex color',
+        isLowercase: 'Must be lowercase',
+        isUppercase: 'Must be uppercase',
+    };
+    return messages[rule] || `Validation failed for ${field}`;
+}
+/**
+ * Evaluate every synchronous rule except `isUnique` (which needs an async
+ * database query - see `Validator.isUniqueAsync`). Shared by `validate`,
+ * `validateField`, `validateAsync`, and `validateFieldAsync` so the rule
+ * dispatch logic only lives in one place.
+ */
+function evaluateSyncRule(rule, value, ruleValue) {
+    switch (rule) {
+        case 'len':
+            return Validator.len(value, ruleValue);
+        case 'min':
+            return Validator.min(value, ruleValue);
+        case 'max':
+            return Validator.max(value, ruleValue);
+        case 'range':
+            return Validator.range(value, ruleValue);
+        case 'isIn':
+            return Array.isArray(ruleValue) ? Validator.isIn(value, ruleValue) : true;
+        case 'notIn':
+            return Array.isArray(ruleValue) ? Validator.notIn(value, ruleValue) : true;
+        case 'equals':
+            return Validator.equals(value, ruleValue);
+        case 'notEquals':
+            return Validator.notEquals(value, ruleValue);
+        case 'matches':
+            return Validator.matches(value, ruleValue);
+        case 'notMatches':
+            return Validator.notMatches(value, ruleValue);
+        case 'isUnique':
+            // Synchronous fallback only - always passes. Use validateAsync /
+            // validateFieldAsync for a real database uniqueness check.
+            return Validator.isUnique(value, ruleValue);
+        default: {
+            const method = validatorMethods[rule];
+            return method ? method(value) : true;
+        }
+    }
+}
+function shouldSkipRule(ruleValue) {
+    return ruleValue === false;
+}
+function getCustomMessage(rule, ruleValue) {
+    if (typeof ruleValue === 'string' && rule !== 'isIn' && rule !== 'notIn') {
+        return ruleValue;
+    }
+    return undefined;
+}
+/**
+ * Run all validators on data and return validation result
+ * @param data - The data object to validate
+ * @param validators - The validator configuration
+ * @returns Validation result with valid flag and errors array
+ */
+function validate(data, validators) {
+    const errors = [];
+    for (const [field, rules] of Object.entries(validators)) {
+        const value = data[field];
+        for (const [rule, ruleValue] of Object.entries(rules)) {
+            // Skip if ruleValue is false (validation disabled)
+            if (shouldSkipRule(ruleValue)) {
+                continue;
+            }
+            const isValid = evaluateSyncRule(rule, value, ruleValue);
+            if (!isValid) {
+                const customMessage = getCustomMessage(rule, ruleValue);
+                const message = getErrorMessage(rule, field, ruleValue, customMessage);
+                errors.push({
+                    message,
+                    type: 'Validation error',
+                    path: field,
+                    value: value,
+                });
+            }
+        }
+    }
+    return {
+        valid: errors.length === 0,
+        errors,
+    };
+}
+/**
+ * Validate a single field with given rules
+ */
+function validateField(value, rules) {
+    const errors = [];
+    for (const [rule, ruleValue] of Object.entries(rules)) {
+        if (shouldSkipRule(ruleValue)) {
+            continue;
+        }
+        const isValid = evaluateSyncRule(rule, value, ruleValue);
+        if (!isValid) {
+            const customMessage = getCustomMessage(rule, ruleValue);
+            const message = getErrorMessage(rule, 'value', ruleValue, customMessage);
+            errors.push({
+                message,
+                type: 'Validation error',
+                path: 'value',
+                value: value,
+            });
+        }
+    }
+    return {
+        valid: errors.length === 0,
+        errors,
+    };
+}
+/**
+ * Async counterpart to `validate()` that performs a real database
+ * uniqueness check for `isUnique` rules (via `Validator.isUniqueAsync`)
+ * instead of always passing.
+ *
+ * @param data - The data object to validate
+ * @param validators - The validator configuration
+ * @param context - Optional async context, e.g. `{ exclude: { id: 5 } }`
+ *   to exclude the current record from the uniqueness lookup on update.
+ */
+async function validateAsync(data, validators, context) {
+    const errors = [];
+    for (const [field, rules] of Object.entries(validators)) {
+        const value = data[field];
+        for (const [rule, ruleValue] of Object.entries(rules)) {
+            if (shouldSkipRule(ruleValue)) {
+                continue;
+            }
+            let isValid;
+            if (rule === 'isUnique') {
+                const opts = (typeof ruleValue === 'object' && ruleValue !== null && !Array.isArray(ruleValue)
+                    ? ruleValue
+                    : {});
+                isValid = await Validator.isUniqueAsync(value, {
+                    model: opts.model,
+                    field: opts.field ?? field,
+                    where: opts.where,
+                    exclude: context?.exclude,
+                });
+            }
+            else {
+                isValid = evaluateSyncRule(rule, value, ruleValue);
+            }
+            if (!isValid) {
+                const customMessage = getCustomMessage(rule, ruleValue);
+                const message = getErrorMessage(rule, field, ruleValue, customMessage);
+                errors.push({
+                    message,
+                    type: 'Validation error',
+                    path: field,
+                    value: value,
+                });
+            }
+        }
+    }
+    return {
+        valid: errors.length === 0,
+        errors,
+    };
+}
+/**
+ * Async counterpart to `validateField()` - see `validateAsync`.
+ */
+async function validateFieldAsync(value, rules, context) {
+    const errors = [];
+    for (const [rule, ruleValue] of Object.entries(rules)) {
+        if (shouldSkipRule(ruleValue)) {
+            continue;
+        }
+        let isValid;
+        if (rule === 'isUnique') {
+            const opts = (typeof ruleValue === 'object' && ruleValue !== null && !Array.isArray(ruleValue)
+                ? ruleValue
+                : {});
+            isValid = await Validator.isUniqueAsync(value, {
+                model: opts.model,
+                field: opts.field ?? context?.field,
+                where: opts.where,
+                exclude: context?.exclude,
+            });
+        }
+        else {
+            isValid = evaluateSyncRule(rule, value, ruleValue);
+        }
+        if (!isValid) {
+            const customMessage = getCustomMessage(rule, ruleValue);
+            const message = getErrorMessage(rule, 'value', ruleValue, customMessage);
+            errors.push({
+                message,
+                type: 'Validation error',
+                path: 'value',
+                value: value,
+            });
+        }
+    }
+    return {
+        valid: errors.length === 0,
+        errors,
+    };
+}
+/**
+ * Create a ValidationError from validation result
+ */
+function createValidationError(result) {
+    const error = new ValidationError(result.errors.length > 0 ? result.errors[0].message : 'Validation error', result.errors);
+    return error;
+}
+// ==================== DataType Integration ====================
+/**
+ * Get validation rules based on DataType
+ * Useful for automatic validation based on column type
+ */
+function getValidatorsForDataType(dataType) {
+    const validators = {};
+    switch (dataType.toUpperCase()) {
+        case 'INTEGER':
+        case 'BIGINT':
+            validators.isInt = true;
+            break;
+        case 'FLOAT':
+        case 'DOUBLE':
+        case 'DECIMAL':
+            validators.isFloat = true;
+            break;
+        case 'BOOLEAN':
+            validators.isBoolean = true;
+            break;
+        case 'DATE':
+        case 'DATETIME':
+            validators.isDate = true;
+            break;
+        case 'DATEONLY':
+            validators.isDateString = true;
+            break;
+        case 'TIME':
+            validators.isTime = true;
+            break;
+        case 'UUID':
+        case 'UUIDV4':
+            validators.isUUID = true;
+            break;
+        case 'JSON':
+        case 'JSONB':
+            validators.isJSON = true;
+            break;
+        case 'TEXT':
+        case 'VARCHAR':
+        case 'CHAR':
+        case 'STRING':
+            // No specific validators for string types
+            break;
+    }
+    return validators;
+}
+exports.default = {
+    Validator,
+    ValidationError,
+    validate,
+    validateField,
+    createValidationError,
+    getValidatorsForDataType,
+};