Erros

{
  "error": {
    "code": "PLAN_FEATURE_LOCKED",
    "message": "Essa feature está liberada a partir do plano VOO.",
    "details": {
      "feature": "CONTACTS",
      "currentPlan": "ESSENTIAL",
      "upgradeTo": "VOO"
    }
  }
}

// arara.js
const API_URL = 'https://api.ararahq.com/v1/messages';
const MAX_ATTEMPTS = 4;

class AraraError extends Error {
  constructor(status, code, message, details) {
    super(message);
    this.name = 'AraraError';
    this.status = status;
    this.code = code; // undefined quando a resposta não segue o formato padrão
    this.details = details;
  }
}

const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));

async function readError(res) {
  const text = await res.text();
  let payload = null;
  try {
    payload = text ? JSON.parse(text) : null;
  } catch {
    payload = null;
  }

  const error = payload && payload.error;
  if (error && typeof error === 'object') {
    return new AraraError(res.status, error.code, error.message || `HTTP ${res.status}`, error.details || {});
  }
  const message = typeof error === 'string' ? error : `HTTP ${res.status}`;
  return new AraraError(res.status, undefined, message, {});
}

function shouldRetry(res, error) {
  if (error.code === 'MARKETING_FREQUENCY_EXCEEDED') return false;
  return res.status === 429 || res.status >= 500;
}

function retryDelayMs(res, attempt) {
  const retryAfter = Number(res.headers.get('Retry-After'));
  if (Number.isFinite(retryAfter) && retryAfter > 0) return retryAfter * 1000;
  return 500 * 2 ** attempt;
}

// idempotencyKey: derive de um id do seu sistema, ex.: `pedido-${order.id}-confirmacao`.
async function sendMessage(body, idempotencyKey) {
  for (let attempt = 0; attempt < MAX_ATTEMPTS; attempt += 1) {
    const res = await fetch(API_URL, {
      method: 'POST',
      headers: {
        Authorization: `Bearer ${process.env.ARARA_API_KEY}`,
        'Content-Type': 'application/json',
        'Idempotency-Key': idempotencyKey,
      },
      body: JSON.stringify(body),
    });

    if (res.ok) return res.json();

    const error = await readError(res);
    const lastAttempt = attempt === MAX_ATTEMPTS - 1;
    if (!shouldRetry(res, error) || lastAttempt) throw error;

    await sleep(retryDelayMs(res, attempt));
  }
  throw new Error('unreachable');
}

module.exports = { sendMessage, AraraError };

// confirmar-pedido.js
const { sendMessage, AraraError } = require('./arara');

async function confirmarPedido(order) {
  try {
    return await sendMessage(
      {
        receiver: order.phone, // +5511999999999
        templateName: 'pedido_confirmado',
        templateVariables: [order.customerName, String(order.id)],
      },
      `pedido-${order.id}-confirmacao`,
    );
  } catch (err) {
    if (!(err instanceof AraraError)) throw err;

    if (err.status === 401) throw new Error('Chave de API inválida, revogada ou expirada');
    if (err.status === 403 && !err.code) throw new Error('Chave de API sem permissão para esta rota');

    switch (err.code) {
      case 'RECIPIENT_OPTED_OUT':
      case 'NUMBER_BLOCKED':
      case 'INVALID_RECIPIENT':
        console.warn(`Remova ${order.phone} da lista: ${err.code}`);
        return null;
      case 'INSUFFICIENT_FUNDS':
      case 'ACCOUNT_NOT_ACTIVATED':
        throw new Error(`Envios parados: ${err.message}`);
      default:
        throw err;
    }
  }
}

module.exports = { confirmarPedido };