@easyflow/javascript-sdk 2.1.8 → 2.1.10

package/libs/integration-wrapper.mjs

@@ -1,285 +0,0 @@
-/**
- * Easyflow SDK Integration Wrapper
- *
- * Este wrapper facilita a integração com plataformas low-code/no-code como:
- * - Lovable.dev
- * - Bubble
- * - Webflow
- * - Zapier
- * - Make.com
- * - Outras plataformas
- */
-
-import { EasyflowSDK } from '../sdk.mjs'
-import { Validator } from './validator.mjs'
-import { Sanitizer } from './sanitizer.mjs'
-
-/**
- * Wrapper de integração universal para plataformas low-code/no-code
- */
-class EasyflowIntegrationWrapper {
-    constructor(config = {}) {
-        this.config = {
-            autoInitialize: true,
-            globalScope: 'window',
-            exposeGlobally: true,
-            enableDebug: false,
-            ...config,
-        }
-
-        this.sdk = null
-        this.isInitialized = false
-
-        if (this.config.autoInitialize) {
-            this.initialize()
-        }
-    }
-
-    /**
-     * Inicializa o wrapper e expõe funcionalidades globalmente
-     */
-    initialize() {
-        try {
-            // Criar instância do SDK
-            if (!this.config.businessId) {
-                throw new Error('businessId é obrigatório para inicialização')
-            }
-
-            this.sdk = new EasyflowSDK(this.config.businessId)
-            this.isInitialized = true
-
-            // Expor funcionalidades globalmente se configurado
-            if (this.config.exposeGlobally) {
-                this.exposeToGlobalScope()
-            }
-
-            // Log de sucesso
-            if (this.config.enableDebug) {
-                console.log(
-                    '✅ Easyflow SDK Integration Wrapper inicializado com sucesso'
-                )
-            }
-
-            return true
-        } catch (error) {
-            console.error('❌ Erro ao inicializar Easyflow SDK:', error.message)
-            return false
-        }
-    }
-
-    exposeToGlobalScope() {
-        const globalObj = this.getGlobalObject()
-        globalObj.EasyflowSDK = EasyflowSDK
-        globalObj.EasyflowSDKWrapper = this
-        globalObj.easyflow = this.sdk
-        globalObj.easyflowSDK = {
-            createCustomer: (data) => this.safeCall('createCustomer', data),
-            getCustomer: (id) => this.safeCall('getCustomer', id),
-            updateCustomer: (id, data) =>
-                this.safeCall('updateCustomer', id, data),
-            placeOrder: (offerId, data) =>
-                this.safeCall('placeOrder', offerId, data),
-            charge: (data) => this.safeCall('charge', data),
-            encrypt: (data) => this.safeCall('encrypt', data),
-            addCreditCard: (customerId, token) =>
-                this.safeCall('addCreditCard', customerId, token),
-            getCreditCard: (customerId, cardId) =>
-                this.safeCall('getCreditCard', customerId, cardId),
-            removeCreditCard: (customerId, cardId) =>
-                this.safeCall('removeCreditCard', customerId, cardId),
-            getOffer: (id) => this.safeCall('getOffer', id),
-            getOrder: (id) => this.safeCall('getOrder', id),
-            getPix: (orderId) => this.safeCall('getPix', orderId),
-            getBankBillet: (orderId) => this.safeCall('getBankBillet', orderId),
-            validate: {
-                email: (email) => Validator.validateEmail(email),
-                cpf: (cpf) => Validator.validateCPF(cpf),
-                cnpj: (cnpj) => Validator.validateCNPJ(cnpj),
-                phone: (phone) => Validator.validatePhone(phone),
-                address: (address) => Validator.validateAddress(address),
-                customer: (customer) => Validator.validateCustomer(customer),
-            },
-            sanitize: {
-                input: (input) => Sanitizer.sanitizeInput(input),
-                headers: (headers) => Sanitizer.sanitizeHeaders(headers),
-                customer: (customer) =>
-                    Sanitizer.sanitizeObjectFields(customer),
-            },
-            getVersion: () => this.sdk.version,
-            getStatus: () => ({
-                initialized: this.isInitialized,
-                businessId: this.config.businessId,
-            }),
-            configure: (newConfig) => this.configure(newConfig),
-        }
-        globalObj.easyflowCallbacks = {
-            onCustomerCreated: null,
-            onPaymentProcessed: null,
-            onError: null,
-        }
-
-        if (this.config.enableDebug) {
-            console.log('Easyflow SDK exposto globalmente como "easyflowSDK"')
-        }
-    }
-
-    /**
-     * Obtém o objeto global baseado na configuração
-     */
-    getGlobalObject() {
-        switch (this.config.globalScope) {
-            case 'window':
-                return typeof window !== 'undefined' ? window : global
-            case 'global':
-                return typeof global !== 'undefined' ? global : window
-            default:
-                return typeof window !== 'undefined' ? window : global
-        }
-    }
-
-    async safeCall(method, ...args) {
-        try {
-            if (!this.isInitialized || !this.sdk)
-                throw new Error(
-                    'SDK não inicializado. Execute easyflowSDK.initialize() primeiro.'
-                )
-
-            if (!this.sdk[method])
-                throw new Error(`Método "${method}" não encontrado no SDK`)
-
-            const result = await this.sdk[method](...args)
-            this.executeCallbacks(method, result, null)
-            return {
-                success: true,
-                data: result,
-                error: null,
-            }
-        } catch (error) {
-            const errorResult = {
-                success: false,
-                data: null,
-                error: {
-                    message: error.message,
-                    code: error.code || 'UNKNOWN_ERROR',
-                    type: error.constructor.name,
-                },
-            }
-            this.executeCallbacks(method, null, errorResult.error)
-            return errorResult
-        }
-    }
-
-    executeCallbacks(method, result, error) {
-        const globalObj = this.getGlobalObject()
-        if (error && globalObj.easyflowCallbacks.onError) {
-            try {
-                globalObj.easyflowCallbacks.onError(error, method)
-            } catch (callbackError) {
-                console.warn('Erro no callback onError:', callbackError)
-            }
-        }
-        if (result && !error) {
-            if (
-                method === 'createCustomer' &&
-                globalObj.easyflowCallbacks.onCustomerCreated
-            ) {
-                try {
-                    globalObj.easyflowCallbacks.onCustomerCreated(result)
-                } catch (callbackError) {
-                    console.warn(
-                        'Erro no callback onCustomerCreated:',
-                        callbackError
-                    )
-                }
-            }
-
-            if (
-                (method === 'placeOrder' || method === 'charge') &&
-                globalObj.easyflowCallbacks.onPaymentProcessed
-            ) {
-                try {
-                    globalObj.easyflowCallbacks.onPaymentProcessed(
-                        result,
-                        method
-                    )
-                } catch (callbackError) {
-                    console.warn(
-                        'Erro no callback onPaymentProcessed:',
-                        callbackError
-                    )
-                }
-            }
-        }
-    }
-
-    /**
-     * Configura callbacks para eventos
-     */
-    on(event, callback) {
-        const globalObj = this.getGlobalObject()
-
-        switch (event) {
-            case 'customerCreated':
-                globalObj.easyflowCallbacks.onCustomerCreated = callback
-                break
-            case 'paymentProcessed':
-                globalObj.easyflowCallbacks.onPaymentProcessed = callback
-                break
-            case 'error':
-                globalObj.easyflowCallbacks.onError = callback
-                break
-            default:
-                console.warn(`Evento desconhecido: ${event}`)
-        }
-    }
-
-    /**
-     * Configura novas opções
-     */
-    configure(newConfig) {
-        this.config = { ...this.config, ...newConfig }
-        if (this.config.enableDebug)
-            console.log('Configuração atualizada:', this.config)
-        return this.config
-    }
-    getStatus() {
-        return {
-            initialized: this.isInitialized,
-            businessId: this.config.businessId,
-            sdkVersion: this.sdk?.version || 'N/A',
-            wrapperVersion: '1.0.0',
-        }
-    }
-}
-
-function initializeEasyflow(config) {
-    return new EasyflowIntegrationWrapper(config)
-}
-
-function validateEasyflowData(type, data) {
-    try {
-        switch (type) {
-            case 'email':
-                return Validator.validateEmail(data)
-            case 'cpf':
-                return Validator.validateCPF(data)
-            case 'cnpj':
-                return Validator.validateCNPJ(data)
-            case 'phone':
-                return Validator.validatePhone(data)
-            case 'address':
-                return Validator.validateAddress(data)
-            case 'customer':
-                return Validator.validateCustomer(data)
-            default:
-                throw new Error(`Tipo de validação desconhecido: ${type}`)
-        }
-    } catch (error) {
-        return {
-            valid: false,
-            error: error.message,
-        }
-    }
-}
-
-export { EasyflowIntegrationWrapper, initializeEasyflow, validateEasyflowData }

