Codex

OpenAI Codex CLI proporciona generación de código y asistencia en terminal con IA. Aprende cómo integrar EmailVerify para tareas de verificación de correo electrónico.

¿Qué es Codex CLI?

Codex CLI es la herramienta de línea de comandos de OpenAI que aprovecha el modelo Codex para:

Traducción de lenguaje natural a código
Generación de comandos de shell
Completado y depuración de código
Automatización de tareas

Configuración

Instalar EmailVerify CLI

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

Configurar Entorno

export EMAILVERIFY_API_KEY=your-api-key
export OPENAI_API_KEY=your-openai-key

Ejemplos de Uso

Generar Script de Verificación

Prompt: Escribe un script Python que verifique una lista de correos electrónicos usando la API de EmailVerify

Salida de Codex:

import os
import requests
from typing import List, Dict

def verify_emails(emails: List[str]) -> List[Dict]:
    """Verifica una lista de direcciones de correo electrónico usando la API de EmailVerify."""
    api_key = os.environ.get('EMAILVERIFY_API_KEY')
    results = []

    for email in emails:
        response = requests.post(
            'https://api.emailverify.ai/v1/verify',
            headers={
                'Authorization': f'Bearer {api_key}',
                'Content-Type': 'application/json',
            },
            json={'email': email}
        )
        results.append(response.json())

    return results

def main():
    emails = [
        'test@example.com',
        'user@gmail.com',
        'fake@mailinator.com',
    ]

    results = verify_emails(emails)

    for result in results:
        status = '✅' if result['status'] == 'valid' else '❌'
        print(f"{status} {result['email']}: {result['status']}")

if __name__ == '__main__':
    main()

Generar Comando de Shell

Prompt: Un one-liner para verificar todos los correos electrónicos en la segunda columna de un archivo CSV

Salida de Codex:

cut -d',' -f2 users.csv | tail -n +2 | while read email; do bv verify "$email" --quiet && echo "✅ $email" || echo "❌ $email"; done

Generar Casos de Prueba

Prompt: Genera pruebas Jest para una función de verificación de correo electrónico

Salida de Codex:

import { verifyEmail } from './email-service';

describe('Email Verification', () => {
  beforeAll(() => {
    process.env.EMAILVERIFY_API_KEY = 'test-api-key';
  });

  test('valida el formato de correo electrónico correcto', async () => {
    const result = await verifyEmail('user@example.com');
    expect(result).toHaveProperty('status');
    expect(result).toHaveProperty('score');
  });

  test('rechaza formato de correo electrónico inválido', async () => {
    const result = await verifyEmail('not-an-email');
    expect(result.status).toBe('invalid');
  });

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

  test('maneja errores de API con elegancia', async () => {
    // Simular error de red
    const result = await verifyEmail('test@example.com');
    expect(result).not.toBeNull();
  });
});

Generar Integración de API

Prompt: Crea un módulo Node.js para integración con EmailVerify con caché

Salida de Codex:

import NodeCache from 'node-cache';

interface VerificationResult {
  email: string;
  status: 'valid' | 'invalid' | 'unknown';
  score: number;
  result: {
    deliverable: boolean;
    disposable: boolean;
    role: boolean;
  };
}

class EmailVerifyClient {
  private apiKey: string;
  private cache: NodeCache;
  private baseUrl = 'https://api.emailverify.ai/v1';

  constructor(apiKey: string, cacheTTL: number = 3600) {
    this.apiKey = apiKey;
    this.cache = new NodeCache({ stdTTL: cacheTTL });
  }

  async verify(email: string): Promise<VerificationResult> {
    // Verificar caché primero
    const cached = this.cache.get<VerificationResult>(email);
    if (cached) return cached;

    const response = await fetch(`${this.baseUrl}/verify`, {
      method: 'POST',
      headers: {
        'Authorization': `Bearer ${this.apiKey}`,
        'Content-Type': 'application/json',
      },
      body: JSON.stringify({ email }),
    });

    const result = await response.json();

    // Cachear el resultado
    this.cache.set(email, result);

    return result;
  }

  async verifyBulk(emails: string[]): Promise<VerificationResult[]> {
    const response = await fetch(`${this.baseUrl}/verify/bulk`, {
      method: 'POST',
      headers: {
        'Authorization': `Bearer ${this.apiKey}`,
        'Content-Type': 'application/json',
      },
      body: JSON.stringify({ emails }),
    });

    return response.json();
  }
}

export default EmailVerifyClient;

Patrones de Generación de Código

Patrón 1: Middleware de Validación

Prompt: Middleware Express para validar correo electrónico en el cuerpo de la solicitud

import { Request, Response, NextFunction } from 'express';

export const validateEmail = async (
  req: Request,
  res: Response,
  next: NextFunction
) => {
  const { email } = req.body;

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

  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();

  if (result.status === 'invalid') {
    return res.status(400).json({ error: 'Dirección de correo electrónico inválida' });
  }

  if (result.result.disposable) {
    return res.status(400).json({ error: 'No se permiten correos electrónicos desechables' });
  }

  req.verificationResult = result;
  next();
};

Patrón 2: Hook de React

Prompt: Hook de React para verificación de correo electrónico con debounce

import { useState, useEffect } from 'react';
import { useDebouncedCallback } from 'use-debounce';

interface VerificationState {
  isLoading: boolean;
  isValid: boolean | null;
  result: any;
  error: string | null;
}

export function useEmailVerification(debounceMs: number = 500) {
  const [state, setState] = useState<VerificationState>({
    isLoading: false,
    isValid: null,
    result: null,
    error: null,
  });

  const verify = useDebouncedCallback(async (email: string) => {
    if (!email || !email.includes('@')) {
      setState({ isLoading: false, isValid: null, result: null, error: null });
      return;
    }

    setState(prev => ({ ...prev, isLoading: true, error: null }));

    try {
      const response = await fetch('/api/verify-email', {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({ email }),
      });

      const result = await response.json();

      setState({
        isLoading: false,
        isValid: result.status === 'valid',
        result,
        error: null,
      });
    } catch (error) {
      setState({
        isLoading: false,
        isValid: null,
        result: null,
        error: 'Verificación fallida',
      });
    }
  }, debounceMs);

  return { ...state, verify };
}

Próximos Pasos

OpenCode

Alternativa de código abierto

Droid

Asistente de IA para terminal

Referencia API

Documentación completa de la API

Codex

OpenCode

Droid

Referencia API

On this page