@easyflow/javascript-sdk 2.1.8 → 2.1.9

package/libs/errors.mjs

@@ -1,62 +0,0 @@
-/**
- * Custom error class for Easyflow SDK
- */
-export class EasyflowError extends Error {
-    /**
-     * @param {string} message - Error message
-     * @param {number} status - HTTP status code
-     * @param {string} code - Error code for programmatic handling
-     */
-    constructor(message, status, code) {
-        super(message)
-        this.name = 'EasyflowError'
-        this.status = status
-        this.code = code
-    }
-}
-
-/**
- * Erros de Segurança
- */
-export class SecurityError extends Error {
-    constructor(message) {
-        super(message)
-        this.name = 'SecurityError'
-        this.code = 'SECURITY_VIOLATION'
-    }
-}
-
-export class ValidationError extends Error {
-    constructor(message) {
-        super(message)
-        this.name = 'ValidationError'
-        this.code = 'VALIDATION_ERROR'
-    }
-}
-
-export class NetworkError extends Error {
-    constructor(message) {
-        super(message)
-        this.name = 'NetworkError'
-        this.code = 'NETWORK_ERROR'
-    }
-}
-
-/**
- * Error codes for Easyflow SDK
- */
-export const ERROR_CODES = {
-    VALIDATION_ERROR: 'VALIDATION_ERROR',
-    MISSING_BUSINESS_ID: 'MISSING_BUSINESS_ID',
-    OFFER_NOT_FOUND: 'OFFER_NOT_FOUND',
-    ORDER_NOT_FOUND: 'ORDER_NOT_FOUND',
-    INVALID_PAYMENT_METHOD: 'INVALID_PAYMENT_METHOD',
-    MISSING_CREDIT_CARD_DATA: 'MISSING_CREDIT_CARD_DATA',
-    PLACE_ORDER_FAILED: 'PLACE_ORDER_FAILED',
-    CHARGE_FAILED: 'CHARGE_FAILED',
-    ENCRYPTION_FAILED: 'ENCRYPTION_FAILED',
-    NETWORK_ERROR: 'NETWORK_ERROR',
-    INVALID_RESPONSE: 'INVALID_RESPONSE',
-    GET_OFFER_FAILED: 'GET_OFFER_FAILED',
-    GET_ORDER_FAILED: 'GET_ORDER_FAILED',
-}

package/libs/errors.spec.js

