javascript · level 3 check

a polite request queue.

Time to ship a real tool. A pet rescue looks up its animals on Gwecode's practice server, at `https://api.example.com/pets/` followed by a name. Servers can be slow, busy or broken, and people type messy names. Your tool must cope with all of it, politely.

The names arrive one per `prompt` until it gives back `null`. Trim and lowercase each one, drop blanks and repeats with a Set, skip anything that is not letters (`/^[a-z]+$/.test(name)` checks that), then sort the rest. The queue never runs more than two requests at once, and records its peak.

Retry a server error, status 500 or above, up to two more times. Never retry a missing pet (404) or a garbled reply. `Promise.allSettled` lets one failure leave the others standing, so the report covers every pet, then a summary. Fill in each `____`, then run the tests.

Your program

const BASE = "https://api.example.com/pets/";
const LIMIT = 2;
const RETRIES = 2;

class LookupError extends Error {
  constructor(reason, tries) {
    super(reason);
    this.name = "LookupError";
    this.tries = tries;
  }
}

function describe(status) {
  if (status === 404) { return "not found"; }
  if (status >= 500) { return "server error"; }
  return `refused (${status})`;
}

function attempts(tries) {
  if (tries === 1) { return "1 try"; }
  return `${tries} tries`;
}

async function fetchPet(name) {
  for (let tries = 1; tries <= RETRIES + 1; tries++) {
    const reply = await fetch(BASE + name);
    if (reply.ok) {
      try {
        return { pet: await reply.json(), tries };
      } catch (error) {
        throw new LookupError("bad reply", tries);
      }
    }
    if (reply.status < ____ || tries > RETRIES) {
      throw new LookupError(describe(reply.status), tries);
    }
  }
}

const { names, skipped } = readNames();
for (const bad of skipped) {
  console.log(`Skipped "${bad}": use letters only`);
}
if (names.length === 0) {
  console.log("Nothing to look up.");
} else {
  const queue = createQueue(LIMIT);
  const outcomes = await Promise.____(names.map((name) => queue.add(() => fetchPet(name))));
  let found = 0;
  for (let i = 0; i < names.length; i++) {
    const outcome = outcomes[i];
    if (outcome.status === "____") {
      const { pet, tries } = outcome.value;
      found++;
      console.log(`${names[i]}: ${pet.kind}, age ${pet.age} (${attempts(tries)})`);
    } else if (outcome.reason instanceof LookupError) {
      console.log(`${names[i]}: ${outcome.reason.message} (${attempts(outcome.reason.tries)})`);
    } else {
      throw outcome.reason;
    }
  }
  console.log(`${found} of ${names.length} found. Peak requests at once: ${queue.peak}.`);
}

Fill in every ____ then run the checks.

1 It looks up every pet, sorted, two at a timeuses: Promise.allSettled
2 It cleans up messy namesuses: Set
3 It retries a busy server, then gives upuses: custom errors
4 It never retries a missing petuses: throwing and catching
5 It survives a garbled replyuses: try...catch
6 It copes when there is nothing to look upuses: validating input

Take as long as you like and try as many times as you want.

a polite request queue.

level up.

playground