Kurs JavaScript i TypeScript · Moduł 4: Programowanie asynchroniczne

Obsługa żądań HTTP - Praktyczne wzorce i zaawansowane techniki

30 min czytania ·
W tej lekcji9

W poprzednim ćwiczeniu zapoznaliśmy się z podstawami Fetch API, które pozwala na wykonywanie żądań HTTP w JavaScript. Teraz rozszerzymy naszą wiedzę o bardziej zaawansowane techniki i praktyczne wzorce, które pomogą nam stworzyć solidny system komunikacji w naszym Parku Jurajskim. Przyjrzymy się, jak obsługiwać różne scenariusze, które mogą wystąpić podczas komunikacji sieciowej.

Kompleksowa obsługa błędów

W środowisku tak krytycznym jak Park Jurajski, gdzie awaria systemu może doprowadzić do niebezpiecznych sytuacji, prawidłowa obsługa błędów w komunikacji HTTP jest niezwykle ważna. Stwórzmy bardziej zaawansowany mechanizm obsługi błędów:

async function bezpieczneZapytanie(url, options = {}) {
  const controller = new AbortController();
  const { signal } = controller;

  // Ustawienie timeoutu (10 sekund)
  const timeoutId = setTimeout(() => controller.abort(), 10000);

  try {
    const response = await fetch(url, { ...options, signal });
    clearTimeout(timeoutId);

    // Kategorie błędów HTTP
    if (response.status >= 500) {
      throw new Error('Błąd serwera, prawdopodobnie tymczasowy problem.');
    } else if (response.status === 404) {
      throw new Error('Zasób nie został znaleziony.');
    } else if (response.status === 403) {
      throw new Error('Brak uprawnień do tego zasobu.');
    } else if (response.status === 401) {
      throw new Error('Wymagane uwierzytelnienie. Zaloguj się ponownie.');
    } else if (!response.ok) {
      throw new Error(`Nieoczekiwany błąd HTTP: ${response.status}`);
    }

    // Obsługa różnych typów odpowiedzi
    const contentType = response.headers.get('content-type');
    if (contentType && contentType.includes('application/json')) {
      return await response.json();
    } else if (contentType && contentType.includes('text/')) {
      return await response.text();
    } else {
      return await response.blob();
    }
  } catch (error) {
    clearTimeout(timeoutId);

    // Obsługa różnych typów błędów
    if (error.name === 'AbortError') {
      throw new Error('Żądanie przerwane - upłynął limit czasu (10s).');
    } else if (!navigator.onLine) {
      throw new Error('Brak połączenia internetowego. Sprawdź swoje połączenie z siecią.');
    } else {
      console.error('Szczegóły błędu:', error);
      throw new Error(`Błąd podczas komunikacji z serwerem: ${error.message}`);
    }
  }
}

Wzorzec retry - automatyczne ponawianie żądań

W sieci Parku Jurajskiego mogą występować chwilowe problemy z łącznością, szczególnie w odległych częściach wyspy. Zaimplementujmy mechanizm automatycznego ponawiania nieudanych żądań:

/**
 * Wykonuje żądanie HTTP z automatycznymi ponownymi próbami
 * @param {Function} requestFn - Funkcja wykonująca żądanie, zwracająca Promise
 * @param {Object} options - Opcje konfiguracyjne
 * @returns {Promise} - Wynik żądania lub ostatni błąd po wyczerpaniu prób
 */
async function zPonawianiem(requestFn, options = {}) {
  const {
    maxProb = 3,
    poczatkoweOpoznienie = 1000,
    czynnikOpoznienia = 2,
    maxOpoznienie = 10000,
    timeoutMs = 10000,
    czyPonowic = (error) => {
      // Domyślnie ponawiamy tylko dla błędów serwera (5xx) i problemów z siecią
      return (
        error.message.includes('Błąd serwera') ||
        error.message.includes('Brak połączenia') ||
        error.name === 'AbortError'
      );
    }
  } = options;

  let ostatniBlad;
  let proba = 0;

  while (proba <= maxProb) {
    try {
      // Dla każdej próby tworzymy nowy kontroler przerwania
      const controller = new AbortController();
      const timeoutId = setTimeout(() => controller.abort(), timeoutMs);

      // Jeśli to nie pierwsza próba, czekamy przed ponowieniem
      if (proba > 0) {
        const opoznienie = Math.min(
          poczatkoweOpoznienie * Math.pow(czynnikOpoznienia, proba - 1),
          maxOpoznienie
        );
        console.log(`Próba ${proba}/${maxProb} nie powiodła się. Ponowienie za ${opoznienie}ms...`);
        await new Promise(resolve => setTimeout(resolve, opoznienie));
      }

      // Wykonanie żądania
      const wynik = await requestFn(controller.signal);
      clearTimeout(timeoutId);
      return wynik;
    } catch (error) {
      clearTimeout(timeoutId);
      ostatniBlad = error;

      // Sprawdzenie, czy ponawiać próbę
      if (proba === maxProb || !czyPonowic(error)) {
        break;
      }

      proba++;
    }
  }

  // Wyrzucenie ostatniego błędu po wyczerpaniu prób
  throw new Error(`Nie udało się po ${maxProb} próbach: ${ostatniBlad.message}`);
}

// Przykład użycia
async function pobierzDaneDinozaura(id) {
  return zPonawianiem(
    async (signal) => {
      const response = await fetch(`https://api.jurassic-park.com/dinosaurs/${id}`, { signal });

      if (!response.ok) {
        throw new Error(`Błąd HTTP: ${response.status}`);
      }

      return response.json();
    },
    {
      maxProb: 5,
      poczatkoweOpoznienie: 500,
      czyPonowic: (error) => error.message.includes('Błąd HTTP: 5')
    }
  );
}

Kolejkowanie żądań i limit równoległych połączeń

W sytuacjach, gdy musimy wykonać wiele żądań HTTP, ale chcemy ograniczyć liczbę równoczesnych połączeń, aby nie przeciążyć sieci lub serwera, możemy zaimplementować kolejkowanie żądań:

class KolejkaZadan {
  constructor(maxRownoleglosc = 3) {
    this.maxRownoleglosc = maxRownoleglosc;
    this.aktywneZadania = 0;
    this.kolejka = [];
  }

  async dodaj(zadanie) {
    // Jeśli mamy miejsce na więcej równoległych zadań, wykonaj od razu
    if (this.aktywneZadania < this.maxRownoleglosc) {
      return this.wykonaj(zadanie);
    }

    // W przeciwnym razie dodaj do kolejki
    return new Promise((resolve, reject) => {
      this.kolejka.push({ zadanie, resolve, reject });
    });
  }

  async wykonaj(zadanie) {
    this.aktywneZadania++;

    try {
      // Wykonanie zadania
      const wynik = await zadanie();
      return wynik;
    } catch (error) {
      throw error;
    } finally {
      this.aktywneZadania--;
      this.przetworzNastepne();
    }
  }

  przetworzNastepne() {
    if (this.kolejka.length === 0 || this.aktywneZadania >= this.maxRownoleglosc) {
      return;
    }

    // Pobierz następne zadanie z kolejki
    const { zadanie, resolve, reject } = this.kolejka.shift();

    // Wykonaj zadanie i przekieruj wynik do oczekującego Promise
    this.wykonaj(zadanie)
      .then(resolve)
      .catch(reject);
  }
}

