@easyflow/javascript-sdk 2.1.7

package/jest.config.js

@@ -0,0 +1,37 @@
+export default {
+    testEnvironment: 'node',
+    globals: {
+        'ts-jest': {
+            useESM: true,
+        },
+    },
+    moduleNameMapper: {
+        '^(\\.{1,2}/.*)\\.js$': '$1',
+    },
+    transform: {},
+    testMatch: [
+        '**/test.js',
+        '**/__tests__/**/*.js',
+        '**/?(*.)+(spec|test).js',
+    ],
+    collectCoverageFrom: [
+        'sdk.mjs',
+        'libs/*.mjs',
+        '!**/node_modules/**',
+        '!**/dist/**',
+        '!**/docs/**',
+    ],
+    coverageReporters: ['text', 'lcov', 'html'],
+    coverageThreshold: {
+        global: {
+            branches: 80,
+            functions: 80,
+            lines: 80,
+            statements: 80,
+        },
+    },
+    setupFilesAfterEnv: ['<rootDir>/test-setup.cjs'],
+    verbose: true,
+    clearMocks: true,
+    restoreMocks: true,
+}

package/jsdoc.json

@@ -0,0 +1,42 @@
+{
+  "tags": {
+    "allowUnknownTags": true,
+    "dictionaries": [
+      "jsdoc",
+      "closure"
+    ]
+  },
+  "source": {
+    "include": [
+      "sdk.mjs",
+      "http.mjs"
+    ],
+    "includePattern": "\\.mjs$",
+    "excludePattern": "(node_modules/|docs)"
+  },
+  "plugins": [],
+  "templates": {
+    "cleverLinks": false,
+    "monospaceLinks": false,
+    "default": {
+      "outputSourceFiles": true
+    },
+    "path": "node_modules/clean-jsdoc-theme",
+    "theme_opts": {
+      "title": "Easyflow SDK Documentation",
+      "menu": {
+        "GitHub repo": {
+          "href": "https://github.com/easyflow/sdk-javascript",
+          "target": "_blank",
+          "class": "menu-item",
+          "id": "repository"
+        }
+      }
+    }
+  },
+  "opts": {
+    "destination": "./docs",
+    "recurse": true,
+    "readme": "./README.md"
+  }
+}

package/libs/auto-integration.mjs

