@easyflow/javascript-sdk 2.1.7

package/libs/validator.spec.js

@@ -0,0 +1,615 @@
+import { describe, expect, jest, test } from '@jest/globals'
+import { Validator } from './validator.mjs'
+import { EasyflowError } from './errors.mjs'
+
+jest.mock('./exception-handler.mjs', () => ({
+    throwsError: jest.fn((error) => {
+        throw error
+    }),
+}))
+
+describe('Validator', () => {
+    describe('validateEmail', () => {
+        test('should validate correct email addresses', () => {
+            const validEmails = [
+                'user@example.com',
+                'user.name@example.com',
+                'user+tag@example.co.uk',
+                '123@example.org',
+                'user@subdomain.example.com',
+            ]
+
+            validEmails.forEach((email) => {
+                expect(() => Validator.validateEmail(email)).not.toThrow()
+            })
+        })
+
+        test('should reject invalid email addresses', () => {
+            const invalidEmails = [
+                'invalid-email',
+                '@example.com',
+                'user@',
+                'user..name@example.com',
+                '.user@example.com',
+                'user@example.com.',
+                'user name@example.com',
+                'user@example..com',
+            ]
+
+            invalidEmails.forEach((email) => {
+                expect(() => Validator.validateEmail(email)).toThrow(
+                    EasyflowError
+                )
+            })
+        })
+
+        test('should reject emails that are too long', () => {
+            const longEmail = 'a'.repeat(250) + '@example.com'
+            expect(() => Validator.validateEmail(longEmail)).toThrow(
+                EasyflowError
+            )
+        })
+    })
+
+    describe('validateCPF', () => {
+        test('should validate correct CPFs', () => {
+            const validCPFs = ['12345678909', '11144477735']
+
+            validCPFs.forEach((cpf) => {
+                expect(() => Validator.validateCPF(cpf)).not.toThrow()
+            })
+        })
+
+        test('should reject invalid CPFs', () => {
+            const invalidCPFs = [
+                '12345678910',
+                '11111111111',
+                '00000000000',
+                '123',
+                '123456789012',
+                'abc123def45',
+            ]
+
+            invalidCPFs.forEach((cpf) => {
+                expect(() => Validator.validateCPF(cpf)).toThrow(EasyflowError)
+            })
+        })
+    })
+
+    describe('validateCNPJ', () => {
+        test('should validate correct CNPJs', () => {
+            const validCNPJs = ['11222333000181', '00000000000191']
+
+            validCNPJs.forEach((cnpj) => {
+                expect(() => Validator.validateCNPJ(cnpj)).not.toThrow()
+            })
+        })
+
+        test('should reject invalid CNPJs', () => {
+            const invalidCNPJs = [
+                '11222333000182',
+                '11111111111111',
+                '00000000000000',
+                '123',
+                '123456789012345',
+                'abc123def45678',
+            ]
+
+            invalidCNPJs.forEach((cnpj) => {
+                expect(() => Validator.validateCNPJ(cnpj)).toThrow(
+                    EasyflowError
+                )
+            })
+        })
+    })
+
+    describe('validateLegalDocument', () => {
+        test('should validate correct legal documents', () => {
+            const validDocuments = [
+                { type: 'CPF', number: '12345678909' },
+                { type: 'CNPJ', number: '11222333000181' },
+            ]
+
+            validDocuments.forEach((doc) => {
+                expect(() => Validator.validateLegalDocument(doc)).not.toThrow()
+            })
+        })
+
+        test('should reject documents with non-digit numbers', () => {
+            expect(() =>
+                Validator.validateLegalDocument({
+                    type: 'CPF',
+                    number: '123.456.789-09',
+                })
+            ).toThrow(EasyflowError)
+
+            expect(() =>
+                Validator.validateLegalDocument({
+                    type: 'CNPJ',
+                    number: '11.222.333/0001-81',
+                })
+            ).toThrow(EasyflowError)
+        })
+
+        test('should reject invalid document types', () => {
+            expect(() =>
+                Validator.validateLegalDocument({
+                    type: 'INVALID',
+                    number: '12345678909',
+                })
+            ).toThrow(EasyflowError)
+        })
+
+        test('should reject missing fields', () => {
+            expect(() =>
+                Validator.validateLegalDocument({
+                    type: 'CPF',
+                })
+            ).toThrow(EasyflowError)
+        })
+    })
+
+    describe('validatePhone', () => {
+        test('should validate correct phone numbers', () => {
+            const validPhones = [
+                {
+                    areaCode: '+55',
+                    ddd: '11',
+                    number: '999999999',
+                    isMobile: true,
+                },
+                {
+                    areaCode: '+1',
+                    ddd: '21',
+                    number: '12345678',
+                    isMobile: false,
+                },
+            ]
+
+            validPhones.forEach((phone) => {
+                expect(() => Validator.validatePhone(phone)).not.toThrow()
+            })
+        })
+
+        test('should reject invalid phone numbers', () => {
+            const invalidPhones = [
+                {
+                    areaCode: '55',
+                    ddd: '11',
+                    number: '999999999',
+                    isMobile: true,
+                },
+                {
+                    areaCode: '+55',
+                    ddd: '1',
+                    number: '999999999',
+                    isMobile: true,
+                },
+                {
+                    areaCode: '+55',
+                    ddd: '11',
+                    number: '123',
+                    isMobile: true,
+                },
+            ]
+
+            invalidPhones.forEach((phone) => {
+                expect(() => Validator.validatePhone(phone)).toThrow(
+                    EasyflowError
+                )
+            })
+        })
+    })
+
+    describe('validateAddress', () => {
+        test('should validate correct addresses', () => {
+            const validAddress = {
+                zipCode: '01234567',
+                street: 'Main Street',
+                complement: 'Apt 123',
+                neighborhood: 'Downtown',
+                city: 'São Paulo',
+                state: 'SP',
+                number: '123',
+            }
+
+            expect(() => Validator.validateAddress(validAddress)).not.toThrow()
+        })
+
+        test('should reject invalid addresses', () => {
+            const invalidAddresses = [
+                {
+                    zipCode: '123',
+                    street: 'Main Street',
+                    neighborhood: 'Downtown',
+                    city: 'São Paulo',
+                    state: 'SP',
+                    number: '123',
+                },
+                {
+                    zipCode: '01234-567',
+                    street: 'Main Street',
+                    neighborhood: 'Downtown',
+                    city: 'São Paulo',
+                    state: 'SP',
+                    number: '123',
+                },
+                {
+                    zipCode: '01234567',
+                    street: 'Ma',
+                    neighborhood: 'Downtown',
+                    city: 'São Paulo',
+                    state: 'SP',
+                    number: '123',
+                },
+                {
+                    zipCode: '01234567',
+                    street: 'Main Street',
+                    neighborhood: 'Downtown',
+                    city: 'São Paulo',
+                    state: 'INVALID',
+                    number: '123',
+                },
+            ]
+
+            invalidAddresses.forEach((address) => {
+                expect(() => Validator.validateAddress(address)).toThrow(
+                    EasyflowError
+                )
+            })
+        })
+    })
+
+    describe('validateCustomer', () => {
+        test('should validate correct customer data', () => {
+            const validCustomer = {
+                name: 'John Doe',
+                email: 'john@example.com',
+                document: { type: 'CPF', number: '12345678909' },
+                phone: {
+                    areaCode: '+55',
+                    ddd: '11',
+                    number: '999999999',
+                    isMobile: true,
+                },
+            }
+
+            expect(() =>
+                Validator.validateCustomer(validCustomer)
+            ).not.toThrow()
+        })
+
+        test('should reject invalid customer data', () => {
+            const invalidCustomer = {
+                name: 'J',
+                email: 'invalid-email',
+                document: { type: 'CPF', number: '12345678909' },
+                phone: {
+                    areaCode: '+55',
+                    ddd: '11',
+                    number: '999999999',
+                    isMobile: true,
+                },
+            }
+
+            expect(() => Validator.validateCustomer(invalidCustomer)).toThrow(
+                EasyflowError
+            )
+        })
+    })
+
+    describe('validatePagination', () => {
+        test('should validate correct pagination parameters', () => {
+            expect(() => Validator.validatePagination(1, 10)).not.toThrow()
+            expect(() => Validator.validatePagination(5, 50)).not.toThrow()
+        })
+
+        test('should reject invalid pagination parameters', () => {
+            expect(() => Validator.validatePagination(0, 10)).toThrow(
+                EasyflowError
+            )
+            expect(() => Validator.validatePagination(1, 0)).toThrow(
+                EasyflowError
+            )
+            expect(() => Validator.validatePagination(1, 101)).toThrow(
+                EasyflowError
+            )
+        })
+    })
+
+    describe('validateBusinessId', () => {
+        test('should validate correct business IDs', () => {
+            const validBusinessIds = [
+                'business-123',
+                'my-business',
+                'company-456-789',
+            ]
+
+            validBusinessIds.forEach((id) => {
+                expect(() => Validator.validateBusinessId(id)).not.toThrow()
+            })
+        })
+
+        test('should reject invalid business IDs', () => {
+            const invalidBusinessIds = [
+                'ab',
+                '-business',
+                'business-',
+                'business--123',
+                'business_123',
+                'business.123',
+            ]
+
+            invalidBusinessIds.forEach((id) => {
+                expect(() => Validator.validateBusinessId(id)).toThrow(
+                    EasyflowError
+                )
+            })
+        })
+    })
+
+    describe('validateCreditCardToken', () => {
+        test('should validate correct credit card tokens', () => {
+            const validTokens = [
+                'a'.repeat(32),
+                'a'.repeat(64),
+                'a'.repeat(128),
+                'abc123_-def456'.repeat(3),
+            ]
+
+            validTokens.forEach((token) => {
+                expect(() =>
+                    Validator.validateCreditCardToken(token)
+                ).not.toThrow()
+            })
+        })
+
+        test('should reject invalid credit card tokens', () => {
+            const invalidTokens = [
+                'a'.repeat(31),
+                'a'.repeat(129),
+                'abc@123',
+                'abc 123',
+                'abc.123',
+            ]
+
+            invalidTokens.forEach((token) => {
+                expect(() => Validator.validateCreditCardToken(token)).toThrow(
+                    EasyflowError
+                )
+            })
+        })
+    })
+
+    describe('validateOrderId', () => {
+        test('should validate correct order IDs', () => {
+            const validOrderIds = [
+                // UUID v4 examples (strict v4)
+                'f47ac10b-58cc-4372-a567-0e02b2c3d479',
+                'a8098c1a-f86e-4f4c-a9f5-0b8add7c7f3d',
+                '16fd2706-8baf-433b-82eb-8c7fada847da',
+                '58c8f2e0-3d22-4b5d-98ab-9c0a1f2b3c4d',
+                // UUID v7 examples
+                '01890b24-2d7f-7c3f-8f1a-123456789abc',
+                '01890b24-2d7f-7c3f-9f1a-123456789abc',
+                '01890b24-2d7f-7c3f-af1a-123456789abc',
+                '01890b24-2d7f-7c3f-bf1a-123456789abc',
+                // MongoDB ObjectId examples
+                '507f1f77bcf86cd799439011',
+                '507f1f77bcf86cd799439012',
+                '507f1f77bcf86cd799439013',
+                '507f1f77bcf86cd799439014',
+            ]
+
+            validOrderIds.forEach((id) => {
+                expect(() => Validator.validateOrderId(id)).not.toThrow()
+            })
+        })
+
+        test('should reject invalid order IDs', () => {
+            const invalidOrderIds = [
+                // Old format patterns
+                'order-1234567890123456',
+                'order-abcdefghijklmnop',
+                // Invalid UUIDs
+                '550e8400-e29b-41d4-a716-44665544000',
+                '550e8400-e29b-41d4-a716-4466554400000',
+                '550e8400-e29b-41d4-a716-44665544000g',
+                '550e8400-e29b-41d4-a716-44665544000',
+                // Invalid UUID v7 (wrong version)
+                '01890b24-2d7f-8c3f-8f1a-123456789abc',
+                '01890b24-2d7f-6c3f-8f1a-123456789abc',
+                // Invalid MongoDB ObjectId
+                '507f1f77bcf86cd79943901',
+                '507f1f77bcf86cd7994390111',
+                '507f1f77bcf86cd79943901g',
+                // Other invalid formats
+                'invalid-uuid',
+                '12345678-1234-1234-1234-123456789012',
+                'not-an-id',
+                '12345',
+                'abc-def-ghi',
+            ]
+
+            invalidOrderIds.forEach((id) => {
+                expect(() => Validator.validateOrderId(id)).toThrow(
+                    EasyflowError
+                )
+            })
+        })
+    })
+
+    describe('validateOfferId', () => {
+        test('should validate correct offer IDs', () => {
+            const validOfferIds = [
+                // UUID v4 examples (strict v4)
+                'f47ac10b-58cc-4372-a567-0e02b2c3d479',
+                'a8098c1a-f86e-4f4c-a9f5-0b8add7c7f3d',
+                '16fd2706-8baf-433b-82eb-8c7fada847da',
+                '58c8f2e0-3d22-4b5d-98ab-9c0a1f2b3c4d',
+                // UUID v7 examples
+                '01890b24-2d7f-7c3f-8f1a-123456789abc',
+                '01890b24-2d7f-7c3f-9f1a-123456789abc',
+                '01890b24-2d7f-7c3f-af1a-123456789abc',
+                '01890b24-2d7f-7c3f-bf1a-123456789abc',
+                // MongoDB ObjectId examples
+                '507f1f77bcf86cd799439011',
+                '507f1f77bcf86cd799439012',
+                '507f1f77bcf86cd799439013',
+                '507f1f77bcf86cd799439014',
+            ]
+
+            validOfferIds.forEach((id) => {
+                expect(() => Validator.validateOfferId(id)).not.toThrow()
+            })
+        })
+
+        test('should reject invalid offer IDs', () => {
+            const invalidOfferIds = [
+                // Old format patterns
+                'offer-1234567890123456',
+                'offer-abcdefghijklmnop',
+                // Invalid UUIDs
+                '550e8400-e29b-41d4-a716-44665544000',
+                '550e8400-e29b-41d4-a716-4466554400000',
+                '550e8400-e29b-41d4-a716-44665544000g',
+                '550e8400-e29b-41d4-a716-44665544000',
+                // Invalid UUID v7 (wrong version)
+                '01890b24-2d7f-8c3f-8f1a-123456789abc',
+                '01890b24-2d7f-6c3f-8f1a-123456789abc',
+                // Invalid MongoDB ObjectId
+                '507f1f77bcf86cd79943901',
+                '507f1f77bcf86cd7994390111',
+                '507f1f77bcf86cd79943901g',
+                // Other invalid formats
+                'invalid-uuid',
+                '12345678-1234-1234-1234-123456789012',
+                'not-an-id',
+                '12345',
+                'abc-def-ghi',
+            ]
+
+            invalidOfferIds.forEach((id) => {
+                expect(() => Validator.validateOfferId(id)).toThrow(
+                    EasyflowError
+                )
+            })
+        })
+    })
+
+    describe('validateCustomerId', () => {
+        test('should validate correct customer IDs', () => {
+            const validCustomerIds = [
+                // UUID v4 examples (strict v4)
+                'f47ac10b-58cc-4372-a567-0e02b2c3d479',
+                'a8098c1a-f86e-4f4c-a9f5-0b8add7c7f3d',
+                '16fd2706-8baf-433b-82eb-8c7fada847da',
+                '58c8f2e0-3d22-4b5d-98ab-9c0a1f2b3c4d',
+                // UUID v7 examples
+                '01890b24-2d7f-7c3f-8f1a-123456789abc',
+                '01890b24-2d7f-7c3f-9f1a-123456789abc',
+                '01890b24-2d7f-7c3f-af1a-123456789abc',
+                '01890b24-2d7f-7c3f-bf1a-123456789abc',
+                // MongoDB ObjectId examples
+                '507f1f77bcf86cd799439011',
+                '507f1f77bcf86cd799439012',
+                '507f1f77bcf86cd799439013',
+                '507f1f77bcf86cd799439014',
+            ]
+
+            validCustomerIds.forEach((id) => {
+                expect(() => Validator.validateCustomerId(id)).not.toThrow()
+            })
+        })
+
+        test('should reject invalid customer IDs', () => {
+            const invalidCustomerIds = [
+                // Old format patterns
+                'customer-1234567890123456',
+                'customer-abcdefghijklmnop',
+                // Invalid UUIDs
+                '550e8400-e29b-41d4-a716-44665544000',
+                '550e8400-e29b-41d4-a716-4466554400000',
+                '550e8400-e29b-41d4-a716-44665544000g',
+                '550e8400-e29b-41d4-a716-44665544000',
+                // Invalid UUID v7 (wrong version)
+                '01890b24-2d7f-8c3f-8f1a-123456789abc',
+                '01890b24-2d7f-6c3f-8f1a-123456789abc',
+                // Invalid MongoDB ObjectId
+                '507f1f77bcf86cd79943901',
+                '507f1f77bcf86cd7994390111',
+                '507f1f77bcf86cd79943901g',
+                // Other invalid formats
+                'invalid-uuid',
+                '12345678-1234-1234-1234-123456789012',
+                'not-an-id',
+                '12345',
+                'abc-def-ghi',
+            ]
+
+            invalidCustomerIds.forEach((id) => {
+                expect(() => Validator.validateCustomerId(id)).toThrow(
+                    EasyflowError
+                )
+            })
+        })
+    })
+
+    describe('validateCreditCardId', () => {
+        test('should validate correct credit card IDs', () => {
+            const validCreditCardIds = [
+                // UUID v4 examples (strict v4)
+                'f47ac10b-58cc-4372-a567-0e02b2c3d479',
+                'a8098c1a-f86e-4f4c-a9f5-0b8add7c7f3d',
+                '16fd2706-8baf-433b-82eb-8c7fada847da',
+                '58c8f2e0-3d22-4b5d-98ab-9c0a1f2b3c4d',
+                // UUID v7 examples
+                '01890b24-2d7f-7c3f-8f1a-123456789abc',
+                '01890b24-2d7f-7c3f-9f1a-123456789abc',
+                '01890b24-2d7f-7c3f-af1a-123456789abc',
+                '01890b24-2d7f-7c3f-bf1a-123456789abc',
+                // MongoDB ObjectId examples
+                '507f1f77bcf86cd799439011',
+                '507f1f77bcf86cd799439012',
+                '507f1f77bcf86cd799439013',
+                '507f1f77bcf86cd799439014',
+            ]
+
+            validCreditCardIds.forEach((id) => {
+                expect(() => Validator.validateCreditCardId(id)).not.toThrow()
+            })
+        })
+
+        test('should reject invalid credit card IDs', () => {
+            const invalidCreditCardIds = [
+                // Old format patterns
+                'card-1234567890123456',
+                'credit-card-abcdefghijklmnop',
+                // Invalid UUIDs
+                '550e8400-e29b-41d4-a716-44665544000',
+                '550e8400-e29b-41d4-a716-4466554400000',
+                '550e8400-e29b-41d4-a716-44665544000g',
+                '550e8400-e29b-41d4-a716-44665544000',
+                // Invalid UUID v7 (wrong version)
+                '01890b24-2d7f-8c3f-8f1a-123456789abc',
+                '01890b24-2d7f-6c3f-8f1a-123456789abc',
+                // Invalid MongoDB ObjectId
+                '507f1f77bcf86cd79943901',
+                '507f1f77bcf86cd7994390111',
+                '507f1f77bcf86cd79943901g',
+                // Other invalid formats
+                'invalid-uuid',
+                '12345678-1234-1234-1234-123456789012',
+                'not-an-id',
+                '12345',
+                'abc-def-ghi',
+            ]
+
+            invalidCreditCardIds.forEach((id) => {
+                expect(() => Validator.validateCreditCardId(id)).toThrow(
+                    EasyflowError
+                )
+            })
+        })
+    })
+})

