async forEach Fires 1000 Calls, Awaits Zero

// ─── Demonstrating that async functions always return a Promise ───

async function getWelcomeMessage() {
  // We return a plain string, but the async keyword
  // automatically wraps this in Promise.resolve('Hello!')
  return 'Hello from an async function!';
}

// Proof: call it and check what we get back
const result = getWelcomeMessage();
console.log(result instanceof Promise); // true — it's always a Promise

// Use .then() on it — totally valid because it IS a Promise
result.then((message) => console.log(message));

// ─── Demonstrating what await actually does ───

function simulateNetworkDelay(ms) {
  // Returns a Promise that resolves after `ms` milliseconds
  // This mimics a real API call or database query
  return new Promise((resolve) => setTimeout(resolve, ms));
}

async function fetchUserProfile() {
  console.log('1. fetchUserProfile started');

  // await pauses THIS function but NOT the whole program.
  // The event loop is free to run other code during this wait.
  await simulateNetworkDelay(1000);

  console.log('3. fetchUserProfile resumed after 1 second');
  return { id: 42, name: 'Sarah Connor', role: 'engineer' };
}

console.log('0. Before calling fetchUserProfile');
fetchUserProfile().then((user) => console.log('4. Got user:', user.name));
console.log('2. After calling fetchUserProfile — proof the thread is NOT blocked');

// ─── Pattern 1: try/catch — most readable for most situations ───

async function loadUserDashboard(userId) {
  try {
    // Both of these can throw — one try/catch covers both
    const userResponse = await fetch(`https://api.example.com/users/${userId}`);

    if (!userResponse.ok) {
      // Manually throw so we catch HTTP errors, not just network errors
      throw new Error(`HTTP ${userResponse.status}: Failed to load user ${userId}`);
    }

    const user = await userResponse.json(); // This can also throw if JSON is malformed
    console.log(`Dashboard loaded for: ${user.name}`);
    return user;

  } catch (error) {
    // One place to handle every failure in this async flow
    console.error('Dashboard failed to load:', error.message);
    return null; // Return a safe fallback so callers don't blow up
  }
}

// ─── Pattern 2: The 'safeAwait' helper — great for granular error handling ───
// Instead of nested try/catches, wrap each await to get [error, result] tuples
// Inspired by Go's error handling style

async function safeAwait(promise) {
  try {
    const data = await promise;
    return [null, data]; // [error, result] — error is null on success
  } catch (error) {
    return [error, null]; // error is populated on failure
  }
}

async function processOrder(orderId) {
  // Step 1: Validate the order
  const [validationError, order] = await safeAwait(
    fetch(`https://api.example.com/orders/${orderId}`).then((r) => r.json())
  );

  if (validationError) {
    console.error('Order validation failed:', validationError.message);
    return;
  }

  // Step 2: Charge the customer — different error, different handling
  const [paymentError, receipt] = await safeAwait(
    fetch('https://api.example.com/payments', {
      method: 'POST',
      body: JSON.stringify({ orderId: order.id, amount: order.total }),
    }).then((r) => r.json())
  );

  if (paymentError) {
    // Handle payment failure specifically — maybe alert the user differently
    console.error('Payment failed — order preserved for retry:', paymentError.message);
    return;
  }

  console.log(`Order ${orderId} confirmed. Receipt ID: ${receipt.id}`);
}

// ─── Pattern 3: Propagate errors upward intentionally ───
// Sometimes you WANT the error to bubble up to the caller

async function getProductPrice(productId) {
  const response = await fetch(`https://api.example.com/products/${productId}`);
  if (!response.ok) throw new Error(`Product ${productId} not found`);
  const product = await response.json();
  return product.price;
  // No try/catch here — the caller decides how to handle the failure
}

// The caller owns the error strategy
async function renderProductPage(productId) {
  try {
    const price = await getProductPrice(productId);
    console.log(`Price: $${price}`);
  } catch (error) {
    console.log('Could not load price. Showing "Contact for pricing" instead.');
  }
}

// ─── Best Practice 1: always check response.ok ───
async function fetchUserSafe(userId) {
  const response = await fetch(`/api/users/${userId}`);
  if (!response.ok) {
    // This is NOT caught by try/catch unless we throw
    throw new Error(`API error: ${response.status} ${response.statusText}`);
  }
  return response.json();
}

