@easyflow/javascript-sdk 2.1.8 → 2.1.9

package/libs/validator.mjs

@@ -1,952 +0,0 @@
-import { EasyflowError, ERROR_CODES, ValidationError } from './errors.mjs'
-import { PAYMENT_METHODS } from './constants.mjs'
-import { throwsError } from './exception-handler.mjs'
-import { SECURITY_CONFIG } from './security.mjs'
-
-/**
- * Validation utilities for Easyflow SDK
- */
-export class Validator {
-    /**
-     * Validates if a value is a non-empty string
-     * @param {*} value - Value to validate
-     * @param {string} fieldName - Field name for error message
-     * @returns {boolean} True if valid
-     * @throws {EasyflowError} If validation fails
-     */
-    static isString(value, fieldName) {
-        if (!value || typeof value !== 'string') {
-            throwsError(
-                new EasyflowError(
-                    `${fieldName} must be a non-empty string`,
-                    400,
-                    ERROR_CODES.VALIDATION_ERROR
-                )
-            )
-        }
-        return true
-    }
-
-    /**
-     * Validates if a value is a valid object
-     * @param {*} value - Value to validate
-     * @param {string} fieldName - Field name for error message
-     * @returns {boolean} True if valid
-     * @throws {EasyflowError} If validation fails
-     */
-    static isObject(value, fieldName) {
-        if (!value || typeof value !== 'object' || Array.isArray(value)) {
-            throwsError(
-                new EasyflowError(
-                    `${fieldName} must be a valid object`,
-                    400,
-                    ERROR_CODES.VALIDATION_ERROR
-                )
-            )
-        }
-        return true
-    }
-
-    /**
-     * Validates if a value is a non-empty array
-     * @param {*} value - Value to validate
-     * @param {string} fieldName - Field name for error message
-     * @returns {boolean} True if valid
-     * @throws {EasyflowError} If validation fails
-     */
-    static isArray(value, fieldName) {
-        if (!Array.isArray(value) || value.length === 0) {
-            throwsError(
-                new EasyflowError(
-                    `${fieldName} must be a non-empty array`,
-                    400,
-                    ERROR_CODES.VALIDATION_ERROR
-                )
-            )
-        }
-        return true
-    }
-
-    /**
-     * Validates a payment method object
-     * @param {Object} payment - Payment method to validate
-     * @throws {EasyflowError} If validation fails
-     */
-    static validatePaymentMethod(payment) {
-        Validator.isObject(payment, 'payment')
-        Validator.isString(payment.method, 'payment.method')
-        if (!Object.values(PAYMENT_METHODS).includes(payment.method)) {
-            throwsError(
-                new EasyflowError(
-                    `Invalid payment method: ${payment.method}`,
-                    400,
-                    ERROR_CODES.INVALID_PAYMENT_METHOD
-                )
-            )
-        }
-
-        switch (payment.method) {
-            case PAYMENT_METHODS.CREDIT_CARD:
-                if (!payment.creditCard) {
-                    throwsError(
-                        new EasyflowError(
-                            'Credit card data is required for credit-card payment method',
-                            400,
-                            ERROR_CODES.MISSING_CREDIT_CARD_DATA
-                        )
-                    )
-                    Validator.validateCreditCardData(payment.creditCard)
-                }
-                break
-            case PAYMENT_METHODS.PIX:
-                break
-            case PAYMENT_METHODS.BANK_BILLET:
-                break
-        }
-    }
-
-    /**
-     * Validates credit card data
-     * @param {Object} creditCard - Credit card data to validate
-     * @throws {EasyflowError} If validation fails
-     */
-    static validateCreditCardData(creditCard) {
-        Validator.isObject(creditCard, 'creditCard')
-        const requiredFields = [
-            'cardNumber',
-            'holderName',
-            'month',
-            'year',
-            'cvv',
-        ]
-        requiredFields.forEach((field) => {
-            Validator.isString(creditCard[field], `creditCard.${field}`)
-        })
-        if (!/^\d{13,19}$/.test(creditCard.cardNumber))
-            throw new ValidationError('Invalid card number')
-
-        if (!/^\d{3,4}$/.test(creditCard.cvv))
-            throw new ValidationError('Invalid CVV')
-        if (
-            !/^\d{1,2}$/.test(creditCard.month) ||
-            parseInt(creditCard.month) < 1 ||
-            parseInt(creditCard.month) > 12
-        )
-            throw new ValidationError('Invalid expiration month')
-        if (!/^\d{4}$/.test(creditCard.year))
-            throw new ValidationError('Invalid expiration year')
-        if (!creditCard.holderName || creditCard.holderName.length < 2)
-            throw new ValidationError('Invalid holder name')
-    }
-
-    /**
-     * Validates order data
-     * @param {Object} data - Order data to validate
-     * @throws {EasyflowError} If validation fails
-     */
-    static validateOrderData(data) {
-        Validator.isObject(data, 'data')
-        Validator.isArray(data.payments, 'data.payments')
-        data.payments.forEach((payment, index) => {
-            try {
-                Validator.validatePaymentMethod(payment)
-                Validator.isBiggerThanZero(
-                    payment.numberInstallments,
-                    'numberInstallments'
-                )
-            } catch (error) {
-                throwsError(
-                    new EasyflowError(
-                        `Invalid payment at index ${index}: ${error.message}`,
-                        error.status,
-                        error.code
-                    )
-                )
-            }
-        })
-    }
-
-    /**
-     * Validates if value is a valid number
-     * @param {Number} value - Number value to validate
-     * @param {String} fieldName - Field name for error message
-     * @throws {EasyflowError} If validation fails
-     */
-    static isNumber(value, fieldName) {
-        if (typeof value !== 'number' || isNaN(value)) {
-            throwsError(
-                new EasyflowError(
-                    `${fieldName} must be a valid number`,
-                    400,
-                    ERROR_CODES.VALIDATION_ERROR
-                )
-            )
-        }
-        return true
-    }
-
-    /**
-     * Validates if a number is greater than zero
-     * @param {Number} value - Number value to validate
-     * @param {String} fieldName - Field name for error message
-     * @throws {EasyflowError} If validation fails
-     */
-    static isBiggerThanZero(value, fieldName) {
-        if (!Validator.isNumber(value, fieldName) || value <= 0) {
-            throwsError(
-                new EasyflowError(
-                    `${fieldName} must be a number greater than zero`,
-                    400,
-                    ERROR_CODES.VALIDATION_ERROR
-                )
-            )
-        }
-        return true
-    }
-
-    /**
-     * Validates a URL
-     * @param url - URL to validate
-     * @returns {string} Validated URL
-     * @throws {ValidationError} If validation fails
-     */
-    static validateUrl(url) {
-        try {
-            const parsed = new URL(url)
-            if (!SECURITY_CONFIG.ALLOWED_DOMAINS.includes(parsed.hostname))
-                throwsError(new ValidationError('Invalid domain'))
-            if (parsed.protocol !== 'https:')
-                throwsError(new ValidationError('HTTPS required'))
-            return parsed.toString()
-        } catch (error) {
-            throwsError(new ValidationError('Invalid URL'))
-        }
-    }
-
-    /**
-     * Validates charge items data
-     * @param {Object} items - Charge Items Data to validate
-     * @throws {EasyflowError} If validation fails
-     */
-    static validateChargeItemsData(items) {
-        Validator.isArray(items, 'items')
-        items.forEach((record, index) => {
-            try {
-                Validator.isObject(record, `items[${index}]`)
-                if (record.name) Validator.isString(record.name, 'name')
-                if (record.description)
-                    Validator.isString(record.description, 'description')
-                if (record.quantity)
-                    Validator.isBiggerThanZero(record.quantity, 'quantity')
-                if (record.priceInCents)
-                    Validator.isNumber(record.priceInCents, 'priceInCents')
-            } catch (error) {
-                throwsError(
-                    new EasyflowError(
-                        `Invalid items at index ${index}: ${error.message}`,
-                        error.status,
-                        error.code
-                    )
-                )
-            }
-        })
-    }
-
-    /**
-     * Validates email format
-     * @param {string} email - Email to validate
-     * @param {string} fieldName - Field name for error message
-     * @returns {boolean} True if valid
-     * @throws {EasyflowError} If validation fails
-     */
-    static validateEmail(email, fieldName = 'email') {
-        Validator.isString(email, fieldName)
-        const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/
-        if (!emailRegex.test(email)) {
-            throwsError(
-                new EasyflowError(
-                    `${fieldName} must be a valid email address`,
-                    400,
-                    ERROR_CODES.VALIDATION_ERROR
-                )
-            )
-        }
-
-        if (email.length > 254) {
-            throwsError(
-                new EasyflowError(
-                    `${fieldName} is too long (max 254 characters)`,
-                    400,
-                    ERROR_CODES.VALIDATION_ERROR
-                )
-            )
-        }
-
-        if (
-            email.includes('..') ||
-            email.startsWith('.') ||
-            email.endsWith('.')
-        ) {
-            throwsError(
-                new EasyflowError(
-                    `${fieldName} contains invalid characters`,
-                    400,
-                    ERROR_CODES.VALIDATION_ERROR
-                )
-            )
-        }
-
-        return true
-    }
-
-    /**
-     * Validates CPF (Brazilian individual taxpayer number)
-     * @param {string} cpf - CPF to validate
-     * @param {string} fieldName - Field name for error message
-     * @returns {boolean} True if valid
-     * @throws {EasyflowError} If validation fails
-     */
-    static validateCPF(cpf, fieldName = 'CPF') {
-        Validator.isString(cpf, fieldName)
-
-        const cleanCpf = cpf.replace(/\D/g, '')
-
-        if (cleanCpf.length !== 11) {
-            throwsError(
-                new EasyflowError(
-                    `${fieldName} must have exactly 11 digits`,
-                    400,
-                    ERROR_CODES.VALIDATION_ERROR
-                )
-            )
-        }
-
-        if (/^(\d)\1{10}$/.test(cleanCpf)) {
-            throwsError(
-                new EasyflowError(
-                    `${fieldName} is invalid (all digits are the same)`,
-                    400,
-                    ERROR_CODES.VALIDATION_ERROR
-                )
-            )
-        }
-
-        let sum = 0
-        for (let i = 0; i < 9; i++) {
-            sum += parseInt(cleanCpf.charAt(i)) * (10 - i)
-        }
-        let remainder = (sum * 10) % 11
-        if (remainder === 10 || remainder === 11) remainder = 0
-        if (remainder !== parseInt(cleanCpf.charAt(9))) {
-            throwsError(
-                new EasyflowError(
-                    `${fieldName} is invalid`,
-                    400,
-                    ERROR_CODES.VALIDATION_ERROR
-                )
-            )
-        }
-
-        sum = 0
-        for (let i = 0; i < 10; i++) {
-            sum += parseInt(cleanCpf.charAt(i)) * (11 - i)
-        }
-        remainder = (sum * 10) % 11
-        if (remainder === 10 || remainder === 11) remainder = 0
-        if (remainder !== parseInt(cleanCpf.charAt(10))) {
-            throwsError(
-                new EasyflowError(
-                    `${fieldName} is invalid`,
-                    400,
-                    ERROR_CODES.VALIDATION_ERROR
-                )
-            )
-        }
-
-        return true
-    }
-
-    /**
-     * Validates CNPJ (Brazilian company taxpayer number)
-     * @param {string} cnpj - CNPJ to validate
-     * @param {string} fieldName - Field name for error message
-     * @returns {boolean} True if valid
-     * @throws {EasyflowError} If validation fails
-     */
-    static validateCNPJ(cnpj, fieldName = 'CNPJ') {
-        Validator.isString(cnpj, fieldName)
-
-        const cleanCnpj = cnpj.replace(/\D/g, '')
-
-        if (cleanCnpj.length !== 14) {
-            throwsError(
-                new EasyflowError(
-                    `${fieldName} must have exactly 14 digits`,
-                    400,
-                    ERROR_CODES.VALIDATION_ERROR
-                )
-            )
-        }
-
-        if (/^(\d)\1{13}$/.test(cleanCnpj)) {
-            throwsError(
-                new EasyflowError(
-                    `${fieldName} is invalid (all digits are the same)`,
-                    400,
-                    ERROR_CODES.VALIDATION_ERROR
-                )
-            )
-        }
-
-        const weights1 = [5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2]
-        const weights2 = [6, 5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2]
-
-        let sum = 0
-        for (let i = 0; i < 12; i++) {
-            sum += parseInt(cleanCnpj.charAt(i)) * weights1[i]
-        }
-        let remainder = sum % 11
-        let digit1 = remainder < 2 ? 0 : 11 - remainder
-
-        if (digit1 !== parseInt(cleanCnpj.charAt(12))) {
-            throwsError(
-                new EasyflowError(
-                    `${fieldName} is invalid`,
-                    400,
-                    ERROR_CODES.VALIDATION_ERROR
-                )
-            )
-        }
-
-        sum = 0
-        for (let i = 0; i < 13; i++) {
-            sum += parseInt(cleanCnpj.charAt(i)) * weights2[i]
-        }
-        remainder = sum % 11
-        let digit2 = remainder < 2 ? 0 : 11 - remainder
-
-        if (digit2 !== parseInt(cleanCnpj.charAt(13))) {
-            throwsError(
-                new EasyflowError(
-                    `${fieldName} is invalid`,
-                    400,
-                    ERROR_CODES.VALIDATION_ERROR
-                )
-            )
-        }
-
-        return true
-    }
-
-    /**
-     * Validates legal document (CPF or CNPJ)
-     * @param {Object} document - Document object to validate
-     * @param {string} fieldName - Field name for error message
-     * @returns {boolean} True if valid
-     * @throws {EasyflowError} If validation fails
-     */
-    static validateLegalDocument(document, fieldName = 'document') {
-        Validator.isObject(document, fieldName)
-        Validator.isString(document.type, `${fieldName}.type`)
-        Validator.isString(document.number, `${fieldName}.number`)
-
-        if (!['CPF', 'CNPJ'].includes(document.type)) {
-            throwsError(
-                new EasyflowError(
-                    `${fieldName}.type must be either 'CPF' or 'CNPJ'`,
-                    400,
-                    ERROR_CODES.VALIDATION_ERROR
-                )
-            )
-        }
-
-        if (!/^\d+$/.test(document.number)) {
-            throwsError(
-                new EasyflowError(
-                    `${fieldName}.number must contain only digits`,
-                    400,
-                    ERROR_CODES.VALIDATION_ERROR
-                )
-            )
-        }
-
-        if (document.type === 'CPF') {
-            Validator.validateCPF(document.number, `${fieldName}.number`)
-        } else {
-            Validator.validateCNPJ(document.number, `${fieldName}.number`)
-        }
-
-        return true
-    }
-
-    /**
-     * Validates phone number
-     * @param {Object} phone - Phone object to validate
-     * @param {string} fieldName - Field name for error message
-     * @returns {boolean} True if valid
-     * @throws {EasyflowError} If validation fails
-     */
-    static validatePhone(phone, fieldName = 'phone') {
-        Validator.isObject(phone, fieldName)
-        Validator.isString(phone.areaCode, `${fieldName}.areaCode`)
-        Validator.isString(phone.ddd, `${fieldName}.ddd`)
-        Validator.isString(phone.number, `${fieldName}.number`)
-
-        if (!/^\+\d{1,4}$/.test(phone.areaCode)) {
-            throwsError(
-                new EasyflowError(
-                    `${fieldName}.areaCode must be in format +XX or +XXX`,
-                    400,
-                    ERROR_CODES.VALIDATION_ERROR
-                )
-            )
-        }
-
-        if (!/^\d{2}$/.test(phone.ddd)) {
-            throwsError(
-                new EasyflowError(
-                    `${fieldName}.ddd must be exactly 2 digits`,
-                    400,
-                    ERROR_CODES.VALIDATION_ERROR
-                )
-            )
-        }
-
-        if (!/^\d{8,9}$/.test(phone.number)) {
-            throwsError(
-                new EasyflowError(
-                    `${fieldName}.number must be 8 or 9 digits`,
-                    400,
-                    ERROR_CODES.VALIDATION_ERROR
-                )
-            )
-        }
-
-        if (typeof phone.isMobile !== 'boolean') {
-            throwsError(
-                new EasyflowError(
-                    `${fieldName}.isMobile must be a boolean`,
-                    400,
-                    ERROR_CODES.VALIDATION_ERROR
-                )
-            )
-        }
-
-        return true
-    }
-
-    /**
-     * Validates address
-     * @param {Object} address - Address object to validate
-     * @param {string} fieldName - Field name for error message
-     * @returns {boolean} True if valid
-     * @throws {EasyflowError} If validation fails
-     */
-    static validateAddress(address, fieldName = 'address') {
-        Validator.isObject(address, fieldName)
-
-        const requiredFields = [
-            'zipCode',
-            'street',
-            'neighborhood',
-            'city',
-            'state',
-            'number',
-        ]
-        requiredFields.forEach((field) => {
-            Validator.isString(address[field], `${fieldName}.${field}`)
-        })
-
-        if (address.complement) {
-            Validator.isString(address.complement, `${fieldName}.complement`)
-        }
-
-        if (!/^\d{8}$/.test(address.zipCode)) {
-            throwsError(
-                new EasyflowError(
-                    `${fieldName}.zipCode must be exactly 8 digits`,
-                    400,
-                    ERROR_CODES.VALIDATION_ERROR
-                )
-            )
-        }
-
-        if (address.street.length < 3 || address.street.length > 100) {
-            throwsError(
-                new EasyflowError(
-                    `${fieldName}.street must be between 3 and 100 characters`,
-                    400,
-                    ERROR_CODES.VALIDATION_ERROR
-                )
-            )
-        }
-
-        if (
-            address.neighborhood.length < 2 ||
-            address.neighborhood.length > 50
-        ) {
-            throwsError(
-                new EasyflowError(
-                    `${fieldName}.neighborhood must be between 2 and 50 characters`,
-                    400,
-                    ERROR_CODES.VALIDATION_ERROR
-                )
-            )
-        }
-
-        if (address.city.length < 2 || address.city.length > 50) {
-            throwsError(
-                new EasyflowError(
-                    `${fieldName}.city must be between 2 and 50 characters`,
-                    400,
-                    ERROR_CODES.VALIDATION_ERROR
-                )
-            )
-        }
-
-        const validStates = [
-            'AC',
-            'AL',
-            'AP',
-            'AM',
-            'BA',
-            'CE',
-            'DF',
-            'ES',
-            'GO',
-            'MA',
-            'MT',
-            'MS',
-            'MG',
-            'PA',
-            'PB',
-            'PR',
-            'PE',
-            'PI',
-            'RJ',
-            'RN',
-            'RS',
-            'RO',
-            'RR',
-            'SC',
-            'SP',
-            'SE',
-            'TO',
-        ]
-        if (!validStates.includes(address.state.toUpperCase())) {
-            throwsError(
-                new EasyflowError(
-                    `${fieldName}.state must be a valid Brazilian state abbreviation`,
-                    400,
-                    ERROR_CODES.VALIDATION_ERROR
-                )
-            )
-        }
-
-        if (!/^\d+[A-Za-z]?$/.test(address.number)) {
-            throwsError(
-                new EasyflowError(
-                    `${fieldName}.number must be a valid street number`,
-                    400,
-                    ERROR_CODES.VALIDATION_ERROR
-                )
-            )
-        }
-
-        return true
-    }
-
-    /**
-     * Validates customer data
-     * @param {Object} customer - Customer object to validate
-     * @param {string} fieldName - Field name for error message
-     * @returns {boolean} True if valid
-     * @throws {EasyflowError} If validation fails
-     */
-    static validateCustomer(customer, fieldName = 'customer') {
-        Validator.isObject(customer, fieldName)
-        Validator.isString(customer.name, `${fieldName}.name`)
-        Validator.validateEmail(customer.email, `${fieldName}.email`)
-        Validator.validateLegalDocument(
-            customer.document,
-            `${fieldName}.document`
-        )
-        Validator.validatePhone(customer.phone, `${fieldName}.phone`)
-
-        if (customer.name.length < 2 || customer.name.length > 100) {
-            throwsError(
-                new EasyflowError(
-                    `${fieldName}.name must be between 2 and 100 characters`,
-                    400,
-                    ERROR_CODES.VALIDATION_ERROR
-                )
-            )
-        }
-
-        if (customer.address) {
-            Validator.validateAddress(customer.address, `${fieldName}.address`)
-        }
-
-        if (customer.deliveryAddress) {
-            Validator.validateAddress(
-                customer.deliveryAddress,
-                `${fieldName}.deliveryAddress`
-            )
-        }
-
-        return true
-    }
-
-    /**
-     * Validates pagination parameters
-     * @param {number} page - Page number
-     * @param {number} limit - Items per page
-     * @param {string} fieldName - Field name for error message
-     * @returns {boolean} True if valid
-     * @throws {EasyflowError} If validation fails
-     */
-    static validatePagination(page, limit, fieldName = 'pagination') {
-        Validator.isNumber(page, `${fieldName}.page`)
-        Validator.isNumber(limit, `${fieldName}.limit`)
-
-        if (page < 1) {
-            throwsError(
-                new EasyflowError(
-                    `${fieldName}.page must be greater than 0`,
-                    400,
-                    ERROR_CODES.VALIDATION_ERROR
-                )
-            )
-        }
-
-        if (limit < 1 || limit > 100) {
-            throwsError(
-                new EasyflowError(
-                    `${fieldName}.limit must be between 1 and 100`,
-                    400,
-                    ERROR_CODES.VALIDATION_ERROR
-                )
-            )
-        }
-
-        return true
-    }
-
-    /**
-     * Validates business ID format
-     * @param {string} businessId - Business ID to validate
-     * @param {string} fieldName - Field name for error message
-     * @returns {boolean} True if valid
-     * @throws {EasyflowError} If validation fails
-     */
-    static validateBusinessId(businessId, fieldName = 'businessId') {
-        Validator.isString(businessId, fieldName)
-
-        if (!/^[a-zA-Z0-9-]{3,50}$/.test(businessId)) {
-            throwsError(
-                new EasyflowError(
-                    `${fieldName} must be 3-50 characters long and contain only letters, numbers, and hyphens`,
-                    400,
-                    ERROR_CODES.VALIDATION_ERROR
-                )
-            )
-        }
-
-        if (businessId.startsWith('-') || businessId.endsWith('-')) {
-            throwsError(
-                new EasyflowError(
-                    `${fieldName} cannot start or end with a hyphen`,
-                    400,
-                    ERROR_CODES.VALIDATION_ERROR
-                )
-            )
-        }
-
-        if (businessId.includes('--')) {
-            throwsError(
-                new EasyflowError(
-                    `${fieldName} cannot contain consecutive hyphens`,
-                    400,
-                    ERROR_CODES.VALIDATION_ERROR
-                )
-            )
-        }
-
-        return true
-    }
-
-    /**
-     * Validates credit card token
-     * @param {string} token - Credit card token to validate
-     * @param {string} fieldName - Field name for error message
-     * @returns {boolean} True if valid
-     * @throws {EasyflowError} If validation fails
-     */
-    static validateCreditCardToken(token, fieldName = 'creditCardToken') {
-        Validator.isString(token, fieldName)
-
-        if (!/^[a-zA-Z0-9_-]{32,128}$/.test(token)) {
-            throwsError(
-                new EasyflowError(
-                    `${fieldName} must be a valid secure token (32-128 characters, alphanumeric, underscore, hyphen)`,
-                    400,
-                    ERROR_CODES.VALIDATION_ERROR
-                )
-            )
-        }
-
-        return true
-    }
-
-    /**
-     * Validates order ID format (UUID v4, UUID v7, or MongoDB ObjectId)
-     * @param {string} orderId - Order ID to validate
-     * @param {string} fieldName - Field name for error message
-     * @returns {boolean} True if valid
-     * @throws {EasyflowError} If validation fails
-     */
-    static validateOrderId(orderId, fieldName = 'orderId') {
-        Validator.isString(orderId, fieldName)
-
-        // UUID v4: xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx (y = 8,9,A,B)
-        const uuidV4Pattern =
-            /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i
-
-        // UUID v7: xxxxxxxx-xxxx-7xxx-yxxx-xxxxxxxxxxxx (y = 8,9,A,B)
-        const uuidV7Pattern =
-            /^[0-9a-f]{8}-[0-9a-f]{4}-7[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i
-
-        // MongoDB ObjectId: 24 hex characters
-        const mongoIdPattern = /^[0-9a-f]{24}$/i
-
-        if (
-            uuidV4Pattern.test(orderId) ||
-            uuidV7Pattern.test(orderId) ||
-            mongoIdPattern.test(orderId)
-        ) {
-            return true
-        }
-
-        throwsError(
-            new EasyflowError(
-                `${fieldName} must be a valid UUID v4, UUID v7, or MongoDB ObjectId`,
-                400,
-                ERROR_CODES.VALIDATION_ERROR
-            )
-        )
-    }
-
-    /**
-     * Validates offer ID format (UUID v4, UUID v7, or MongoDB ObjectId)
-     * @param {string} offerId - Offer ID to validate
-     * @param {string} fieldName - Field name for error message
-     * @returns {boolean} True if valid
-     * @throws {EasyflowError} If validation fails
-     */
-    static validateOfferId(offerId, fieldName = 'offerId') {
-        Validator.isString(offerId, fieldName)
-
-        // UUID v4: xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx (y = 8,9,A,B)
-        const uuidV4Pattern =
-            /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i
-
-        // UUID v7: xxxxxxxx-xxxx-7xxx-yxxx-xxxxxxxxxxxx (y = 8,9,A,B)
-        const uuidV7Pattern =
-            /^[0-9a-f]{8}-[0-9a-f]{4}-7[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i
-
-        // MongoDB ObjectId: 24 hex characters
-        const mongoIdPattern = /^[0-9a-f]{24}$/i
-
-        if (
-            uuidV4Pattern.test(offerId) ||
-            uuidV7Pattern.test(offerId) ||
-            mongoIdPattern.test(offerId)
-        ) {
-            return true
-        }
-
-        throwsError(
-            new EasyflowError(
-                `${fieldName} must be a valid UUID v4, UUID v7, or MongoDB ObjectId`,
-                400,
-                ERROR_CODES.VALIDATION_ERROR
-            )
-        )
-    }
-
-    /**
-     * Validates customer ID format (UUID v4, UUID v7, or MongoDB ObjectId)
-     * @param {string} customerId - Customer ID to validate
-     * @param {string} fieldName - Field name for error message
-     * @returns {boolean} True if valid
-     * @throws {EasyflowError} If validation fails
-     */
-    static validateCustomerId(customerId, fieldName = 'customerId') {
-        Validator.isString(customerId, fieldName)
-
-        // UUID v4: xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx (y = 8,9,A,B)
-        const uuidV4Pattern =
-            /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i
-
-        // UUID v7: xxxxxxxx-xxxx-7xxx-yxxx-xxxxxxxxxxxx (y = 8,9,A,B)
-        const uuidV7Pattern =
-            /^[0-9a-f]{8}-[0-9a-f]{4}-7[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i
-
-        // MongoDB ObjectId: 24 hex characters
-        const mongoIdPattern = /^[0-9a-f]{24}$/i
-
-        if (
-            uuidV4Pattern.test(customerId) ||
-            uuidV7Pattern.test(customerId) ||
-            mongoIdPattern.test(customerId)
-        ) {
-            return true
-        }
-
-        throwsError(
-            new EasyflowError(
-                `${fieldName} must be a valid UUID v4, UUID v7, or MongoDB ObjectId`,
-                400,
-                ERROR_CODES.VALIDATION_ERROR
-            )
-        )
-    }
-
-    /**
-     * Validates credit card ID format (UUID v4, UUID v7, or MongoDB ObjectId)
-     * @param {string} creditCardId - Credit card ID to validate
-     * @param {string} fieldName - Field name for error message
-     * @returns {boolean} True if valid
-     * @throws {EasyflowError} If validation fails
-     */
-    static validateCreditCardId(creditCardId, fieldName = 'creditCardId') {
-        Validator.isString(creditCardId, fieldName)
-
-        // UUID v4: xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx (y = 8,9,A,B)
-        const uuidV4Pattern =
-            /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i
-
-        // UUID v7: xxxxxxxx-xxxx-7xxx-yxxx-xxxxxxxxxxxx (y = 8,9,A,B)
-        const uuidV7Pattern =
-            /^[0-9a-f]{8}-[0-9a-f]{4}-7[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i
-
-        // MongoDB ObjectId: 24 hex characters
-        const mongoIdPattern = /^[0-9a-f]{24}$/i
-
-        if (
-            uuidV4Pattern.test(creditCardId) ||
-            uuidV7Pattern.test(creditCardId) ||
-            mongoIdPattern.test(creditCardId)
-        ) {
-            return true
-        }
-
-        throwsError(
-            new EasyflowError(
-                `${fieldName} must be a valid UUID v4, UUID v7, or MongoDB ObjectId`,
-                400,
-                ERROR_CODES.VALIDATION_ERROR
-            )
-        )
-    }
-}