Reading list

// The command line: node main.js add <title> [--author <name>] | read <id> | list [--unread]
import {parseArgs} from "node:util";
import {BookError, formatBook} from "./books.js";
import {loadList, saveList} from "./store.js";

const USAGE = "Usage: node main.js add <title> [--author <name>] | read <id> | list [--unread]  (--file <path>)";

// TODO: parse --file, --author and --unread with parseArgs, run the command,
// print BookErrors as "reading-list: <message>" on stderr with exit code 1.
console.error(USAGE);
process.exitCode = 2;

// The reading list itself: pure logic, no files, no network.

// A typed error for bad input: field names what was wrong ("title" or "id").
export class BookError extends Error {
  // TODO: constructor(field, message): message, name "BookError" and field
}

export class ReadingList {
  constructor(books = []) {
    // TODO: keep a copy of the books
  }

  add(title, author = "") {
    // TODO: refuse an empty title, give the next id, return the new book
    throw new Error("add is not written yet");
  }

  markRead(id) {
    // TODO: set read to true, or throw a BookError for an unknown id
    throw new Error("markRead is not written yet");
  }

  list({unread = false} = {}) {
    // TODO: every book, or only the unread ones
    return [];
  }

  toJSON() {
    return this.list();
  }
}

export const formatBook = (book) =>
  `${book.read ? "[x]" : "[ ]"} ${book.id}. ${book.title}${book.author ? " by " + book.author : ""}`;

// Keeps the list in a JSON file between runs.
import {readFile, writeFile} from "node:fs/promises";
import {ReadingList} from "./books.js";

export async function loadList(file) {
  // TODO: read and parse the file; a missing file (ENOENT) is an empty list
  throw new Error("loadList is not written yet");
}

export async function saveList(file, list) {
  // TODO: write the list as JSON
  throw new Error("saveList is not written yet");
}

// The fetch client for the reading-list server.
import {formatBook} from "./books.js";

export class ApiError extends Error {
  // TODO: constructor(status, message): message, name "ApiError" and status
}

// Sends a request and returns the JSON answer; a status that is not ok becomes an ApiError.
export async function request(url, {method = "GET", body, signal} = {}) {
  // TODO
  throw new Error("request is not written yet");
}

export const addBook = (api, title, author) => request(api + "/books", {method: "POST", body: {title, author}});

export const markRead = (api, id) => request(`${api}/books/${id}`, {method: "PATCH", body: {read: true}});

// Loads the list and tells render what to show. A new load cancels the one before it.
export function createListView(api, render, timeoutMs = 1000) {
  return async function load(path = "/books") {
    // TODO: Loading…, the list or No books yet., a message for a 5xx and for a timeout,
    // and cancel the load before this one.
  };
}

// A small local JSON server for the reading list, made with node:http. You do not need to change it.
import {createServer} from "node:http";

export async function startServer(books = []) {
  let nextId = books.length + 1;
  const server = createServer(async (request, response) => {
    const json = (status, value) => {
      response.writeHead(status, {"Content-Type": "application/json"});
      response.end(JSON.stringify(value));
    };
    let body = "";
    for await (const chunk of request) body += chunk;
    const {method, url} = request;
    const match = url.match(/^\/books\/(\d+)$/);
    if (method === "GET" && url === "/books") json(200, books);
    else if (method === "POST" && url === "/books") {
      const {title, author} = JSON.parse(body || "{}");
      if (typeof title !== "string" || title.trim() === "") return json(400, {error: "title is required"});
      const book = {id: nextId++, title: title.trim(), author: author ?? "", read: false};
      books.push(book);
      json(201, book);
    } else if (method === "PATCH" && match) {
      const book = books.find((b) => b.id === Number(match[1]));
      if (!book) return json(404, {error: "no such book"});
      book.read = JSON.parse(body || "{}").read === true;
      json(200, book);
    } else if (url === "/broken") json(500, {error: "database is down"});
    else if (url === "/slow") {
      // answers after 300 ms, unless the client gave up
      const timer = setTimeout(() => json(200, books), 300);
      response.on("close", () => clearTimeout(timer));
    } else json(404, {error: "not found"});
  });
  await new Promise((resolve) => server.listen(0, "127.0.0.1", resolve)); // port 0: any free port
  return {
    url: `http://127.0.0.1:${server.address().port}`,
    close: () => new Promise((resolve) => server.close(resolve))
  };
}

{
  "type": "module"
}

import {test} from 'node:test';
import assert from 'node:assert/strict';
import {spawnSync} from 'node:child_process';
import {mkdtempSync, readFileSync} from 'node:fs';
import {tmpdir} from 'node:os';
import {join} from 'node:path';
import {ReadingList, BookError} from './books.js';
import {loadList, saveList} from './store.js';
import {request, addBook, markRead, createListView, ApiError} from './client.js';
import {startServer} from './server.js';

// A fresh data file per test, in its own temporary folder.
const dataFile = () => join(mkdtempSync(join(tmpdir(), 'reading-list-')), 'list.json');
const cli = (...args) => spawnSync(process.execPath, ['main.js', ...args], {encoding: 'utf8'});
const DUNE = {id: 1, title: 'Dune', author: 'Frank Herbert', read: false};

