Diagrama de Componentes

🏗️ Visão Geral dos Componentes

O Payment Gateway é organizado em camadas bem definidas, cada uma com responsabilidades específicas:

┌─────────────────────────────────────────────────────────────────┐
│                        PRESENTATION LAYER                       │
├─────────────────┬─────────────────┬─────────────────────────────┤
│   Dashboard     │   Widget API    │      Public Assets         │
│   Admin Panel   │   Embed Scripts │      Static Files          │
└─────────────────┴─────────────────┴─────────────────────────────┘
                               │
┌─────────────────────────────────────────────────────────────────┐
│                          API GATEWAY                            │
├─────────────────┬─────────────────┬─────────────────────────────┤
│   Rate Limiting │   Authentication│      CORS & Security       │
│   Load Balancer │   Authorization │      Request Logging       │
└─────────────────┴─────────────────┴─────────────────────────────┘
                               │
┌─────────────────────────────────────────────────────────────────┐
│                       BUSINESS LOGIC LAYER                      │
├─────────────────┬─────────────────┬─────────────────────────────┤
│ Payment Service │ Webhook Service │    Security Service        │
│ Validation      │ Event Processing│    Encryption/Decryption   │
│ Orchestration   │ Retry Logic     │    Fraud Detection         │
└─────────────────┴─────────────────┴─────────────────────────────┘
                               │
┌─────────────────────────────────────────────────────────────────┐
│                      INTEGRATION LAYER                          │
├─────────────────┬─────────────────┬─────────────────────────────┤
│ Stripe Adapter  │ PayPal Adapter  │   MercadoPago Adapter      │
│ Card Processing │ Express Checkout│   PIX & Boleto             │
│ Subscriptions   │ Subscriptions   │   Credit Card              │
└─────────────────┴─────────────────┴─────────────────────────────┘
                               │
┌─────────────────────────────────────────────────────────────────┐
│                         DATA ACCESS LAYER                       │
├─────────────────┬─────────────────┬─────────────────────────────┤
│ Database Models │    Cache Layer  │      File Storage          │
│ Query Builder   │    Redis Client │      Log Files             │
│ Migrations      │    Session Store│      Backup Files          │
└─────────────────┴─────────────────┴─────────────────────────────┘
                               │
┌─────────────────────────────────────────────────────────────────┐
│                       INFRASTRUCTURE LAYER                      │
├─────────────────┬─────────────────┬─────────────────────────────┤
│   SQLite/PG     │     Redis       │      Monitoring            │
│   Database      │     Cache       │      Prometheus            │
│   Persistence   │     Sessions    │      Health Checks         │
└─────────────────┴─────────────────┴─────────────────────────────┘

📦 Detalhamento dos Componentes

🎨 Presentation Layer

Dashboard (public/dashboard.html)

• Responsabilidade: Interface administrativa para monitoring

• Tecnologia: HTML, CSS, JavaScript vanilla + Chart.js

• Features:

  • Real-time payment statistics

  • Provider health monitoring

  • Transaction analytics

  • System performance metrics

Widget API (src/controllers/WidgetController.js)

• Responsabilidade: Servir widgets embarcáveis

• Tecnologia: Express.js

• Features:

  • Dynamic widget generation

  • Theme customization

  • Cross-domain embedding

  • Event-driven communication

Public Assets (public/)

• Responsabilidade: Servir arquivos estáticos

• Conteúdo:

  • CSS themes

  • JavaScript libraries

  • Images and icons

  • Widget scripts

🚪 API Gateway Layer

Rate Limiting (api/middleware/rateLimitMiddleware.js)

• Implementação: express-rate-limit

• Configuração:

  • 1000 requests/hour por IP (geral)

  • 100 requests/hour para endpoints de pagamento

  • 10 requests/minute para login

Authentication (api/middleware/authMiddleware.js)

• Método: JWT tokens com refresh

• Features:

  • Token validation

  • Role-based access control

  • Session management

  • API key authentication

Security (api/middleware/securityMiddleware.js)

• Implementação: helmet + custom rules

• Features:

  • CORS configuration

  • CSP headers

  • Request sanitization

  • Security headers

🧠 Business Logic Layer

Payment Service (src/services/PaymentService.js)

class PaymentService {
  async processPayment(paymentData) {
    // 1. Validate input data
    // 2. Select optimal provider
    // 3. Execute payment
    // 4. Handle response
    // 5. Store transaction
    // 6. Trigger webhooks
  }
}

Webhook Service (src/services/WebhookService.js)

class WebhookService {
  async processWebhook(provider, payload, signature) {
    // 1. Verify webhook signature
    // 2. Parse event data
    // 3. Update transaction status
    // 4. Trigger business events
    // 5. Log for audit
  }
}

Security Service (src/services/SecurityService.js)

