Codex

OpenAI Codex CLI fournit une génération de code et une assistance terminal alimentées par l'IA. Découvrez comment intégrer EmailVerify pour les tâches de vérification d'email.

Qu'est-ce que Codex CLI ?

Codex CLI est l'outil en ligne de commande d'OpenAI qui exploite le modèle Codex pour :

La traduction du langage naturel en code
La génération de commandes shell
La complétion et le débogage de code
L'automatisation de tâches

Configuration

Installer la CLI EmailVerify

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

Configurer l'environnement

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

Exemples d'utilisation

Générer un script de vérification

Prompt : Écris un script Python qui vérifie une liste d'emails en utilisant l'API EmailVerify

Sortie Codex :

import os
import requests
from typing import List, Dict

def verify_emails(emails: List[str]) -> List[Dict]:
    """Vérifier une liste d'adresses email en utilisant l'API 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()

Générer une commande shell

Prompt : Une ligne de commande pour vérifier tous les emails dans la deuxième colonne d'un fichier CSV

Sortie Codex :

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

Générer des cas de test

Prompt : Génère des tests Jest pour une fonction de vérification d'email

Sortie Codex :

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

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

  test('validates correct email format', async () => {
    const result = await verifyEmail('user@example.com');
    expect(result).toHaveProperty('status');
    expect(result).toHaveProperty('score');
  });

  test('rejects invalid email format', async () => {
    const result = await verifyEmail('not-an-email');
    expect(result.status).toBe('invalid');
  });

  test('detects disposable emails', async () => {
    const result = await verifyEmail('test@mailinator.com');
    expect(result.result.disposable).toBe(true);
  });

  test('handles API errors gracefully', async () => {
    // Simuler une erreur réseau
    const result = await verifyEmail('test@example.com');
    expect(result).not.toBeNull();
  });
});

Générer une intégration API

Prompt : Crée un module Node.js pour l'intégration EmailVerify avec mise en cache

Sortie 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> {
    // Vérifier d'abord le cache
    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();

    // Mettre en cache le résultat
    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;

Modèles de génération de code

Modèle 1 : Middleware de validation

Prompt : Middleware Express pour valider l'email dans le corps de la requête

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: 'Email is required' });
  }

  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: 'Invalid email address' });
  }

  if (result.result.disposable) {
    return res.status(400).json({ error: 'Disposable emails not allowed' });
  }

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

Modèle 2 : Hook React

Prompt : Hook React pour la vérification d'email avec 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: 'Verification failed',
      });
    }
  }, debounceMs);

  return { ...state, verify };
}

Prochaines étapes

OpenCode

Alternative open-source

Droid

Assistant IA pour terminal

Référence API

Documentation API complète

Codex

OpenCode

Droid

Référence API

On this page