Droid

npm install -g @emailverify/cli
bv config set api-key YOUR_API_KEY

export EMAILVERIFY_API_KEY=your-api-key

Ejecutando: bv verify john@example.com --json

{
  "email": "john@example.com",
  "status": "valid",
  "score": 0.88,
  "result": {
    "deliverable": true,
    "disposable": false,
    "role": false
  }
}

✅ El correo electrónico es válido (88% de confianza)

Procesaré el CSV y verificaré cada correo electrónico.

Leyendo contacts.csv... 250 entradas encontradas.

Progreso: ████████████████████ 100%

Informe Resumen:
┌──────────────┬───────┬────────┐
│ Estado       │ Cant. │ %      │
├──────────────┼───────┼────────┤
│ Válido       │ 198   │ 79.2%  │
│ Inválido     │ 32    │ 12.8%  │
│ Desconocido  │ 12    │ 4.8%   │
│ Desechable   │ 8     │ 3.2%   │
└──────────────┴───────┴────────┘

Archivos generados:
- contacts_valid.csv (198 correos electrónicos)
- contacts_invalid.csv (32 correos electrónicos)
- contacts_review.csv (20 correos electrónicos)

¿Te gustaría que te explicara alguno de los correos electrónicos inválidos?

// routes/verify.ts
import { Router } from 'express';
import rateLimit from 'express-rate-limit';

const router = Router();

// Límite de tasa: 100 solicitudes por minuto
const limiter = rateLimit({
  windowMs: 60 * 1000,
  max: 100,
  message: { error: 'Demasiadas solicitudes' }
});

router.post('/verify', limiter, async (req, res) => {
  const { email } = req.body;

  if (!email) {
    return res.status(400).json({ error: 'El correo electrónico es requerido' });
  }

  try {
    const response = await fetch('https://api.emailverify.ai/v1/verify', {
      method: 'POST',
      headers: {
        'Authorization': `Bearer ${process.env.EMAILVERIFY_API_KEY}`,
        'Content-Type': 'application/json',
      },
      body: JSON.stringify({ email }),
    });

    const result = await response.json();

    return res.json({
      email,
      isValid: result.status === 'valid',
      score: result.score,
      flags: {
        disposable: result.result.disposable,
        role: result.result.role,
      }
    });
  } catch (error) {
    return res.status(500).json({ error: 'Servicio de verificación no disponible' });
  }
});

export default router;

# Crear el script de verificación
cat > /usr/local/bin/verify-daily-signups.sh << 'EOF'
#!/bin/bash
set -e

LOG_FILE="/var/log/email-verification.log"
DB_HOST="${DB_HOST:-localhost}"
DB_NAME="${DB_NAME:-myapp}"

echo "$(date): Iniciando verificación diaria de correos electrónicos" >> $LOG_FILE

# Obtener correos electrónicos no verificados de la base de datos
emails=$(psql -h $DB_HOST -d $DB_NAME -t -c \
  "SELECT email FROM users WHERE email_verified IS NULL AND created_at > NOW() - INTERVAL '1 day'")

count=0
invalid=0

for email in $emails; do
  result=$(bv verify "$email" --json 2>/dev/null)
  status=$(echo "$result" | jq -r '.status')

  if [ "$status" = "valid" ]; then
    psql -h $DB_HOST -d $DB_NAME -c \
      "UPDATE users SET email_verified = true WHERE email = '$email'"
  else
    psql -h $DB_HOST -d $DB_NAME -c \
      "UPDATE users SET email_verified = false, email_status = '$status' WHERE email = '$email'"
    ((invalid++))
  fi
  ((count++))

  sleep 0.1  # Límite de tasa
done

echo "$(date): Verificados $count correos electrónicos, $invalid inválidos" >> $LOG_FILE
EOF

chmod +x /usr/local/bin/verify-daily-signups.sh

# Agregar al crontab (se ejecuta a las 2 AM diariamente)
(crontab -l 2>/dev/null; echo "0 2 * * * /usr/local/bin/verify-daily-signups.sh") | crontab -

echo "✅ Cron job creado. Se ejecutará diariamente a las 2 AM."

// __tests__/email-verification.test.ts
import { describe, it, expect, beforeAll } from 'vitest';

describe('Integración de Verificación de Correo Electrónico', () => {
  const API_URL = 'https://api.emailverify.ai/v1/verify';
  let apiKey: string;

  beforeAll(() => {
    apiKey = process.env.EMAILVERIFY_API_KEY!;
    if (!apiKey) {
      throw new Error('EMAILVERIFY_API_KEY no configurado');
    }
  });

  async function verifyEmail(email: string) {
    const response = await fetch(API_URL, {
      method: 'POST',
      headers: {
        'Authorization': `Bearer ${apiKey}`,
        'Content-Type': 'application/json',
      },
      body: JSON.stringify({ email }),
    });
    return response.json();
  }

  it('devuelve válido para correo electrónico conocido bueno', async () => {
    const result = await verifyEmail('test@gmail.com');
    expect(result.status).toBe('valid');
    expect(result.score).toBeGreaterThan(0.5);
  });

  it('detecta correos electrónicos desechables', async () => {
    const result = await verifyEmail('test@mailinator.com');
    expect(result.result.disposable).toBe(true);
  });

  it('detecta correos electrónicos basados en roles', async () => {
    const result = await verifyEmail('info@example.com');
    expect(result.result.role).toBe(true);
  });

  it('maneja dominios inválidos', async () => {
    const result = await verifyEmail('user@thisisnotarealdomain12345.xyz');
    expect(result.status).toBe('invalid');
  });

  it('devuelve estructura adecuada', async () => {
    const result = await verifyEmail('user@example.com');

    expect(result).toHaveProperty('email');
    expect(result).toHaveProperty('status');
    expect(result).toHaveProperty('score');
    expect(result).toHaveProperty('result');
    expect(result.result).toHaveProperty('deliverable');
    expect(result.result).toHaveProperty('disposable');
    expect(result.result).toHaveProperty('role');
  });
});

# ~/.droid/aliases.yml
aliases:
  vmail:
    description: "Verificar una dirección de correo electrónico"
    command: "bv verify $1 --color"

  vmail-json:
    description: "Verificar un correo electrónico y mostrar JSON"
    command: "bv verify $1 --json | jq ."

  vmail-batch:
    description: "Verificar correos electrónicos desde un archivo"
    command: "bv verify --file $1 --output results.csv"

  vmail-check:
    description: "Verificación rápida si el correo electrónico es válido (devuelve 0 o 1)"
    command: "bv verify $1 --quiet"

droid vmail user@example.com
droid vmail-batch contacts.txt