// ─── Best Practice 2: wrap in try/catch (or propagate with .catch) ───
async function safeUserLoad(userId) {
  try {
    const user = await fetchUserSafe(userId);
    return user;
  } catch (err) {
    console.error('User load failed:', err.message);
    return null; // return fallback
  }
}

// ─── Best Practice 3: Promise.allSettled for tolerant parallel ops ───
async function loadDashboard(userId) {
  const results = await Promise.allSettled([
    fetchUserSafe(userId),
    fetchOrders(userId),
    fetchNotifications(userId),
  ]);

  // Filter successes, log failures
  const successData = results
    .filter(r => r.status === 'fulfilled')
    .map(r => r.value);

  results
    .filter(r => r.status === 'rejected')
    .forEach(r => console.warn('A call failed:', r.reason));

  return successData;
}

// ─── Best Practice 5: consistent error strategy ───
// Don't mix .catch() and try/catch on same promise chain
// Bad:
// const data = await fetch(url).catch(err => handle(err));
// try { data; } catch (err) {} // Confusing, may miss errors

// Good: pick one
const data = await fetch(url).catch(err => {
  console.error(err);
  return null;
});

// ─── The slow way: Sequential (bad for independent operations) ───

async function loadDashboardSlowly(userId) {
  console.time('sequential');

  // Each await WAITS for the previous one to finish.
  // Total time = 400ms + 350ms + 300ms = 1050ms
  const userProfile = await fetchUserProfile(userId);       // 400ms
  const recentOrders = await fetchRecentOrders(userId);     // 350ms  
  const notifications = await fetchNotifications(userId);   // 300ms

  console.timeEnd('sequential'); // ~1050ms
  return { userProfile, recentOrders, notifications };
}

// ─── The fast way: Parallel with Promise.all() ───

async function loadDashboardFast(userId) {
  console.time('parallel');

  // All three fetches START at the same time.
  // Total time ≈ max(400ms, 350ms, 300ms) = 400ms
  const [userProfile, recentOrders, notifications] = await Promise.all([
    fetchUserProfile(userId),    // Fires immediately
    fetchRecentOrders(userId),   // Also fires immediately
    fetchNotifications(userId),  // Also fires immediately
  ]);

  // Note: if ANY of these rejects, the whole Promise.all rejects.
  // Use Promise.allSettled if you want partial results on failure.

  console.timeEnd('parallel'); // ~400ms
  return { userProfile, recentOrders, notifications };
}

// ─── When some requests CAN fail without breaking everything ───

async function loadDashboardResilient(userId) {
  const results = await Promise.allSettled([
    fetchUserProfile(userId),
    fetchRecentOrders(userId),
    fetchNotifications(userId),
  ]);

  // allSettled never throws — each result has a status
  const [profileResult, ordersResult, notificationsResult] = results;

  const dashboard = {
    // Show user profile if loaded, otherwise show a fallback
    user: profileResult.status === 'fulfilled'
      ? profileResult.value
      : { name: 'Guest', role: 'unknown' },

    // Show orders if loaded, otherwise show empty state
    orders: ordersResult.status === 'fulfilled'
      ? ordersResult.value
      : [],

    // Notification count can silently fail — not critical
    notificationCount: notificationsResult.status === 'fulfilled'
      ? notificationsResult.value.length
      : 0,
  };

  if (ordersResult.status === 'rejected') {
    console.warn('Orders failed to load:', ordersResult.reason.message);
  }

  return dashboard;
}

// ─── Mock fetch helpers to make this runnable ───
function fetchUserProfile(userId) {
  return new Promise((resolve) =>
    setTimeout(() => resolve({ id: userId, name: 'Alex Rivera', role: 'admin' }), 400)
  );
}
function fetchRecentOrders(userId) {
  return new Promise((resolve) =>
    setTimeout(() => resolve([{ id: 'ORD-001', total: 89.99 }]), 350)
  );
}
function fetchNotifications(userId) {
  return new Promise((resolve) =>
    setTimeout(() => resolve([{ msg: 'Your order shipped' }, { msg: 'Flash sale today' }]), 300)
  );
}