@@ -0,0 +1,333 @@
+/**
+ * Auto-Integration Script for Easyflow SDK
+ *
+ * Este script detecta automaticamente a plataforma e configura
+ * a integração de forma otimizada para cada ambiente.
+ */
+
+import { EasyflowIntegrationWrapper } from './integration-wrapper.mjs'
+
+/**
+ * Detector de plataformas
+ */
+class PlatformDetector {
+    static detect() {
+        // Detectar Lovable.dev
+        if (this.isLovable()) {
+            return {
+                name: 'Lovable.dev',
+                type: 'low-code',
+                features: ['chat-ai', 'visual-editor', 'workflows'],
+                integration: 'automatic',
+            }
+        }
+
+        // Detectar Bubble
+        if (this.isBubble()) {
+            return {
+                name: 'Bubble',
+                type: 'low-code',
+                features: ['visual-editor', 'database', 'workflows'],
+                integration: 'javascript',
+            }
+        }
+
+        // Detectar Webflow
+        if (this.isWebflow()) {
+            return {
+                name: 'Webflow',
+                type: 'design-platform',
+                features: ['visual-editor', 'cms', 'ecommerce'],
+                integration: 'javascript',
+            }
+        }
+
+        // Detectar Zapier
+        if (this.isZapier()) {
+            return {
+                name: 'Zapier',
+                type: 'automation',
+                features: ['webhooks', 'integrations', 'workflows'],
+                integration: 'webhook',
+            }
+        }
+
+        // Detectar Make.com
+        if (this.isMake()) {
+            return {
+                name: 'Make.com',
+                type: 'automation',
+                features: ['visual-workflows', 'integrations'],
+                integration: 'webhook',
+            }
+        }
+
+        // Plataforma genérica
+        return {
+            name: 'Generic Platform',
+            type: 'unknown',
+            features: ['javascript-support'],
+            integration: 'manual',
+        }
+    }
+
+    static isLovable() {
+        return (
+            window.location.hostname.includes('lovable') ||
+            document.querySelector('[data-lovable]') ||
+            window.lovableConfig
+        )
+    }
+
+    static isBubble() {
+        return (
+            window.location.hostname.includes('bubble') ||
+            window.bubble ||
+            document.querySelector('[data-bubble]')
+        )
+    }
+
+    static isWebflow() {
+        return (
+            window.location.hostname.includes('webflow') ||
+            window.Webflow ||
+            document.querySelector('[data-wf-site]')
+        )
+    }
+
+    static isZapier() {
+        return (
+            window.location.hostname.includes('zapier') ||
+            window.zapier ||
+            document.querySelector('[data-zapier]')
+        )
+    }
+
+    static isMake() {
+        return (
+            window.location.hostname.includes('make') ||
+            window.make ||
+            document.querySelector('[data-make]')
+        )
+    }
+}
+
+/**
+ * Configurador automático de integração
+ */
+class AutoIntegrationConfigurator {
+    constructor() {
+        this.platform = PlatformDetector.detect()
+        this.wrapper = null
+        this.config = this.getDefaultConfig()
+    }
+
+    /**
+     * Obter configuração padrão baseada na plataforma
+     */
+    getDefaultConfig() {
+        const baseConfig = {
+            autoInitialize: true,
+            exposeGlobally: true,
+            enableDebug: false,
+        }
+
+        switch (this.platform.name) {
+            case 'Lovable.dev':
+                return {
+                    ...baseConfig,
+                    globalScope: 'window',
+                    enableDebug: true,
+                    platform: 'lovable',
+                }
+
+            case 'Bubble':
+                return {
+                    ...baseConfig,
+                    globalScope: 'window',
+                    enableDebug: false,
+                    platform: 'bubble',
+                }
+
+            case 'Webflow':
+                return {
+                    ...baseConfig,
+                    globalScope: 'window',
+                    enableDebug: false,
+                    platform: 'webflow',
+                }
+
+            case 'Zapier':
+            case 'Make.com':
+                return {
+                    ...baseConfig,
+                    globalScope: 'global',
+                    enableDebug: false,
+                    platform: this.platform.name.toLowerCase(),
+                }
+
+            default:
+                return {
+                    ...baseConfig,
+                    globalScope: 'window',
+                    enableDebug: false,
+                    platform: 'generic',
+                }
+        }
+    }
+
+    /**
+     * Configurar integração automaticamente
+     */
+    async configure(config = {}) {
+        try {
+            // Mesclar configurações
+            this.config = { ...this.config, ...config }
+
+            // Criar wrapper
+            this.wrapper = new EasyflowIntegrationWrapper(this.config)
+
+            // Configurar callbacks específicos da plataforma
+            this.configurePlatformCallbacks()
+
+            // Log de sucesso
+            if (this.config.enableDebug) {
+                console.log(
+                    `🚀 Easyflow SDK configurado automaticamente para ${this.platform.name}`
+                )
+                console.log(`📋 Configurações:`, this.config)
+            }
+
+            return this.wrapper
+        } catch (error) {
+            console.error('❌ Erro na configuração automática:', error)
+            throw error
+        }
+    }
+
+    /**
+     * Configurar callbacks específicos da plataforma
+     */
+    configurePlatformCallbacks() {
+        if (!this.wrapper) return
+
+        switch (this.platform.name) {
+            case 'Lovable.dev':
+                this.configureLovableCallbacks()
+                break
+
+            case 'Bubble':
+                this.configureBubbleCallbacks()
+                break
+
+            case 'Webflow':
+                this.configureWebflowCallbacks()
+                break
+
+            case 'Zapier':
+            case 'Make.com':
+                this.configureAutomationCallbacks()
+                break
+        }
+    }
+
+    /**
+     * Callbacks específicos para Lovable
+     */
+    configureLovableCallbacks() {
+        this.wrapper.on('customerCreated', (customer) => {
+            console.log('🎉 Cliente criado no Lovable:', customer)
+            // Aqui você pode adicionar lógica específica do Lovable
+        })
+
+        this.wrapper.on('paymentProcessed', (result) => {
+            console.log('💳 Pagamento processado no Lovable:', result)
+            // Aqui você pode adicionar lógica específica do Lovable
+        })
+    }
+
+    /**
+     * Callbacks específicos para Bubble
+     */
+    configureBubbleCallbacks() {
+        this.wrapper.on('customerCreated', (customer) => {
+            console.log('🎉 Cliente criado no Bubble:', customer)
+            // Aqui você pode adicionar lógica específica do Bubble
+            if (window.bubble_fn_updateCustomer) {
+                window.bubble_fn_updateCustomer(customer)
+            }
+        })
+
+        this.wrapper.on('paymentProcessed', (result) => {
+            console.log('💳 Pagamento processado no Bubble:', result)
+            // Aqui você pode adicionar lógica específica do Bubble
+            if (window.bubble_fn_updatePaymentStatus) {
+                window.bubble_fn_updatePaymentStatus(result)
+            }
+        })
+    }
+
+    /**
+     * Callbacks específicos para Webflow
+     */
+    configureWebflowCallbacks() {
+        this.wrapper.on('customerCreated', (customer) => {
+            console.log('🎉 Cliente criado no Webflow:', customer)
+            // Aqui você pode adicionar lógica específica do Webflow
+        })
+
+        this.wrapper.on('paymentProcessed', (result) => {
+            console.log('💳 Pagamento processado no Webflow:', result)
+            // Aqui você pode adicionar lógica específica do Webflow
+        })
+    }
+
+    /**
+     * Callbacks para plataformas de automação
+     */
+    configureAutomationCallbacks() {
+        this.wrapper.on('customerCreated', (customer) => {
+            console.log('🎉 Cliente criado via automação:', customer)
+            // Aqui você pode adicionar lógica para webhooks
+        })
+
+        this.wrapper.on('paymentProcessed', (result) => {
+            console.log('💳 Pagamento processado via automação:', result)
+            // Aqui você pode adicionar lógica para webhooks
+        })
+    }
+
+    /**
+     * Obter informações da plataforma
+     */
+    getPlatformInfo() {
+        return {
+            ...this.platform,
+            config: this.config,
+            wrapper: this.wrapper,
+        }
+    }
+}
+
+/**
+ * Função de inicialização automática
+ */
+function autoConfigureEasyflow(config = {}) {
+    const configurator = new AutoIntegrationConfigurator()
+    return configurator.configure(config)
+}
+
+/**
+ * Função para obter informações da plataforma
+ */
+function getPlatformInfo() {
+    const configurator = new AutoIntegrationConfigurator()
+    return configurator.getPlatformInfo()
+}
+
+export {
+    PlatformDetector,
+    AutoIntegrationConfigurator,
+    autoConfigureEasyflow,
+    getPlatformInfo,
+}

