counterfact 0.1.2 → 0.2.0

package/.eslintrc.cjs

@@ -1,6 +1,8 @@
 "use strict";
 
 module.exports = {
+  ignorePatterns: ["/node_modules/", "/coverage/", "/reports/"],
+
   extends: ["hardcore", "hardcore/ts", "hardcore/node"],
 
   parserOptions: {
@@ -77,5 +79,43 @@ module.exports = {
         "node/no-unpublished-import": "off",
       },
     },
+
+    {
+      files: ["*.cjs"],
+      extends: ["hardcore", "hardcore/node"],
+
+      rules: {
+        "import/no-commonjs": "off",
+      },
+
+      parserOptions: {
+        sourceType: "script",
+      },
+    },
+
+    {
+      files: ["demo-ts/**/*.ts"],
+      extends: ["hardcore", "hardcore/node", "hardcore/ts"],
+
+      parserOptions: {
+        sourceType: "module",
+        project: "./demo-ts/tsconfig.json",
+      },
+
+      rules: {
+        "import/prefer-default-export": "off",
+        "import/no-unused-modules": "off",
+        "func-style": "off",
+        camelcase: "off",
+        "@typescript-eslint/naming-convention": "off",
+        "no-magic-numbers": "off",
+        "no-param-reassign": "off",
+        "import/group-exports": "off",
+        "max-len": "off",
+        "etc/prefer-interface": "off",
+        "@typescript-eslint/prefer-readonly-parameter-types": "off",
+        "eslint-comments/no-unused-disable": "off",
+      },
+    },
   ],
 };

package/.github/workflows/coveralls.yaml

@@ -0,0 +1,28 @@
+on: ["pull_request"]
+
+name: Coveralls
+
+jobs:
+
+  build:
+    name: Coveralls
+    runs-on: ubuntu-latest
+    steps:
+
+    - uses: actions/checkout@v3
+
+    - name: Setup Node.js 16.x
+      uses: actions/setup-node@v3
+      with:
+        node-version: 16.x
+        cache: yarn
+
+    - name: install, run tests
+      run: |
+        yarn
+        yarn test
+
+    - name: Coveralls
+      uses: coverallsapp/github-action@1.1.3
+      with:
+        github-token: ${{ secrets.GITHUB_TOKEN }}

package/.husky/post-commit

@@ -0,0 +1,4 @@
+#!/usr/bin/env sh
+. "$(dirname -- "$0")/_/husky.sh"
+
+npm run lint

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # counterfact
 
+## 0.2.0
+
+### Minor Changes
+
+- 741e4fe: change path parameters from [this] to {this} for consistency with OpenAPI
+- f237c38: proof of concept specifying routes with TypeScript and ts-node
+
+### Patch Changes
+
+- 420cd52: return a 404 with a helpful error message when a handler for a route does not exist
+- c11a475: allow the intial context (nee "store") to be passed as the second argument to `counterfact()`
+
 ## 0.1.2
 
 ### Patch Changes

package/README.md

@@ -1,26 +1,7 @@
 # Counterfact
 