// Przykład użycia kolejki do monitorowania wielu dinozaurów
async function monitorujWszystkieDinozaury(listaId) {
  const kolejka = new KolejkaZadan(5); // Maksymalnie 5 równoczesnych żądań
  const wyniki = [];
  const bledy = [];

  // Funkcje pomocnicze do śledzenia postępu
  const totalZadan = listaId.length;
  let ukonczoneZadania = 0;

  function aktualizujPostep() {
    ukonczoneZadania++;
    const procent = Math.floor((ukonczoneZadania / totalZadan) * 100);
    console.log(`Postęp monitorowania: ${procent}% (${ukonczoneZadania}/${totalZadan})`);
  }

  // Tworzenie tablicy Promise dla wszystkich zadań
  const promisy = listaId.map(id => {
    return kolejka.dodaj(async () => {
      try {
        console.log(`Monitorowanie dinozaura #${id}...`);
        const wynik = await pobierzDaneDinozaura(id);
        wyniki.push(wynik);
        aktualizujPostep();
        return wynik;
      } catch (error) {
        bledy.push({ id, error: error.message });
        aktualizujPostep();
        throw error;
      }
    }).catch(error => {
      // Przechwytujemy błędy, aby nie przerywać całego procesu
      console.error(`Błąd monitorowania dinozaura #${id}:`, error.message);
    });
  });

  // Czekamy na zakończenie wszystkich zadań
  await Promise.all(promisy);

  return {
    wyniki,
    bledy,
    podsumowanie: {
      total: totalZadan,
      sukces: wyniki.length,
      blad: bledy.length
    }
  };
}

Zarządzanie danymi w pamięci podręcznej (caching)

W Parku Jurajskim mamy dane, które zmieniają się rzadko (np. gatunki dinozaurów) oraz dane, które zmieniają się często (np. lokalizacje dinozaurów). Implementacja pamięci podręcznej pomoże zoptymalizować komunikację:

class ZarzadcaPamieciPodrecznej {
  constructor() {
    this.cache = new Map();
    this.statystyki = {
      trafienia: 0,
      pudla: 0,
      unieważnienia: 0
    };
  }

  /**
   * Pobiera dane z cache lub wykonuje funkcję pobierającą, jeśli danych nie ma w cache
   * @param {string} klucz - Unikalny identyfikator danych w cache
   * @param {Function} pobierzFn - Funkcja pobierająca dane, jeśli nie ma ich w cache
   * @param {Object} opcje - Opcje cache
   * @returns {Promise} - Promise z danymi
   */
  async pobierz(klucz, pobierzFn, opcje = {}) {
    const {
      ttl = 60000, // Domyślny czas życia: 1 minuta
      forceRefresh = false, // Czy wymusić odświeżenie pomimo obecności w cache
      onlyIfCached = false // Czy zwracać tylko z cache (bez zapytania sieciowego)
    } = opcje;

    // Sprawdź czy dane są w cache i czy są aktualne
    const wpis = this.cache.get(klucz);
    const teraz = Date.now();

    if (wpis && !forceRefresh && teraz < wpis.expiresAt) {
      // Dane znalezione w cache i ważne
      this.statystyki.trafienia++;
      return wpis.dane;
    }

    // Jeśli żądamy tylko z cache i nie ma danych, zwróć null
    if (onlyIfCached) {
      return null;
    }

    // Danych nie ma w cache lub wymuszamy odświeżenie
    this.statystyki.pudla++;

    try {
      // Pobierz dane
      const dane = await pobierzFn();

      // Zapisz w cache
      this.cache.set(klucz, {
        dane,
        expiresAt: teraz + ttl,
        dodanoAt: teraz
      });

      return dane;
    } catch (error) {
      // Jeśli mamy stare dane w cache, możemy je zwrócić jako awaryjne
      if (wpis) {
        console.warn(`Błąd pobierania danych dla ${klucz}, używam przestarzałych danych z cache:`, error);
        return wpis.dane;
      }

      // W przeciwnym razie propagujemy błąd
      throw error;
    }
  }

  /**
   * Unieważnia wpisy w cache pasujące do wzorca
   * @param {string|RegExp} wzorzec - Wzorzec do dopasowania kluczy cache
   */
  uniewaznij(wzorzec) {
    const isString = typeof wzorzec === 'string';
    let licznik = 0;

    for (const klucz of this.cache.keys()) {
      if (isString ? klucz.includes(wzorzec) : wzorzec.test(klucz)) {
        this.cache.delete(klucz);
        licznik++;
      }
    }

    this.statystyki.unieważnienia += licznik;
    return licznik;
  }

  /**
   * Czyści wszystkie wpisy cache
   */
  wyczysc() {
    const licznik = this.cache.size;
    this.cache.clear();
    this.statystyki.unieważnienia += licznik;
    return licznik;
  }

  /**
   * Zwraca statystyki użycia cache
   */
  pobierzStatystyki() {
    const totalZapytan = this.statystyki.trafienia + this.statystyki.pudla;
    const wspolczynnikTrafien = totalZapytan === 0 ? 0 : this.statystyki.trafienia / totalZapytan;

    return {
      ...this.statystyki,
      totalZapytan,
      wspolczynnikTrafien: wspolczynnikTrafien.toFixed(2),
      aktywneWpisy: this.cache.size
    };
  }
}

// Utworzenie instancji zarządcy pamięci podręcznej
const cacheDinozaurow = new ZarzadcaPamieciPodrecznej();

// Przykład użycia
async function pobierzDaneDinozauraZCache(id, opcje = {}) {
  return cacheDinozaurow.pobierz(
    `dino-${id}`,
    async () => {
      const response = await fetch(`https://api.jurassic-park.com/dinosaurs/${id}`);
      if (!response.ok) {
        throw new Error(`Błąd HTTP: ${response.status}`);
      }
      return response.json();
    },
    {
      ttl: 300000, // 5 minut dla danych dinozaura
      ...opcje
    }
  );
}

// Funkcja do unieważniania cache po aktualizacji
async function aktualizujDinozaura(id, dane) {
  const response = await fetch(`https://api.jurassic-park.com/dinosaurs/${id}`, {
    method: 'PUT',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify(dane)
  });

  if (!response.ok) {
    throw new Error(`Błąd aktualizacji: ${response.status}`);
  }

  // Unieważnij cache tego dinozaura
  cacheDinozaurow.uniewaznij(`dino-${id}`);

  // Unieważnij również listę dinozaurów, które mogą zawierać tego dinozaura
  cacheDinozaurow.uniewaznij('dino-list');

  return response.json();
}

// Pobieranie listy dinozaurów z cache na krócej (dane zmieniają się częściej)
async function pobierzListeDinozaurow(filter = {}) {
  const queryParams = new URLSearchParams(filter).toString();
  const cacheKey = `dino-list-${queryParams || 'all'}`;

  return cacheDinozaurow.pobierz(
    cacheKey,
    async () => {
      const url = `https://api.jurassic-park.com/dinosaurs?${queryParams}`;
      const response = await fetch(url);
      if (!response.ok) {
        throw new Error(`Błąd HTTP: ${response.status}`);
      }
      return response.json();
    },
    { ttl: 60000 } // 1 minuta dla list dinozaurów
  );
}

Obsługa żądań synchronizowanych z serwerem

W Parku Jurajskim musimy czasami wykonywać operacje, które wymagają synchronizacji z serwerem, np. aktualizacje statusu zdrowia dinozaurów. Zaimplementujmy mechanizm, który zapewni, że dane zostaną zapisane nawet w przypadku problemów z łącznością:

class KolejkaSynchronizacji {
  constructor(opcje = {}) {
    // Klucz w localStorage do przechowywania kolejki
    this.klucz = opcje.klucz || 'dinozaury-sync-queue';

    // Ładowanie zapisanej kolejki
    this.kolejka = this.zaladujKolejke();

    // Flaga wskazująca, czy synchronizacja jest aktywna
    this.jestSynchronizacja = false;

    // Automatyczne rozpoczęcie synchronizacji
    if (opcje.autoSync !== false) {
      this.rozpocznijSynchronizacje();
    }

    // Nasłuchiwanie na zmiany stanu online/offline
    window.addEventListener('online', () => {
      console.log('Połączenie przywrócone. Rozpoczynam synchronizację...');
      this.rozpocznijSynchronizacje();
    });

    window.addEventListener('offline', () => {
      console.log('Utracono połączenie. Synchronizacja wstrzymana.');
    });
  }

  /**
   * Ładuje kolejkę z localStorage
   */
  zaladujKolejke() {
    try {
      const zapisanaKolejka = localStorage.getItem(this.klucz);
      return zapisanaKolejka ? JSON.parse(zapisanaKolejka) : [];
    } catch (error) {
      console.error('Błąd podczas ładowania kolejki synchronizacji:', error);
      return [];
    }
  }