class SecurityService {
  encrypt(data) { /* AES-256 encryption */ }
  decrypt(encryptedData) { /* AES-256 decryption */ }
  tokenizeCard(cardNumber) { /* PCI compliant tokenization */ }
  detectFraud(transaction) { /* Fraud scoring */ }
}

🔌 Integration Layer

Stripe Adapter (integrations/stripe/stripe-provider.js)

class StripeProvider extends PaymentProvider {
  async processPayment(paymentData) {
    const paymentIntent = await stripe.paymentIntents.create({
      amount: paymentData.amount * 100,
      currency: paymentData.currency,
      automatic_payment_methods: { enabled: true }
    });
    return this.normalizeResponse(paymentIntent);
  }
}

PayPal Adapter (integrations/paypal/paypal-provider.js)

class PayPalProvider extends PaymentProvider {
  async processPayment(paymentData) {
    const order = await this.createOrder(paymentData);
    return this.normalizeResponse(order);
  }
}

MercadoPago Adapter (integrations/mercadopago/mercadopago-provider.js)

class MercadoPagoProvider extends PaymentProvider {
  async processPayment(paymentData) {
    if (paymentData.method === 'pix') {
      return await this.createPixPayment(paymentData);
    }
    return await this.createPreference(paymentData);
  }
}

💾 Data Access Layer

Database Models (src/models/)

class Database {
  constructor() {
    this.db = new sqlite3.Database('./database/payments.sqlite');
  }
  
  async createPayment(paymentData) {
    // Insert payment record with transaction
  }
  
  async getPaymentById(id) {
    // Retrieve payment with related data
  }
}

Cache Layer (src/services/CacheService.js)

class CacheService {
  constructor() {
    this.redis = new Redis(process.env.REDIS_URL);
  }
  
  async get(key) { /* Redis get */ }
  async set(key, value, ttl) { /* Redis set with TTL */ }
  async invalidate(pattern) { /* Pattern-based invalidation */ }
}

🔧 Infrastructure Layer

Database Schema

-- Core payment tables
CREATE TABLE payments (
  id TEXT PRIMARY KEY,
  merchant_id TEXT NOT NULL,
  amount DECIMAL(10,2) NOT NULL,
  currency TEXT NOT NULL,
  status TEXT NOT NULL,
  provider TEXT NOT NULL,
  created_at DATETIME DEFAULT CURRENT_TIMESTAMP
);

CREATE TABLE transactions (
  id TEXT PRIMARY KEY,
  payment_id TEXT NOT NULL,
  provider_transaction_id TEXT,
  status TEXT NOT NULL,
  metadata JSON,
  FOREIGN KEY (payment_id) REFERENCES payments(id)
);

Monitoring Components (monitoring/)

• Health Checks: Database, Redis, external APIs

• Metrics: Business KPIs, technical metrics

• Alerting: Slack, email, PagerDuty integration

• Dashboards: Real-time monitoring interface

🔄 Fluxo de Dados Entre Componentes

1. Payment Processing Flow

Client Request
    ↓
API Gateway (rate limit, auth)
    ↓
Payment Controller
    ↓
Payment Service (validation, orchestration)
    ↓
Provider Adapter (Stripe/PayPal/MercadoPago)
    ↓
External API Call
    ↓
Response Processing
    ↓
Database Storage
    ↓
Webhook Trigger
    ↓
Client Response

2. Webhook Processing Flow

Provider Webhook
    ↓
Webhook Controller (signature verification)
    ↓
Webhook Service (event processing)
    ↓
Payment Status Update
    ↓
Business Event Trigger
    ↓
Audit Log

3. Monitoring Data Flow

Application Events
    ↓
Metrics Collection (Prometheus)
    ↓
Time Series Storage
    ↓
Dashboard Visualization
    ↓
Alerting Rules
    ↓
Notification Channels

🚀 Deployment Components

Container Architecture

# Multi-stage build
FROM node:18-alpine AS builder
FROM node:18-alpine AS runtime
# Optimized for production

Kubernetes Components

• Deployment: Application pods with rolling updates

• Service: Load balancer for internal communication

• Ingress: External traffic routing with TLS

• ConfigMap: Non-sensitive configuration

• Secret: Sensitive data (API keys, passwords)

• HPA: Horizontal Pod Autoscaler

📊 Performance Características

Latency Targets

• Payment API: < 200ms (95th percentile)

• Dashboard: < 1s (initial load)

• Webhooks: < 100ms (processing)

Throughput Targets

• Payments: 1000 TPS (sustained)

• Webhooks: 5000 TPS (burst)

• API Calls: 10000 TPS (general)

Availability

• Target: 99.9% uptime

• RTO: 5 minutes (Recovery Time Objective)

• RPO: 15 minutes (Recovery Point Objective)

---

Última atualização: December 2024