/** The error that fn throws (or its promise rejects with); the test fails when there is none. */
async function caught(fn) {
  try {
    await fn();
  } catch (error) {
    return error;
  }
  assert.fail('nothing was thrown');
}

/** Starts the server with books, gives its address to body, and always closes it. */
async function withServer(books, body) {
  const server = await startServer(books);
  try {
    await body(server.url);
  } finally {
    await server.close();
  }
}

test('add stores a book with the next id', () => {
  const list = new ReadingList([DUNE]);
  const book = list.add('  Emma ', 'Jane Austen');
  assert.deepEqual(book, {id: 2, title: 'Emma', author: 'Jane Austen', read: false});
  assert.equal(list.list().length, 2, 'the list should now hold two books');
});

test('list returns every book, or only the unread ones', () => {
  const list = new ReadingList([DUNE, {id: 2, title: 'Emma', author: '', read: true}]);
  assert.deepEqual(list.list().map((b) => b.id), [1, 2]);
  assert.deepEqual(list.list({unread: true}).map((b) => b.id), [1]);
});

test('markRead marks one book as read', () => {
  const list = new ReadingList([DUNE]);
  assert.equal(list.markRead(1).read, true, 'markRead should return the updated book');
  assert.equal(list.list()[0].read, true, 'the book in the list should be read');
});

test('invalid input throws a BookError with its field', async () => {
  const list = new ReadingList([DUNE]);
  const empty = await caught(() => list.add('   '));
  assert.ok(empty instanceof BookError, `add('   ') threw ${empty.name}, not a BookError`);
  assert.equal(empty.field, 'title');
  assert.equal(empty.message, 'title is required');
  const missing = await caught(() => list.markRead(9));
  assert.ok(missing instanceof BookError, `markRead(9) threw ${missing.name}, not a BookError`);
  assert.equal(missing.field, 'id');
  assert.equal(missing.message, 'no book with id 9');
});

test('the list survives a save and a load, and a missing file is an empty list', async () => {
  const file = dataFile();
  assert.deepEqual((await loadList(file)).list(), [], 'a missing file should give an empty list');
  const list = new ReadingList();
  list.add('Dune', 'Frank Herbert');
  await saveList(file, list);
  assert.deepEqual(JSON.parse(readFileSync(file, 'utf8')), [DUNE], 'the file should hold the books as JSON');
  assert.deepEqual((await loadList(file)).list(), [DUNE]);
});

test('node main.js adds, marks and lists books', () => {
  const file = dataFile();
  assert.equal(cli('add', 'Dune', '--author', 'Frank Herbert', '--file', file).stdout, 'Added [ ] 1. Dune by Frank Herbert\n');
  cli('add', 'The', 'Dispossessed', '--file', file);
  assert.equal(cli('read', '1', '--file', file).stdout, 'Read [x] 1. Dune by Frank Herbert\n');
  const r = cli('list', '--unread', '--file', file);
  assert.equal(r.status, 0, `the exit code was ${r.status}; stderr: ${r.stderr}`);
  assert.equal(r.stdout, '[ ] 2. The Dispossessed\n');
});

test('node main.js reports a bad id on stderr with exit code 1', () => {
  const r = cli('read', '9', '--file', dataFile());
  assert.equal(r.status, 1, `the exit code was ${r.status}`);
  assert.equal(r.stderr, 'reading-list: no book with id 9\n');
  assert.equal(r.stdout, '', 'nothing should be printed on stdout');
});

test('the client sends JSON and turns an error status into an ApiError', async () => {
  await withServer([DUNE], async (api) => {
    assert.deepEqual(await addBook(api, 'Emma', 'Jane Austen'), {id: 2, title: 'Emma', author: 'Jane Austen', read: false});
    assert.equal((await markRead(api, 2)).read, true);
    const error = await caught(() => request(api + '/books/9', {method: 'PATCH', body: {read: true}}));
    assert.ok(error instanceof ApiError, `request threw ${error.name}, not an ApiError`);
    assert.equal(error.status, 404);
    assert.equal(error.message, 'no such book');
  });
});

test('the client shows Loading… and then the list', async () => {
  await withServer([DUNE], async (api) => {
    const shown = [];
    await createListView(api, (text) => shown.push(text))();
    assert.deepEqual(shown, ['Loading…', '[ ] 1. Dune by Frank Herbert']);
  });
});

test('the client handles a 500 response', async () => {
  await withServer([], async (api) => {
    const shown = [];
    await createListView(api, (text) => shown.push(text))('/broken');
    assert.deepEqual(shown, ['Loading…', 'The server has a problem. Please try again later.']);
  });
});

test('the client cancels a slow request', async () => {
  await withServer([DUNE], async (api) => {
    const shown = [];
    await createListView(api, (text) => shown.push(text), 50)('/slow');
    assert.deepEqual(shown, ['Loading…', 'The server is too slow. Please try again.'], 'a slow answer should time out');
    shown.length = 0;
    const load = createListView(api, (text) => shown.push(text));
    await Promise.all([load('/slow'), load('/books')]);
    await new Promise((resolve) => setTimeout(resolve, 400)); // longer than /slow takes
    assert.deepEqual(shown, ['Loading…', 'Loading…', '[ ] 1. Dune by Frank Herbert'], 'a newer load should cancel the older one');
  });
});