Checklist de revue de code avec Claude Code

Optimiser les revues de code avec Claude Code

La revue de code est un processus essentiel pour maintenir la qualité, mais la charge sur les relecteurs est un défi. En utilisant Claude Code, vous pouvez réaliser des revues efficaces basées sur une checklist systématique.

Vérification de sécurité

> Fais une revue de sécurité du code de cette PR.
> Vérifie les XSS, injections SQL et vulnérabilités d'authentification.

// Checklist de sécurité
const securityChecks = {
  // 1. Validation des entrées
  inputValidation: {
    check: 'Les entrées utilisateur sont-elles assainies ?',
    bad: `element.innerHTML = userInput;`,
    good: `element.textContent = userInput;`,
  },

  // 2. Injection SQL
  sqlInjection: {
    check: 'Des requêtes paramétrées sont-elles utilisées ?',
    bad: `db.query(\`SELECT * FROM users WHERE id = \${userId}\`);`,
    good: `db.query('SELECT * FROM users WHERE id = ?', [userId]);`,
  },

  // 3. Authentification et autorisation
  auth: {
    check: 'Les endpoints API ont-ils un middleware d\'authentification ?',
    bad: `app.get('/api/admin/users', handler);`,
    good: `app.get('/api/admin/users', requireAuth, requireAdmin, handler);`,
  },

  // 4. Exposition de secrets
  secrets: {
    check: 'Des variables d\'environnement ne fuient-elles pas côté client ?',
    bad: `const apiKey = "sk-1234567890abcdef";`,
    good: `const apiKey = process.env.API_KEY;`,
  },
};

Vérification des performances

// Checklist de performance
const performanceChecks = [
  {
    item: 'Y a-t-il des requêtes N+1 ?',
    bad: `
      const users = await db.user.findMany();
      for (const user of users) {
        const posts = await db.post.findMany({ where: { userId: user.id } });
      }`,
    good: `
      const users = await db.user.findMany({
        include: { posts: true },
      });`,
  },
  {
    item: 'Y a-t-il des re-rendus inutiles ?',
    bad: `
      function Component() {
        const handler = () => doSomething();
        return <Child onClick={handler} />;
      }`,
    good: `
      function Component() {
        const handler = useCallback(() => doSomething(), []);
        return <Child onClick={handler} />;
      }`,
  },
  {
    item: 'La virtualisation est-elle appliquée aux grandes listes ?',
    check: 'Listes de plus de 1000 éléments → envisager react-virtual',
  },
];

Vérification de lisibilité et maintenabilité

> Propose des améliorations de lisibilité pour ce code.
> Vérifie les conventions de nommage, la longueur des fonctions et la pertinence des commentaires.

// Points de vérification de lisibilité

// 1. Longueur des fonctions (idéalement moins de 30 lignes)
// ❌ Tout le traitement dans une seule fonction
async function processOrder(order: Order) {
  // 100 lignes de traitement...
}

// ✅ Division par responsabilité
async function processOrder(order: Order) {
  const validated = validateOrder(order);
  const priced = calculateTotal(validated);
  const payment = await processPayment(priced);
  return createConfirmation(payment);
}

// 2. Patron de retour anticipé
// ❌ Imbrication profonde
function getDiscount(user: User) {
  if (user) {
    if (user.isPremium) {
      if (user.orders > 10) {
        return 0.2;
      }
      return 0.1;
    }
    return 0.05;
  }
  return 0;
}

// ✅ Retour anticipé
function getDiscount(user: User) {
  if (!user) return 0;
  if (!user.isPremium) return 0.05;
  if (user.orders > 10) return 0.2;
  return 0.1;
}

// 3. Élimination des nombres magiques
// ❌
if (status === 3) { /* ... */ }

// ✅
const ORDER_STATUS = { PENDING: 1, PROCESSING: 2, COMPLETED: 3 } as const;
if (status === ORDER_STATUS.COMPLETED) { /* ... */ }

Vérification de la gestion d’erreurs

// Points de vérification de la gestion d'erreurs

// ❌ Erreur avalée silencieusement
try {
  await saveData(data);
} catch (e) {
  // ne rien faire
}

// ✅ Gestion d'erreur appropriée
try {
  await saveData(data);
} catch (error) {
  logger.error('Échec de la sauvegarde des données', { error, data: data.id });
  throw new AppError('SAVE_FAILED', 'La sauvegarde des données a échoué', { cause: error });
}

Script d’automatisation de revue

// scripts/review-check.ts
import { execSync } from 'child_process';

interface ReviewIssue {
  file: string;
  line: number;
  severity: 'error' | 'warning' | 'info';
  message: string;
}

function checkForIssues(): ReviewIssue[] {
  const issues: ReviewIssue[] = [];
  const diff = execSync('git diff --cached --name-only').toString().split('\n');

  for (const file of diff.filter(f => f.endsWith('.ts') || f.endsWith('.tsx'))) {
    const content = execSync(`git show :${file}`).toString();
    const lines = content.split('\n');

    lines.forEach((line, index) => {
      // Vérification de console.log
      if (line.includes('console.log') && !file.includes('scripts/')) {
        issues.push({
          file, line: index + 1, severity: 'warning',
          message: 'Un console.log est resté',
        });
      }

      // Vérification TODO/FIXME
      if (/\/\/\s*(TODO|FIXME|HACK)/i.test(line)) {
        issues.push({
          file, line: index + 1, severity: 'info',
          message: 'Un commentaire TODO/FIXME est présent',
        });
      }

      // Vérification du type any
      if (/:\s*any\b/.test(line)) {
        issues.push({
          file, line: index + 1, severity: 'warning',
          message: 'Le type any est utilisé',
        });
      }
    });
  }

  return issues;
}

const issues = checkForIssues();
issues.forEach(i => console.log(`[${i.severity}] ${i.file}:${i.line} - ${i.message}`));

Conclusion

La revue de code est étroitement liée aux stratégies de test. Avec Claude Code, vous pouvez réaliser efficacement des revues systématiques du point de vue de la sécurité, des performances et de la lisibilité. En combinant avec les techniques de programmation en binôme avec l’IA, vous pouvez allier qualité et rapidité de revue. Pour les bonnes pratiques de revue de code, consultez Google Engineering Practices.