Using Promise.allSettled for Reliable JavaScript APIs

// Building a dashboard from three data sources
const [users, metrics, featureFlags] = await Promise.all([
  fetchUsers(),         // Critical
  fetchMetrics(),       // Critical
  fetchFeatureFlags(),  // Optional — outage would kill the whole dashboard
]);

const results = await Promise.allSettled([
  fetchUsers(),
  fetchMetrics(),
  fetchFeatureFlags(),
]);
 
// results is always an array with the same length as the input:
// [
//   { status: "fulfilled", value: [...users] },
//   { status: "fulfilled", value: {...metrics} },
//   { status: "rejected",  reason: Error("Feature flags service unavailable") },
// ]

const results = await Promise.allSettled([
  fetchUsers(),
  fetchMetrics(),
  fetchFeatureFlags(),
]);
 
// Destructure with fallbacks
const [usersResult, metricsResult, flagsResult] = results;
 
const users = usersResult.status === "fulfilled"
  ? usersResult.value
  : [];
 
const metrics = metricsResult.status === "fulfilled"
  ? metricsResult.value
  : defaultMetrics;
 
const flags = flagsResult.status === "fulfilled"
  ? flagsResult.value
  : {};
 
if (flagsResult.status === "rejected") {
  console.warn("Feature flags unavailable, using defaults:", flagsResult.reason.message);
}
 
renderDashboard({ users, metrics, flags });

// Helper: Split allSettled results into successes and failures
function partitionSettled(results) {
  return results.reduce(
    (acc, result) => {
      if (result.status === "fulfilled") {
        acc.fulfilled.push(result.value);
      } else {
        acc.rejected.push(result.reason);
      }
      return acc;
    },
    { fulfilled: [], rejected: [] }
  );
}
 
// Usage
async function batchFetchUsers(ids) {
  const results = await Promise.allSettled(
    ids.map((id) => fetchUser(id))
  );
 
  const { fulfilled: users, rejected: errors } = partitionSettled(results);
 
  if (errors.length > 0) {
    console.warn(`${errors.length}/${ids.length} user fetches failed`);
    errors.forEach((e) => console.warn(" -", e.message));
  }
 
  return users;
}

async function enrichArticles(articles) {
  const enrichmentResults = await Promise.allSettled(
    articles.map(async (article) => {
      const [views, comments] = await Promise.all([
        fetchViewCount(article.id),
        fetchCommentCount(article.id),
      ]);
      return { id: article.id, views, comments };
    })
  );
 
  return articles.map((article, i) => {
    const result = enrichmentResults[i];
    if (result.status === "fulfilled") {
      return { ...article, ...result.value };
    }
    // Enrichment failed: return the article as-is
    return { ...article, views: null, comments: null };
  });
}

async function fetchWithRetrySubset(items, fetcher, maxRetries = 2) {
  let pending = items;
  const succeeded = [];
  let attempt = 0;
 
  while (pending.length > 0 && attempt < maxRetries) {
    const results = await Promise.allSettled(pending.map(fetcher));
 
    const nextPending = [];
    for (let i = 0; i < results.length; i++) {
      if (results[i].status === "fulfilled") {
        succeeded.push(results[i].value);
      } else {
        nextPending.push(pending[i]); // Keep for retry
        console.warn(`Retrying item ${pending[i].id}:`, results[i].reason.message);
      }
    }
 
    pending = nextPending;
    attempt++;
 
    if (pending.length > 0 && attempt < maxRetries) {
      await new Promise((r) => setTimeout(r, 500 * attempt)); // Backoff
    }
  }
 
  return {
    succeeded,
    failed: pending, // Items that failed all retries
  };
}

/**
 * @template T
 * @param {Promise<T>[]} promises
 * @returns {Promise<{value: T | null, error: Error | null}[]>}
 */
async function settleAll(promises) {
  const results = await Promise.allSettled(promises);
  return results.map((r) => ({
    value: r.status === "fulfilled" ? r.value : null,
    error: r.status === "rejected" ? r.reason : null,
  }));
}
 
// Normalized result:
// [
//   { value: {...user}, error: null },
//   { value: null, error: Error("Not found") },
// ]

// Promise.all: first rejection shortcuts everything
try {
  const results = await Promise.all([p1, p2, p3]);
  // Either all three values, or catch fires
} catch (err) {
  // You only know WHICH one failed if the Error has identifying info
  // The other Promises already ran but their results are lost
}
 
// Promise.allSettled: always get all outcomes
const results = await Promise.allSettled([p1, p2, p3]);
// Always 3 results, each labeled fulfilled or rejected
// No need for try/catch — the outer Promise never rejects