@@ -1,178 +0,0 @@
-import { jest } from '@jest/globals'
-import {
-    EasyflowError,
-    SecurityError,
-    ValidationError,
-    NetworkError,
-    ERROR_CODES,
-} from './errors.mjs'
-
-describe('Error Classes', () => {
-    describe('EasyflowError', () => {
-        test('should create EasyflowError with message, status, and code', () => {
-            const error = new EasyflowError('Test error', 400, 'TEST_ERROR')
-
-            expect(error.message).toBe('Test error')
-            expect(error.status).toBe(400)
-            expect(error.code).toBe('TEST_ERROR')
-            expect(error.name).toBe('EasyflowError')
-            expect(error).toBeInstanceOf(Error)
-        })
-
-        test('should create EasyflowError with only message', () => {
-            const error = new EasyflowError('Test error')
-
-            expect(error.message).toBe('Test error')
-            expect(error.status).toBeUndefined()
-            expect(error.code).toBeUndefined()
-            expect(error.name).toBe('EasyflowError')
-        })
-
-        test('should be throwable', () => {
-            expect(() => {
-                throw new EasyflowError('Test error', 400, 'TEST_ERROR')
-            }).toThrow(EasyflowError)
-        })
-    })
-
-    describe('SecurityError', () => {
-        test('should create SecurityError with message', () => {
-            const error = new SecurityError('Security violation')
-
-            expect(error.message).toBe('Security violation')
-            expect(error.name).toBe('SecurityError')
-            expect(error.code).toBe('SECURITY_VIOLATION')
-            expect(error).toBeInstanceOf(Error)
-        })
-
-        test('should be throwable', () => {
-            expect(() => {
-                throw new SecurityError('Security violation')
-            }).toThrow(SecurityError)
-        })
-
-        test('should have correct error code', () => {
-            const error = new SecurityError('Test')
-            expect(error.code).toBe('SECURITY_VIOLATION')
-        })
-    })
-
-    describe('ValidationError', () => {
-        test('should create ValidationError with message', () => {
-            const error = new ValidationError('Validation failed')
-
-            expect(error.message).toBe('Validation failed')
-            expect(error.name).toBe('ValidationError')
-            expect(error.code).toBe('VALIDATION_ERROR')
-            expect(error).toBeInstanceOf(Error)
-        })
-
-        test('should be throwable', () => {
-            expect(() => {
-                throw new ValidationError('Validation failed')
-            }).toThrow(ValidationError)
-        })
-
-        test('should have correct error code', () => {
-            const error = new ValidationError('Test')
-            expect(error.code).toBe('VALIDATION_ERROR')
-        })
-    })
-
-    describe('NetworkError', () => {
-        test('should create NetworkError with message', () => {
-            const error = new NetworkError('Network timeout')
-
-            expect(error.message).toBe('Network timeout')
-            expect(error.name).toBe('NetworkError')
-            expect(error.code).toBe('NETWORK_ERROR')
-            expect(error).toBeInstanceOf(Error)
-        })
-
-        test('should be throwable', () => {
-            expect(() => {
-                throw new NetworkError('Network timeout')
-            }).toThrow(NetworkError)
-        })
-
-        test('should have correct error code', () => {
-            const error = new NetworkError('Test')
-            expect(error.code).toBe('NETWORK_ERROR')
-        })
-    })
-
-    describe('ERROR_CODES', () => {
-        test('should contain all expected error codes', () => {
-            expect(ERROR_CODES).toEqual({
-                VALIDATION_ERROR: 'VALIDATION_ERROR',
-                MISSING_BUSINESS_ID: 'MISSING_BUSINESS_ID',
-                OFFER_NOT_FOUND: 'OFFER_NOT_FOUND',
-                ORDER_NOT_FOUND: 'ORDER_NOT_FOUND',
-                INVALID_PAYMENT_METHOD: 'INVALID_PAYMENT_METHOD',
-                MISSING_CREDIT_CARD_DATA: 'MISSING_CREDIT_CARD_DATA',
-                PLACE_ORDER_FAILED: 'PLACE_ORDER_FAILED',
-                CHARGE_FAILED: 'CHARGE_FAILED',
-                ENCRYPTION_FAILED: 'ENCRYPTION_FAILED',
-                NETWORK_ERROR: 'NETWORK_ERROR',
-                INVALID_RESPONSE: 'INVALID_RESPONSE',
-                GET_OFFER_FAILED: 'GET_OFFER_FAILED',
-                GET_ORDER_FAILED: 'GET_ORDER_FAILED',
-            })
-        })
-
-        test('should have correct error code values', () => {
-            expect(ERROR_CODES.VALIDATION_ERROR).toBe('VALIDATION_ERROR')
-            expect(ERROR_CODES.NETWORK_ERROR).toBe('NETWORK_ERROR')
-            expect(ERROR_CODES.MISSING_BUSINESS_ID).toBe('MISSING_BUSINESS_ID')
-            expect(ERROR_CODES.OFFER_NOT_FOUND).toBe('OFFER_NOT_FOUND')
-            expect(ERROR_CODES.ORDER_NOT_FOUND).toBe('ORDER_NOT_FOUND')
-            expect(ERROR_CODES.INVALID_PAYMENT_METHOD).toBe(
-                'INVALID_PAYMENT_METHOD'
-            )
-            expect(ERROR_CODES.MISSING_CREDIT_CARD_DATA).toBe(
-                'MISSING_CREDIT_CARD_DATA'
-            )
-            expect(ERROR_CODES.PLACE_ORDER_FAILED).toBe('PLACE_ORDER_FAILED')
-            expect(ERROR_CODES.CHARGE_FAILED).toBe('CHARGE_FAILED')
-            expect(ERROR_CODES.ENCRYPTION_FAILED).toBe('ENCRYPTION_FAILED')
-            expect(ERROR_CODES.INVALID_RESPONSE).toBe('INVALID_RESPONSE')
-            expect(ERROR_CODES.GET_OFFER_FAILED).toBe('GET_OFFER_FAILED')
-            expect(ERROR_CODES.GET_ORDER_FAILED).toBe('GET_ORDER_FAILED')
-        })
-    })
-
-    describe('Error Inheritance', () => {
-        test('all custom errors should inherit from Error', () => {
-            expect(new EasyflowError()).toBeInstanceOf(Error)
-            expect(new SecurityError()).toBeInstanceOf(Error)
-            expect(new ValidationError()).toBeInstanceOf(Error)
-            expect(new NetworkError()).toBeInstanceOf(Error)
-        })
-
-        test('SecurityError should not be instance of EasyflowError', () => {
-            expect(new SecurityError()).not.toBeInstanceOf(EasyflowError)
-        })
-
-        test('ValidationError should not be instance of EasyflowError', () => {
-            expect(new ValidationError()).not.toBeInstanceOf(EasyflowError)
-        })
-
-        test('NetworkError should not be instance of EasyflowError', () => {
-            expect(new NetworkError()).not.toBeInstanceOf(EasyflowError)
-        })
-    })
-
-    describe('Error Stack Traces', () => {
-        test('should have stack traces', () => {
-            const error = new EasyflowError('Test error')
-            expect(error.stack).toBeDefined()
-            expect(typeof error.stack).toBe('string')
-        })
-
-        test('should have stack traces for all error types', () => {
-            expect(new SecurityError('Test').stack).toBeDefined()
-            expect(new ValidationError('Test').stack).toBeDefined()
-            expect(new NetworkError('Test').stack).toBeDefined()
-        })
-    })
-})

