@server/next 0.20.7 → 0.20.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@server/next",
-  "version": "0.20.7",
+  "version": "0.20.9",
   "description": "An experimental reimplementation of server.js focused on the DX",
   "homepage": "https://node-server.com/",
   "repository": "https://github.com/franciscop/server-next.git",
@@ -9,7 +9,7 @@
   "author": "Francisco Presencia <public@francisco.io> (https://francisco.io/)",
   "license": "UNLICENSED",
   "scripts": {
-    "demo": "nodemon ./demo/app.js",
+    "demo": "nodemon ./demo/src/index.js",
     "start": "bun test --watch",
     "test": "bun test",
     "test:jest": "node --experimental-vm-modules node_modules/jest/bin/jest.js"

package/src/auth.test.js

@@ -2,68 +2,61 @@ import kv from "polystore";
 
 import server from "./index.js";
 
-const url = (token) =>
-  new Request("http://localhost:3000/", {
-    headers: { authorization: token },
-  });
-
 describe("auth", () => {
   const store = kv(new Map());
-  const app = server({ store }).get("/", (ctx) => {
-    return ctx.headers.authorization;
-  });
+  const api = server({ store })
+    .get("/", (ctx) => ctx.headers.authorization)
+    .test();
 
   it("should be Bearer", async () => {
-    const res = await app.fetch(url("Basic REqA2l022l8Q0tuIRtqLOPUy"));
-    expect(await res.text()).toBe("Invalid Authorization type, 'Basic'");
+    const authorization = "Basic REqA2l022l8Q0tuIRtqLOPUy";
+    const { data } = await api.get("/", { headers: { authorization } });
+    expect(data).toBe("Invalid Authorization type, 'Basic'");
   });
 
   it("should have the proper token", async () => {
-    const res = await app.fetch(url("Bearer hola"));
-    expect(await res.text()).toBe("Invalid Authorization token");
+    const authorization = "Bearer hola";
+    const { data } = await api.get("/", { headers: { authorization } });
+    expect(data).toBe("Invalid Authorization token");
   });
 
   it("can get the nested get", async () => {
-    const res = await app.fetch(url("Bearer REqA2l022l8Q0tuIRtqLOPUy"));
-    expect(await res.text()).toBe("Bearer REqA2l022l8Q0tuIRtqLOPUy");
+    const authorization = "Bearer REqA2l022l8Q0tuIRtqLOPUy";
+    const { data } = await api.get("/", { headers: { authorization } });
+    expect(data).toBe("Bearer REqA2l022l8Q0tuIRtqLOPUy");
   });
+});
 
-  describe.skip("user creation flow", () => {
-    const url = (path, options = {}) =>
-      new Request("http://localhost:3000" + path, {
-        headers: {
-          cookie: "session=REqA2l022l8Q0tuIRtqLOPUy",
-          "content-type": "application/json",
-        },
-        ...options,
-        body: JSON.stringify(options.body),
-      });
-
-    const store = kv(new Map());
-    const app = server({ auth: "email", store });
-
-    it("can create a new user", async () => {
-      const registered = await app.fetch(
-        url("/register", {
-          method: "POST",
-          body: { email: "abc@test.com", password: "11111111" },
-        })
-      );
-      console.log(registered);
-      console.log(Object.fromEntries(await store.entries()));
-      console.log(await registered.text());
-      expect(registered.status).toBe(201);
+describe("user creation flow", () => {
+  // These are obviously mock data
+  const EMAIL = "abc@test.com";
+  const PASS = "11111111";
+  const CREDENTIALS = { email: EMAIL, password: PASS };
 
-      const login = await app.fetch(
-        url("/login", {
-          method: "POST",
-          body: { email: "abc@test.com", password: "11111111" },
-        })
-      );
-      console.log(login);
-      console.log(Object.fromEntries(await store.entries()));
-      console.log(await login.text());
-      expect(login.status).toBe(200);
-    });
+  const store = kv(new Map());
+  const auth = { type: "token", providers: "email" };
+  const api = server({ auth, store }).test();
+
+  it("can create a new user", async () => {
+    const register = await api.post("/auth/register/email", CREDENTIALS);
+    expect(register.status).toBe(201);
+    expect(await store.keys()).toEqual([
+      "auth:abc@test.com",
+      "session:" + register.data.token,
+    ]);
+
+    const authorization = "Bearer " + register.data.token;
+    const headers = { authorization };
+    const logout = await api.post("/auth/logout", {}, { headers });
+
+    expect(logout.status).toBe(200);
+    expect(await store.keys()).toEqual(["auth:abc@test.com"]);
+
+    const login = await api.post("/auth/login/email", CREDENTIALS);
+    expect(login.status).toBe(200);
+    expect(await store.keys()).toEqual([
+      "auth:abc@test.com",
+      "session:" + login.data.token,
+    ]);
   });
 });

package/src/context/findAuth.js

@@ -1,4 +1,4 @@
-import { ServerError } from "../";
+import { ServerError } from "../index.js";
 
 export default async function findAuth(ctx) {
   // NO AUTH AT ALL
@@ -7,7 +7,11 @@ export default async function findAuth(ctx) {
   if (!store) return;
 
   // AUTHENTICATION IS AVAILABLE
-  ctx.auth = { type: ctx.options.auth.type, store };
+  ctx.auth = {
+    type: ctx.options.auth.type,
+    providers: ctx.options.auth.providers,
+    store,
+  };
 
   // If the user is not authenticated, there's no auth to retrieve
   if (!ctx.headers.authorization) return;

package/src/context/findSession.js

@@ -1,4 +1,4 @@
-import { ServerError } from "../";
+import { ServerError } from "../index.js";
 
 class NoSession {}
 

package/src/errors/index.js

@@ -1,10 +1,18 @@
-import ServerError from "../ServerError";
+import ServerError from "../ServerError.js";
 
 ServerError.extend({
+  NO_STORE: `You need a 'store' to write 'ctx.session'`,
   NO_STORE_WRITE: `You need a 'store' to write 'ctx.session.{key}'`,
   NO_STORE_READ: `You need a 'store' to read 'ctx.session.{key}'`,
   AUTH_INVALID_TYPE: `Invalid Authorization type, '{type}'`,
   AUTH_INVALID_TOKEN: `Invalid Authorization token`,
+
+  LOGIN_NO_EMAIL: "The email is required to log in",
+  LOGIN_INVALID_EMAIL: "The email you wrote is not correct",
+  LOGIN_NO_PASSWORD: "The email is required to log in",
+  LOGIN_INVALID_PASSWORD: "The email you wrote is not correct",
+  LOGIN_WRONG_ACCOUNT: `That email does not correspond to any account`,
+  LOGIN_WRONG_PASSWORD: `That is not the valid password`,
 });
 
 export default ServerError;

package/src/helpers/cookies.test.js

@@ -0,0 +1,23 @@
+import server, { cookies } from "../index.js";
+
+describe("set-cookie", () => {
+  const app = server()
+    .get("/hello", () => {
+      return cookies({ hello: "world" }).send();
+    })
+    .get("/multiple", () => {
+      return cookies({ a: "b", c: "d" }).send();
+    });
+
+  it("sets the right cookie", async () => {
+    const api = app.test();
+    const res = await api.get("/hello");
+    expect(res.headers["set-cookie"]).toBe("hello=world");
+  });
+
+  it("can set multiple cookies", async () => {
+    const api = app.test();
+    const res = await api.get("/multiple");
+    expect(res.headers["set-cookie"]).toEqual(["a=b", "c=d"]);
+  });
+});

package/src/helpers/createCookies.js

@@ -1,13 +1,11 @@
 // Takes an object and returns a string with the proper cookie values
 export default function createCookies(cookies) {
-  if (!cookies || !Object.keys(cookies).length) return "";
-  return Object.entries(cookies)
-    .map(([key, val]) => {
-      if (typeof val === "string") {
-        val = { value: val, path: "/" };
-      }
-      const { value, path } = val;
-      return `${key}=${value};Path=${path}`;
-    })
-    .join(";");
+  if (!cookies || !Object.keys(cookies).length) return [];
+  return Object.entries(cookies).map(([key, val]) => {
+    if (typeof val === "string") {
+      val = { value: val, path };
+    }
+    const { value, path } = val;
+    return `${key}=${value}${path ? ";Path=" + path : ""}`;
+  });
 }

package/src/index.js

@@ -196,3 +196,55 @@ server.prototype.router = function (basePath, router) {
   }
   return this;
 };
+
+server.prototype.test = function () {
+  let cookie = "";
+  const fetch = async (path, options = {}) => {
+    if (!options.headers) options.headers = {};
+    if (options.body && typeof options.body !== "string") {
+      options.headers["content-type"] = "application/json";
+      options.body = JSON.stringify(options.body);
+    }
+    if (cookie && !options.headers.cookie) {
+      options.headers.cookie = cookie;
+    }
+    const res = await this.fetch(
+      new Request("http://localhost:3000" + path, options)
+    );
+
+    const headers = {};
+    for (const [key, value] of res.headers.entries()) {
+      if (headers[key]) {
+        if (!Array.isArray(headers[key])) {
+          headers[key] = [headers[key]];
+        }
+        headers[key].push(value);
+      } else {
+        headers[key] = value;
+      }
+    }
+    let data;
+    if (headers["set-cookie"]) {
+      // TODO: this should really be a smart merge of the 2
+      cookie = headers["set-cookie"];
+    }
+    if (headers["content-type"]?.includes("application/json")) {
+      data = await res.json();
+    } else {
+      data = await res.text();
+    }
+    return { status: res.status, headers, data };
+  };
+  return {
+    get: (path, options) => fetch(path, { method: "get", ...options }),
+    head: (path, options) => fetch(path, { method: "head", ...options }),
+    post: (path, body, options) =>
+      fetch(path, { method: "post", body, ...options }),
+    put: (path, body, options) =>
+      fetch(path, { method: "put", body, ...options }),
+    patch: (path, body, options) =>
+      fetch(path, { method: "patch", body, ...options }),
+    delete: (path, options) => fetch(path, { method: "delete", ...options }),
+    options: (path, options) => fetch(path, { method: "options", ...options }),
+  };
+};

package/src/index.test.js

@@ -1,59 +1,50 @@
 import server, { status } from "./index.js";
 
 describe("return different types", () => {
-  const app = server()
+  const api = server()
     .get("/", () => "Hello world")
     .get("/text", () => "Hello world")
     .get("/array", () => ["Hello world"])
     .get("/object", () => ({ hello: "world" }))
-    .get("/status", () => 201);
+    .get("/status", () => 201)
+    .test();
 
   it("can get the plain text", async () => {
-    const res = await app.fetch(new Request("http://localhost:3000/text"));
-    expect(await res.text()).toBe("Hello world");
+    const { data } = await api.get("/text");
+    expect(data).toBe("Hello world");
   });
 
   it("can get the array", async () => {
-    const res = await app.fetch(new Request("http://localhost:3000/array"));
-    expect(await res.json()).toEqual(["Hello world"]);
+    const { data } = await api.get("/array");
+    expect(data).toEqual(["Hello world"]);
   });
 
   it("can get the object", async () => {
-    const res = await app.fetch(new Request("http://localhost:3000/object"));
-    expect(await res.json()).toEqual({ hello: "world" });
+    const { data } = await api.get("/object");
+    expect(data).toEqual({ hello: "world" });
   });
 
   it("can get the status", async () => {
-    const res = await app.fetch(new Request("http://localhost:3000/status"));
-    expect(res.status).toBe(201);
+    const { status } = await api.get("/status");
+    expect(status).toBe(201);
   });
 });
 
 describe("simple post works", () => {
-  const app = server().post("/", (ctx) => status(201).send(ctx.body));
+  const api = server()
+    .post("/", (ctx) => status(201).send(ctx.body))
+    .test();
 
   it("can post new data", async () => {
-    const res = await app.fetch(
-      new Request("http://localhost:3000/", {
-        method: "POST",
-        body: "New Data",
-      })
-    );
-
-    expect(res.status).toBe(201);
-    expect(await res.text()).toBe("New Data");
+    const { data, status } = await api.post("/", "New Data");
+    expect(status).toBe(201);
+    expect(data).toBe("New Data");
   });
 
   it("will return JSON", async () => {
-    const res = await app.fetch(
-      new Request("http://localhost:3000/", {
-        method: "POST",
-        body: JSON.stringify({ hello: "world" }),
-        headers: { "content-type": "application/json" },
-      })
-    );
-
-    expect(res.status).toBe(201);
-    expect(await res.json()).toEqual({ hello: "world" });
+    const { data, status, headers } = await api.post("/", { hello: "world" });
+    expect(status).toBe(201);
+    expect(data).toEqual({ hello: "world" });
+    expect(headers["content-type"]).toBe("application/json");
   });
 });

package/src/middle/index.js

@@ -1,40 +1,71 @@
 import argon2 from "argon2";
 
-import { createId } from "../helpers";
-import { status } from "../reply";
+import { createId } from "../helpers/index.js";
+import { status, type } from "../reply.js";
+import ServerError from "../ServerError.js";
 
 export default function middle(ctx) {
-  // if (ctx.auth?.type?.includes("email")) {
-  //   ctx.app.post("/register", async (ctx) => {
-  //     const { email, password, ...data } = ctx.body;
-  //     if (!email || !/@/.test(email)) throw new Error("Email needed");
-  //     if (!password || password.length < 8) throw new Error("Password needed");
-  //     const id = createId();
-  //     const time = new Date().toISOString();
-  //     const pass = await argon2.hash(password);
-  //     await ctx.auth.store.set(email, { id, email, password: pass, ...data });
-  //     const token = await ctx.options.session.store.add({ id, email, time });
-  //     return status(201).send({ id, token, email, ...data });
-  //   });
-  //
-  //   ctx.app.post("/login", async (ctx) => {
-  //     const { email, password } = ctx.body;
-  //     if (!email || !/@/.test(email)) throw new Error("Email needed");
-  //     if (!password || password.length < 8) throw new Error("Password needed");
-  //     const time = new Date().toISOString();
-  //     const user = await ctx.auth.store.get(email);
-  //     if (!user) {
-  //       return status(400).send("Invalid email");
-  //     }
-  //     if (!(await argon2.verify(user.password, password))) {
-  //       return status(400).send("Invalid password");
-  //     }
-  //     const token = await ctx.options.session.store.add({
-  //       id: user.id,
-  //       email,
-  //       time,
-  //     });
-  //     return { id: user.id, token, email };
-  //   });
-  // }
+  if (ctx.options.public) {
+    ctx.app.handlers.get.unshift([
+      "*",
+      "*",
+      async function publicFolder(ctx) {
+        try {
+          const asset = await ctx.options.public.read(ctx.url.pathname);
+          if (asset) {
+            return type(ctx.url.pathname.split(".").pop()).send(asset);
+          }
+        } catch (error) {}
+      },
+    ]);
+  }
+
+  if (!ctx.auth) return;
+  if (ctx.auth?.providers?.includes("email")) {
+    ctx.app.post("/auth/register/email", async (ctx) => {
+      const { email, password, ...data } = ctx.body;
+      if (!email || !/@/.test(email)) throw new Error("Email needed");
+      if (!password || password.length < 8) throw new Error("Password needed");
+      if (await ctx.auth.store.has(email)) {
+        throw new Error("Email is already registered");
+      }
+      const id = createId();
+      const time = new Date().toISOString();
+      const pass = await argon2.hash(password);
+      await ctx.auth.store.set(email, { id, email, password: pass, ...data });
+
+      // TYPE GOES HERE
+      const token = await ctx.options.session.store.add({ id, email, time });
+      return status(201).json({ id, token, email, ...data });
+    });
+
+    ctx.app.post("/auth/logout", async (ctx) => {
+      if (ctx.auth.id) {
+        await ctx.options.session.store.del(ctx.auth.id);
+      }
+      return status(200).send();
+    });
+
+    ctx.app.post("/auth/login/email", async (ctx) => {
+      const { email, password } = ctx.body;
+      if (!email) throw ServerError.LOGIN_NO_EMAIL();
+      if (!/@/.test(email)) throw ServerError.LOGIN_INVALID_EMAIL();
+      if (!password) throw ServerError.LOGIN_NO_PASSWORD();
+      if (password.length < 8) throw ServerError.LOGIN_INVALID_PASSWORD();
+
+      const time = new Date().toISOString();
+      const user = await ctx.auth.store.get(email);
+      if (!user) throw ServerError.LOGIN_WRONG_EMAIL();
+      const isValid = await argon2.verify(user.password, password);
+      if (!isValid) throw ServerError.LOGIN_WRONG_PASSWORD();
+
+      // TYPE GOES HERE
+      const token = await ctx.options.session.store.add({
+        id: user.id,
+        email,
+        time,
+      });
+      return { id: user.id, token, email };
+    });
+  }
 }

package/src/parseResponse.js

@@ -42,21 +42,16 @@ export default async function parseResponse(out, ctx) {
   // If we have a session, we need to persist it into a cookie
   if (Object.keys(ctx.session || {}).length) {
     if (!ctx.options.session?.store) {
-      throw ServerError.NO_STORE_WRITE({});
+      throw ServerError.NO_STORE({});
     }
 
-    let id;
     // Persistence is based on the Token
-    if (ctx.auth) {
-      id = ctx.auth.id;
-    } else {
-      // Persistence is based on the Cookies
-      // No session cookies, generate a _persistent_ cookie
-      if (!ctx.cookies.session) {
-        ctx.res.cookies.session = createId();
-      }
-      id = ctx.cookies.session;
+    // Persistence is based on the Cookies
+    // No session cookies, generate a _persistent_ cookie
+    if (!ctx.cookies.session) {
+      ctx.res.cookies.session = createId();
     }
+    const id = ctx.cookies.session;
 
     // Saves the session in the session store
     // Note that this is async but we are totally fine deferring it
@@ -66,7 +61,9 @@ export default async function parseResponse(out, ctx) {
   // Cookies to headers
   if (ctx.options.cookies) {
     if (Object.keys(ctx.res.cookies).length) {
-      ctx.res.headers["set-cookie"] = createCookies(ctx.res.cookies);
+      createCookies(ctx.res.cookies).forEach((cookie) => {
+        ctx.res.headers.append("set-cookie", cookie);
+      });
     }
   }
 

package/src/reply.js

@@ -2,14 +2,20 @@ import fs from "fs/promises";
 
 import { createCookies, types } from "./helpers/index.js";
 
-function Reply() {}
-
-Reply.prototype.res = { headers: {}, cookies: {} };
+function Reply() {
+  this.res = {
+    headers: {},
+    cookies: {},
+  };
+}
 
 // INTERNAL
 Reply.prototype.generateHeaders = function () {
-  const cookies = createCookies(this.res.cookies);
-  return { ...this.res.headers, "set-cookie": cookies };
+  const headers = new Headers(this.res.headers);
+  createCookies(this.res.cookies).forEach((cookie) => {
+    headers.append("set-cookie", cookie);
+  });
+  return headers;
 };
 
 // PARTIAL
@@ -49,7 +55,7 @@ Reply.prototype.cookies = function (cookies) {
 
 // FINAL
 Reply.prototype.json = function (body) {
-  return headers({ "content-type": "application/json" }).send(
+  return this.headers({ "content-type": "application/json" }).send(
     JSON.stringify(body)
   );
 };
@@ -74,7 +80,7 @@ Reply.prototype.view = async function (path) {
     }
     const data = await ctx.options.views.read(path);
     if (data) return this.type(path.split(".").pop()).send(data);
-    return status(404).send();
+    return this.status(404).send();
   };
 };
 

package/src/router.test.js

@@ -1,18 +1,16 @@
-import server, { router } from "./index.js";
-
-const url = (path, options = {}) =>
-  new Request("http://localhost:3000" + path, options);
+import server, { router, status } from "./index.js";
 
 describe("can route properly", () => {
-  const api = router()
+  const apiRouter = router()
     .get("/hello", (ctx) => "Hello " + ctx.url.pathname)
     .put("/hello", (ctx) => "Hello " + ctx.url.pathname)
     .post("/hello", (ctx) => "Hello " + ctx.url.pathname);
 
   const app = server()
-    .router("/", api)
-    .router("/api/", api)
+    .router("/", apiRouter)
+    .router("/api/", apiRouter)
     .get("/", () => "Fallback");
+  const api = app.test();
 
   // INTERNAL - so this might change in the future
   it("has the correct structure", () => {
@@ -21,27 +19,39 @@ describe("can route properly", () => {
   });
 
   it("can get fallback when nothing matches", async () => {
-    const res = await app.fetch(url("/"));
-    expect(await res.text()).toBe("Fallback");
+    const res = await api.get("/");
+    expect(res.data).toBe("Fallback");
   });
 
   it("can get the base get", async () => {
-    const res = await app.fetch(url("/hello"));
-    expect(await res.text()).toBe("Hello /hello");
+    const res = await api.get("/hello");
+    expect(res.data).toBe("Hello /hello");
   });
 
   it("can get the nested get", async () => {
-    const res = await app.fetch(url("/api/hello"));
-    expect(await res.text()).toBe("Hello /api/hello");
+    const res = await api.get("/api/hello");
+    expect(res.data).toBe("Hello /api/hello");
   });
 
   it("can post to the base get", async () => {
-    const res = await app.fetch(url("/hello", { method: "POST" }));
-    expect(await res.text()).toBe("Hello /hello");
+    const res = await api.post("/hello");
+    expect(res.data).toBe("Hello /hello");
   });
 
   it("can post to the nested get", async () => {
-    const res = await app.fetch(url("/api/hello", { method: "POST" }));
-    expect(await res.text()).toBe("Hello /api/hello");
+    const res = await api.post("/api/hello");
+    expect(res.data).toBe("Hello /api/hello");
+  });
+
+  it("no status reuse", async () => {
+    const api = server()
+      .get("/a", () => status(201).send("hello"))
+      .get("/b", () => ({ hello: "bye" }))
+      .get("/", () => "Fallback")
+      .test();
+    const { status: statusA } = await api.get("/a");
+    expect(statusA).toBe(201);
+    const { status: statusB } = await api.get("/b");
+    expect(statusB).toBe(200);
   });
 });

package/src/session.test.js

@@ -2,64 +2,64 @@ import kv from "polystore";
 
 import server from "./index.js";
 
-const url = (path, options = {}) =>
-  new Request("http://localhost:3000" + path, {
-    headers: { cookie: "session=REqA2l022l8Q0tuIRtqLOPUy" },
-    ...options,
-  });
-
 describe("session", () => {
   const store = kv(new Map());
-  const app = server({ store })
+  const api = server({ store })
     .get("/hello", (ctx) => "Hello " + ctx.session.a)
     .post("/hello", (ctx) => {
       if (!ctx.session.a) ctx.session.a = 0;
       ctx.session.a += 1;
       return "Bye " + ctx.session.a;
     })
-    .get("/", () => "Fallback");
+    .get("/", () => "Fallback")
+    .test();
 
   it("can get the nested get", async () => {
+    const cookie = "session=REqA2l022l8Q0tuIRtqLOPUy";
+    const options = { headers: { cookie } };
     await store.set("session:REqA2l022l8Q0tuIRtqLOPUy", { a: 0 });
 
-    const res = await app.fetch(url("/hello"));
-    expect(await res.text()).toBe("Hello 0");
+    const res = await api.get("/hello", options);
+    expect(res.data).toBe("Hello 0");
 
-    const res2 = await app.fetch(url("/hello", { method: "POST" }));
-    expect(await res2.text()).toBe("Bye 1");
-    const res3 = await app.fetch(url("/hello"));
-    expect(await res3.text()).toBe("Hello 1");
+    const res2 = await api.post("/hello", {}, options);
+    expect(res2.data).toBe("Bye 1");
+
+    const res3 = await api.get("/hello", options);
+    expect(res3.data).toBe("Hello 1");
     expect(await store.get("session:REqA2l022l8Q0tuIRtqLOPUy")).toEqual({
       a: 1,
     });
 
-    const res4 = await app.fetch(url("/hello", { method: "POST" }));
-    expect(await res4.text()).toBe("Bye 2");
-    const res5 = await app.fetch(url("/hello"));
-    expect(await res5.text()).toBe("Hello 2");
+    const res4 = await api.post("/hello", {}, options);
+    expect(res4.data).toBe("Bye 2");
+
+    const res5 = await api.get("/hello", options);
+    expect(res5.data).toBe("Hello 2");
     expect(await store.get("session:REqA2l022l8Q0tuIRtqLOPUy")).toEqual({
       a: 2,
     });
   });
+});
 
-  const missingStore = server({ store: null })
+describe("missing store", () => {
+  const api = server({ store: null })
     .get("/read", (ctx) => "Bye " + ctx.session.a)
     .get("/write", (ctx) => {
       ctx.session.a = "hello";
       return "All good";
-    });
+    })
+    .test();
 
   it("cannot read a session without a store", async () => {
-    const res = await missingStore.fetch(url("/read"));
-    const body = await res.text();
+    const res = await api.get("/read");
     expect(res.status).toBe(500);
-    expect(body).toBe("You need a 'store' to read 'ctx.session.a'");
+    expect(res.data).toBe("You need a 'store' to read 'ctx.session.a'");
   });
 
   it("cannot write a session without a store", async () => {
-    const res = await missingStore.fetch(url("/write"));
-    const body = await res.text();
+    const res = await api.get("/write");
     expect(res.status).toBe(500);
-    expect(body).toBe("You need a 'store' to write 'ctx.session.a'");
+    expect(res.data).toBe("You need a 'store' to write 'ctx.session.a'");
   });
 });

package/src/url.test.js

@@ -2,23 +2,25 @@ import server from "./index.js";
 
 describe("can match the url", () => {
   it("stops at the first matching route", async () => {
-    const app = server()
+    const api = server()
       .get("/:id", (ctx) => ctx.url.params)
-      .get("/*", (ctx) => ctx.url.params);
+      .get("/*", (ctx) => ctx.url.params)
+      .test();
 
-    const res = await app.fetch(new Request("http://localhost:3000/hello"));
-    expect(await res.json()).toEqual({ id: "hello" });
+    const { data, headers } = await api.get("/hello");
+    expect(data).toEqual({ id: "hello" });
+    expect(headers["content-type"]).toEqual("application/json");
   });
 
   it("but it doesn't if it's a use", async () => {
-    const app = server()
-      .use(() => {
-        // No-op
-      })
+    const api = server()
+      .use(() => {}) // No-op
       .get("/:id", (ctx) => ctx.url.params)
-      .get("/*", (ctx) => ctx.url.params);
+      .get("/*", (ctx) => ctx.url.params)
+      .test();
 
-    const res = await app.fetch(new Request("http://localhost:3000/hello"));
-    expect(await res.json()).toEqual({ id: "hello" });
+    const { data, headers, ...rest } = await api.get("/hello");
+    expect(data).toEqual({ id: "hello" });
+    expect(headers["content-type"]).toEqual("application/json");
   });
 });