// Run the fast version
loadDashboardFast(7).then((data) => {
  console.log('User:', data.userProfile.name);
  console.log('Orders:', data.recentOrders.length);
  console.log('Notifications:', data.notifications.length);
});

// ─── Benchmark sequential vs parallel ───

function delay(ms) {
  return new Promise(resolve => setTimeout(resolve, ms));
}

async function sequentialExample(items) {
  const results = [];
  for (const item of items) {
    await delay(100); // simulate async work
    results.push(item * 2);
  }
  return results;
}

async function parallelExample(items) {
  const promises = items.map(async (item) => {
    await delay(100);
    return item * 2;
  });
  return Promise.all(promises);
}

// Simulate 5 items, each taking 100ms
const items = [1, 2, 3, 4, 5];

console.time('sequential');
await sequentialExample(items);
console.timeEnd('sequential'); // ~500ms

console.time('parallel');
await parallelExample(items);
console.timeEnd('parallel');   // ~100ms

// ─── A production-quality async service with timeout and retry ───

// Utility: Rejects after `ms` milliseconds — used for timeouts
function createTimeoutPromise(ms, operationName) {
  return new Promise((_, reject) =>
    setTimeout(
      () => reject(new Error(`${operationName} timed out after ${ms}ms`)),
      ms
    )
  );
}

// Utility: Retries a Promise-returning function up to `maxAttempts` times
async function withRetry(asyncFn, maxAttempts = 3, delayMs = 500) {
  let lastError;

  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
    try {
      return await asyncFn(); // Try running the function
    } catch (error) {
      lastError = error;

      const isLastAttempt = attempt === maxAttempts;
      if (isLastAttempt) break;

      console.warn(`Attempt ${attempt} failed. Retrying in ${delayMs}ms...`);
      // Wait before retrying — prevents hammering a struggling server
      await new Promise((resolve) => setTimeout(resolve, delayMs));
    }
  }

  throw lastError; // All retries exhausted — propagate the final error
}

// ─── The actual service layer ───
const WEATHER_API_TIMEOUT_MS = 5000;

async function fetchWeatherData(cityName) {
  // Race: the real request vs a timeout — whoever settles first wins
  const weatherPromise = fetch(
    `https://api.openweathermap.org/data/2.5/weather?q=${cityName}&appid=DEMO_KEY`
  ).then((response) => {
    if (!response.ok) {
      throw new Error(`Weather API error: ${response.status} for city '${cityName}'`);
    }
    return response.json();
  });

  return Promise.race([
    weatherPromise,
    createTimeoutPromise(WEATHER_API_TIMEOUT_MS, `fetchWeatherData(${cityName})`),
  ]);
}

// Public API of our weather service — this is what callers use
const weatherService = {
  async getWeather(cityName) {
    // Wrap the fetch in our retry utility — handles transient failures
    const rawData = await withRetry(
      () => fetchWeatherData(cityName),
      3,   // up to 3 attempts
      800  // 800ms between retries
    );

    // Transform the raw API response into a clean shape our app cares about
    return {
      city: rawData.name,
      country: rawData.sys.country,
      temperatureCelsius: Math.round(rawData.main.temp - 273.15),
      description: rawData.weather[0].description,
      humidity: rawData.main.humidity,
      fetchedAt: new Date().toISOString(),
    };
  },

  async getWeatherForMultipleCities(cityNames) {
    // Fetch all cities in parallel — don't make users wait for each one
    const weatherResults = await Promise.allSettled(
      cityNames.map((city) => this.getWeather(city))
    );

    return weatherResults.map((result, index) => ({
      city: cityNames[index],
      success: result.status === 'fulfilled',
      data: result.status === 'fulfilled' ? result.value : null,
      error: result.status === 'rejected' ? result.reason.message : null,
    }));
  },
};

// ─── Usage — clean and readable because the complexity is hidden ───
async function renderWeatherDashboard() {
  const cities = ['London', 'Tokyo', 'New York'];

  console.log(`Fetching weather for: ${cities.join(', ')}`);

  const results = await weatherService.getWeatherForMultipleCities(cities);

  results.forEach(({ city, success, data, error }) => {
    if (success) {
      console.log(`${city}: ${data.temperatureCelsius}°C, ${data.description}`);
    } else {
      console.log(`${city}: Failed to load — ${error}`);
    }
  });
}