  /**
   * Zapisuje kolejkę do localStorage
   */
  zapiszKolejke() {
    try {
      localStorage.setItem(this.klucz, JSON.stringify(this.kolejka));
    } catch (error) {
      console.error('Błąd podczas zapisywania kolejki synchronizacji:', error);
    }
  }

  /**
   * Dodaje operację do kolejki synchronizacji
   * @param {string} url - URL do żądania
   * @param {Object} opcje - Opcje fetch
   * @param {string} typ - Typ operacji (np. 'aktualizacja-zdrowia')
   * @returns {string} - ID operacji w kolejce
   */
  dodajDoKolejki(url, opcje = {}, typ = 'nieznany') {
    const id = `op-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;

    this.kolejka.push({
      id,
      url,
      opcje,
      typ,
      dodano: new Date().toISOString(),
      proby: 0
    });

    this.zapiszKolejke();
    this.rozpocznijSynchronizacje();

    return id;
  }

  /**
   * Rozpoczyna proces synchronizacji
   */
  async rozpocznijSynchronizacje() {
    // Jeśli już synchronizujemy lub nie ma połączenia, nie rób nic
    if (this.jestSynchronizacja || !navigator.onLine || this.kolejka.length === 0) {
      return;
    }

    this.jestSynchronizacja = true;

    try {
      let index = 0;
      while (index < this.kolejka.length) {
        const operacja = this.kolejka[index];

        try {
          console.log(`Synchronizacja operacji: ${operacja.typ} (${operacja.id})`);

          // Inkrementacja liczby prób
          operacja.proby++;
          this.zapiszKolejke();

          // Wykonanie żądania
          const response = await fetch(operacja.url, operacja.opcje);

          if (!response.ok) {
            throw new Error(`Błąd HTTP: ${response.status}`);
          }

          // Operacja zakończona sukcesem, usuń z kolejki
          this.kolejka.splice(index, 1);
          this.zapiszKolejke();

          console.log(`Operacja ${operacja.id} zsynchronizowana pomyślnie`);

          // Nie zwiększaj indeksu, ponieważ usunęliśmy element
        } catch (error) {
          console.error(`Błąd synchronizacji operacji ${operacja.id}:`, error);

          // Jeśli osiągnęliśmy maksymalną liczbę prób, oznacz jako nieudaną
          if (operacja.proby >= 5) {
            console.warn(`Operacja ${operacja.id} przekroczyła limit prób. Oznaczanie jako nieudana.`);
            operacja.status = 'nieudana';
            operacja.bladKomunikat = error.message;
            this.zapiszKolejke();
          }

          // Przejdź do następnej operacji
          index++;
        }
      }
    } finally {
      this.jestSynchronizacja = false;

      // Jeśli wciąż są elementy w kolejce, ponowna próba za 1 minutę
      if (this.kolejka.some(op => !op.status || op.status !== 'nieudana')) {
        setTimeout(() => this.rozpocznijSynchronizacje(), 60000);
      }
    }
  }

  /**
   * Usuwa nieudane operacje z kolejki
   */
  wyczyscNieudaneOperacje() {
    const poprzedniaLiczba = this.kolejka.length;
    this.kolejka = this.kolejka.filter(op => !op.status || op.status !== 'nieudana');
    this.zapiszKolejke();
    return poprzedniaLiczba - this.kolejka.length;
  }

  /**
   * Zwraca aktualny stan kolejki
   */
  pobierzStatus() {
    const wszystkie = this.kolejka.length;
    const nieudane = this.kolejka.filter(op => op.status === 'nieudana').length;
    const oczekujace = wszystkie - nieudane;

    return {
      wszystkie,
      oczekujace,
      nieudane,
      jestSynchronizacja: this.jestSynchronizacja
    };
  }
}

// Utworzenie instancji kolejki synchronizacji
const syncDinozaurow = new KolejkaSynchronizacji({
  klucz: 'jurassic-park-dino-sync'
});

// Przykład użycia: aktualizacja zdrowia dinozaura, która będzie synchronizowana
function aktualizujZdrowieDinozaura(id, parametryZdrowia) {
  // Przygotuj dane do wysyłki
  const dane = {
    id,
    health: parametryZdrowia.health,
    lastCheckTime: new Date().toISOString(),
    symptoms: parametryZdrowia.symptoms || [],
    updatedBy: 'dr-wu'
  };

  // Jeśli jesteśmy online, próbuj od razu
  if (navigator.onLine) {
    return fetch(`https://api.jurassic-park.com/dinosaurs/${id}/health`, {
      method: 'PUT',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify(dane)
    })
    .then(response => {
      if (!response.ok) {
        throw new Error(`Błąd HTTP: ${response.status}`);
      }
      return response.json();
    })
    .catch(error => {
      console.warn('Nie udało się zaktualizować zdrowia online, dodaję do kolejki synchronizacji');

      // Dodaj do kolejki synchronizacji
      syncDinozaurow.dodajDoKolejki(
        `https://api.jurassic-park.com/dinosaurs/${id}/health`,
        {
          method: 'PUT',
          headers: { 'Content-Type': 'application/json' },
          body: JSON.stringify(dane)
        },
        `aktualizacja-zdrowia-${id}`
      );

      // Zwróć dane, jakby operacja się powiodła, choć będzie zsynchronizowana później
      return {
        ...dane,
        pendingSync: true
      };
    });
  } else {
    // Jeśli jesteśmy offline, od razu dodaj do kolejki
    syncDinozaurow.dodajDoKolejki(
      `https://api.jurassic-park.com/dinosaurs/${id}/health`,
      {
        method: 'PUT',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify(dane)
      },
      `aktualizacja-zdrowia-${id}`
    );

    return Promise.resolve({
      ...dane,
      pendingSync: true
    });
  }
}

Uwierzytelnianie i odświeżanie tokenów

W systemie Parku Jurajskiego potrzebujemy zabezpieczyć dostęp do API, używając tokenów uwierzytelniających. Zaimplementujmy mechanizm, który automatycznie odświeża token, gdy wygaśnie:

class ZarzadcaUwierzytelniania {
  constructor() {
    this.tokenAccessKey = 'jp-access-token';
    this.tokenRefreshKey = 'jp-refresh-token';
    this.expiryKey = 'jp-token-expiry';
    this.refreshInProgress = false;
    this.refreshListeners = [];
  }

  /**
   * Pobiera aktualny token dostępu
   * @param {boolean} autoRefresh - Czy automatycznie odświeżyć token, jeśli wygasł
   * @returns {Promise<string>} - Promise z tokenem dostępu
   */
  async pobierzTokenDostepowy(autoRefresh = true) {
    const token = localStorage.getItem(this.tokenAccessKey);
    const expiry = localStorage.getItem(this.expiryKey);

    // Sprawdź, czy token istnieje i czy nie wygasł
    if (token && expiry) {
      const expiryDate = new Date(expiry);
      const now = new Date();

      // Dodajemy 1 minutę buforu, aby uniknąć używania wygasającego za chwilę tokenu
      const bufferTime = 60 * 1000; // 1 minuta w milisekundach

      if (expiryDate.getTime() - now.getTime() > bufferTime) {
        return token;
      }

      // Token wygasł lub wygaśnie wkrótce
      if (autoRefresh) {
        return this.odswiezToken();
      }
    }

    throw new Error('Brak ważnego tokenu dostępowego');
  }