package/mocks/offer.mock.js

@@ -0,0 +1,77 @@
+/* OFFER MODEL MOCK
+          {
+            id: string,
+            business: {
+              id: string,
+              owner: {
+                id: string,
+                name: string,
+              },
+            },
+            checkoutTemplate: {
+              id: string,
+              createdAt: string,
+              isDefault: boolean,
+              color: 'black-white' | 'blue-theme' | 'green-theme' | 'red-theme' | 'purple-theme' | 'yellow-theme',
+              theme: 'light-theme' | 'dark-theme',
+              name: string,
+              requestAddress: boolean,
+              requestDeliveryAddress: boolean,
+              showSellerName: boolean,
+              acceptNaturalPersonBuyer: boolean,
+              acceptCorporationBuyer: boolean,
+              creditCard: {
+                defaultInstallments?: number | null,
+                maxInstallments?: number | null,
+              },
+              billet: {
+                dueDateDelay?: number | null,
+              },
+              pix: {
+                expirationInMinutes?: number | null,
+              }
+            },
+            name: string,
+            warrantyInDays: number,
+            status: 'draft' | 'active' | 'inactive' | 'blocked',
+            createdAt: string,
+            items: Array<
+              {
+                id: string,
+                product: {
+                  id: string,
+                  name: string,
+                  description: string,
+                  type: 'Online-Course' | 'Mentoring' | 'Consultancy' | 'Subscription' | 'Community' | 'Online-Event' | 'Face-to-face-Event' | 'E-Book' | 'Downloadable-File' | 'App' | 'Physical-Product' | 'Services' | 'Others',
+                  image: {
+                    name: string | null,
+                    path: string | null,
+                    url: string | null,
+                    isPublic: boolean,
+                    extension: string | null,
+                  },
+                  supportContact: {
+                    name: string | null,
+                    email: string | null,
+                    validated: boolean | null
+                  },
+                },
+                priceInCents: number,
+                priceWithoutDiscountValueInCents: number,
+                offerItemType: 'unique-purchase' | 'recurrent',
+                optional: boolean,
+                recurrence?: {
+                  periodicity: 'Monthly' | 'Quarterly' | 'Biannualy' | 'Annualy',
+                  numberRecurrence: number,
+                  recurrenceValueInCents: number,
+                  repeatIndefinitely: boolean,
+                  customValue: {
+                    recurrenceFrom: number | null,
+                    recurrenceTo: number | null,
+                    valueInCents: number | null,
+                  },
+                },
+              }
+            >,
+          }
+        */