reliant-type 1.0.0

package/dist/cjs/core/schema/mode/interfaces/precompilation/FieldPrecompilers.js

@@ -0,0 +1,778 @@
+'use strict';
+
+require('../validators/TypeValidators.js');
+var ConstraintParser = require('../validators/ConstraintParser.js');
+var ValidationHelpers = require('../validators/ValidationHelpers.js');
+var ErrorHandler = require('../errors/ErrorHandler.js');
+var errors_type = require('../errors/types/errors.type.js');
+
+/**
+ * Field-Specific Precompilers
+ *
+ * Each field type gets its own specialized precompiler for maximum performance
+ */
+class FieldPrecompilers {
+    /**
+     *  Precompile union field validators
+     *
+     */
+    static precompileUnion(unionType) {
+        // Use the fixed union validation from ValidationHelpers
+        const validator = (value) => {
+            return ValidationHelpers.ValidationHelpers.validateUnionType(unionType, value);
+        };
+        validator._fieldType = unionType;
+        validator._isCompiled = true;
+        return validator;
+    }
+    /**
+     *  Precompile string field validators
+     */
+    static precompileString(constraints = {}) {
+        const { minLength, maxLength, pattern } = constraints;
+        // Pre-compile validation logic based on constraints
+        if (!minLength && !maxLength && !pattern) {
+            //  Simple string validation
+            const validator = (value) => {
+                if (typeof value === "string") {
+                    return {
+                        success: true,
+                        errors: [],
+                        warnings: [],
+                        data: value,
+                    };
+                }
+                return {
+                    success: false,
+                    errors: [ErrorHandler.ErrorHandler.createTypeError([], "string", value)],
+                    warnings: [],
+                    data: undefined,
+                };
+            };
+            validator._fieldType = "string";
+            validator._isCompiled = true;
+            return validator;
+        }
+        // OPTIMIZED: String with constraints
+        const validator = (value) => {
+            if (typeof value !== "string") {
+                return {
+                    success: false,
+                    errors: [ErrorHandler.ErrorHandler.createTypeError([], "string", value)],
+                    warnings: [],
+                    data: undefined,
+                };
+            }
+            const errors = [];
+            if (minLength !== undefined && value.length < minLength) {
+                errors.push({
+                    code: "STRING_TOO_SHORT",
+                    message: `String must be at least ${minLength} characters`,
+                    path: [],
+                    expected: `string(minLength: ${minLength})`,
+                    received: value,
+                    receivedType: "string",
+                });
+            }
+            if (maxLength !== undefined && value.length > maxLength) {
+                errors.push({
+                    code: "STRING_TOO_LONG",
+                    message: `String must be at most ${maxLength} characters`,
+                    path: [],
+                    expected: `string(maxLength: ${maxLength})`,
+                    received: value,
+                    receivedType: "string",
+                });
+            }
+            if (pattern && !pattern.test(value)) {
+                errors.push({
+                    code: "STRING_PATTERN_MISMATCH",
+                    message: `String does not match required pattern`,
+                    path: [],
+                    expected: `string(pattern: ${pattern})`,
+                    received: value,
+                    receivedType: "string",
+                });
+            }
+            if (errors.length > 0) {
+                return {
+                    success: false,
+                    errors,
+                    warnings: [],
+                    data: undefined,
+                };
+            }
+            return {
+                success: true,
+                errors: [],
+                warnings: [],
+                data: value,
+            };
+        };
+        validator._fieldType =
+            `string(${minLength || ""},${maxLength || ""})`;
+        validator._isCompiled = true;
+        return validator;
+    }
+    /**
+     *  Precompile float field validators (for float and double types)
+     */
+    static precompileFloat(constraints = {}) {
+        const { min, max } = constraints;
+        const validator = (value) => {
+            // DEBUG: Add logging to see what's happening
+            // console.log("🔍 precompileFloat validator executing:");
+            // console.log("  - value:", value, "type:", typeof value);
+            // console.log("  - constraints: min =", min, ", max =", max);
+            if (typeof value !== "number" || isNaN(value) || !isFinite(value)) {
+                // console.log("  - FAIL: not a valid number");
+                return {
+                    success: false,
+                    errors: [ErrorHandler.ErrorHandler.createTypeError([], "float", value)],
+                    warnings: [],
+                    data: undefined,
+                };
+            }
+            const errors = [];
+            if (min !== undefined && value < min) {
+                // console.log("  - FAIL: value", value, "< min", min);
+                errors.push({
+                    code: errors_type.ErrorCode.NUMBER_TOO_SMALL,
+                    message: `Float must be at least ${min}`,
+                    path: [],
+                    expected: `float(min: ${min})`,
+                    received: value,
+                    receivedType: "number",
+                });
+            }
+            if (max !== undefined && value > max) {
+                // console.log("  - FAIL: value", value, "> max", max);
+                errors.push({
+                    code: errors_type.ErrorCode.NUMBER_TOO_LARGE,
+                    message: `Float must be at most ${max}`,
+                    path: [],
+                    expected: `float(max: ${max})`,
+                    received: value,
+                    receivedType: "number",
+                });
+            }
+            if (errors.length > 0) {
+                // console.log("  - FINAL RESULT: FAIL with errors:", errors);
+                return {
+                    success: false,
+                    errors,
+                    warnings: [],
+                    data: undefined,
+                };
+            }
+            // console.log("  - FINAL RESULT: PASS");
+            return {
+                success: true,
+                errors: [],
+                warnings: [],
+                data: value,
+            };
+        };
+        validator._fieldType = `float(${min || ""},${max || ""})`;
+        validator._isCompiled = true;
+        return validator;
+    }
+    /**
+     *  Precompile positive number field validators
+     */
+    static precompilePositiveNumber(constraints = {}) {
+        const { min, max } = constraints;
+        const validator = (value) => {
+            if (typeof value !== "number" || isNaN(value) || !isFinite(value)) {
+                return {
+                    success: false,
+                    errors: [ErrorHandler.ErrorHandler.createTypeError([], "positive number", value)],
+                    warnings: [],
+                    data: undefined,
+                };
+            }
+            const errors = [];
+            // CRITICAL: Positive validation - must be > 0
+            if (value <= 0) {
+                errors.push({
+                    code: "NUMBER_NOT_POSITIVE",
+                    message: "Number must be positive",
+                    path: [],
+                    expected: "positive",
+                    received: value,
+                    receivedType: "number",
+                });
+            }
+            if (min !== undefined && value < min) {
+                errors.push({
+                    code: errors_type.ErrorCode.NUMBER_TOO_SMALL,
+                    message: `Number must be at least ${min}`,
+                    path: [],
+                    expected: `positive(min: ${min})`,
+                    received: value,
+                    receivedType: "number",
+                });
+            }
+            if (max !== undefined && value > max) {
+                errors.push({
+                    code: errors_type.ErrorCode.NUMBER_TOO_LARGE,
+                    message: `Number must be at most ${max}`,
+                    path: [],
+                    expected: `positive(max: ${max})`,
+                    received: value,
+                    receivedType: "number",
+                });
+            }
+            if (errors.length > 0) {
+                return {
+                    success: false,
+                    errors,
+                    warnings: [],
+                    data: undefined,
+                };
+            }
+            return {
+                success: true,
+                errors: [],
+                warnings: [],
+                data: value,
+            };
+        };
+        validator._fieldType = `positive(${min || ""},${max || ""})`;
+        validator._isCompiled = true;
+        return validator;
+    }
+    /**
+     *  Precompile negative number field validators
+     */
+    static precompileNegativeNumber(constraints = {}) {
+        const { min, max } = constraints;
+        const validator = (value) => {
+            if (typeof value !== "number" || isNaN(value) || !isFinite(value)) {
+                return {
+                    success: false,
+                    errors: [ErrorHandler.ErrorHandler.createTypeError([], "negative number", value)],
+                    warnings: [],
+                    data: undefined,
+                };
+            }
+            const errors = [];
+            // CRITICAL: Negative validation - must be < 0
+            if (value >= 0) {
+                errors.push({
+                    code: errors_type.ErrorCode.NOT_NEGATIVE,
+                    message: "Number must be negative",
+                    path: [],
+                    expected: "negative",
+                    received: value,
+                    receivedType: "number",
+                });
+            }
+            if (min !== undefined && value < min) {
+                errors.push({
+                    code: errors_type.ErrorCode.NUMBER_TOO_SMALL,
+                    message: `Number must be at least ${min}`,
+                    path: [],
+                    expected: `negative(min: ${min})`,
+                    received: value,
+                    receivedType: "number",
+                });
+            }
+            if (max !== undefined && value > max) {
+                errors.push({
+                    code: errors_type.ErrorCode.NUMBER_TOO_LARGE,
+                    message: `Number must be at most ${max}`,
+                    path: [],
+                    expected: `negative(max: ${max})`,
+                    received: value,
+                    receivedType: "number",
+                });
+            }
+            if (errors.length > 0) {
+                return {
+                    success: false,
+                    errors,
+                    warnings: [],
+                    data: undefined,
+                };
+            }
+            return {
+                success: true,
+                errors: [],
+                warnings: [],
+                data: value,
+            };
+        };
+        validator._fieldType = `negative(${min || ""},${max || ""})`;
+        validator._isCompiled = true;
+        return validator;
+    }
+    /**
+     *  Precompile number field validators
+     */
+    static precompileNumber(constraints = {}) {
+        const { min, max, integer, strictlyPositive, strictlyNegative } = constraints;
+        const validator = (value) => {
+            // DEBUG: Add logging to see if validator is being called
+            // // console.log("🔍 precompileNumber validator executing:");
+            // // console.log("  - value:", value, "type:", typeof value);
+            // // console.log(
+            //   "  - constraints: strictlyPositive =",
+            //   strictlyPositive,
+            //   ", strictlyNegative =",
+            //   strictlyNegative
+            // );
+            if (typeof value !== "number" || isNaN(value)) {
+                // // console.log("  - FAIL: not a number");
+                return {
+                    success: false,
+                    errors: [ErrorHandler.ErrorHandler.createTypeError([], "number", value)],
+                    warnings: [],
+                    data: undefined,
+                };
+            }
+            const errors = [];
+            if (integer && !Number.isInteger(value)) {
+                // // console.log("  - FAIL: not an integer");
+                errors.push({
+                    code: errors_type.ErrorCode.NOT_INTEGER,
+                    message: "Number must be an integer",
+                    path: [],
+                    expected: "integer",
+                    received: value,
+                    receivedType: "number",
+                });
+            }
+            // CRITICAL FIX: Handle strict positive/negative validation
+            if (strictlyPositive && value <= 0) {
+                // console.log("  - FAIL: not strictly positive (value <= 0)");
+                errors.push({
+                    code: errors_type.ErrorCode.NOT_POSITIVE,
+                    message: "Number must be positive",
+                    path: [],
+                    expected: "positive",
+                    received: value,
+                    receivedType: "number",
+                });
+            }
+            if (strictlyNegative && value >= 0) {
+                // console.log("  - FAIL: not strictly negative (value >= 0)");
+                errors.push({
+                    code: errors_type.ErrorCode.NOT_NEGATIVE,
+                    message: "Number must be negative",
+                    path: [],
+                    expected: "negative",
+                    received: value,
+                    receivedType: "number",
+                });
+            }
+            if (min !== undefined && value < min) {
+                // console.log("  - FAIL: value < min");
+                errors.push({
+                    code: errors_type.ErrorCode.NUMBER_TOO_SMALL,
+                    message: `Number must be at least ${min}`,
+                    path: [],
+                    expected: `number(min: ${min})`,
+                    received: value,
+                    receivedType: "number",
+                });
+            }
+            if (max !== undefined && value > max) {
+                // console.log("  - FAIL: value > max");
+                errors.push({
+                    code: errors_type.ErrorCode.NUMBER_TOO_LARGE,
+                    message: `Number must be at most ${max}`,
+                    path: [],
+                    expected: `number(max: ${max})`,
+                    received: value,
+                    receivedType: "number",
+                });
+            }
+            if (errors.length > 0) {
+                // console.log("  - FINAL RESULT: FAIL with errors:", errors);
+                return {
+                    success: false,
+                    errors,
+                    warnings: [],
+                    data: undefined,
+                };
+            }
+            // console.log("  - FINAL RESULT: PASS");
+            return {
+                success: true,
+                errors: [],
+                warnings: [],
+                data: value,
+            };
+        };
+        validator._fieldType = `number(${min || ""},${max || ""})`;
+        validator._isCompiled = true;
+        return validator;
+    }
+    /**
+     *  Precompile boolean field validators
+     */
+    static precompileBoolean() {
+        const validator = (value) => {
+            if (typeof value === "boolean") {
+                return {
+                    success: true,
+                    errors: [],
+                    warnings: [],
+                    data: value,
+                };
+            }
+            return {
+                success: false,
+                errors: [ErrorHandler.ErrorHandler.createTypeError([], "boolean", value)],
+                warnings: [],
+                data: undefined,
+            };
+        };
+        validator._fieldType = "boolean";
+        validator._isCompiled = true;
+        return validator;
+    }
+    /**
+     *  Precompile array field validators
+     */
+    static precompileArray(elementValidator, constraints = {}) {
+        const { minLength, maxLength, unique } = constraints;
+        const validator = (value) => {
+            if (!Array.isArray(value)) {
+                return {
+                    success: false,
+                    errors: [ErrorHandler.ErrorHandler.createTypeError([], "array", value)],
+                    warnings: [],
+                    data: undefined,
+                };
+            }
+            const errors = [];
+            if (minLength !== undefined && value.length < minLength) {
+                errors.push({
+                    code: errors_type.ErrorCode.ARRAY_TOO_SHORT,
+                    message: `Array must have at least ${minLength} elements`,
+                    path: [],
+                    expected: `array(minLength: ${minLength})`,
+                    received: value,
+                    receivedType: "array",
+                });
+            }
+            if (maxLength !== undefined && value.length > maxLength) {
+                errors.push({
+                    code: errors_type.ErrorCode.ARRAY_TOO_LONG,
+                    message: `Array must have at most ${maxLength} elements`,
+                    path: [],
+                    expected: `array(maxLength: ${maxLength})`,
+                    received: value,
+                    receivedType: "array",
+                });
+            }
+            // Validate each element
+            const validatedArray = [];
+            for (let i = 0; i < value.length; i++) {
+                const elementResult = elementValidator(value[i]);
+                if (!elementResult.success) {
+                    errors.push(...elementResult.errors.map((error) => ({
+                        ...error,
+                        path: [i.toString(), ...error.path],
+                    })));
+                }
+                else {
+                    validatedArray.push(elementResult.data);
+                }
+            }
+            // Check uniqueness if required
+            if (unique && validatedArray.length > 0) {
+                const uniqueValues = new Set(validatedArray.map((v) => JSON.stringify(v)));
+                if (uniqueValues.size !== validatedArray.length) {
+                    errors.push({
+                        code: errors_type.ErrorCode.ARRAY_VALUES_NOT_UNIQUE,
+                        message: "Array elements must be unique",
+                        path: [],
+                        expected: "unique",
+                        received: value,
+                        receivedType: "array",
+                    });
+                }
+            }
+            if (errors.length > 0) {
+                return {
+                    success: false,
+                    errors,
+                    warnings: [],
+                    data: undefined,
+                };
+            }
+            return {
+                success: true,
+                errors: [],
+                warnings: [],
+                data: validatedArray,
+            };
+        };
+        validator._fieldType = `${elementValidator._fieldType}[]`;
+        validator._isCompiled = true;
+        return validator;
+    }
+    /**
+     *  Precompile optional field validators
+     */
+    static precompileOptional(baseValidator, defaultValue) {
+        const validator = (value) => {
+            if (value === undefined) {
+                return {
+                    success: true,
+                    errors: [],
+                    warnings: [],
+                    data: defaultValue,
+                };
+            }
+            return baseValidator(value);
+        };
+        validator._fieldType = `${baseValidator._fieldType}?`;
+        validator._isCompiled = true;
+        return validator;
+    }
+    /**
+     *  Precompile constant field validators
+     */
+    static precompileConstant(constantValue) {
+        const stringValue = String(constantValue);
+        const validator = (value) => {
+            if (value === constantValue || String(value) === stringValue) {
+                return {
+                    success: true,
+                    errors: [],
+                    warnings: [],
+                    data: constantValue,
+                };
+            }
+            return {
+                success: false,
+                errors: [
+                    ErrorHandler.ErrorHandler.createConstantError([], "constant", value, constantValue),
+                ],
+                warnings: [],
+                data: undefined,
+            };
+        };
+        validator._fieldType = `=${constantValue}`;
+        validator._isCompiled = true;
+        return validator;
+    }
+    /**
+     * Precompile record field types (record<string, number>, Record<string, any>, etc.)
+     */
+    static precompileRecord(recordType) {
+        const validator = (value) => {
+            // Use ValidationHelpers.validateRecordType for proper record validation
+            return ValidationHelpers.ValidationHelpers.validateRecordType(recordType, value, (fieldType, value) => {
+                // Recursively validate nested field types using the same precompiler system
+                const nestedValidator = FieldPrecompilers.parseAndCompile(fieldType);
+                return nestedValidator(value);
+            });
+        };
+        validator._fieldType = recordType;
+        validator._isCompiled = true;
+        return validator;
+    }
+    /**
+     *  Precompile special field types (email, url, json, etc.)
+     */
+    static precompileSpecialType(type) {
+        const validator = (value) => {
+            // CRITICAL FIX: Parse constraints from the type string for proper validation
+            const parsed = ConstraintParser.ConstraintParser.parseConstraints(type);
+            // Use the imported ValidationHelpers with proper constraints
+            return ValidationHelpers.ValidationHelpers.routeTypeValidation(parsed.type, value, { ...parsed.constraints }, parsed.constraints);
+        };
+        validator._fieldType = type;
+        validator._isCompiled = true;
+        return validator;
+    }
+    /**
+     * Parse field type and create appropriate precompiled validator
+     */
+    static parseAndCompile(fieldType) {
+        // Handle optional fields
+        const isOptional = fieldType.endsWith("?");
+        const baseType = isOptional ? fieldType.slice(0, -1) : fieldType;
+        // Handle constants
+        if (baseType.startsWith("=")) {
+            const constantValue = baseType.slice(1);
+            const validator = this.precompileConstant(constantValue);
+            return isOptional ? this.precompileOptional(validator) : validator;
+        }
+        // Handle unions
+        if (baseType.includes("|")) {
+            const validator = this.precompileUnion(baseType);
+            return isOptional ? this.precompileOptional(validator) : validator;
+        }
+        // Handle arrays
+        if (baseType.endsWith("[]")) {
+            const elementType = baseType.slice(0, -2);
+            const elementValidator = this.parseAndCompile(elementType);
+            const validator = this.precompileArray(elementValidator);
+            return isOptional ? this.precompileOptional(validator) : validator;
+        }
+        // Handle record types (record<string, number>, Record<string, any>, etc.)
+        if ((baseType.startsWith("record<") && baseType.endsWith(">")) ||
+            (baseType.startsWith("Record<") && baseType.endsWith(">"))) {
+            const validator = this.precompileRecord(baseType);
+            return isOptional ? this.precompileOptional(validator) : validator;
+        }
+        // Handle basic types with constraints (including URL args like url.https)
+        const constraintMatch = baseType.match(/^([\w.]+)(?:\(([^)]*)\))?$/);
+        if (constraintMatch) {
+            const [, type, constraintsStr] = constraintMatch;
+            switch (type) {
+                case "string":
+                    const stringConstraints = this.parseStringConstraints(constraintsStr);
+                    const stringValidator = this.precompileString(stringConstraints);
+                    return isOptional
+                        ? this.precompileOptional(stringValidator)
+                        : stringValidator;
+                case "number":
+                case "int":
+                case "integer":
+                case "float":
+                    const numberConstraints = this.parseNumberConstraints(constraintsStr, type);
+                    const numberValidator = this.precompileNumber(numberConstraints);
+                    return isOptional
+                        ? this.precompileOptional(numberValidator)
+                        : numberValidator;
+                case "positive":
+                    // CRITICAL FIX: Handle positive numbers with proper validation
+                    const positiveConstraints = this.parseNumberConstraints(constraintsStr, type);
+                    const positiveValidator = this.precompilePositiveNumber(positiveConstraints);
+                    return isOptional
+                        ? this.precompileOptional(positiveValidator)
+                        : positiveValidator;
+                case "negative":
+                    // CRITICAL FIX: Handle negative numbers with proper validation
+                    const negativeConstraints = this.parseNumberConstraints(constraintsStr, type);
+                    const negativeValidator = this.precompileNegativeNumber(negativeConstraints);
+                    return isOptional
+                        ? this.precompileOptional(negativeValidator)
+                        : negativeValidator;
+                case "double":
+                    // CRITICAL FIX: Handle double with float constraints to match ValidationHelpers routing
+                    const doubleConstraints = this.parseNumberConstraints(constraintsStr, type);
+                    const doubleValidator = this.precompileFloat(doubleConstraints);
+                    return isOptional
+                        ? this.precompileOptional(doubleValidator)
+                        : doubleValidator;
+                case "boolean":
+                case "bool":
+                    const boolValidator = this.precompileBoolean();
+                    return isOptional
+                        ? this.precompileOptional(boolValidator)
+                        : boolValidator;
+                // Handle new field types by delegating to ValidationHelpers
+                case "json":
+                case "ip":
+                case "password":
+                case "text":
+                case "object":
+                case "url":
+                case "email":
+                case "uuid":
+                case "phone":
+                case "slug":
+                case "username":
+                case "hexcolor":
+                case "base64":
+                case "jwt":
+                case "semver":
+                case "date":
+                case "any":
+                    const specialValidator = this.precompileSpecialType(type);
+                    return isOptional
+                        ? this.precompileOptional(specialValidator)
+                        : specialValidator;
+                default:
+                    // Check if it's a URL arg (url.https, url.http, etc.)
+                    if (type.startsWith("url.")) {
+                        const urlArgValidator = this.precompileSpecialType(type);
+                        return isOptional
+                            ? this.precompileOptional(urlArgValidator)
+                            : urlArgValidator;
+                    }
+                    // Fallback for unknown types
+                    return this.createFallbackValidator(fieldType);
+            }
+        }
+        return this.createFallbackValidator(fieldType);
+    }
+    static parseStringConstraints(constraintsStr) {
+        if (!constraintsStr)
+            return {};
+        // CRITICAL FIX: Use ConstraintParser to properly handle regex patterns
+        const ConstraintParser = require("../validators/ConstraintParser").ConstraintParser;
+        try {
+            // Parse the full constraint string using the proper parser
+            const fullType = `string(${constraintsStr})`;
+            const parsed = ConstraintParser.parseConstraints(fullType);
+            // Extract the constraints we need
+            const constraints = {};
+            if (parsed.constraints.minLength !== undefined) {
+                constraints.minLength = parsed.constraints.minLength;
+            }
+            if (parsed.constraints.maxLength !== undefined) {
+                constraints.maxLength = parsed.constraints.maxLength;
+            }
+            if (parsed.constraints.pattern) {
+                constraints.pattern = parsed.constraints.pattern;
+            }
+            return constraints;
+        }
+        catch (error) {
+            // Fallback to simple parsing for backward compatibility
+            const parts = constraintsStr.split(",");
+            const constraints = {};
+            if (parts[0] && parts[0].trim()) {
+                constraints.minLength = parseInt(parts[0].trim());
+            }
+            if (parts[1] && parts[1].trim()) {
+                constraints.maxLength = parseInt(parts[1].trim());
+            }
+            return constraints;
+        }
+    }
+    static parseNumberConstraints(constraintsStr, type) {
+        const constraints = {};
+        if (type === "int" || type === "integer") {
+            constraints.integer = true;
+        }
+        // NOTE: positive and negative types are now handled by separate precompilers
+        // No need to set special constraints here
+        if (constraintsStr) {
+            const parts = constraintsStr.split(",");
+            if (parts[0] && parts[0].trim()) {
+                constraints.min = parseFloat(parts[0].trim());
+            }
+            if (parts[1] && parts[1].trim()) {
+                constraints.max = parseFloat(parts[1].trim());
+            }
+        }
+        return constraints;
+    }
+    static createFallbackValidator(fieldType) {
+        const validator = (value) => {
+            // Basic fallback validation
+            return {
+                success: true,
+                errors: [],
+                warnings: [`Fallback validation used for type: ${fieldType}`],
+                data: value,
+            };
+        };
+        validator._fieldType = fieldType;
+        validator._isCompiled = true;
+        return validator;
+    }
+}
+
+exports.FieldPrecompilers = FieldPrecompilers;
+//# sourceMappingURL=FieldPrecompilers.js.map