renderWeatherDashboard();

/**
 * Processes an array of items in batches.
 * Each batch runs its items in parallel (Promise.all).
 * A configurable delay is inserted between batches to respect rate limits.
 *
 * @param {Array} items - The items to process.
 * @param {Function} asyncFn - An async function that processes a single item.
 * @param {number} concurrency - Number of items to process in parallel per batch.
 * @param {number} delayMs - Delay (ms) between batches. Default 0.
 * @param {boolean} useSettled - If true, use Promise.allSettled; if false, Promise.all.
 * @returns {Promise<Array>} Results from all items, in order.
 */
async function batchProcess(items, asyncFn, concurrency, delayMs = 0, useSettled = false) {
  const results = [];
  const batches = [];

  // Split items into chunks
  for (let i = 0; i < items.length; i += concurrency) {
    batches.push(items.slice(i, i + concurrency));
  }

  for (let batchIndex = 0; batchIndex < batches.length; batchIndex++) {
    const batch = batches[batchIndex];
    console.log(`Processing batch ${batchIndex + 1}/${batches.length} (${batch.length} items)`);

    // Map each item to the async function (promises start immediately)
    const promises = batch.map((item, idx) => asyncFn(item, batchIndex * concurrency + idx));

    let batchResults;
    if (useSettled) {
      batchResults = await Promise.allSettled(promises);
    } else {
      batchResults = await Promise.all(promises);
    }

    results.push(...batchResults);

    // Delay between batches (except after the last one)
    if (delayMs > 0 && batchIndex < batches.length - 1) {
      await new Promise(resolve => setTimeout(resolve, delayMs));
    }
  }

  return results;
}

// ─── Example: Processing 100 payment IDs with concurrency 20 and 500ms delay ───

async function processPayment(paymentId) {
  // Simulate API call
  await new Promise(resolve => setTimeout(resolve, 200));
  return { id: paymentId, status: 'paid' };
}

const paymentIds = Array.from({ length: 100 }, (_, i) => `PAY-${i + 1}`);

const allResults = await batchProcess(
  paymentIds,
  processPayment,
  20,    // concurrency: 20 simultaneous calls
  500,   // 500ms delay between batches
  true   // use allSettled so one failure doesn't kill the batch
);

const succeeded = allResults.filter(r => r.status === 'fulfilled').map(r => r.value);
const failed = allResults.filter(r => r.status === 'rejected').map(r => r.reason);
console.log(`Succeeded: ${succeeded.length}, Failed: ${failed.length}`);

// io.thecodeforge — javascript tutorial

// This works — async function declaration is hoisted
await fetchUserData(42);

async function fetchUserData(userId) {
  // Simulate API call
  return { id: userId, name: 'Alice' };
}

// This blows up — const is NOT hoisted
await fetchOrderHistory(42);
// ReferenceError: Cannot access 'fetchOrderHistory' before initialization

const fetchOrderHistory = async (userId) => {
  return { userId, orders: [] };
};

// io.thecodeforge — javascript tutorial

// BEFORE: monolithic promise chain, error swallowed at the end
function loadDashboardLegacy(userId) {
  return fetchUser(userId)
    .then(user => fetchUserPosts(user.id))
    .then(posts => enrichPostsWithComments(posts))
    .catch(err => {
      console.error('Dashboard failed:', err);
      return null; // Everything fails or nothing
    });
}

// AFTER: scoped error handling, independent retry logic
async function loadDashboardRefactored(userId) {
  let user;
  try {
    user = await fetchUser(userId);
  } catch (err) {
    console.error('User fetch failed, aborting:', err);
    return null;
  }
  
  let posts;
  try {
    posts = await fetchUserPosts(user.id);
  } catch (err) {
    console.error('Posts fetch failed, showing empty dashboard:', err);
    posts = []; // Degrade gracefully, don't crash the whole thing
  }
  
  try {
    posts = await enrichPostsWithComments(posts);
  } catch (err) {
    console.warn('Comment enrichment failed, showing posts only:', err);
  }
  
  return { user, posts };
}