  /**
   * Odświeża token dostępu używając tokenu odświeżającego
   * @returns {Promise<string>} - Promise z nowym tokenem dostępu
   */
  async odswiezToken() {
    // Jeśli odświeżanie jest już w toku, zaczekaj na jego wynik
    if (this.refreshInProgress) {
      return new Promise((resolve, reject) => {
        this.refreshListeners.push({ resolve, reject });
      });
    }

    this.refreshInProgress = true;

    try {
      const refreshToken = localStorage.getItem(this.tokenRefreshKey);

      if (!refreshToken) {
        throw new Error('Brak tokenu odświeżającego');
      }

      const response = await fetch('https://api.jurassic-park.com/auth/refresh', {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({ refresh_token: refreshToken })
      });

      if (!response.ok) {
        if (response.status === 401) {
          // Token odświeżający jest nieprawidłowy, wyloguj użytkownika
          this.wyloguj();
          throw new Error('Sesja wygasła. Zaloguj się ponownie.');
        }
        throw new Error(`Błąd odświeżania tokenu: ${response.status}`);
      }

      const data = await response.json();

      // Zapisz nowe tokeny
      localStorage.setItem(this.tokenAccessKey, data.access_token);
      localStorage.setItem(this.tokenRefreshKey, data.refresh_token);

      // Oblicz czas wygaśnięcia
      const expiry = new Date();
      expiry.setSeconds(expiry.getSeconds() + data.expires_in);
      localStorage.setItem(this.expiryKey, expiry.toISOString());

      // Powiadom wszystkich oczekujących
      this.refreshListeners.forEach(listener => {
        listener.resolve(data.access_token);
      });

      this.refreshListeners = [];
      return data.access_token;
    } catch (error) {
      // W przypadku błędu, powiadom wszystkich oczekujących
      this.refreshListeners.forEach(listener => {
        listener.reject(error);
      });

      this.refreshListeners = [];
      throw error;
    } finally {
      this.refreshInProgress = false;
    }
  }

  /**
   * Zapisuje tokeny po zalogowaniu
   * @param {Object} authData - Dane uwierzytelniające
   */
  zapiszTokeny(authData) {
    localStorage.setItem(this.tokenAccessKey, authData.access_token);
    localStorage.setItem(this.tokenRefreshKey, authData.refresh_token);

    // Oblicz czas wygaśnięcia
    const expiry = new Date();
    expiry.setSeconds(expiry.getSeconds() + authData.expires_in);
    localStorage.setItem(this.expiryKey, expiry.toISOString());
  }

  /**
   * Wylogowuje użytkownika
   */
  wyloguj() {
    localStorage.removeItem(this.tokenAccessKey);
    localStorage.removeItem(this.tokenRefreshKey);
    localStorage.removeItem(this.expiryKey);
  }

  /**
   * Sprawdza, czy użytkownik jest zalogowany
   * @returns {boolean}
   */
  czyZalogowany() {
    return !!localStorage.getItem(this.tokenAccessKey);
  }
}

// Tworzenie instancji zarządcy uwierzytelniania
const auth = new ZarzadcaUwierzytelniania();

// Przykład użycia - funkcja do wykonywania uwierzytelnionych żądań
async function zapytanieUwierzytelnione(url, options = {}) {
  try {
    // Pobierz token dostępu (z automatycznym odświeżaniem)
    const token = await auth.pobierzTokenDostepowy();

    // Dodaj token do nagłówków
    const authOptions = {
      ...options,
      headers: {
        ...options.headers,
        'Authorization': `Bearer ${token}`
      }
    };

    // Wykonaj żądanie
    const response = await fetch(url, authOptions);

    // Obsługa błędów autoryzacji
    if (response.status === 401) {
      // Spróbuj odświeżyć token i ponowić żądanie
      try {
        const newToken = await auth.odswiezToken();

        // Ponów żądanie z nowym tokenem
        const refreshedOptions = {
          ...options,
          headers: {
            ...options.headers,
            'Authorization': `Bearer ${newToken}`
          }
        };

        return fetch(url, refreshedOptions);
      } catch (refreshError) {
        // Nie udało się odświeżyć tokenu, wyloguj użytkownika
        auth.wyloguj();
        window.location.href = '/login'; // Przekieruj do logowania
        throw new Error('Sesja wygasła. Zaloguj się ponownie.');
      }
    }

    return response;
  } catch (error) {
    console.error('Błąd uwierzytelnionego żądania:', error);
    throw error;
  }
}

// Przykład użycia
async function pobierzDaneWybiegu(wybiegId) {
  const response = await zapytanieUwierzytelnione(
    `https://api.jurassic-park.com/paddocks/${wybiegId}`
  );

  if (!response.ok) {
    throw new Error(`Błąd pobierania danych wybiegu: ${response.status}`);
  }

  return response.json();
}

// Funkcja logowania
async function zaloguj(email, haslo) {
  try {
    const response = await fetch('https://api.jurassic-park.com/auth/login', {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({ email, password: haslo })
    });

    if (!response.ok) {
      throw new Error(`Błąd logowania: ${response.status}`);
    }

    const authData = await response.json();

    // Zapisz tokeny
    auth.zapiszTokeny(authData);

    return {
      success: true,
      user: authData.user
    };
  } catch (error) {
    console.error('Błąd logowania:', error);
    return {
      success: false,
      error: error.message
    };
  }
}

Przesyłanie plików z postępem

W Parku Jurajskim często musimy przesyłać duże pliki, takie jak obrazy czy filmy z kamer monitoringu dinozaurów. Zaimplementujmy funkcję, która obsługuje przesyłanie plików z informacją o postępie:

/**
 * Wysyła plik na serwer z monitorowaniem postępu
 * @param {File} plik - Plik do wysłania
 * @param {string} url - URL docelowy
 * @param {Object} opcje - Dodatkowe opcje
 * @returns {Promise} - Promise z wynikiem operacji
 */
async function wyslijPlik(plik, url, opcje = {}) {
  return new Promise((resolve, reject) => {
    // Domyślne opcje
    const {
      metoda = 'POST',
      nazwaPolaPliku = 'file',
      dodatkoweDane = {},
      naPostep = null,
      naBlad = null,
      maxRetries = 3
    } = opcje;

    // Licznik ponownych prób
    let proby = 0;

    // Funkcja do wykonania żądania
    function wykonajWysylanie() {
      // Utworzenie obiektu XHR
      const xhr = new XMLHttpRequest();

      // Konfiguracja obsługi zdarzeń
      xhr.upload.addEventListener('progress', (event) => {
        if (event.lengthComputable && typeof naPostep === 'function') {
          const procent = Math.round((event.loaded / event.total) * 100);
          naPostep({
            loaded: event.loaded,
            total: event.total,
            procent
          });
        }
      });

      xhr.addEventListener('load', () => {
        if (xhr.status >= 200 && xhr.status < 300) {
          try {
            // Parsowanie odpowiedzi JSON
            const odpowiedz = JSON.parse(xhr.responseText);
            resolve(odpowiedz);
          } catch (e) {
            resolve({
              success: true,
              status: xhr.status,
              message: xhr.statusText
            });
          }
        } else {
          const blad = new Error(`Błąd HTTP: ${xhr.status}`);
          blad.status = xhr.status;
          blad.statusText = xhr.statusText;

          if (xhr.status >= 500 && proby < maxRetries) {
            // Dla błędów serwera, spróbuj ponownie
            proby++;
            console.warn(`Błąd wysyłania pliku (${xhr.status}). Ponowna próba ${proby}/${maxRetries}...`);
            setTimeout(wykonajWysylanie, 2000 * proby); // Zwiększanie czasu między próbami
          } else {
            if (typeof naBlad === 'function') {
              naBlad(blad);
            }
            reject(blad);
          }
        }
      });

      xhr.addEventListener('error', () => {
        const blad = new Error('Błąd sieci podczas wysyłania pliku');
        if (typeof naBlad === 'function') {
          naBlad(blad);
        }

        if (proby < maxRetries) {
          proby++;
          console.warn(`Błąd sieci podczas wysyłania. Ponowna próba ${proby}/${maxRetries}...`);
          setTimeout(wykonajWysylanie, 2000 * proby);
        } else {
          reject(blad);
        }
      });

      xhr.addEventListener('abort', () => {
        const blad = new Error('Wysyłanie pliku zostało przerwane');
        if (typeof naBlad === 'function') {
          naBlad(blad);
        }
        reject(blad);
      });

      // Otwarcie połączenia
      xhr.open(metoda, url, true);

      // Przygotowanie danych FormData
      const formData = new FormData();
      formData.append(nazwaPolaPliku, plik);

      // Dodanie dodatkowych danych
      Object.entries(dodatkoweDane).forEach(([klucz, wartosc]) => {
        formData.append(klucz, wartosc);
      });

      // Wysłanie żądania
      xhr.send(formData);

      // Zwrócenie obiektu z metodą przerwania
      return {
        przerwij: () => xhr.abort()
      };
    }

    // Rozpoczęcie wysyłania
    wykonajWysylanie();
  });
}

