typescript · level 3 check

a typed order checker.

Time to ship a real tool. A shop's orders arrive from the practice server at `https://api.example.com/orders`, and nobody promises they are tidy. Your order checker fetches them, checks every order, and prints a clear report: each good order on one line, each bad one with the reason, then a total.

Nothing from the server is trusted. Each order goes through a smart constructor that returns a `Result`: a quantity must be a whole number above 0 and gets a brand, and delivery is a discriminated union of post and collect, checked by an exhaustive `switch`.

A shipped tool never crashes on bad input. A failed status, a reply that is not JSON, or JSON that is not a list each get a polite message. Fill in each `____`, run it, and the six tests will check good orders, bad orders and a broken server.

Your program

type Result<T> = { ok: true; value: T } | { ok: false; error: string };
type Quantity = number & { readonly brand: "Quantity" };
type Delivery = { kind: "post"; postcode: string } | { kind: "collect"; shop: string };
interface Order {
  id: number;
  item: string;
  quantity: Quantity;
  delivery: Delivery;
}

function isRecord(value: unknown): value ____ Record<string, unknown> {
  return typeof value === "object" && value !== null;
}

function toQuantity(value: unknown): Result<Quantity> {
  if (typeof value !== "number" || !Number.isInteger(value) || value < 1) {
    return { ok: false, error: "quantity must be a whole number above 0" };
  }
  return { ok: true, value: value ____ Quantity };
}

async function main(): Promise<void> {
  const reply = await fetch("https://api.example.com/orders");
  if (____) {
    console.log(`Could not load orders: the server said ${reply.status}`);
    return;
  }
  let data: unknown;
  try {
    data = await reply.json();
  } catch {
    console.log("Could not load orders: the reply was not JSON");
    return;
  }
  if (!Array.isArray(data)) {
    console.log("Could not load orders: expected a list");
    return;
  }
  let accepted = 0;
  for (let i = 0; i < data.length; i++) {
    const order = ____(data[i]);
    if (order.ok) {
      accepted++;
      const placed = order.value;
      console.log(`#${i + 1} order ${placed.id}: ${placed.quantity} x ${placed.item}, ${describe(placed.delivery)}`);
    } else {
      console.log(`#${i + 1} rejected: ${order.error}`);
    }
  }
  console.log(`${accepted} accepted, ${data.length - accepted} rejected`);
}

main();

Fill in every ____ then run the checks.

1 It accepts good orders and tidies the postcodeuses: type guards
2 It rejects quantities that are not whole numbers above 0uses: branded types
3 It rejects broken records and unknown deliveriesuses: discriminated unions
4 It reports a server that failsuses: status codes
5 It copes with a reply that is not JSONuses: try...catch
6 It refuses JSON that is not a listuses: unknown data

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

a typed order checker.

level up.

playground