@easyflow/javascript-sdk 2.1.7

package/libs/integration-wrapper.mjs

@@ -0,0 +1,285 @@
+/**
+ * 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

@@ -0,0 +1,161 @@
+/**
+ * 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)
+    }
+}