@server/next 0.20.8 → 0.20.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@server/next",
-  "version": "0.20.8",
+  "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",

package/src/auth.test.js

@@ -2,77 +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("user creation flow", () => {
-    // These are obviously mock data
-    const EMAIL = "abc@test.com";
-    const PASS = "11111111";
-
-    const url = (path, body = {}, headers = {}) =>
-      new Request("http://localhost:3000" + path, {
-        headers: {
-          cookie: "session=REqA2l022l8Q0tuIRtqLOPUy",
-          "content-type": "application/json",
-          ...headers,
-        },
-        method: "POST",
-        body: JSON.stringify(body),
-      });
-
-    const store = kv(new Map());
-    const app = server({ auth: { type: "token", providers: "email" }, store });
-
-    it("can create a new user", async () => {
-      const regReq = await app.fetch(
-        url("/auth/register/email", { email: EMAIL, password: PASS })
-      );
-      const register = await regReq.json();
-      expect(regReq.status).toBe(201);
-      expect(await store.keys()).toEqual([
-        "auth:abc@test.com",
-        "session:" + register.token,
-      ]);
-
-      const logoutReq = await app.fetch(
-        url("/auth/logout", {}, { authorization: "Bearer " + register.token })
-      );
-      expect(logoutReq.status).toBe(200);
-      expect(await store.keys()).toEqual(["auth:abc@test.com"]);
+describe("user creation flow", () => {
+  // These are obviously mock data
+  const EMAIL = "abc@test.com";
+  const PASS = "11111111";
+  const CREDENTIALS = { email: EMAIL, password: PASS };
 
-      const loginReq = await app.fetch(
-        url("/auth/login/email", { email: EMAIL, password: PASS })
-      );
-      const login = await loginReq.json();
-      expect(loginReq.status).toBe(200);
-      expect(await store.keys()).toEqual([
-        "auth:abc@test.com",
-        "session:" + login.token,
-      ]);
-    });
+  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/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/parseResponse.js

@@ -61,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

@@ -11,8 +11,11 @@ function Reply() {
 
 // 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

package/src/router.test.js

@@ -1,18 +1,16 @@
 import server, { router, status } from "./index.js";
 
-const url = (path, options = {}) =>
-  new Request("http://localhost:3000" + path, options);
-
 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,38 +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 app = server()
+    const api = server()
       .get("/a", () => status(201).send("hello"))
       .get("/b", () => ({ hello: "bye" }))
-      .get("/", () => "Fallback");
-    const resA = await app.fetch(url("/a"));
-    expect(resA.status).toBe(201);
-    const resB = await app.fetch(url("/b"));
-    expect(resB.status).toBe(200);
+      .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");
   });
 });