// Przykład użycia
async function wyslijNagranieZKamery(plik, lokalizacja) {
  const controller = document.getElementById('upload-controller');
  const progressBar = document.getElementById('upload-progress');
  const statusText = document.getElementById('upload-status');

  controller.classList.remove('hidden');
  statusText.textContent = 'Przygotowywanie...';

  try {
    const wynik = await wyslijPlik(
      plik,
      'https://api.jurassic-park.com/security/camera-footage',
      {
        dodatkoweDane: {
          location: lokalizacja,
          timestamp: new Date().toISOString(),
          operator: 'dr-wu'
        },
        naPostep: (info) => {
          progressBar.value = info.procent;
          statusText.textContent = `Wysyłanie: ${info.procent}%`;
        },
        naBlad: (blad) => {
          statusText.textContent = `Błąd: ${blad.message}`;
          progressBar.classList.add('error');
        }
      }
    );

    statusText.textContent = 'Wysyłanie ukończone!';
    progressBar.value = 100;

    setTimeout(() => {
      controller.classList.add('hidden');
    }, 3000);

    return wynik;
  } catch (error) {
    statusText.textContent = `Błąd: ${error.message}`;
    progressBar.classList.add('error');
    throw error;
  }
}

Monitorowanie stanu sieci

W Parku Jurajskim musimy być przygotowani na problemy z łącznością, zwłaszcza w oddalonych częściach wyspy. Zaimplementujmy system monitorowania stanu sieci:

class MonitorSieci {
  constructor(opcje = {}) {
    this.sluchacze = {
      zmiana: [],
      online: [],
      offline: []
    };

    this.ostatniPing = null;
    this.opoznienie = null;
    this.status = navigator.onLine ? 'online' : 'offline';
    this.adresEndpointu = opcje.endpointPing || 'https://api.jurassic-park.com/ping';
    this.interwalPingu = opcje.interwalPingu || 30000; // 30 sekund
    this.timeoutPingu = opcje.timeoutPingu || 5000; // 5 sekund

    // Dodanie nasłuchiwaczy na zdarzenia online/offline
    window.addEventListener('online', this.obslugaOnline.bind(this));
    window.addEventListener('offline', this.obslugaOffline.bind(this));

    // Start regularnego pingowania
    if (opcje.autostartPing !== false) {
      this.startPingowanie();
    }
  }

  /**
   * Obsługa zdarzenia przejścia do trybu online
   */
  obslugaOnline() {
    const poprzedniStatus = this.status;
    this.status = 'online';

    // Powiadomienie słuchaczy
    this.powiadomSluchaczy('online');

    if (poprzedniStatus !== this.status) {
      this.powiadomSluchaczy('zmiana', { status: this.status, poprzedni: poprzedniStatus });
    }

    // Wykonaj natychmiastowy ping dla sprawdzenia rzeczywistej łączności
    this.ping();
  }

  /**
   * Obsługa zdarzenia przejścia do trybu offline
   */
  obslugaOffline() {
    const poprzedniStatus = this.status;
    this.status = 'offline';
    this.opoznienie = null;

    // Powiadomienie słuchaczy
    this.powiadomSluchaczy('offline');

    if (poprzedniStatus !== this.status) {
      this.powiadomSluchaczy('zmiana', { status: this.status, poprzedni: poprzedniStatus });
    }
  }

  /**
   * Ping serwera dla sprawdzenia rzeczywistej łączności
   * @returns {Promise<number>} - Promise z czasem opóźnienia w ms
   */
  async ping() {
    if (!navigator.onLine) {
      this.opoznienie = null;
      return Promise.reject(new Error('Przeglądarka jest w trybie offline'));
    }

    try {
      const startTime = Date.now();

      // Ustawienie timeout dla fetch
      const controller = new AbortController();
      const timeoutId = setTimeout(() => controller.abort(), this.timeoutPingu);

      const response = await fetch(`${this.adresEndpointu}?t=${startTime}`, {
        method: 'GET',
        cache: 'no-store',
        signal: controller.signal
      });

      clearTimeout(timeoutId);

      if (!response.ok) {
        throw new Error(`Błąd HTTP: ${response.status}`);
      }

      // Oblicz opóźnienie
      const endTime = Date.now();
      this.opoznienie = endTime - startTime;
      this.ostatniPing = new Date();

      // Aktualizacja statusu
      const poprzedniStatus = this.status;
      this.status = 'online';

      if (poprzedniStatus !== this.status) {
        this.powiadomSluchaczy('zmiana', { status: this.status, poprzedni: poprzedniStatus });
        this.powiadomSluchaczy('online');
      }

      return this.opoznienie;
    } catch (error) {
      // Jeśli timeout lub błąd sieci, oznacz jako offline
      if (error.name === 'AbortError' || error instanceof TypeError) {
        const poprzedniStatus = this.status;
        this.status = 'offline';
        this.opoznienie = null;

        if (poprzedniStatus !== this.status) {
          this.powiadomSluchaczy('zmiana', { status: this.status, poprzedni: poprzedniStatus });
          this.powiadomSluchaczy('offline');
        }
      }

      throw error;
    }
  }

  /**
   * Rozpoczyna regularne pingowanie serwera
   */
  startPingowanie() {
    // Zatrzymaj istniejący interwał, jeśli istnieje
    this.stopPingowanie();

    // Wykonaj pierwszy ping natychmiast
    this.ping().catch(e => console.warn('Błąd początkowego pingu:', e));

    // Ustaw interwał pingowania
    this.pingInterval = setInterval(() => {
      this.ping().catch(e => console.warn('Błąd pingowania:', e));
    }, this.interwalPingu);
  }

  /**
   * Zatrzymuje regularne pingowanie serwera
   */
  stopPingowanie() {
    if (this.pingInterval) {
      clearInterval(this.pingInterval);
      this.pingInterval = null;
    }
  }

  /**
   * Dodaje słuchacza na zdarzenie
   * @param {string} typZdarzenia - Typ zdarzenia ('zmiana', 'online', 'offline')
   * @param {Function} callback - Funkcja callback
   */
  nasluchuj(typZdarzenia, callback) {
    if (this.sluchacze[typZdarzenia]) {
      this.sluchacze[typZdarzenia].push(callback);
    }
    return this; // Dla chain API
  }

  /**
   * Usuwa słuchacza
   * @param {string} typZdarzenia - Typ zdarzenia
   * @param {Function} callback - Funkcja callback do usunięcia
   */
  przestanNasluchiwac(typZdarzenia, callback) {
    if (this.sluchacze[typZdarzenia]) {
      this.sluchacze[typZdarzenia] = this.sluchacze[typZdarzenia].filter(cb => cb !== callback);
    }
    return this;
  }

  /**
   * Powiadamia słuchaczy o zdarzeniu
   * @param {string} typZdarzenia - Typ zdarzenia
   * @param {Object} dane - Dane zdarzenia
   */
  powiadomSluchaczy(typZdarzenia, dane = {}) {
    if (this.sluchacze[typZdarzenia]) {
      this.sluchacze[typZdarzenia].forEach(callback => {
        try {
          callback({
            typ: typZdarzenia,
            timestamp: new Date(),
            status: this.status,
            opoznienie: this.opoznienie,
            ...dane
          });
        } catch (e) {
          console.error(`Błąd w słuchaczu ${typZdarzenia}:`, e);
        }
      });
    }
  }

  /**
   * Zwraca aktualny stan sieci
   */
  pobierzStan() {
    return {
      status: this.status,
      opoznienie: this.opoznienie,
      ostatniPing: this.ostatniPing,
      przegldarkaOnline: navigator.onLine
    };
  }
}

// Utworzenie instancji monitora sieci
const monitorSieci = new MonitorSieci();