package/libs/constants.mjs

@@ -0,0 +1,61 @@
+/**
+ * Default configuration for Easyflow SDK
+ */
+export const DEFAULT_CONFIG = {
+    baseUrl: 'https://pay.easyflow.digital',
+    timeout: 30000,
+    headers: {},
+}
+
+/**
+ * Payment method constants
+ */
+export const PAYMENT_METHODS = {
+    CREDIT_CARD: 'credit-card',
+    PIX: 'pix',
+    BANK_BILLET: 'bank-billet',
+}
+
+/**
+ * API target constants
+ */
+export const TARGETS = {
+    CHARGE: 'charge',
+    PLACE_ORDER: 'place-order',
+    ENCRYPT: 'encrypt',
+    GET_OFFER: 'get-offer',
+    GET_ORDER: 'get-order',
+    CREATE_CUSTOMER: 'create-customer',
+    GET_CUSTOMER: 'get-customer',
+    UPDATE_CUSTOMER: 'update-customer',
+    ADD_CREDIT_CARD: 'add-credit-card',
+    REMOVE_CREDIT_CARD: 'delete-credit-card',
+    GET_CREDIT_CARD: 'get-credit-card',
+}
+
+/**
+ * HTTP status codes used in the SDK
+ * @type {{OK: number, CREATED: number, NO_CONTENT: number, BAD_REQUEST: number, UNAUTHORIZED: number, FORBIDDEN: number, NOT_FOUND: number, INTERNAL_SERVER_ERROR: number}}
+ */
+export const HTTP_STATUS_CODES = {
+    OK: 200,
+    CREATED: 201,
+    NO_CONTENT: 204,
+    BAD_REQUEST: 400,
+    UNAUTHORIZED: 401,
+    FORBIDDEN: 403,
+    NOT_FOUND: 404,
+    INTERNAL_SERVER_ERROR: 500,
+}
+
+/**
+ * HTTP request methods used in the SDK
+ * @type {{GET: string, POST: string, PATCH: string, DELETE: string, PUT: string}}
+ */
+export const HTTP_REQUEST_METHODS = {
+    GET: 'GET',
+    POST: 'POST',
+    PATCH: 'PATCH',
+    DELETE: 'DELETE',
+    PUT: 'PUT',
+}