package/libs/exception-handler.mjs

@@ -1,21 +0,0 @@
-/**
- * Exception handler utility for Easyflow SDK
- *
- * This module provides a centralized way to handle and throw errors
- * throughout the SDK.
- */
-
-/**
- * Throws an error - used for centralized error handling
- *
- * @param {Error} error - Error object to throw
- * @throws {Error} The provided error
- *
- * @example
- * ```javascript
- * throwsError(new ValidationError('Invalid input'));
- * ```
- */
-export const throwsError = (error) => {
-    throw error
-}

package/libs/exception-handler.spec.js

@@ -1,237 +0,0 @@
-import { jest } from '@jest/globals'
-import { throwsError } from './exception-handler.mjs'
-
-describe('Exception Handler', () => {
-    describe('throwsError', () => {
-        test('should throw the provided error', () => {
-            const testError = new Error('Test error message')
-
-            expect(() => {
-                throwsError(testError)
-            }).toThrow(testError)
-        })
-
-        test('should throw custom error types', () => {
-            const customError = {
-                name: 'CustomError',
-                message: 'Custom error message',
-                code: 'CUSTOM_ERROR',
-            }
-
-            expect(() => {
-                throwsError(customError)
-            }).toThrow(customError)
-        })
-
-        test('should throw error with message', () => {
-            const errorMessage = 'Network timeout error'
-            const testError = new Error(errorMessage)
-
-            expect(() => {
-                throwsError(testError)
-            }).toThrow(errorMessage)
-        })
-
-        test('should throw error with stack trace', () => {
-            const testError = new Error('Test error')
-
-            expect(() => {
-                throwsError(testError)
-            }).toThrow(testError)
-
-            expect(testError.stack).toBeDefined()
-        })
-
-        test('should throw error with additional properties', () => {
-            const testError = new Error('Test error')
-            testError.statusCode = 500
-            testError.customProperty = 'custom value'
-
-            expect(() => {
-                throwsError(testError)
-            }).toThrow(testError)
-
-            expect(testError.statusCode).toBe(500)
-            expect(testError.customProperty).toBe('custom value')
-        })
-
-        test('should throw null error', () => {
-            expect(() => {
-                throwsError(null)
-            }).toThrow()
-        })
-
-        test('should throw undefined error', () => {
-            expect(() => {
-                throwsError(undefined)
-            }).toThrow()
-        })
-
-        test('should throw string as error', () => {
-            const errorString = 'String error message'
-
-            expect(() => {
-                throwsError(errorString)
-            }).toThrow(errorString)
-        })
-
-        test('should throw number as error', () => {
-            const errorNumber = 404
-
-            expect(() => {
-                throwsError(errorNumber)
-            }).toThrow()
-        })
-
-        test('should throw object as error', () => {
-            const errorObject = {
-                message: 'Object error message',
-                code: 'OBJECT_ERROR',
-            }
-
-            expect(() => {
-                throwsError(errorObject)
-            }).toThrow()
-        })
-
-        test('should preserve error name', () => {
-            const testError = new TypeError('Type error message')
-
-            expect(() => {
-                throwsError(testError)
-            }).toThrow(TypeError)
-        })
-
-        test('should preserve error constructor', () => {
-            const testError = new RangeError('Range error message')
-
-            expect(() => {
-                throwsError(testError)
-            }).toThrow(RangeError)
-        })
-
-        test('should handle multiple consecutive throws', () => {
-            const error1 = new Error('First error')
-            const error2 = new Error('Second error')
-
-            expect(() => {
-                throwsError(error1)
-            }).toThrow('First error')
-
-            expect(() => {
-                throwsError(error2)
-            }).toThrow('Second error')
-        })
-
-        test('should handle async context', async () => {
-            const testError = new Error('Async error')
-
-            await expect(async () => {
-                throwsError(testError)
-            }).rejects.toThrow('Async error')
-        })
-
-        test('should handle promise rejection context', () => {
-            const testError = new Error('Promise error')
-
-            const promise = Promise.resolve().then(() => {
-                throwsError(testError)
-            })
-
-            return expect(promise).rejects.toThrow('Promise error')
-        })
-
-        test('should handle error with circular references', () => {
-            const testError = new Error('Circular error')
-            testError.self = testError
-
-            expect(() => {
-                throwsError(testError)
-            }).toThrow(testError)
-        })
-
-        test('should handle error with functions', () => {
-            const testError = new Error('Function error')
-            testError.handler = () => 'handler function'
-
-            expect(() => {
-                throwsError(testError)
-            }).toThrow(testError)
-
-            expect(typeof testError.handler).toBe('function')
-        })
-
-        test('should handle error with arrays', () => {
-            const testError = new Error('Array error')
-            testError.items = [1, 2, 3, 'test']
-
-            expect(() => {
-                throwsError(testError)
-            }).toThrow(testError)
-
-            expect(Array.isArray(testError.items)).toBe(true)
-        })
-
-        test('should handle error with nested objects', () => {
-            const testError = new Error('Nested error')
-            testError.details = {
-                level1: {
-                    level2: {
-                        level3: 'deep value',
-                    },
-                },
-            }
-
-            expect(() => {
-                throwsError(testError)
-            }).toThrow(testError)
-
-            expect(testError.details.level1.level2.level3).toBe('deep value')
-        })
-
-        test('should handle error with symbols', () => {
-            const testError = new Error('Symbol error')
-            const symbol = Symbol('test')
-            testError[symbol] = 'symbol value'
-
-            expect(() => {
-                throwsError(testError)
-            }).toThrow(testError)
-
-            expect(testError[symbol]).toBe('symbol value')
-        })
-
-        test('should handle error with getters and setters', () => {
-            const testError = new Error('Getter/Setter error')
-            Object.defineProperty(testError, 'computed', {
-                get() {
-                    return 'computed value'
-                },
-                set(value) {
-                    this._computed = value
-                },
-                enumerable: true,
-            })
-
-            expect(() => {
-                throwsError(testError)
-            }).toThrow(testError)
-
-            expect(testError.computed).toBe('computed value')
-        })
-
-        test('should handle error with non-enumerable properties', () => {
-            const testError = new Error('Non-enumerable error')
-            Object.defineProperty(testError, 'hidden', {
-                value: 'hidden value',
-                enumerable: false,
-            })
-
-            expect(() => {
-                throwsError(testError)
-            }).toThrow(testError)
-
-            expect(testError.hidden).toBe('hidden value')
-        })
-    })
-})