// Przykład użycia
monitorSieci.nasluchuj('zmiana', (info) => {
  console.log(`Zmiana stanu sieci: ${info.poprzedni} -> ${info.status}`);

  // Aktualizacja interfejsu użytkownika
  const statusIndicator = document.getElementById('network-status');
  if (statusIndicator) {
    statusIndicator.className = `status-${info.status}`;
    statusIndicator.textContent = info.status === 'online'
      ? `Online (ping: ${info.opoznienie}ms)`
      : 'Offline';
  }
});

monitorSieci.nasluchuj('offline', () => {
  // Pokaż powiadomienie użytkownikowi
  pokazPowiadomienie('Utracono połączenie z siecią', 'error');

  // Włącz tryb offline w aplikacji
  app.wlaczTrybOffline();
});

monitorSieci.nasluchuj('online', (info) => {
  pokazPowiadomienie(`Połączenie przywrócone (ping: ${info.opoznienie}ms)`, 'success');

  // Synchronizuj dane z serwerem
  syncDinozaurow.rozpocznijSynchronizacje();

  // Wyłącz tryb offline
  app.wylaczTrybOffline();
});

function pokazPowiadomienie(tekst, typ) {
  const notification = document.createElement('div');
  notification.className = `notification ${typ}`;
  notification.textContent = tekst;

  document.body.appendChild(notification);

  // Usuń powiadomienie po 5 sekundach
  setTimeout(() => {
    notification.classList.add('fade-out');
    setTimeout(() => {
      document.body.removeChild(notification);
    }, 500);
  }, 5000);
}

Podsumowanie - Tworzenie kompleksowego klienta API

Łącząc wszystkie omówione techniki, możemy stworzyć wysoko wydajny, odporny na błędy i przyjazny dla użytkownika system komunikacji z API. Oto przykład kompletnego rozwiązania:

/**
 * Kompleksowy klient API dla systemu Parku Jurajskiego
 */
class JurassicAPIClient {
  constructor(opcje = {}) {
    // Konfiguracja bazowego URL
    this.baseUrl = opcje.baseUrl || 'https://api.jurassic-park.com';

    // Inicjalizacja zarządcy uwierzytelniania
    this.auth = new ZarzadcaUwierzytelniania();

    // Inicjalizacja cache
    this.cache = new ZarzadcaPamieciPodrecznej();

    // Inicjalizacja kolejki synchronizacji
    this.syncQueue = new KolejkaSynchronizacji({
      klucz: 'jp-sync-queue',
      autoSync: true
    });

    // Inicjalizacja monitora sieci
    this.networkMonitor = new MonitorSieci({
      endpointPing: `${this.baseUrl}/ping`,
      interwalPingu: 30000
    });

    // Monitorowanie stanu sieci
    this.networkMonitor.nasluchuj('online', () => {
      this.syncQueue.rozpocznijSynchronizacje();
    });

    // Domyślne opcje żądań
    this.defaultOptions = {
      timeout: 30000,
      retries: 3,
      cacheTime: 300000, // 5 minut
      useCache: true
    };
  }

  /**
   * Wykonuje żądanie HTTP
   * @param {string} endpoint - Endpoint API
   * @param {Object} opcje - Opcje żądania
   * @returns {Promise} - Promise z wynikiem żądania
   */
  async request(endpoint, opcje = {}) {
    // Połączenie domyślnych opcji z przekazanymi
    const {
      method = 'GET',
      body,
      headers = {},
      useAuth = true,
      useCache = this.defaultOptions.useCache,
      cacheTime = this.defaultOptions.cacheTime,
      forceRefresh = false,
      timeout = this.defaultOptions.timeout,
      retries = this.defaultOptions.retries,
      offlineFallback = true
    } = opcje;

    // Przygotowanie klucza cache
    const cacheKey = `${method}:${endpoint}:${JSON.stringify(body || {})}`;

    // Sprawdzenie, czy zapytanie jest w cache (tylko dla GET)
    if (method === 'GET' && useCache && !forceRefresh) {
      try {
        const cachedData = await this.cache.pobierz(
          cacheKey,
          () => {}, // Pusta funkcja, bo nie chcemy jeszcze wykonywać żądania
          { ttl: cacheTime, onlyIfCached: true }
        );

        if (cachedData) {
          return cachedData;
        }
      } catch (error) {
        // Ignoruj błędy cache
      }
    }

    // Sprawdzenie stanu sieci
    if (!this.networkMonitor.pobierzStan().status === 'online') {
      // Jesteśmy offline, sprawdź czy mamy dane w cache
      if (method === 'GET' && useCache && offlineFallback) {
        try {
          const cachedData = await this.cache.pobierz(
            cacheKey,
            () => {}, // Pusta funkcja, bo nie chcemy jeszcze wykonywać żądania
            { ttl: Infinity, onlyIfCached: true, ignoreExpiry: true }
          );

          if (cachedData) {
            // Informacje o trybie offline
            return {
              ...cachedData,
              _meta: {
                fromCache: true,
                offlineMode: true,
                timestamp: new Date()
              }
            };
          }
        } catch (error) {
          // Ignoruj błędy cache
        }
      }

      // Jeśli to żądanie modyfikujące dane, dodaj do kolejki synchronizacji
      if (method !== 'GET' && offlineFallback) {
        return this.addToSyncQueue(endpoint, { method, body, headers, useAuth });
      }

      throw new Error('Brak połączenia z siecią. Nie można wykonać żądania.');
    }

    // Funkcja wykonująca właściwe żądanie
    const executeRequest = async (signal) => {
      // Przygotowanie URL
      const url = `${this.baseUrl}${endpoint}`;

      // Przygotowanie opcji żądania
      const requestOptions = {
        method,
        headers: {
          'Content-Type': 'application/json',
          ...headers
        },
        signal
      };

      // Dodanie ciała żądania, jeśli istnieje
      if (body) {
        requestOptions.body = JSON.stringify(body);
      }

      // Dodanie tokenu uwierzytelniającego, jeśli wymagane
      if (useAuth) {
        try {
          const token = await this.auth.pobierzTokenDostepowy();
          requestOptions.headers['Authorization'] = `Bearer ${token}`;
        } catch (error) {
          // Jeśli nie udało się pobrać tokenu, a żądanie wymaga uwierzytelnienia
          throw new Error('Brak uwierzytelnienia. Zaloguj się ponownie.');
        }
      }

      // Wykonanie żądania z timeoutem
      const controller = new AbortController();
      const { signal: abortSignal } = controller;
      if (signal) {
        // Jeśli przekazano signal z zewnątrz, łączymy go z naszym
        signal.addEventListener('abort', () => controller.abort());
      }

      const timeoutId = setTimeout(() => controller.abort(), timeout);
      requestOptions.signal = abortSignal;

      try {
        const response = await fetch(url, requestOptions);
        clearTimeout(timeoutId);

        // Obsługa błędów HTTP
        if (response.status === 401 && useAuth) {
          // Próba odświeżenia tokenu
          try {
            await this.auth.odswiezToken();
            // Ponowna próba z nowym tokenem
            return this.request(endpoint, opcje);
          } catch (refreshError) {
            throw new Error('Sesja wygasła. Zaloguj się ponownie.');
          }
        }

        if (!response.ok) {
          const error = new Error(`Błąd HTTP: ${response.status}`);
          error.status = response.status;
          error.statusText = response.statusText;

          // Próba pobrania szczegółów błędu z odpowiedzi
          try {
            const errorData = await response.json();
            error.data = errorData;
            error.message = errorData.message || error.message;
          } catch (e) {
            // Ignoruj błędy parsowania
          }

          throw error;
        }

        // Parsowanie odpowiedzi w zależności od typu
        const contentType = response.headers.get('content-type');
        let data;

        if (contentType && contentType.includes('application/json')) {
          data = await response.json();
        } else if (contentType && contentType.includes('text/')) {
          data = await response.text();
        } else {
          data = await response.blob();
        }

        // Zapisanie odpowiedzi w cache dla żądań GET
        if (method === 'GET' && useCache) {
          this.cache.pobierz(cacheKey, () => data, { ttl: cacheTime, forceRefresh: true });
        }

        return data;
      } catch (error) {
        clearTimeout(timeoutId);

        if (error.name === 'AbortError') {
          throw new Error(`Żądanie przerwane po upływie czasu (${timeout}ms)`);
        }

        throw error;
      }
    };

    // Wykonanie żądania z ponawianiem prób
    return zPonawianiem(
      (signal) => executeRequest(signal),
      {
        maxProb: retries,
        poczatkoweOpoznienie: 1000,
        czynnikOpoznienia: 2,
        timeoutMs: timeout
      }
    );
  }

