dymo-api 1.2.32 → 1.2.33

package/dist/esm/lib/resilience/fallback.js

@@ -1,423 +0,0 @@
-export class FallbackDataGenerator {
-    static generateFallbackData(method, inputData) {
-        switch (method) {
-            case "isValidData": return this.generateDataValidationAnalysis(inputData);
-            case "isValidEmail": return this.generateEmailValidatorResponse(inputData);
-            case "isValidIP": return this.generateIPValidatorResponse(inputData);
-            case "isValidPhone": return this.generatePhoneValidatorResponse(inputData);
-            case "protectReq": return this.generateHTTPRequest(inputData);
-            case "sendEmail": return this.generateEmailStatus();
-            case "getRandom": return this.generateSRNSummary(inputData);
-            case "extractWithTextly": return this.generateExtractWithTextly(inputData);
-            case "getPrayerTimes": return this.generatePrayerTimes(inputData);
-            case "satinize": return this.generateSatinizedInputAnalysis(inputData);
-            case "isValidPwd": return this.generatePasswordValidationResult(inputData);
-            default: throw new Error(`Unknown method for fallback: ${method}`);
-        }
-    }
-    ;
-    static validateURL(url) {
-        if (!url)
-            return false;
-        const urlRegex = /^https?:\/\/(?:[-\w.])+(?:\:[0-9]+)?(?:\/(?:[\w\/_.])*(?:\?(?:[\w&=%.])*)?(?:\#(?:[\w.])*)?)?$/;
-        return urlRegex.test(url);
-    }
-    ;
-    static validateEmail(email) {
-        if (!email)
-            return false;
-        const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
-        return emailRegex.test(email);
-    }
-    ;
-    static validateDomain(domain) {
-        if (!domain)
-            return false;
-        const domainRegex = /^[a-zA-Z0-9][a-zA-Z0-9-]{0,61}[a-zA-Z0-9](?:\.[a-zA-Z0-9][a-zA-Z0-9-]{0,61}[a-zA-Z0-9])*$/;
-        if (!domainRegex.test(domain))
-            return false;
-        // Validar que tenga un TLD (último punto + contenido)
-        const parts = domain.split('.');
-        return parts.length >= 2 && parts[parts.length - 1].length > 0;
-    }
-    ;
-    static validateCreditCard(creditCard) {
-        if (!creditCard)
-            return false;
-        const cardNumber = typeof creditCard === "string" ? creditCard : creditCard?.pan || "";
-        if (!cardNumber)
-            return false;
-        const cardRegex = /^\d{13,19}$/;
-        if (!cardRegex.test(cardNumber.replace(/\s/g, "")))
-            return false;
-        // Luhn algorithm
-        const digits = cardNumber.replace(/\s/g, "").split("").map(Number);
-        let sum = 0;
-        let isEven = false;
-        for (let i = digits.length - 1; i >= 0; i--) {
-            let digit = digits[i];
-            if (isEven) {
-                digit *= 2;
-                if (digit > 9)
-                    digit -= 9;
-            }
-            sum += digit;
-            isEven = !isEven;
-        }
-        return sum % 10 === 0;
-    }
-    ;
-    static validateIP(ip) {
-        if (!ip)
-            return false;
-        const ipv4Regex = /^(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$/;
-        const ipv6Regex = /^(?:[0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}$/;
-        return ipv4Regex.test(ip) || ipv6Regex.test(ip);
-    }
-    ;
-    static validatePhone(phone) {
-        if (!phone)
-            return false;
-        const phoneRegex = /^\+?[1-9]\d{1,14}$/;
-        return phoneRegex.test(phone.replace(/[^\d+]/g, ""));
-    }
-    ;
-    static validateWallet(wallet) {
-        if (!wallet)
-            return false;
-        const bitcoinRegex = /^[13][a-km-zA-HJ-NP-Z1-9]{25,34}$/;
-        const ethereumRegex = /^0x[a-fA-F0-9]{40}$/;
-        return bitcoinRegex.test(wallet) || ethereumRegex.test(wallet);
-    }
-    ;
-    static validateIBAN(iban) {
-        if (!iban)
-            return false;
-        const ibanRegex = /^[A-Z]{2}\d{2}[A-Z0-9]{11,30}$/;
-        return ibanRegex.test(iban.replace(/\s/g, "").toUpperCase());
-    }
-    ;
-    static extractDomain(url) {
-        if (!url)
-            return "";
-        try {
-            return new URL(url).hostname;
-        }
-        catch {
-            return "";
-        }
-    }
-    ;
-    static generateDataValidationAnalysis(inputData) {
-        return {
-            url: {
-                valid: this.validateURL(inputData?.url),
-                fraud: false,
-                freeSubdomain: false,
-                customTLD: false,
-                url: inputData?.url || "",
-                domain: this.extractDomain(inputData?.url),
-                plugins: {
-                    blocklist: false,
-                    compromiseDetector: false,
-                    mxRecords: [],
-                    nsfw: false,
-                    reputation: "unknown",
-                    riskScore: 0,
-                    torNetwork: false,
-                    typosquatting: 0,
-                    urlShortener: false
-                }
-            },
-            email: this.generateEmailDataAnalysis(inputData?.email),
-            phone: this.generatePhoneDataAnalysis(inputData?.phone),
-            domain: {
-                valid: this.validateDomain(inputData?.domain),
-                fraud: false,
-                freeSubdomain: false,
-                customTLD: false,
-                domain: inputData?.domain || "",
-                plugins: {
-                    blocklist: false,
-                    compromiseDetector: false,
-                    mxRecords: [],
-                    nsfw: false,
-                    reputation: "unknown",
-                    riskScore: 0,
-                    torNetwork: false,
-                    typosquatting: 0,
-                    urlShortener: false
-                }
-            },
-            creditCard: {
-                valid: this.validateCreditCard(inputData?.creditCard),
-                fraud: false,
-                test: false,
-                type: "unknown",
-                creditCard: typeof inputData?.creditCard === "string" ? inputData.creditCard : inputData?.creditCard?.pan || "",
-                plugins: {
-                    blocklist: false,
-                    riskScore: 0
-                }
-            },
-            ip: this.generateIPDataAnalysis(inputData?.ip),
-            wallet: {
-                valid: this.validateWallet(inputData?.wallet),
-                fraud: false,
-                wallet: inputData?.wallet || "",
-                type: "unknown",
-                plugins: {
-                    blocklist: false,
-                    riskScore: 0,
-                    torNetwork: false
-                }
-            },
-            userAgent: {
-                valid: false,
-                fraud: false,
-                userAgent: inputData?.userAgent || "",
-                bot: true,
-                device: { type: "unknown", brand: "unknown" },
-                plugins: {
-                    blocklist: false,
-                    riskScore: 0
-                }
-            },
-            iban: {
-                valid: this.validateIBAN(inputData?.iban),
-                fraud: false,
-                iban: inputData?.iban || "",
-                plugins: {
-                    blocklist: false,
-                    riskScore: 0
-                }
-            }
-        };
-    }
-    ;
-    static generateEmailValidatorResponse(inputData) {
-        return {
-            email: inputData?.email || "",
-            allow: this.validateEmail(inputData?.email),
-            reasons: this.validateEmail(inputData?.email) ? [] : ["INVALID"],
-            response: this.generateEmailDataAnalysis(inputData?.email)
-        };
-    }
-    ;
-    static generateEmailDataAnalysis(email) {
-        return {
-            valid: this.validateEmail(email),
-            fraud: false,
-            proxiedEmail: false,
-            freeSubdomain: false,
-            corporate: false,
-            email: email || "",
-            realUser: "",
-            didYouMean: null,
-            noReply: false,
-            customTLD: false,
-            domain: "",
-            roleAccount: false,
-            plugins: {
-                mxRecords: [],
-                blocklist: false,
-                compromiseDetector: false,
-                nsfw: false,
-                reputation: "unknown",
-                riskScore: 0,
-                torNetwork: false,
-                typosquatting: 0,
-                urlShortener: false
-            }
-        };
-    }
-    ;
-    static generateIPValidatorResponse(inputData) {
-        return {
-            ip: inputData?.ip || "",
-            allow: this.validateIP(inputData?.ip),
-            reasons: this.validateIP(inputData?.ip) ? [] : ["INVALID"],
-            response: this.generateIPDataAnalysis(inputData?.ip)
-        };
-    }
-    ;
-    static generateIPDataAnalysis(ip) {
-        const isValid = this.validateIP(ip);
-        return {
-            valid: isValid,
-            type: isValid ? "IPv4" : "Invalid",
-            class: isValid ? "A" : "Unknown",
-            fraud: false,
-            ip: ip || "",
-            continent: "",
-            continentCode: "",
-            country: "",
-            countryCode: "",
-            region: "",
-            regionName: "",
-            city: "",
-            district: "",
-            zipCode: "",
-            lat: 0,
-            lon: 0,
-            timezone: "",
-            offset: 0,
-            currency: "",
-            isp: "",
-            org: "",
-            as: "",
-            asname: "",
-            mobile: false,
-            proxy: true,
-            hosting: false,
-            plugins: {
-                blocklist: false,
-                riskScore: 0
-            }
-        };
-    }
-    ;
-    static generatePhoneValidatorResponse(inputData) {
-        return {
-            phone: inputData?.phone || "",
-            allow: this.validatePhone(inputData?.phone),
-            reasons: this.validatePhone(inputData?.phone) ? [] : ["INVALID"],
-            response: this.generatePhoneDataAnalysis(inputData?.phone)
-        };
-    }
-    ;
-    static generatePhoneDataAnalysis(phone) {
-        const phoneNumber = phone?.phone || phone;
-        const isValid = this.validatePhone(phoneNumber);
-        return {
-            valid: isValid,
-            fraud: false,
-            phone: phone?.phone || "",
-            prefix: "",
-            number: "",
-            lineType: "Unknown",
-            carrierInfo: {
-                carrierName: "",
-                accuracy: 0,
-                carrierCountry: "",
-                carrierCountryCode: ""
-            },
-            country: "",
-            countryCode: "",
-            plugins: {
-                blocklist: false,
-                riskScore: 0
-            }
-        };
-    }
-    ;
-    static generateHTTPRequest(inputData) {
-        return {
-            method: inputData?.method || "GET",
-            url: inputData?.url || "",
-            headers: inputData?.headers || {},
-            body: inputData?.body || null,
-            allow: false,
-            reasons: ["FRAUD"],
-            protected: true
-        };
-    }
-    ;
-    static generateEmailStatus() {
-        return {
-            status: false,
-            error: "API unavailable - using fallback response"
-        };
-    }
-    ;
-    static generateSRNSummary(inputData) {
-        const quantity = inputData?.quantity || 1;
-        const values = Array.from({ length: quantity }, () => ({
-            integer: 0,
-            float: 0.0
-        }));
-        return {
-            values,
-            executionTime: 0
-        };
-    }
-    ;
-    static generateExtractWithTextly(inputData) {
-        return {
-            data: inputData?.data || "",
-            extracted: {},
-            error: "API unavailable - using fallback response"
-        };
-    }
-    ;
-    static generatePrayerTimes(inputData) {
-        return {
-            error: "API unavailable - using fallback response"
-        };
-    }
-    ;
-    static generateSatinizedInputAnalysis(inputData) {
-        return {
-            input: inputData?.input || "",
-            formats: {
-                ascii: false,
-                bitcoinAddress: false,
-                cLikeIdentifier: false,
-                coordinates: false,
-                crediCard: false,
-                date: false,
-                discordUsername: false,
-                doi: false,
-                domain: false,
-                e164Phone: false,
-                email: false,
-                emoji: false,
-                hanUnification: false,
-                hashtag: false,
-                hyphenWordBreak: false,
-                ipv6: false,
-                ip: false,
-                jiraTicket: false,
-                macAddress: false,
-                name: false,
-                number: false,
-                panFromGstin: false,
-                password: false,
-                port: false,
-                tel: false,
-                text: false,
-                semver: false,
-                ssn: false,
-                uuid: false,
-                url: false,
-                urlSlug: false,
-                username: false
-            },
-            includes: {
-                spaces: false,
-                hasSql: false,
-                hasNoSql: false,
-                letters: false,
-                uppercase: false,
-                lowercase: false,
-                symbols: false,
-                digits: false
-            }
-        };
-    }
-    ;
-    static generatePasswordValidationResult(inputData) {
-        return {
-            valid: false,
-            password: inputData?.password || "",
-            details: [
-                {
-                    validation: "length",
-                    message: "API unavailable - using fallback response"
-                }
-            ]
-        };
-    }
-    ;
-}
-;

package/dist/esm/lib/resilience/index.js

@@ -1,131 +0,0 @@
-class RateLimitManager {
-    constructor() {
-        this.tracker = {};
-    }
-    static getInstance() {
-        if (!RateLimitManager.instance)
-            RateLimitManager.instance = new RateLimitManager();
-        return RateLimitManager.instance;
-    }
-    ;
-    updateRateLimit(clientId, headers) {
-        if (!this.tracker[clientId])
-            this.tracker[clientId] = {};
-        const limitInfo = this.tracker[clientId];
-        if (headers["x-ratelimit-limit-requests"])
-            limitInfo.limit = parseInt(headers["x-ratelimit-limit-requests"]);
-        if (headers["x-ratelimit-remaining-requests"])
-            limitInfo.remaining = parseInt(headers["x-ratelimit-remaining-requests"]);
-        if (headers["x-ratelimit-reset-requests"])
-            limitInfo.resetTime = headers["x-ratelimit-reset-requests"];
-        if (headers["retry-after"])
-            limitInfo.retryAfter = parseInt(headers["retry-after"]);
-        limitInfo.lastUpdated = Date.now();
-    }
-    ;
-    isRateLimited(clientId) {
-        const limitInfo = this.tracker[clientId];
-        return limitInfo?.remaining !== undefined && limitInfo.remaining <= 0;
-    }
-    ;
-    getRetryAfter(clientId) {
-        return this.tracker[clientId]?.retryAfter;
-    }
-    ;
-    clearExpiredLimits() {
-        const now = Date.now();
-        Object.keys(this.tracker).forEach(clientId => {
-            const limitInfo = this.tracker[clientId];
-            if (limitInfo.lastUpdated && (now - limitInfo.lastUpdated) > 300000)
-                delete this.tracker[clientId];
-        });
-    }
-    ;
-}
-;
-export class ResilienceManager {
-    constructor(config = {}, clientId = "default") {
-        this.config = {
-            fallbackEnabled: config.fallbackEnabled ?? false,
-            retryAttempts: Math.max(0, config.retryAttempts ?? 2), // Number of additional retries
-            retryDelay: Math.max(0, config.retryDelay ?? 1000)
-        };
-        this.clientId = clientId;
-        this.rateLimitManager = RateLimitManager.getInstance();
-    }
-    ;
-    async executeWithResilience(axiosClient, requestConfig, fallbackData) {
-        let lastError;
-        const totalAttempts = 1 + this.config.retryAttempts; // 1 normal + N retries
-        // Clean up expired rate limits periodically
-        this.rateLimitManager.clearExpiredLimits();
-        // Check if client is currently rate limited
-        if (this.rateLimitManager.isRateLimited(this.clientId)) {
-            const retryAfter = this.rateLimitManager.getRetryAfter(this.clientId);
-            if (retryAfter) {
-                console.warn(`[Dymo API] Client ${this.clientId} is rate limited. Waiting ${retryAfter} seconds...`);
-                await this.sleep(retryAfter * 1000);
-            }
-        }
-        for (let attempt = 1; attempt <= totalAttempts; attempt++) {
-            try {
-                const response = await axiosClient.request(requestConfig);
-                // Update rate limit tracking
-                this.rateLimitManager.updateRateLimit(this.clientId, response.headers);
-                // Check for rate limiting
-                if (response.status === 429) {
-                    const retryAfter = this.rateLimitManager.getRetryAfter(this.clientId);
-                    if (retryAfter) {
-                        console.warn(`[Dymo API] Rate limited. Waiting ${retryAfter} seconds (no retries)`);
-                        await this.sleep(retryAfter * 1000);
-                    }
-                    throw new Error(`Rate limited (429) - not retrying`);
-                }
-                return response.data;
-            }
-            catch (error) {
-                lastError = error;
-                let shouldRetry = this.shouldRetry(error);
-                const isLastAttempt = attempt === totalAttempts;
-                // Don't retry on rate limiting (429)
-                if (error.response?.status === 429)
-                    shouldRetry = false;
-                if (!shouldRetry || isLastAttempt) {
-                    if (this.config.fallbackEnabled && fallbackData) {
-                        console.warn(`[Dymo API] Request failed after ${attempt} attempts. Using fallback data.`);
-                        return fallbackData;
-                    }
-                    throw error;
-                }
-                const delay = this.config.retryDelay * Math.pow(2, attempt - 1);
-                console.warn(`[Dymo API] Attempt ${attempt} failed. Retrying in ${delay}ms...`);
-                await this.sleep(delay);
-            }
-        }
-        throw lastError;
-    }
-    ;
-    shouldRetry(error) {
-        const statusCode = error.response?.status;
-        const isNetworkError = !error.response && error.code !== "ECONNABORTED";
-        const isServerError = statusCode && statusCode >= 500;
-        // Retry on: network errors, server errors (5xx)
-        // DON'T retry on: rate limiting (429) - handled separately
-        // DON'T retry on: client errors (4xx except 429)
-        return isNetworkError || isServerError;
-    }
-    ;
-    sleep(ms) {
-        return new Promise(resolve => setTimeout(resolve, ms));
-    }
-    ;
-    getConfig() {
-        return { ...this.config };
-    }
-    ;
-    getClientId() {
-        return this.clientId;
-    }
-    ;
-}
-;

package/dist/esm/lib/types/data-verifier.js

@@ -1 +0,0 @@
-export {};

package/dist/esm/lib/types/interfaces.js

@@ -1,8 +0,0 @@
-;
-;
-;
-;
-export * from "./rules";
-export * from "./primitives";
-export * from "./data-verifier";
-export * from "./well-known-bots";

package/dist/esm/lib/types/primitives.js

@@ -1 +0,0 @@
-export {};

package/dist/esm/lib/types/rules.js

@@ -1 +0,0 @@
-export {};