Refaktoryzacja starszego kodu - Cursor

Scenariusz

Odziedziczyłeś 5-letni backend e-commerce napisany w Node.js z Express. Nie ma testów, używa callbacków zamiast promises, miesza logikę biznesową z zapytaniami do bazy danych i rozrósł się do 15 000 linii w ponad 50 plikach. Twoje zadanie: unowocześnić go bez łamania istniejącej funkcjonalności, która obsługuje 10 000 użytkowników dziennie.

Cele nauczania

Po ukończeniu tej lekcji opanujesz:

Analizowanie i rozumienie starszych baz kodu
Tworzenie kompleksowej dokumentacji z nieudokumentowanego kodu
Bezpieczne strategie refaktoryzacji z pomocą AI
Dodawanie testów do nietestowanego kodu
Techniki stopniowej modernizacji
Zarządzanie ryzykiem podczas dużych refaktoryzacji

Wymagania wstępne

Ukończenie lekcji 1 lub równoważne doświadczenie
Zrozumienie ewolucji JavaScript (callbacks → promises → async/await)
Podstawowa znajomość frameworków testowych
Git do kontroli wersji

Wyzwanie

Przekształć starszą bazę kodu poprzez:

Zrozumienie istniejącej architektury
Dokumentowanie krytycznych przepływów
Dodanie pokrycia testowego
Modernizację do obecnych standardów
Poprawę wydajności
Utrzymanie zgodności wstecznej

Implementacja krok po kroku

Faza 1: Analiza bazy kodu

Wstępna ocena

Otwórz starszy projekt w Cursor i zacznij od trybu Ask:

@src
"Przeanalizuj tę bazę kodu i podaj:
1. Stos technologiczny i wersje
2. Ogólny wzorzec architektury
3. Główne punkty wejścia i krytyczne ścieżki
4. Ocenę jakości kodu
5. Potencjalne ryzyka i dług techniczny"

Analiza zależności

@package.json @package-lock.json
"Przeanalizuj zależności:
- Które są przestarzałe i wymagają aktualizacji?
- Które są deprecated lub porzucone?
- Które mają znane luki bezpieczeństwa?
- Jaka jest ścieżka aktualizacji dla krytycznych zależności?"

Tworzenie dokumentacji architektury

Przełącz się na tryb Agent:

@src
"Stwórz kompleksową dokumentację architektury:
- Diagram przeglądu systemu (mermaid)
- Relacje komponentów
- Diagramy przepływu danych
- Mapowanie endpointów API
- Dokumentację schematu bazy danych
Zapisz do docs/architecture/legacy-analysis.md"

Faza 2: Zrozumienie logiki biznesowej

Śledzenie krytycznych ścieżek

@src/routes @src/controllers
"Prześledź kompletny przepływ dla:
1. Rejestracji i logowania użytkownika
2. Wyszukiwania i wyświetlania produktów
3. Składania zamówienia
4. Przetwarzania płatności
Udokumentuj każdy przepływ z diagramami sekwencji"

Wyodrębnienie reguł biznesowych

@src
"Zidentyfikuj i udokumentuj wszystkie reguły biznesowe:
- Kalkulacje cen
- Logikę rabatów
- Zarządzanie zapasami
- Reguły uprawnień użytkowników
- Walidację płatności
Stwórz dokument reguł biznesowych"

Mapowanie interakcji z bazą danych

@src/models @src/db
"Przeanalizuj interakcje z bazą danych:
- Wymień wszystkie używane tabele/kolekcje
- Zidentyfikuj relacje
- Znajdź zapytania N+1
- Udokumentuj granice transakcji
- Zwróć uwagę na brakujące indeksy"

Faza 3: Tworzenie pokrycia testowego

Konfiguracja frameworka testowego

"Skonfiguruj nowoczesny framework testowy:
- Zainstaluj Jest i Supertest
- Skonfiguruj dla istniejącego kodu
- Dodaj konfigurację bazy danych testowej
- Stwórz narzędzia testowe
- Dodaj skrypty npm do testowania"

Generowanie testów integracyjnych

@src/routes/products.js
"Wygeneruj testy integracyjne dla endpointów produktów:
- Testuj wszystkie operacje CRUD
- Uwzględnij przypadki brzegowe
- Testuj scenariusze błędów
- Waliduj formaty odpowiedzi
- Sprawdź autentykację/autoryzację"