  /**
   * Dodaje żądanie do kolejki synchronizacji (tryb offline)
   * @param {string} endpoint - Endpoint API
   * @param {Object} opcje - Opcje żądania
   * @returns {Promise} - Promise z tymczasowym wynikiem
   */
  addToSyncQueue(endpoint, opcje) {
    const { method, body } = opcje;

    // Generowanie unikalnego ID dla operacji
    const operationId = `op-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;

    // Dodanie do kolejki synchronizacji
    this.syncQueue.dodajDoKolejki(
      `${this.baseUrl}${endpoint}`,
      {
        method,
        headers: {
          'Content-Type': 'application/json',
          // Token będzie dodany podczas rzeczywistej synchronizacji
        },
        body: body ? JSON.stringify(body) : undefined
      },
      `${method}-${endpoint}`
    );

    // Zwrócenie tymczasowej odpowiedzi
    return Promise.resolve({
      _meta: {
        pendingSync: true,
        operationId,
        timestamp: new Date(),
        offlineMode: true
      },
      ...body // Zwróć przekazane dane jako tymczasowy wynik
    });
  }

  // Metody pomocnicze dla różnych typów żądań

  /**
   * Wykonuje żądanie GET
   * @param {string} endpoint - Endpoint API
   * @param {Object} opcje - Opcje żądania
   * @returns {Promise} - Promise z wynikiem żądania
   */
  async get(endpoint, opcje = {}) {
    return this.request(endpoint, { ...opcje, method: 'GET' });
  }

  /**
   * Wykonuje żądanie POST
   * @param {string} endpoint - Endpoint API
   * @param {Object} body - Ciało żądania
   * @param {Object} opcje - Opcje żądania
   * @returns {Promise} - Promise z wynikiem żądania
   */
  async post(endpoint, body, opcje = {}) {
    return this.request(endpoint, { ...opcje, method: 'POST', body });
  }

  /**
   * Wykonuje żądanie PUT
   * @param {string} endpoint - Endpoint API
   * @param {Object} body - Ciało żądania
   * @param {Object} opcje - Opcje żądania
   * @returns {Promise} - Promise z wynikiem żądania
   */
  async put(endpoint, body, opcje = {}) {
    return this.request(endpoint, { ...opcje, method: 'PUT', body });
  }

  /**
   * Wykonuje żądanie DELETE
   * @param {string} endpoint - Endpoint API
   * @param {Object} opcje - Opcje żądania
   * @returns {Promise} - Promise z wynikiem żądania
   */
  async delete(endpoint, opcje = {}) {
    return this.request(endpoint, { ...opcje, method: 'DELETE' });
  }

  /**
   * Wysyła plik na serwer
   * @param {string} endpoint - Endpoint API
   * @param {File} plik - Plik do wysłania
   * @param {Object} opcje - Opcje żądania
   * @returns {Promise} - Promise z wynikiem żądania
   */
  async uploadFile(endpoint, plik, opcje = {}) {
    const {
      nazwaPolaPliku = 'file',
      dodatkoweDane = {},
      naPostep = null,
      useAuth = true
    } = opcje;

    // Jeśli offline, dodaj do kolejki synchronizacji
    if (!this.networkMonitor.pobierzStan().status === 'online') {
      throw new Error('Nie można wysłać pliku w trybie offline.');
    }

    // Przygotowanie danych FormData
    const formData = new FormData();
    formData.append(nazwaPolaPliku, plik);

    // Dodanie dodatkowych danych
    Object.entries(dodatkoweDane).forEach(([klucz, wartosc]) => {
      formData.append(klucz, JSON.stringify(wartosc));
    });

    // Opcje żądania
    const requestOptions = {
      method: 'POST',
      body: formData
    };

    // Dodanie tokenu uwierzytelniającego, jeśli wymagane
    if (useAuth) {
      try {
        const token = await this.auth.pobierzTokenDostepowy();
        requestOptions.headers = {
          'Authorization': `Bearer ${token}`
        };
      } catch (error) {
        throw new Error('Brak uwierzytelnienia. Zaloguj się ponownie.');
      }
    }

    return new Promise((resolve, reject) => {
      const xhr = new XMLHttpRequest();

      xhr.upload.addEventListener('progress', (event) => {
        if (event.lengthComputable && typeof naPostep === 'function') {
          const procent = Math.round((event.loaded / event.total) * 100);
          naPostep({
            loaded: event.loaded,
            total: event.total,
            procent
          });
        }
      });

      xhr.addEventListener('load', () => {
        if (xhr.status >= 200 && xhr.status < 300) {
          try {
            const odpowiedz = JSON.parse(xhr.responseText);
            resolve(odpowiedz);
          } catch (e) {
            resolve({
              success: true,
              status: xhr.status,
              message: xhr.statusText
            });
          }
        } else {
          const blad = new Error(`Błąd HTTP: ${xhr.status}`);
          blad.status = xhr.status;
          blad.statusText = xhr.statusText;
          reject(blad);
        }
      });

      xhr.addEventListener('error', () => {
        reject(new Error('Błąd sieci podczas wysyłania pliku'));
      });

      xhr.addEventListener('abort', () => {
        reject(new Error('Wysyłanie pliku zostało przerwane'));
      });

      xhr.open('POST', `${this.baseUrl}${endpoint}`, true);

      if (requestOptions.headers) {
        Object.entries(requestOptions.headers).forEach(([key, value]) => {
          xhr.setRequestHeader(key, value);
        });
      }

      xhr.send(formData);
    });
  }

  /**
   * Uwierzytelnia użytkownika
   * @param {string} email - Adres email
   * @param {string} haslo - Hasło
   * @returns {Promise} - Promise z wynikiem uwierzytelnienia
   */
  async login(email, haslo) {
    try {
      const response = await this.request('/auth/login', {
        method: 'POST',
        body: { email, password: haslo },
        useAuth: false
      });

      // Zapisz tokeny
      this.auth.zapiszTokeny(response);

      return {
        success: true,
        user: response.user
      };
    } catch (error) {
      return {
        success: false,
        error: error.message
      };
    }
  }

  /**
   * Wylogowuje użytkownika
   */
  logout() {
    this.auth.wyloguj();
    // Opcjonalne wyczyszczenie cache przy wylogowaniu
    this.cache.wyczysc();
  }
}

// Utworzenie instancji klienta API
const api = new JurassicAPIClient({
  baseUrl: 'https://api.jurassic-park.com'
});

// Przykład użycia klienta API

// Logowanie
async function logowanie(email, haslo) {
  const wynik = await api.login(email, haslo);
  if (wynik.success) {
    console.log(`Zalogowano jako ${wynik.user.name}`);
    return true;
  } else {
    console.error(`Błąd logowania: ${wynik.error}`);
    return false;
  }
}

// Pobieranie danych dinozaura
async function pobierzDinozaura(id) {
  try {
    return await api.get(`/dinosaurs/${id}`);
  } catch (error) {
    console.error(`Nie udało się pobrać dinozaura #${id}:`, error.message);
    throw error;
  }
}

// Aktualizacja danych dinozaura
async function aktualizujDinozaura(id, dane) {
  try {
    return await api.put(`/dinosaurs/${id}`, dane);
  } catch (error) {
    console.error(`Nie udało się zaktualizować dinozaura #${id}:`, error.message);
    throw error;
  }
}

