Melhores Práticas

class PaymentCache {
  constructor(ttl = 300000) { // 5 minutos
    this.cache = new Map();
    this.ttl = ttl;
  }

  get(key) {
    const item = this.cache.get(key);
    if (!item) return null;

    if (Date.now() > item.expiry) {
      this.cache.delete(key);
      return null;
    }

    return item.data;
  }

  set(key, data) {
    this.cache.set(key, {
      data,
      expiry: Date.now() + this.ttl
    });
  }

  // Cache para consultas de status
  async getPaymentStatus(transactionId) {
    const cacheKey = `payment_status_${transactionId}`;
    let status = this.get(cacheKey);

    if (!status) {
      status = await this.apiClient.getPayment(transactionId);

      // Cache apenas status finais
      if (['APPROVED', 'DENIED', 'CANCELLED'].includes(status.status)) {
        this.set(cacheKey, status);
      }
    }

    return status;
  }
}

const timeoutConfig = {
  // Operações de consulta
  read: 10000,    // 10 segundos

  // Criação de transações
  create: 30000,  // 30 segundos

  // Operações críticas (captura, cancelamento)
  critical: 60000 // 60 segundos
};

async function createPayment(paymentData) {
  return await makeRequest(
    '/credit-card/v1/payment',
    {
      method: 'POST',
      body: JSON.stringify(paymentData),
      signal: AbortSignal.timeout(timeoutConfig.create)
    }
  );
}

const promClient = require('prom-client');

// Contador de transações
const transactionCounter = new promClient.Counter({
  name: 'firebanking_transactions_total',
  help: 'Total de transações processadas',
  labelNames: ['method', 'status']
});

// Histograma de latência
const requestDuration = new promClient.Histogram({
  name: 'firebanking_request_duration_seconds',
  help: 'Duração das requisições para FireBanking',
  labelNames: ['endpoint', 'method'],
  buckets: [0.1, 0.5, 1, 2, 5, 10]
});

// Gauge para taxa de sucesso
const successRate = new promClient.Gauge({
  name: 'firebanking_success_rate',
  help: 'Taxa de sucesso das transações'
});

// Middleware para medir performance
function measurePerformance(endpoint) {
  const end = requestDuration.startTimer({ endpoint });

  return {
    success: () => {
      end();
      transactionCounter.inc({ method: endpoint, status: 'success' });
    },
    error: () => {
      end();
      transactionCounter.inc({ method: endpoint, status: 'error' });
    }
  };
}

// artillery.yml
config:
  target: 'https://api-gateway.firebanking.dev/v1'
  phases:
    - duration: 60
      arrivalRate: 10
  defaults:
    headers:
      x-api-key: 'SUA_CHAVE_DE_API'

scenarios:
  - name: "Criar pagamento"
    weight: 70
    flow:
      - post:
          url: "/credit-card/v1/payment"
          json:
            purchaseValue: 100
            installments: 1
            externalId: "perf_test_{{ $randomString() }}"

  - name: "Consultar status"
    weight: 30
    flow:
      - get:
          url: "/credit-card/v1/payment/{{ transactionId }}"

app.get('/health', async (req, res) => {
  const checks = {
    timestamp: new Date().toISOString(),
    status: 'ok',
    checks: {}
  };

  try {
    // Verificar conectividade com FireBanking
    const start = Date.now();
    await firebankingClient.getAccountBalance();
    checks.checks.firebanking = {
      status: 'healthy',
      responseTime: Date.now() - start
    };

  } catch (error) {
    checks.status = 'error';
    checks.checks.firebanking = {
      status: 'unhealthy',
      error: error.message
    };
  }

  const httpStatus = checks.status === 'ok' ? 200 : 503;
  res.status(httpStatus).json(checks);
});

class FireBankingClientSingleton {
  constructor() {
    if (FireBankingClientSingleton.instance) {
      return FireBankingClientSingleton.instance;
    }

    this.client = new FireBankingClient({
      apiKey: process.env.FIREBANKING_API_KEY,
      baseUrl: process.env.FIREBANKING_BASE_URL,
      timeout: 30000,
      retries: 3
    });

    FireBankingClientSingleton.instance = this;
    return this;
  }

  getClient() {
    return this.client;
  }
}

// Uso
const client = new FireBankingClientSingleton().getClient();

class CircuitBreaker {
  constructor(threshold = 5, timeout = 60000) {
    this.failureThreshold = threshold;
    this.timeout = timeout;
    this.failureCount = 0;
    this.state = 'CLOSED'; // CLOSED, OPEN, HALF_OPEN
    this.lastFailureTime = null;
  }

  async execute(operation) {
    if (this.state === 'OPEN') {
      if (Date.now() - this.lastFailureTime > this.timeout) {
        this.state = 'HALF_OPEN';
      } else {
        throw new Error('Circuit breaker is OPEN');
      }
    }

    try {
      const result = await operation();

      if (this.state === 'HALF_OPEN') {
        this.state = 'CLOSED';
        this.failureCount = 0;
      }

      return result;

    } catch (error) {
      this.failureCount++;
      this.lastFailureTime = Date.now();

      if (this.failureCount >= this.failureThreshold) {
        this.state = 'OPEN';
      }

      throw error;
    }
  }
}

// Uso
const circuitBreaker = new CircuitBreaker();

async function createPayment(paymentData) {
  return circuitBreaker.execute(() =>
    firebankingClient.createPayment(paymentData)
  );
}