Async/await to pułapka — kiedy Promise.all() uratuje Twoją wydajność

async function getDashboardData(userId) {
  const user = await fetchUser(userId) // 200ms
  const posts = await fetchPosts(userId) // 300ms
  const notifications = await fetchNotifications(userId) // 150ms
  const stats = await fetchStats(userId) // 250ms
 
  return { user, posts, notifications, stats }
}

async function getDashboardData(userId) {
  const [user, posts, notifications, stats] = await Promise.all([
    fetchUser(userId), // 200ms
    fetchPosts(userId), // 300ms
    fetchNotifications(userId), // 150ms
    fetchStats(userId), // 250ms
  ])
 
  return { user, posts, notifications, stats }
}

const delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms))
 
async function sequential() {
  await delay(200)
  await delay(300)
  await delay(150)
  await delay(250)
}
 
async function parallel() {
  await Promise.all([delay(200), delay(300), delay(150), delay(250)])
}
 
// Pomiar
console.time('sequential')
await sequential()
console.timeEnd('sequential') // ~900ms
 
console.time('parallel')
await parallel()
console.timeEnd('parallel') // ~300ms

// ✅ Niezależne — mogą działać równolegle
const [user, products, cart] = await Promise.all([
  fetchUser(userId),
  fetchProducts(categoryId),
  fetchCart(userId),
])

// ❌ Zależne — muszą być sekwencyjne
const user = await fetchUser(userId)
const orders = await fetchOrders(user.customerId) // potrzebuje user.customerId
const payments = await fetchPayments(orders[0].id) // potrzebuje orders

try {
  const [a, b, c] = await Promise.all([
    fetchA(), // OK
    fetchB(), // FAIL — rzuca błąd
    fetchC(), // nadal się wykonuje — wynik jest tylko ignorowany
  ])
} catch (error) {
  // catch dostaje błąd z pierwszej odrzuconej Promise
  // nie dostajesz częściowych wyników w prosty sposób
  // pozostałe operacje dalej wykonują się w tle, chyba że same wspierają anulowanie
}

const results = await Promise.allSettled([
  fetchA(),
  fetchB(), // może się nie powieść
  fetchC(),
])
 
// results = [
//   { status: 'fulfilled', value: resultA },
//   { status: 'rejected', reason: Error },
//   { status: 'fulfilled', value: resultC },
// ]
 
// Wyciągnij tylko udane
const successful = results
  .filter((r) => r.status === 'fulfilled')
  .map((r) => r.value)
 
// Wyciągnij błędy do logowania
const errors = results
  .filter((r) => r.status === 'rejected')
  .map((r) => r.reason)

// Generic timeout wrapper
function withTimeout(promise, ms) {
  return Promise.race([
    promise,
    new Promise((_, reject) =>
      setTimeout(() => reject(new Error('Timeout')), ms),
    ),
  ])
}
 
const data = await withTimeout(fetchData(), 5000)

// Fallback pattern — użyj pierwszego działającego źródła
const data = await Promise.any([
  fetchFromPrimaryAPI(),
  fetchFromBackupAPI(),
  fetchFromCache(),
])

async function getOrderDetails(orderId) {
  // Krok 1: Pobierz zamówienie
  const order = await fetchOrder(orderId)
 
  // Krok 2: Równolegle pobierz powiązane dane
  const [customer, products, shipping] = await Promise.all([
    fetchCustomer(order.customerId),
    fetchProducts(order.productIds),
    fetchShipping(order.shippingId),
  ])
 
  return { order, customer, products, shipping }
}

async function processBatch(items, fn, concurrency = 5) {
  const results = []
 
  for (let i = 0; i < items.length; i += concurrency) {
    const batch = items.slice(i, i + concurrency)
    const batchResults = await Promise.all(batch.map(fn))
    results.push(...batchResults)
  }
 
  return results
}
 
// Użycie: przetwórz 100 elementów, max 5 na raz
const users = await processBatch(userIds, fetchUser, 5)

async function fetchWithRetry(fn, maxRetries = 3) {
  for (let i = 0; i < maxRetries; i++) {
    try {
      return await fn()
    } catch (error) {
      if (i === maxRetries - 1) throw error
 
      const delay = Math.pow(2, i) * 1000 // 1s, 2s, 4s
      await new Promise((r) => setTimeout(r, delay))
    }
  }
}
 
// Użycie
const data = await fetchWithRetry(async () => {
  const response = await fetch('https://api.example.com/flaky-endpoint')
 
  if (!response.ok) {
    throw new Error(`HTTP ${response.status}`)
  }
 
  return response.json()
})

async function promisePool(items, fn, concurrency) {
  const results = new Array(items.length)
  let index = 0
 
  async function worker() {
    while (index < items.length) {
      const currentIndex = index++
      results[currentIndex] = await fn(items[currentIndex])
    }
  }
 
  await Promise.all(Array.from({ length: concurrency }, worker))
 
  return results
}
 
// 1000 elementów, max 10 równoległych operacji
const results = await promisePool(largeArray, processItem, 10)

// ❌ Źle — każda iteracja czeka na poprzednią
const sequentialResults = []
 
for (const id of ids) {
  const data = await fetchData(id)
  sequentialResults.push(data)
}
 
// ✅ Dobrze — równoległe
const parallelResults = await Promise.all(ids.map((id) => fetchData(id)))

// ❌ Źle — await na tablicy NIE rozwiązuje Promise w środku
const pendingResults = await ids.map((id) => fetchData(id))
// pendingResults = [Promise, Promise, Promise...]
 
// ✅ Dobrze
const resolvedResults = await Promise.all(ids.map((id) => fetchData(id)))
// resolvedResults = [data, data, data...]

// ❌ Źle — forEach ignoruje Promise
ids.forEach(async (id) => {
  await processItem(id) // Te operacje "uciekają"
})
console.log('Done') // Wyświetli się przed zakończeniem!
 
// ✅ Dobrze
await Promise.all(ids.map((id) => processItem(id)))
console.log('Done') // Teraz czeka na wszystkie

// ❌ Ryzykowne — 2000 requestów naraz to proszenie się o problemy
const allAtOnceResults = await Promise.all(ids.map((id) => fetchData(id)))
 
// ✅ Lepiej — limit równoległości
const limitedResults = await processBatch(ids, fetchData, 10)

async function withTiming(name, fn) {
  const start = performance.now()
  const result = await fn()
  const duration = performance.now() - start
  console.log(`${name}: ${duration.toFixed(2)}ms`)
  return result
}
 
// Użycie
const data = await withTiming('Dashboard data', () =>
  Promise.all([fetchUser(), fetchPosts(), fetchStats()]),
)