-<!--
-To make this work we had to trick Stryker into thinking it was running on Travis CI
-As of this writing it's not getting updated automatically.
-
-TRAVIS=true STRYKER_DASHBOARD_API_KEY=XXXXXXX yarn stryker run
-
-https://github.com/stryker-mutator/stryker-js/issues/744
--->
-
 [![Mutation testing badge](https://img.shields.io/endpoint?style=flat&url=https%3A%2F%2Fbadge-api.stryker-mutator.io%2Fgithub.com%2Fpmcelhaney%2Fcounterfact%2Fmain)](https://dashboard.stryker-mutator.io/reports/github.com/pmcelhaney/counterfact/main)
 
-## This is a work in progress.
-
-If you're nosy and don't mind a whole lot of incompleteness:
-
-```sh
-yarn
-yarn test
-node demo/index.js
-```
-
 ## Why?
 
 I was building an UI against back end code that was so cumbersome I spent almost as much time trying to get the latest version of the back end code running as I did writing the front end code. Also I needed to build UI code against features and bug fixes that would not be available for a long time. Eventually I determined in the long run it would be quicker to hack together a fake implementation of the API so that I could keep going. Over time that fake implementation evolved to the point that it was pretty nice to work with. And I loved that I could easily recreate the exact scenarios I needed to test against.
@@ -43,19 +24,7 @@ yarn add -D counterfact
 
 ## Usage
 
-### TL;DR
-
-```js
-// ./path/to/some-route.js
-export function REQUEST_METHOD({parts, of, the, request}) {
-  return {
-    parts,
-    of,
-    the,
-    response
-  };
-}
-```
+See the [demo](./demo/README.md) directory for an example.
 
 ### Using the Koa plugin
 
@@ -71,8 +40,11 @@ const PORT = 3100;
 
 const app = new Koa();
 
+const initialContext = {};
+
 const { koaMiddleware } = await counterfact(
-  fileURLToPath(new URL("routes/", import.meta.url))
+  fileURLToPath(new URL("routes/", import.meta.url)),
+  initialContext
 );
 
 app.use(koaMiddleware);
@@ -93,12 +65,12 @@ To mock an API at `/hello/world`, create a file called `./routes/hello/world.js`
 Inside that file, output a function that handles a GET request.
 
 ```js
-  export function GET() {
-    return {
-      status: 200, // optional HTTP status code (200 is the default)
-      body: "hello world" // HTTP response body
-    }
-  }
+export function GET() {
+  return {
+    status: 200, // optional HTTP status code (200 is the default)
+    body: "hello world", // HTTP response body
+  };
+}
 ```
 
 Now when you run your server and call "GET /hello/world" you should get a 200 response with "hello world" in the body.
@@ -108,21 +80,21 @@ Now when you run your server and call "GET /hello/world" you should get a 200 re
 The get function has one parameter, a context object that contains metadata about the request. We can use that to read a the query string from `/hello/world?greeting=Hi`
 
 ```js
-  export function GET(context) {
-    return {
-      body: "${context.query.greeting} world"
-    }
-  }
+export function GET(context) {
+  return {
+    body: "${context.query.greeting} world",
+  };
+}
 ```
 
 In practice, tend to use destructuring syntax, which is the closest thing we have in JavaScript to named arguments.
 
 ```js
-  export function GET({ query }) {
-    return {
-      body: "${query.greeting} world"
-    }
-  }
+export function GET({ query }) {
+  return {
+    body: "${query.greeting} world",
+  };
+}
 ```
 
 ### Dynamic routes
@@ -130,11 +102,11 @@ In practice, tend to use destructuring syntax, which is the closest thing we hav
 Create another file called `./routes/hello/[name].js`. This file will match `/hello/universe`, `/hello/friends`, and `/hello/whatever-you-want-here`.
 
 ```js
-  export function GET({ greeting, path }) {
-    return {
-      body: "${query.greeting}, ${path.name}!"
-    }
-  }
+export function GET({ greeting, path }) {
+  return {
+    body: "${query.greeting}, ${path.name}!",
+  };
+}
 ```
 
 The `path` object is analogous to the `query` object, holding values in the dynamic parts of the path.
@@ -145,21 +117,20 @@ This feature was [inspired by Next.js](https://nextjs.org/docs/routing/dynamic-r
 
 ### State
 
-State management is handled through a plain old JavaScript object called `store`. The store is initialized as an empty object (`{}`). You can read and write its keys however you like. Changes will persist from one request to another as long as the server is running.
+State management is handled through a plain old JavaScript object called `context`, which is passed as the second argument to the `counterfact()` function (default value = `{}`). You can modify the context object however you like. Changes will persist from one request to another as long as the server is running.
 
-There are no rules around how you manipulate the store. Yes, you read that right.
+There are no rules around how you manipulate the context. Yes, you read that right.
 
 ```js
-  export function GET({ greeting, path, store }) {
-
-    store.visits ??= {};
-    store.visits[path.name] ??= 0;
-    store.visits[path.name] += 1;
+export function GET({ greeting, path, context }) {
+  context.visits ??= {};
+  context.visits[path.name] ??= 0;
+  context.visits[path.name] += 1;
 
-    return {
-      body: "${query.greeting}, ${path.name}!"
-    }
-  }
+  return {
+    body: "${query.greeting}, ${path.name}!",
+  };
+}
 ```
 
 ### Request Methods
@@ -167,23 +138,23 @@ There are no rules around how you manipulate the store. Yes, you read that right
 So far we've only covered `GET` requests. What about `POST`, `PUT`, `PATCH` and `DELETE`? All HTTP request methods are supported. It's a matter exporting functions with the corresponding names.
 
 ```js
-  export function GET({ path, store }) {
+  export function GET({ path, context }) {
 
-    store.friends ??= {};
-    store.friends[path.name] ??= {
+    context.friends ??= {};
+    context.friends[path.name] ??= {
       appearance: "lovely"
     };
 
     return {
-      body: "Hello, ${path.name}. You look ${store.friends[name].appearance} today!"
+      body: "Hello, ${path.name}. You look ${context.friends[name].appearance} today!"
     }
   }
 
-  export function POST(path, store, body) {
+  export function POST(path, context, body) {
 
-    store.friends ??= {};
-    store.friends[path.name] ??= {};
-    store.friends[appearance] = body.appearance;
+    context.friends ??= {};
+    context.friends[path.name] ??= {};
+    context.friends[appearance] = body.appearance;
 
     return {
       body: {
@@ -198,18 +169,18 @@ So far we've only covered `GET` requests. What about `POST`, `PUT`, `PATCH` and
 If you need to do work asynchronously, return a promise or use async / await.
 
 ```js
-  export function PUT({body}) {
-    return doSomeStuffWith(body).then(() => {
-      body: "Successfully did an async PUT"
-    });
-  }
+export function PUT({ body }) {
+  return doSomeStuffWith(body).then(() => {
+    body: "Successfully did an async PUT";
+  });
+}
 
-  export async function DELETE() {
-    await deleteMe();
-    return {
-      body: "Took a while, but now it's deleted."
-    };
-  }
+export async function DELETE() {
+  await deleteMe();
+  return {
+    body: "Took a while, but now it's deleted.",
+  };
+}
 ```
 
 ### Coming soon

package/demo/routes/count.js

@@ -1,12 +1,12 @@
-export function GET({ store }) {
-  if (!store.visits) {
+export function GET({ context }) {
+  if (!context.visits) {
     return {
       body: "You have not visited anyone yet.",
     };
   }
 
   return {
-    body: Object.entries(store.visits)
+    body: Object.entries(context.visits)
       .map(([page, count]) => `You visited ${page} ${count} times.`)
       .join("\n"),
   };

package/demo/routes/hello/[name].js

@@ -1,7 +1,7 @@
-export function GET({ path, store, query }) {
-  store.visits ??= {};
-  store.visits[path.name] ??= 0;
-  store.visits[path.name] += 1;
+export function GET({ path, context, query }) {
+  context.visits ??= {};
+  context.visits[path.name] ??= 0;
+  context.visits[path.name] += 1;
 
   if (!path) {
     return { body: "Hello, stranger!" };

package/demo-ts/README.md

@@ -0,0 +1,19 @@
+# Counterfact Demo - TypeScript
+
+This demo illustrates some of the basic features of Counterfact, with TypeScript.
+
+It requires ts-node (`npm i -g ts-node`).
+
+Start it by running `ts-node-esm index.ts`.
+
+`index.ts` starts a Koa server and loads Counterfact's middleware pointed to route definitions at `./routes`.
+
+Under `./routes` you will find a few endpoints definitions:
+
+`hello.ts` defines `/hello/:name` and says hello to your friends.
+
+`hello/kitty.ts` defines `/hello/kitty`, overriding the behavior defined in `hello.ts`.
+
+`count.ts` defines `/count` and reports how many times you've visited the other URLs.
+
+Try adding more routes. You should be able to see the updates without restarting the server.

package/demo-ts/context/README.md

@@ -0,0 +1,3 @@
+# Context
+
+This folder will contain the context object (currently named "store"), which will define the server state. The `Store.ts` file exports a class which defines the context's type and an instance of that class which holds the state in memory. (It also defines the initial state.)

package/demo-ts/context/Store.ts

@@ -0,0 +1,12 @@
+// This file will be maintained by hand.
+
+interface Visits {
+  [name: string]: number;
+}
+
+export class Context {
+  public visits: Visits = {};
+}
+
+// Counterfact will load this object and use it as the initial state.
+export const store = new Context();

package/demo-ts/context/context.ts

@@ -0,0 +1,12 @@
+// This file will be maintained by hand.
+
+interface Visits {
+  [name: string]: number;
+}
+
+export class Context {
+  public visits?: Visits = {};
+}
+
+// Counterfact will load this object and use it as the initial state.
+export const context = new Context();

package/demo-ts/index.ts

@@ -0,0 +1,25 @@
+/* eslint-disable no-console, node/no-unpublished-import */
+import { fileURLToPath } from "node:url";
+
+// eslint-disable-next-line import/no-extraneous-dependencies
+import Koa from "koa";
+
+import { counterfact } from "../src/counterfact";
+
+const PORT = 3100;
+
+const app = new Koa();
+
+const { koaMiddleware } = await counterfact(
+  fileURLToPath(new URL("routes/", import.meta.url))
+);
+
+app.use(koaMiddleware);
+
+app.listen(PORT);
+console.log("Try these URLs:");
+console.log(`http://localhost:${PORT}/hello/world`);
+console.log(`http://localhost:${PORT}/hello/friends`);
+console.log(`http://localhost:${PORT}/hello/kitty`);
+console.log(`http://localhost:${PORT}/hello/world?greeting=Hi`);
+console.log(`http://localhost:${PORT}/count`);

package/demo-ts/routes/#types.ts

@@ -0,0 +1,7 @@
+import type { HttpResponseStatusCode } from "../types/Http";
+import type { Context } from "../context/context";
+
+export type Get_count = (request: { context: Context }) => {
+  body: string;
+  status?: HttpResponseStatusCode;
+};

package/demo-ts/routes/README.md

@@ -0,0 +1,3 @@
+# Routes
+
+This directory defines the routes. These will be maintained by hand with the exception of files named `#types.ts`, which will be generated from the OpenAPI spec. We may generate files for routes as well, but only if they don't already exist. The `#types.ts` files will be overwritten. The others won't.

package/demo-ts/routes/count.ts

@@ -0,0 +1,18 @@
+import type { Get_count } from "./#types";
+
+export const GET: Get_count = ({ context }) => {
+  if (context.visits === undefined) {
+    return {
+      body: "You have not visited anyone yet.",
+    };
+  }
+
+  return {
+    body: Object.entries(context.visits)
+      .map(
+        ([page, count]: [string, number]) =>
+          `You visited ${page} ${count} times.`
+      )
+      .join("\n"),
+  };
+};

package/demo-ts/routes/hello/#types.ts

@@ -0,0 +1,16 @@
+import type { Context } from "../../context/context";
+import type { HttpResponseStatusCode } from "../../types/Http";
+import type { Greeting } from "../../types/Greeting";
+import type { HtmlImgTag } from "../../types/HtmlImgTag";
+
+export type Get_name = (request: {
+  context: Context;
+  query: { greeting?: string };
+  path: { name: string };
+}) => { body: Greeting; status?: HttpResponseStatusCode };
+
+export type Get_kitty = (request: {
+  context: Context;
+  query: { greeting?: string };
+  path: { name: string };
+}) => { body: HtmlImgTag; status?: HttpResponseStatusCode };

package/demo-ts/routes/hello/[name].ts

@@ -0,0 +1,11 @@
+import type { Get_name } from "./#types";
+
+export const GET: Get_name = ({ path, context, query }) => {
+  context.visits ??= {};
+  context.visits[path.name] ??= 0;
+  context.visits[path.name] += 1;
+
+  return {
+    body: `${query.greeting ?? "Hello"}, ${path.name}!`,
+  };
+};

package/demo-ts/routes/hello/kitty.ts

@@ -0,0 +1,5 @@
+import type { Get_kitty } from "./#types";
+
+export const GET: Get_kitty = () => ({
+  body: '<img src="https://upload.wikimedia.org/wikipedia/en/0/05/Hello_kitty_character_portrait.png">',
+});

package/demo-ts/tsconfig.json

@@ -0,0 +1,9 @@
+{
+  "compilerOptions": {
+    "moduleResolution": "node",
+    "module": "es2022",
+    "target": "es2022",
+    "strictNullChecks": true,
+    "allowSyntheticDefaultImports": true
+  }
+}

package/demo-ts/types/Greeting.ts

@@ -0,0 +1 @@
+export type Greeting = `${string}, ${string}!`;

package/demo-ts/types/HtmlImgTag.ts

@@ -0,0 +1 @@
+export type HtmlImgTag = `<img src="${string}">`;

package/demo-ts/types/Http.ts

@@ -0,0 +1,2 @@
+// eslint-disable-next-line @typescript-eslint/no-magic-numbers
+export type HttpResponseStatusCode = 200 | 404 | 500;

package/demo-ts/types/README.md

@@ -0,0 +1,5 @@
+# Types
+
+This directory is currently maintained by hand. The goal is to generate it from an OpenAPI spec.
+
+Some of the example types currently use template literals so the examples can be something more interesting than plain old strings. We're not expecting to generate template literal types from OpenAPI.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "counterfact",
-  "version": "0.1.2",
+  "version": "0.2.0",
   "description": "a library for building a fake REST API for testing",
   "type": "module",
   "main": "./src/counterfact.js",
@@ -22,18 +22,22 @@
   "scripts": {
     "test": "yarn node --experimental-vm-modules $(yarn bin jest)",
     "test:mutants": "stryker run stryker.config.json",
-    "release": "npx changeset publish"
+    "release": "npx changeset publish",
+    "prepare": "husky install",
+    "lint": "eslint ."
   },
   "devDependencies": {
-    "@changesets/cli": "2.22.0",
-    "@stryker-mutator/core": "6.0.2",
-    "@stryker-mutator/jest-runner": "6.0.2",
-    "eslint": "8.17.0",
+    "@changesets/cli": "2.23.0",
+    "@stryker-mutator/core": "6.1.2",
+    "@stryker-mutator/jest-runner": "6.1.2",
+    "@types/koa": "2.13.4",
+    "eslint": "8.18.0",
     "eslint-config-hardcore": "24.5.0",
     "eslint-formatter-github-annotations": "0.1.0",
-    "jest": "28.1.1",
+    "jest": "28.1.2",
     "koa": "2.13.4",
-    "nodemon": "2.0.16",
+    "husky": "8.0.1",
+    "nodemon": "2.0.18",
     "stryker-cli": "1.0.2",
     "supertest": "6.2.3"
   },

package/src/counterfact.js

@@ -3,8 +3,8 @@ import { Dispatcher } from "./dispatcher.js";
 import { koaMiddleware } from "./koa-middleware.js";
 import { ModuleLoader } from "./module-loader.js";
 
-export async function counterfact(basePath) {
-  const registry = new Registry();
+export async function counterfact(basePath, context = {}) {
+  const registry = new Registry(context);
   const dispatcher = new Dispatcher(registry);
   const moduleLoader = new ModuleLoader(basePath, registry);
 

package/src/dispatcher.js

@@ -13,10 +13,10 @@ export class Dispatcher {
       // path: parts.slice(remainingParts).join("/"),
 
       reduce: (reducer) => {
-        this.registry.store = reducer(this.registry.store);
+        this.registry.context = reducer(this.registry.context);
       },
 
-      store: this.registry.store,
+      context: this.registry.context,
       body,
       query,
     });

package/src/module-loader.js

@@ -20,12 +20,8 @@ export class ModuleLoader extends EventEmitter {
   }
 
   async watch() {
-    if (this.watcher) {
-      throw new Error("already watching");
-    }
-
     this.watcher = chokidar
-      .watch(`${this.basePath}/**/*`)
+      .watch(`${this.basePath}/**/*.{js,mjs,ts,mts}`)
       .on("all", (event, pathName) => {
         if (!["add", "change", "unlink"].includes(event)) {
           return;
@@ -34,6 +30,10 @@ export class ModuleLoader extends EventEmitter {
         const parts = path.parse(pathName.replace(this.basePath, ""));
         const url = `/${path.join(parts.dir, parts.name)}`;
 
+        if (parts.name.includes("#")) {
+          return;
+        }
+
         if (event === "unlink") {
           this.registry.remove(url);
           this.emit("remove", pathName);
@@ -49,7 +49,7 @@ export class ModuleLoader extends EventEmitter {
           })
           // eslint-disable-next-line promise/prefer-await-to-then
           .catch((error) => {
-            throw new Error(String(error));
+            throw error;
           });
       });
     await once(this.watcher, "ready");
@@ -64,12 +64,23 @@ export class ModuleLoader extends EventEmitter {
       withFileTypes: true,
     });
     const imports = files.flatMap(async (file) => {
+      if (file.name.includes("#")) {
+        return;
+      }
+
+      // eslint-disable-next-line no-magic-numbers
+      const extension = file.name.split(".").at(-1);
+
       if (file.isDirectory()) {
         await this.load(path.join(directory, file.name));
 
         return;
       }
 
+      if (!["js", "mjs", "ts", "mts"].includes(extension)) {
+        return;
+      }
+
       const endpoint = await import(
         path.join(this.basePath, directory, file.name)
       );

package/src/registry.js

@@ -5,10 +5,10 @@ export class Registry {
     children: {},
   };
 
-  store;
+  context;
 
-  constructor(store = {}) {
-    this.store = store;
+  constructor(context = {}) {
+    this.context = context;
   }
 
   add(url, module) {
@@ -43,17 +43,21 @@ export class Registry {
     return Boolean(this.handler(url)?.module?.[method]);
   }
 
+  // eslint-disable-next-line max-statements
   handler(url) {
     let node = this.moduleTree;
 
     const path = {};
 
+    const matchedParts = [""];
+
     for (const segment of url.split("/").slice(1)) {
       if (node.children[segment]) {
         node = node.children[segment];
+        matchedParts.push(segment);
       } else {
         const dynamicSegment = Object.keys(node.children).find(
-          (ds) => ds.startsWith("[") && ds.endsWith("]")
+          (ds) => ds.startsWith("{") && ds.endsWith("}")
         );
 
         if (dynamicSegment) {
@@ -61,11 +65,13 @@ export class Registry {
           path[dynamicSegment.slice(1, -1)] = segment;
 
           node = node.children[dynamicSegment];
+
+          matchedParts.push(dynamicSegment);
         }
       }
     }
 
-    return { module: node.module, path };
+    return { module: node.module, path, matchedPath: matchedParts.join("/") };
   }
 
   endpoint(httpRequestMethod, url) {
@@ -73,9 +79,10 @@ export class Registry {
     const lambda = handler?.module?.[httpRequestMethod];
 
     if (!lambda) {
-      throw new Error(
-        `${httpRequestMethod} method for endpoint at "${url}" does not exist`
-      );
+      return () => ({
+        status: 404,
+        body: `Could not find a ${httpRequestMethod} method at ${url}\nGot as far as ${handler.matchedPath}`,
+      });
     }
 
     return ({ ...context }) => lambda({ ...context, path: handler.path });

package/test/counterfact.test.js

@@ -43,4 +43,31 @@ describe("integration test", () => {
       await moduleLoader.stopWatching();
     });
   });
+
+  it("loads the initial context", async () => {
+    const app = new Koa();
+    const request = supertest(app.callback());
+    const files = {
+      "paths/hello.mjs": `
+        export async function GET({context}) {
+          return await Promise.resolve({ body: "Hello " + context.name });
+        }
+      `,
+    };
+
+    await withTemporaryFiles(files, async (basePath) => {
+      const { koaMiddleware, moduleLoader } = await counterfact(
+        `${basePath}/paths`,
+        { name: "World" }
+      );
+
+      app.use(koaMiddleware);
+
+      const getResponse = await request.get("/hello");
+
+      expect(getResponse.text).toBe("Hello World");
+
+      await moduleLoader.stopWatching();
+    });
+  });
 });

package/test/dispatcher.test.js

@@ -96,12 +96,12 @@ describe("a dispatcher", () => {
   it("passes a reducer function that can be used to read / update the store", async () => {
     const registry = new Registry({ value: 0 });
 
-    registry.add("/increment/[value]", {
+    registry.add("/increment/{value}", {
       GET({ reduce, path }) {
         const amountToIncrement = Number.parseInt(path.value, 10);
 
-        reduce((store) => ({
-          value: store.value + amountToIncrement,
+        reduce((context) => ({
+          value: context.value + amountToIncrement,
         }));
 
         return { body: "incremented" };
@@ -116,7 +116,7 @@ describe("a dispatcher", () => {
       body: "",
     });
 
-    expect(registry.store.value).toBe(1);
+    expect(registry.context.value).toBe(1);
 
     await dispatcher.request({
       method: "GET",
@@ -124,18 +124,17 @@ describe("a dispatcher", () => {
       body: "",
     });
 
-    expect(registry.store.value).toBe(3);
+    expect(registry.context.value).toBe(3);
   });
 
   it("allows the store to be mutated directly", async () => {
     const registry = new Registry({ value: 0 });
 
-    registry.add("/increment/[value]", {
-      GET({ store, path }) {
+    registry.add("/increment/{value}", {
+      GET({ context, path }) {
         const amountToIncrement = Number.parseInt(path.value, 10);
 
-        // eslint-disable-next-line no-param-reassign
-        store.value += amountToIncrement;
+        context.value += amountToIncrement;
 
         return { body: "incremented" };
       },
@@ -151,7 +150,7 @@ describe("a dispatcher", () => {
 
     expect(result.body).toBe("incremented");
 
-    expect(registry.store.value).toBe(1);
+    expect(registry.context.value).toBe(1);
 
     await dispatcher.request({
       method: "GET",
@@ -159,6 +158,34 @@ describe("a dispatcher", () => {
       body: "",
     });
 
-    expect(registry.store.value).toBe(3);
+    expect(registry.context.value).toBe(3);
+  });
+});
+
+describe("given a in invalid path", () => {
+  it("returns a 404 when the route is not found", () => {
+    const registry = new Registry();
+
+    registry.add("/your/{side}/{bodyPart}/in/and/your/left/foot/out", {
+      PUT() {
+        return {
+          status: 201,
+          body: "ok",
+        };
+      },
+    });
+
+    const response = new Dispatcher(registry).request({
+      method: "PUT",
+      path: "/your/left/foot/in/and/your/right/foot/out",
+    });
+
+    expect(response.status).toBe(404);
+
+    expect(response.body).toBe(
+      "Could not find a PUT method at " +
+        "/your/left/foot/in/and/your/right/foot/out\n" +
+        "Got as far as /your/{side}/{bodyPart}/in/and/your"
+    );
   });
 });

package/test/lib/with-temporary-files.js

@@ -22,6 +22,14 @@ function createAddFunction(basePath) {
   };
 }
 
+function createAddDirectoryFunction(basePath) {
+  return async function addDirectory(filePath) {
+    const fullPath = path.join(basePath, filePath);
+
+    await fs.mkdir(fullPath, { recursive: true });
+  };
+}
+
 function createRemoveFunction(basePath) {
   return async function remove(filePath) {
     const fullPath = path.join(basePath, filePath);
@@ -52,6 +60,7 @@ export async function withTemporaryFiles(files, ...callbacks) {
       await callback(temporaryDirectory, {
         add: createAddFunction(temporaryDirectory),
         remove: createRemoveFunction(temporaryDirectory),
+        addDirectory: createAddDirectoryFunction(temporaryDirectory),
       });
     }
   } finally {

package/test/module-loader.test.js

@@ -84,6 +84,34 @@ describe("a module loader", () => {
     );
   });
 
+  it("ignores files with the wrong file extension", async () => {
+    const contents = 'export function GET() { return { body: "hello" }; }';
+
+    const files = {
+      "module.mjs": contents,
+      "README.md": contents,
+      "#types.mjs": contents,
+    };
+
+    await withTemporaryFiles(files, async (basePath, { add }) => {
+      const registry = new Registry();
+      const loader = new ModuleLoader(basePath, registry);
+
+      await loader.load();
+      await loader.watch();
+
+      await add("other.txt", "should not be loaded");
+      await add("#other.mjs", "should not be loaded");
+
+      expect(registry.exists("GET", "/module")).toBe(true);
+      expect(registry.exists("GET", "/README")).toBe(false);
+      expect(registry.exists("GET", "/other")).toBe(false);
+      expect(registry.exists("GET", "/types")).toBe(false);
+
+      await loader.stopWatching();
+    });
+  });
+
   // This should work but I can't figure out how to break the
   // module cache when running through Jest (which uses the
   // experimental module API).
@@ -109,7 +137,7 @@ describe("a module loader", () => {
         const response = await registry.endpoint(
           "GET",
           "/change"
-        )({ path: "", reduce: () => undefined, store: {} });
+        )({ path: "", reduce: () => undefined, context: {} });
 
         expect(response.body).toBe("after change");
         expect(registry.exists("GET", "/late/addition")).toBe(true);

package/test/registry.test.js

@@ -56,7 +56,7 @@ describe("a scripted server", () => {
         return foo;
       },
 
-      store: {},
+      context: {},
     };
     const getA = await registry.endpoint("GET", "/a")(props);
     const getB = await registry.endpoint("GET", "/b")(props);
@@ -88,7 +88,7 @@ describe("a scripted server", () => {
   it("handles a dynamic path", () => {
     const registry = new Registry();
 
-    registry.add("/[organization]/users/[username]/friends/[page]", {
+    registry.add("/{organization}/users/{username}/friends/{page}", {
       GET({ path }) {
         return {
           body: `page ${path.page} of ${path.username}'s friends in ${path.organization}`,