Tworzenie testów jednostkowych dla logiki biznesowej

@src/services @src/utils
"Wygeneruj testy jednostkowe dla logiki biznesowej:
- Funkcje kalkulacji cen
- Stosowanie rabatów
- Sprawdzanie zapasów
- Walidację danych
- Funkcje pomocnicze
Dąż do 80% pokrycia krytycznych ścieżek"

Faza 4: Stopniowa modernizacja

Tworzenie planu modernizacji

@docs/architecture/legacy-analysis.md
"Stwórz szczegółowy plan modernizacji:
- Kolejność priorytetów refaktoryzacji
- Ocenę ryzyka dla każdego modułu
- Wymagania zgodności wstecznej
- Możliwości poprawy wydajności
- Harmonogram z kamieniami milowymi"

Refaktoryzacja callbacków na async/await

@src/controllers/products.js
"Zrefaktoryzuj ten kontroler:
- Przekonwertuj callbacki na async/await
- Dodaj właściwą obsługę błędów
- Zachowaj dokładnie to samo zachowanie
- Zachowaj kompatybilność API
Pokaż porównanie przed/po"

Przykład transformacji:

// Przed
function getProduct(req, res) {
  db.query('SELECT * FROM products WHERE id = ?', [req.params.id],
    function(err, results) {
      if (err) {
        res.status(500).send('Error');
        return;
      }
      if (results.length === 0) {
        res.status(404).send('Not found');
        return;
      }
      res.json(results[0]);
    });
}

// Po
async function getProduct(req, res) {
  try {
    const [product] = await db.query(
      'SELECT * FROM products WHERE id = ?',
      [req.params.id]
    );

    if (!product) {
      return res.status(404).json({ error: 'Produkt nie znaleziony' });
    }

    res.json(product);
  } catch (error) {
    logger.error('Błąd pobierania produktu:', error);
    res.status(500).json({ error: 'Błąd wewnętrzny serwera' });
  }
}

Wyodrębnienie logiki biznesowej z kontrolerów

@src/controllers @src/services
"Wyodrębnij logikę biznesową do warstwy serwisów:
- Stwórz klasy/moduły serwisów
- Przenieś reguły biznesowe z kontrolerów
- Dodaj wstrzykiwanie zależności
- Popraw testowalność
- Zachowaj interfejsy kontrolerów"

Faza 5: Optymalizacja bazy danych

Dodanie query buildera/ORM

"Migruj z surowego SQL do query buildera:
- Zainstaluj i skonfiguruj Knex.js
- Stwórz migrację z istniejącego schematu
- Konwertuj zapytania stopniowo
- Dodaj pooling połączeń
- Zaimplementuj transakcje właściwie"

Optymalizacja zapytań

@src/models
"Zoptymalizuj zapytania do bazy danych:
- Napraw problemy zapytań N+1
- Dodaj odpowiednie indeksy
- Zaimplementuj warstwę cache'owania
- Grupuj podobne zapytania
- Dodaj logowanie/monitorowanie zapytań"

Dodanie warstwy walidacji danych

"Zaimplementuj walidację danych:
- Zainstaluj Joi lub Zod
- Stwórz schematy dla wszystkich inputów
- Dodaj middleware walidacji
- Popraw komunikaty błędów
- Udokumentuj reguły walidacji"

Kluczowe zaprezentowane techniki

Technika 1: Wzorzec bezpiecznej refaktoryzacji

Zawsze postępuj według tego wzorca:

// 1. Zrozum obecne zachowanie
@old-file.js
"Wyjaśnij co robi ten kod i wszystkie przypadki brzegowe"

// 2. Dodaj testy dla obecnego zachowania
"Wygeneruj testy weryfikujące obecne zachowanie"

// 3. Refaktoryzuj z pewnością
"Zrefaktoryzuj ten kod zachowując wszystkie testowane zachowania"

// 4. Sprawdź czy testy nadal przechodzą
"Uruchom testy i napraw wszelkie niepowodzenia"

Technika 2: Migracja stopniowa

Migruj moduł po module:

// Stwórz nową wersję obok starej
@src/controllers/products-old.js
"Stwórz zmodernizowaną wersję w products-new.js"