// Pobieranie listy dinozaurów z filtrowaniem
async function pobierzListeDinozaurow(filter = {}) {
  try {
    return await api.get('/dinosaurs', {
      body: filter,
      cacheTime: 60000 // Krótszy czas cache dla list (1 minuta)
    });
  } catch (error) {
    console.error('Nie udało się pobrać listy dinozaurów:', error.message);
    throw error;
  }
}

// Wysyłanie dokumentacji medycznej dinozaura
async function wyslijDokumentacjeMedyczna(dinoId, plik, dane) {
  const progressBar = document.getElementById('upload-progress');
  const statusText = document.getElementById('upload-status');

  try {
    return await api.uploadFile(`/dinosaurs/${dinoId}/medical-records`, plik, {
      dodatkoweDane: dane,
      naPostep: (info) => {
        if (progressBar) progressBar.value = info.procent;
        if (statusText) statusText.textContent = `Wysyłanie: ${info.procent}%`;
      }
    });
  } catch (error) {
    console.error(`Nie udało się wysłać dokumentacji dla dinozaura #${dinoId}:`, error.message);
    if (statusText) statusText.textContent = `Błąd: ${error.message}`;
    throw error;
  }
}

W tym obszernym przykładzie zaimplementowaliśmy zaawansowany klient API, który obsługuje:

  1. Kompleksową obsługę błędów - różne rodzaje błędów HTTP i sieciowych
  2. Automatyczne ponawianie żądań - w przypadku tymczasowych problemów
  3. Cachowanie odpowiedzi - dla szybszego dostępu i wsparcia trybu offline
  4. Kolejkowanie operacji w trybie offline - dla zapewnienia spójności danych
  5. Monitorowanie stanu sieci - dla podejmowania odpowiednich decyzji
  6. Uwierzytelnianie i odświeżanie tokenów - dla bezpiecznego dostępu do API
  7. Wysyłanie plików z monitorowaniem postępu - dla lepszego doświadczenia użytkownika

Taki kompleksowy klient API zapewnia odporność na problemy sieciowe, efektywność dzięki cachowaniu, wsparcie dla trybu offline oraz przyjazne dla użytkownika mechanizmy, takie jak monitorowanie postępu. Jest to idealne rozwiązanie dla krytycznych systemów, takich jak system zarządzania Parkiem Jurajskim, gdzie niezawodność i bezpieczeństwo są kluczowe.

W następnej lekcji przyjrzymy się, jak efektywnie przetwarzać dane JSON otrzymane z API, aby prezentować je użytkownikom w przystępny sposób.

Kod do tej lekcji: index.js
// Function Factory - Fabryka funkcji
console.log("FUNCTION FACTORY - FABRYKA FUNKCJI\n");

// Factory function - funkcja tworząca inne funkcje
function createDinosaurHandler(species, defaultDangerLevel) {
  console.log(`Tworzenie handlera dla: ${species}`);

  // Zwracamy nową funkcję z "zapamiętanymi" parametrami
  return function(action) {
    console.log(`\n[${species}] Akcja: ${action}`);
    console.log(`  Domyślne zagrożenie: ${defaultDangerLevel}/10`);

    switch(action) {
      case 'FEED':
        console.log(`  Karmienie ${species}`);
        break;
      case 'MONITOR':
        console.log(`  Monitoring ${species}`);
        break;
      case 'ALERT':
        console.log(`  ALARM! ${species} wymaga uwagi!`);
        break;
      default:
        console.log(`  Nieznana akcja`);
    }
  };
}

// Tworzenie specjalizowanych handlerów
console.log("=== TWORZENIE HANDLERÓW ===\n");

const trexHandler = createDinosaurHandler('T-Rex', 10);
const triceratopsHandler = createDinosaurHandler('Triceratops', 3);
const velociraptorHandler = createDinosaurHandler('Velociraptor', 8);

// Używanie handlerów
console.log("\n=== UŻYWANIE HANDLERÓW ===");

trexHandler('FEED');
trexHandler('MONITOR');

triceratopsHandler('FEED');
velociraptorHandler('ALERT');

// Factory z dodatkowymi opcjami
console.log("\n=== ZAAWANSOWANA FACTORY ===\n");

function createAdvancedHandler(config) {
  const {
    species,
    dangerLevel,
    feedingTime,
    maxCapacity
  } = config;

  let currentCount = 0;

  return {
    add: function() {
      if (currentCount < maxCapacity) {
        currentCount++;
        console.log(`Dodano ${species}. Obecnie: ${currentCount}/${maxCapacity}`);
        return true;
      } else {
        console.log(`Brak miejsca dla ${species}! (${currentCount}/${maxCapacity})`);
        return false;
      }
    },

    remove: function() {
      if (currentCount > 0) {
        currentCount--;
        console.log(`Usunięto ${species}. Obecnie: ${currentCount}/${maxCapacity}`);
        return true;
      } else {
        console.log(`Brak ${species} do usunięcia`);
        return false;
      }
    },

    getInfo: function() {
      return {
        species,
        dangerLevel,
        feedingTime,
        count: currentCount,
        capacity: maxCapacity,
        occupancy: `${((currentCount / maxCapacity) * 100).toFixed(1)}%`
      };
    },

    feed: function() {
      console.log(`Karmienie ${currentCount} x ${species} o ${feedingTime}`);
    }
  };
}

// Tworzenie zaawansowanych handlerów
const trexManager = createAdvancedHandler({
  species: 'T-Rex',
  dangerLevel: 10,
  feedingTime: '18:00',
  maxCapacity: 5
});

const velociraptorManager = createAdvancedHandler({
  species: 'Velociraptor',
  dangerLevel: 8,
  feedingTime: '16:00',
  maxCapacity: 10
});

console.log("=== ZARZĄDZANIE POPULACJĄ ===\n");

trexManager.add();
trexManager.add();
trexManager.add();

console.log("\nT-Rex Info:", trexManager.getInfo());

trexManager.feed();

console.log("");

velociraptorManager.add();
velociraptorManager.add();
velociraptorManager.add();
velociraptorManager.add();
velociraptorManager.add();

console.log("\nVelociraptor Info:", velociraptorManager.getInfo());

console.log("\n=== KORZYŚCI Z FACTORY PATTERN ===");
console.log("Enkapsulacja - ukryte dane wewnętrzne");
console.log("Reużywalność - łatwe tworzenie podobnych obiektów");
console.log("Customizacja - każdy handler może mieć własną konfigurację");
console.log("Closures - każdy handler pamięta swoje ustawienia");

Hasła z dokumentacji w tej lekcji

Widzisz błąd w tej lekcji?

Sprawdź się

Odpowiedz na pytania z tej lekcji. Wybierz odpowiedź, a od razu zobaczysz, czy jest poprawna.

  1. 1. Co to jest retry pattern w kontekście żądań HTTP?

  2. 2. Która technika jest najbardziej efektywna do debugowania nieobsłużonych błędów w Promise?

Zadania praktyczne w grze

  • Edytor kodu

    Napisz async function fetchWithRetry(url, maxRetries), która ponawia fetch po błędzie z rosnącym opóźnieniem.

  • Układanie w pionie

    Uporządkuj etapy wzorca retry z exponential backoff:

  • Klikanie w kolejności

    Ułóż elementy wyścigu Promise:

  • Układanie w pionie

    Uporządkuj kolejność wykonania tego kodu: console.log('A'); setTimeout(() => console.log('B'), 0); Promise.resolve().then(() => console.log('C')); console.log('D');

  • Układanie w pionie

    Uporządkuj kolejność przetwarzania kodu przez Event Loop:

  • Układanie w pionie

    Uporządkuj etapy pobierania danych z API:

  1. PytanieWzorzec retry
  2. Zadanie z kodemPraktyka: Wzorzec retry z async/await
  3. Ułóż w kolejnościEtapy retry z exponential backoff
  4. Kliknij w kolejnościSkładnia Promise.race
  5. Ułóż w kolejnościKolejność wykonania: synchroniczny vs asynchroniczny
  6. PytanieDebugowanie kodu asynchronicznego
  7. Ułóż w kolejnościPrzetwarzanie kodu przez Event Loop
  8. Ułóż w kolejnościEtapy obsługi żądania HTTP z async/await

Przydatne artykuły