package/libs/logger.mjs

@@ -1,161 +0,0 @@
-/**
- * Secure Logger for Easyflow SDK
- *
- * This class provides secure logging functionality that automatically
- * redacts sensitive information like credit card numbers, tokens, and passwords.
- *
- * @class SecureLogger
- * @since 1.0.0
- */
-export class SecureLogger {
-    /**
-     * Creates a new SecureLogger instance
-     *
-     * @param {string} [level='error'] - Logging level ('error', 'warn', 'info', 'debug')
-     *
-     * @example
-     * ```javascript
-     * const logger = new SecureLogger('info');
-     * logger.info('SDK initialized', { businessId: '123' });
-     * ```
-     */
-    constructor(level = 'error') {
-        this.level = level
-        this.levels = { error: 0, warn: 1, info: 2, debug: 3 }
-    }
-
-    /**
-     * Internal logging method that handles level filtering and data sanitization
-     *
-     * @param {string} level - Log level ('error', 'warn', 'info', 'debug')
-     * @param {string} message - Log message
-     * @param {*} [data=null] - Additional data to log (will be sanitized)
-     *
-     * @private
-     */
-    log(level, message, data = null) {
-        if (this.levels[level] <= this.levels[this.level]) {
-            const sanitizedData = this.sanitizeData(data)
-            const logMessage = `[EasyflowSDK:${level.toUpperCase()}] ${message}`
-
-            if (level === 'error') {
-                console.error(logMessage, sanitizedData)
-            } else if (level === 'warn') {
-                console.warn(logMessage, sanitizedData)
-            } else {
-                console.log(logMessage, sanitizedData)
-            }
-        }
-    }
-
-    /**
-     * Sanitizes data by redacting sensitive information
-     *
-     * This method automatically detects and redacts sensitive fields like
-     * credit card numbers, tokens, passwords, and other sensitive data.
-     * It also truncates long strings to prevent log flooding.
-     *
-     * @param {*} data - Data to sanitize
-     * @returns {*} Sanitized data with sensitive information redacted
-     *
-     * @private
-     *
-     * @example
-     * ```javascript
-     * const sanitized = logger.sanitizeData({
-     *   cardNumber: '4111111111111111',
-     *   token: 'secret-token',
-     *   message: 'Very long message...'
-     * });
-     * // Returns: { cardNumber: '[REDACTED]', token: '[REDACTED]', message: 'Very long message...' }
-     * ```
-     */
-    sanitizeData(data) {
-        if (!data) return null
-
-        const sensitive = [
-            'token',
-            'cardNumber',
-            'password',
-            'cvv',
-            'number',
-            'key',
-            'secret',
-            'apiKey',
-            'private',
-            'credential',
-        ]
-
-        return JSON.parse(
-            JSON.stringify(data, (key, value) => {
-                if (sensitive.some((s) => key.toLowerCase().includes(s))) {
-                    return '[REDACTED]'
-                }
-                if (typeof value === 'string' && value.length > 100) {
-                    return `${value.substring(0, 100)}...`
-                }
-                return value
-            })
-        )
-    }
-
-    /**
-     * Logs an error message
-     *
-     * @param {string} message - Error message
-     * @param {*} [data=null] - Additional error data (will be sanitized)
-     *
-     * @example
-     * ```javascript
-     * logger.error('Failed to process payment', { orderId: '123', error: 'Network timeout' });
-     * ```
-     */
-    error(message, data = null) {
-        this.log('error', message, data)
-    }
-
-    /**
-     * Logs a warning message
-     *
-     * @param {string} message - Warning message
-     * @param {*} [data=null] - Additional warning data (will be sanitized)
-     *
-     * @example
-     * ```javascript
-     * logger.warn('Rate limit approaching', { requests: 25, limit: 30 });
-     * ```
-     */
-    warn(message, data = null) {
-        this.log('warn', message, data)
-    }
-
-    /**
-     * Logs an info message
-     *
-     * @param {string} message - Info message
-     * @param {*} [data=null] - Additional info data (will be sanitized)
-     *
-     * @example
-     * ```javascript
-     * logger.info('Order placed successfully', { orderId: '123', amount: 1000 });
-     * ```
-     */
-    info(message, data = null) {
-        this.log('info', message, data)
-    }
-
-    /**
-     * Logs a debug message
-     *
-     * @param {string} message - Debug message
-     * @param {*} [data=null] - Additional debug data (will be sanitized)
-     *
-     * @example
-     * ```javascript
-     * logger.debug('API request details', { url: '/api/charge', method: 'POST' });
-     * ```
-     */
-    debug(message, data = null) {
-        this.log('debug', message, data)
-    }
-}