Legacy Code : Le refactoring pragmatique sans réécriture complète

// ❌ Modifier fonction legacy (risqué)
function createUser(data) {
  // 200 lignes de legacy code
  // Modifier ici = potentiel de bugs
}

// ✅ Wrapper avec validation
function createUserV2(data) {
  // Nouvelle validation propre
  validateUserData(data);

  // Appeler legacy
  return createUser(data);
}

// Migrer progressivement les appels
- createUser(data)
+ createUserV2(data)

// Étape 1 : Créer interface
interface UserRepository {
  findById(id: string): Promise<User>;
  save(user: User): Promise<void>;
}

// Étape 2 : Implémenter ancien système
class LegacyUserRepository implements UserRepository {
  async findById(id: string) {
    // Appeler ancien code MySQL legacy
    return legacyDb.query('SELECT * FROM users WHERE id = ?', [id]);
  }
}

// Étape 3 : Nouvelle implémentation
class PostgresUserRepository implements UserRepository {
  async findById(id: string) {
    return this.pg.query('SELECT * FROM users WHERE id = $1', [id]);
  }
}

// Étape 4 : Feature flag pour switcher
const userRepo: UserRepository =
  featureFlags.isEnabled('use-postgres')
    ? new PostgresUserRepository()
    : new LegacyUserRepository();

// Étape 5 : Rollout progressif, puis supprimer legacy

// Legacy code (200 lignes, complexe)
function processPayment(order, card) {
  // Mélange de logique business, DB, external calls
  // Impossible à tester
}

// Identifier seam = point d'entrée
// Créer facade
class PaymentService {
  process(order: Order): PaymentResult {
    // Nouvelle logique propre
    const validated = this.validate(order);
    const charged = this.charge(validated);
    const recorded = this.record(charged);

    return recorded;
  }

  private validate(order: Order) {
    // Nouvelle validation
  }

  private charge(order: Order) {
    // Appel legacy temporairement
    return processPayment(order, order.paymentMethod);
  }

  private record(result: PaymentResult) {
    // Nouveau code de persistence
  }
}

// Progressivement, remplacer charge() par nouveau code

// Avant de fixer un bug
function calculateTotal(items) {
  var total = 0;  // var 😱
  for (var i = 0; i < items.length; i++) {  // for loop 😱
    total = total + items[i].price;  // pas de validation
  }
  return total;
}

// Après fix + mini refactoring
function calculateTotal(items: Item[]): number {
  if (!Array.isArray(items)) {
    throw new Error('Items must be an array');
  }

  return items.reduce((total, item) => {
    if (typeof item.price !== 'number') {
      throw new Error('Invalid item price');
    }
    return total + item.price;
  }, 0);
}

// 5 minutes de refactoring, impact énorme

// Avant : God function
function handleCheckout(cart, user, payment) {
  // 150 lignes de code
  // Validation
  // Calcul prix
  // Taxes
  // Shipping
  // Payment
  // Email
  // ...
}

// Après : Extraction progressive
function handleCheckout(cart, user, payment) {
  validateCheckout(cart, user);
  const pricing = calculatePricing(cart);
  const order = createOrder(cart, user, pricing);
  processPayment(order, payment);
  sendConfirmationEmail(user, order);
  return order;
}

// Chaque fonction < 20 lignes, testable

// Avant : Trop de paramètres
function createInvoice(
  customerName,
  customerEmail,
  customerAddress,
  items,
  discount,
  taxRate,
  shippingCost
) {
  // ...
}

// Après : Regrouper
interface InvoiceData {
  customer: Customer;
  items: LineItem[];
  pricing: PricingInfo;
}

function createInvoice(data: InvoiceData) {
  // Beaucoup plus clair
}

// Legacy function (comportement bizarre mais utilisé)
function formatPrice(price) {
  return '$' + price.toFixed(2).replace('.00', '');
}

// Characterization test
describe('formatPrice (legacy behavior)', () => {
  it('removes .00 from whole numbers', () => {
    expect(formatPrice(10)).toBe('$10');  // Pas '$10.00'
  });

  it('keeps decimals for non-whole numbers', () => {
    expect(formatPrice(10.50)).toBe('$10.50');
  });

  it('formats negative numbers', () => {
    expect(formatPrice(-5)).toBe('$-5');  // Bug ? Mais c'est l'existant
  });
});

// Maintenant, refactorer en sécurité

// Capturer outputs legacy
const inputs = loadTestInputs();
const goldenOutputs = inputs.map(input => legacyFunction(input));

// Après refactoring
const newOutputs = inputs.map(input => newFunction(input));

// Comparer
expect(newOutputs).toEqual(goldenOutputs);

// Code complexity (Cyclomatic)
// Tools: ESLint complexity rule
function complex() {
  if (a) {
    if (b) {
      if (c) {
        if (d) {
          // Complexity = 4 (trop élevé)
        }
      }
    }
  }
}

// Code churn (changements fréquents)
git log --format=format: --name-only | \
  sort | uniq -c | sort -rg | head -10

// Files with most bugs
git log --grep="fix\|bug" --name-only | \
  sort | uniq -c | sort -rg