// Dodaj feature flag
"Dodaj feature flag do przełączania między starą a nową implementacją"

// Testuj w produkcji
// Stopniowo migruj ruch
// Usuń starą wersję gdy będzie stabilna

Technika 3: Dokumentacja jako kod

Generuj i utrzymuj dokumentację:

@src/routes
"Wygeneruj dokumentację OpenAPI/Swagger z istniejących tras"

@src/models
"Wygeneruj dokumentację bazy danych z relacjami"

@src/services
"Wygeneruj komentarze JSDoc wyjaśniające logikę biznesową"

Częste pułapki i rozwiązania

Problem: Refaktoryzacja łamie istniejącą funkcjonalność

Rozwiązanie:

Zawsze dodaj testy przed refaktoryzacją
Używaj feature flags do stopniowego wdrażania
Utrzymuj stare endpointy podczas przejścia
Monitoruj wskaźniki błędów dokładnie

Rozszerzone wyzwanie

Posuń refaktoryzację dalej:

Optymalizacja wydajności
- Dodaj warstwę cache’owania Redis
- Zaimplementuj pooling połączeń do bazy danych
- Dodaj kolejkowanie żądań dla ciężkich operacji
- Profiluj i optymalizuj gorące ścieżki
Migracja do mikrousług
- Wyodrębnij serwis autentykacji
- Oddziel przetwarzanie zamówień
- Zaimplementuj API gateway
- Dodaj service discovery
Nowoczesna infrastruktura
- Konteneryzuj z Docker
- Dodaj manifesty Kubernetes
- Zaimplementuj health checki
- Skonfiguruj monitorowanie/alerting

Mierzenie sukcesu

Śledź te metryki:

✅ Pokrycie testami wzrosło z 0% do 80%+
✅ Czasy odpowiedzi poprawiły się o 40%
✅ Wskaźniki błędów pozostają poniżej 0,1%
✅ Wszystkie istniejące API zachowują kompatybilność
✅ Wynik zadłużenia technicznego poprawił się
✅ Prędkość rozwoju zwiększyła się
✅ Metryki złożoności kodu poprawiły się
✅ Zero przestojów podczas migracji

Rezultaty z prawdziwego świata

Zespoły używające tych technik raportują:

70% redukcję zgłoszeń błędów po refaktoryzacji
3x szybszy rozwój funkcji w zrefaktoryzowanym kodzie
50% redukcję czasu wdrażania nowych programistów
90% redukcję incydentów produkcyjnych

Lista kontrolna refaktoryzacji

Przed rozpoczęciem jakiejkolwiek refaktoryzacji:

Obecne zachowanie jest udokumentowane
Testy pokrywają krytyczne ścieżki
Istnieje plan backup/rollback
Monitorowanie jest na miejscu
Zespół jest zgodny co do podejścia
Metryki sukcesu są zdefiniowane
Harmonogram jest realistyczny
Interesariusze są poinformowani

Kluczowe wnioski

Zrozum przed zmianą: Używaj AI do szybkiego zrozumienia wzorców starszego kodu
Testuj wszystko: Nigdy nie refaktoryzuj bez pokrycia testowego
Postęp stopniowy: Małe, bezpieczne zmiany pokonują duże przepisywanie
Dokumentuj w trakcie: Przyszły ty podziękuje obecnemu sobie
Mierz wpływ: Dane dowodzą wartości refaktoryzacji

Inwestycja czasowa

Wstępna analiza: 2-4 godziny
Tworzenie testów: 4-6 godzin
Stopniowa refaktoryzacja: 2-3 dni na moduł
Pełna modernizacja: 2-4 tygodnie dla typowego projektu

ROI: 10x zwrot w ciągu 6 miesięcy dzięki zmniejszeniu błędów i szybszemu rozwojowi

Następne kroki

Opanowałeś transformację starszego kodu. Gotowy na więcej wyzwań?

Automatyzuj to

Stwórz skrypty do automatyzacji częstych wzorców refaktoryzacji

Skaluj to

Zastosuj techniki do większych, bardziej złożonych systemów

Naucz tego

Podziel się swoimi wzorcami refaktoryzacji z zespołem

Kontynuuj do Workflow polowania na błędy →