package/libs/constants.spec.js

@@ -0,0 +1,198 @@
+import { describe, expect, test } from '@jest/globals'
+import {
+    DEFAULT_CONFIG,
+    HTTP_REQUEST_METHODS,
+    HTTP_STATUS_CODES,
+    PAYMENT_METHODS,
+    TARGETS,
+} from './constants.mjs'
+
+describe('Constants', () => {
+    describe('DEFAULT_CONFIG', () => {
+        test('should have correct default configuration', () => {
+            expect(DEFAULT_CONFIG).toEqual({
+                baseUrl: 'https://pay.easyflow.digital',
+                timeout: 30000,
+                headers: {},
+            })
+        })
+
+        test('should have baseUrl property', () => {
+            expect(DEFAULT_CONFIG.baseUrl).toBe('https://pay.easyflow.digital')
+        })
+
+        test('should have timeout property', () => {
+            expect(DEFAULT_CONFIG.timeout).toBe(30000)
+        })
+
+        test('should have headers property', () => {
+            expect(DEFAULT_CONFIG.headers).toEqual({})
+        })
+    })
+
+    describe('PAYMENT_METHODS', () => {
+        test('should contain all expected payment methods', () => {
+            expect(PAYMENT_METHODS).toEqual({
+                CREDIT_CARD: 'credit-card',
+                PIX: 'pix',
+                BANK_BILLET: 'bank-billet',
+            })
+        })
+
+        test('should have CREDIT_CARD method', () => {
+            expect(PAYMENT_METHODS.CREDIT_CARD).toBe('credit-card')
+        })
+
+        test('should have PIX method', () => {
+            expect(PAYMENT_METHODS.PIX).toBe('pix')
+        })
+
+        test('should have BANK_BILLET method', () => {
+            expect(PAYMENT_METHODS.BANK_BILLET).toBe('bank-billet')
+        })
+    })
+
+    describe('TARGETS', () => {
+        test('should contain all expected API targets', () => {
+            expect(TARGETS).toEqual({
+                CHARGE: 'charge',
+                PLACE_ORDER: 'place-order',
+                ENCRYPT: 'encrypt',
+                GET_OFFER: 'get-offer',
+                GET_ORDER: 'get-order',
+                CREATE_CUSTOMER: 'create-customer',
+                GET_CUSTOMER: 'get-customer',
+                UPDATE_CUSTOMER: 'update-customer',
+                ADD_CREDIT_CARD: 'add-credit-card',
+                REMOVE_CREDIT_CARD: 'delete-credit-card',
+                GET_CREDIT_CARD: 'get-credit-card',
+            })
+        })
+
+        test('should have CHARGE target', () => {
+            expect(TARGETS.CHARGE).toBe('charge')
+        })
+
+        test('should have PLACE_ORDER target', () => {
+            expect(TARGETS.PLACE_ORDER).toBe('place-order')
+        })
+
+        test('should have ENCRYPT target', () => {
+            expect(TARGETS.ENCRYPT).toBe('encrypt')
+        })
+
+        test('should have GET_OFFER target', () => {
+            expect(TARGETS.GET_OFFER).toBe('get-offer')
+        })
+
+        test('should have GET_ORDER target', () => {
+            expect(TARGETS.GET_ORDER).toBe('get-order')
+        })
+    })
+
+    describe('HTTP_STATUS_CODES', () => {
+        test('should contain all expected HTTP status codes', () => {
+            expect(HTTP_STATUS_CODES).toEqual({
+                OK: 200,
+                CREATED: 201,
+                NO_CONTENT: 204,
+                BAD_REQUEST: 400,
+                UNAUTHORIZED: 401,
+                FORBIDDEN: 403,
+                NOT_FOUND: 404,
+                INTERNAL_SERVER_ERROR: 500,
+            })
+        })
+
+        test('should have correct status code values', () => {
+            expect(HTTP_STATUS_CODES.OK).toBe(200)
+            expect(HTTP_STATUS_CODES.CREATED).toBe(201)
+            expect(HTTP_STATUS_CODES.NO_CONTENT).toBe(204)
+            expect(HTTP_STATUS_CODES.BAD_REQUEST).toBe(400)
+            expect(HTTP_STATUS_CODES.UNAUTHORIZED).toBe(401)
+            expect(HTTP_STATUS_CODES.FORBIDDEN).toBe(403)
+            expect(HTTP_STATUS_CODES.NOT_FOUND).toBe(404)
+            expect(HTTP_STATUS_CODES.INTERNAL_SERVER_ERROR).toBe(500)
+        })
+    })
+
+    describe('HTTP_REQUEST_METHODS', () => {
+        test('should contain all expected HTTP request methods', () => {
+            expect(HTTP_REQUEST_METHODS).toEqual({
+                GET: 'GET',
+                POST: 'POST',
+                PATCH: 'PATCH',
+                DELETE: 'DELETE',
+                PUT: 'PUT',
+            })
+        })
+
+        test('should have correct HTTP method values', () => {
+            expect(HTTP_REQUEST_METHODS.GET).toBe('GET')
+            expect(HTTP_REQUEST_METHODS.POST).toBe('POST')
+            expect(HTTP_REQUEST_METHODS.PATCH).toBe('PATCH')
+            expect(HTTP_REQUEST_METHODS.DELETE).toBe('DELETE')
+            expect(HTTP_REQUEST_METHODS.PUT).toBe('PUT')
+        })
+    })
+
+    describe('Constants Structure', () => {
+        test('all constants should be objects', () => {
+            expect(typeof DEFAULT_CONFIG).toBe('object')
+            expect(typeof PAYMENT_METHODS).toBe('object')
+            expect(typeof TARGETS).toBe('object')
+            expect(typeof HTTP_STATUS_CODES).toBe('object')
+            expect(typeof HTTP_REQUEST_METHODS).toBe('object')
+        })
+
+        test('all constants should not be null', () => {
+            expect(DEFAULT_CONFIG).not.toBeNull()
+            expect(PAYMENT_METHODS).not.toBeNull()
+            expect(TARGETS).not.toBeNull()
+            expect(HTTP_STATUS_CODES).not.toBeNull()
+            expect(HTTP_REQUEST_METHODS).not.toBeNull()
+        })
+
+        test('all constants should be defined', () => {
+            expect(DEFAULT_CONFIG).toBeDefined()
+            expect(PAYMENT_METHODS).toBeDefined()
+            expect(TARGETS).toBeDefined()
+            expect(HTTP_STATUS_CODES).toBeDefined()
+            expect(HTTP_REQUEST_METHODS).toBeDefined()
+        })
+    })
+
+    describe('Constants Values', () => {
+        test('DEFAULT_CONFIG should have valid URL', () => {
+            expect(DEFAULT_CONFIG.baseUrl).toMatch(/^https?:\/\/.+/)
+        })
+
+        test('DEFAULT_CONFIG timeout should be positive number', () => {
+            expect(DEFAULT_CONFIG.timeout).toBeGreaterThan(0)
+        })
+
+        test('PAYMENT_METHODS should have string values', () => {
+            Object.values(PAYMENT_METHODS).forEach((value) => {
+                expect(typeof value).toBe('string')
+            })
+        })
+
+        test('TARGETS should have string values', () => {
+            Object.values(TARGETS).forEach((value) => {
+                expect(typeof value).toBe('string')
+            })
+        })
+
+        test('HTTP_STATUS_CODES should have number values', () => {
+            Object.values(HTTP_STATUS_CODES).forEach((value) => {
+                expect(typeof value).toBe('number')
+            })
+        })
+
+        test('HTTP_REQUEST_METHODS should have string values', () => {
+            Object.values(HTTP_REQUEST_METHODS).forEach((value) => {
+                expect(typeof value).toBe('string')
+            })
+        })
+    })
+})