@server/next 0.20.8 → 0.20.10

package/src/index.js

@@ -10,6 +10,7 @@ import {
   getMachine,
   handleRequest,
   iterate,
+  parseHeaders,
 } from "./helpers/index.js";
 import middle from "./middle/index.js";
 
@@ -59,13 +60,34 @@ const validateOptions = (options, env = {}) => {
   if (options.store && options.cookies) {
     options.session = { store: options.store.prefix("session:") };
   }
-  options.auth = options.auth || {};
+
+  // AUTH
+  options.auth = options.auth || env.AUTH || null;
   if (options.auth) {
     if (typeof options.auth !== "object") {
-      options.auth = { type: options.auth };
+      const [type, provider] = options.auth.split(":");
+      options.auth = { type, provider };
+    }
+    if (typeof options.auth.provider === "string") {
+      options.auth.provider === options.auth.provider.split("|");
+    }
+    if (!options.auth.type) {
+      throw new Error("Auth options needs a type");
+    }
+    if (!options.auth.provider) {
+      throw new Error("Auth options needs a provider");
+    }
+    if (!options.auth.session && options.store) {
+      options.auth.session = options.store.prefix("auth:");
     }
     if (!options.auth.store && options.store) {
-      options.auth.store = options.store.prefix("auth:");
+      options.auth.store = options.store.prefix("user:");
+    }
+    if (!options.auth.cleanUser) {
+      options.auth.cleanUser = (fullUser) => {
+        const { password, ...user } = fullUser;
+        return user;
+      };
     }
   }
 
@@ -196,3 +218,46 @@ 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 = parseHeaders(res.headers);
+    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 {
+    app: this,
+    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,53 @@
+import "./test/toSucceed.js";
+
 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 req = await api.get("/object");
+    expect(req).toSucceed({ 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 req = await api.get("/status");
+    expect(req).toSucceed();
+    expect(req.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/assets.js

@@ -0,0 +1,12 @@
+import { type } from "../reply.js";
+
+export default async function assets(ctx) {
+  try {
+    // TODO: streaming
+    const asset = await ctx.options.public.read(ctx.url.pathname);
+    if (!asset) return;
+    return type(ctx.url.pathname.split(".").pop()).send(asset);
+  } catch (error) {
+    // NO-OP; if there's no file, keep going the normal flow
+  }
+}

package/src/middle/index.js

@@ -1,71 +1,12 @@
-import argon2 from "argon2";
+import auth from "../auth/index.js";
+import assets from "./assets.js";
 
-import { createId } from "../helpers/index.js";
-import { status, type } from "../reply.js";
-import ServerError from "../ServerError.js";
-
-export default function middle(ctx) {
+export default async function middle(ctx) {
+  // Serve assets
   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) {}
-      },
-    ]);
+    // We need these before other endpoints
+    ctx.app.handlers.get.unshift(["*", "*", assets]);
   }
 
-  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 };
-    });
-  }
+  await auth.middle(ctx);
 }

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/test/toSucceed.js

@@ -0,0 +1,64 @@
+import { expect } from "@jest/globals";
+
+const reset = "\x1b[0m";
+
+const spaceOrEnter = (msg) => {
+  if (typeof msg === "string") {
+    return " ";
+  }
+  return "\n";
+};
+
+export default function toSucceed(request, message) {
+  const pass = request.status >= 200 && request.status < 300;
+
+  if (message && JSON.stringify(request.data) !== JSON.stringify(message)) {
+    if (pass) {
+      return {
+        message: () =>
+          `${reset}Expected body:${spaceOrEnter(
+            message
+          )}${this.utils.printExpected(message)}\nReceived body:${spaceOrEnter(
+            request.data
+          )}${this.utils.printReceived(request.data)}`,
+        pass,
+      };
+    }
+
+    return {
+      message: () =>
+        `${reset}Expected error:${spaceOrEnter(
+          message
+        )}${this.utils.printExpected(message)}\nReceived error:${spaceOrEnter(
+          request.data
+        )}${this.utils.printReceived(request.data)}`,
+      pass: !pass,
+    };
+  }
+
+  if (pass) {
+    return {
+      message: () =>
+        `${reset}Expected ${this.utils.printExpected(
+          request.status
+        )} to be an error code, received body:\n${this.utils.printExpected(
+          request.data
+        )}`,
+      pass: true,
+    };
+  }
+
+  return {
+    message: () =>
+      `${reset}Expected ${this.utils.printReceived(
+        request.status
+      )} to succeed, received body:\n${this.utils.printReceived(
+        request.data,
+        null,
+        2
+      )}`,
+    pass: false,
+  };
+}
+
+expect.extend({ toSucceed });

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");
   });
 });

package/src/auth.test.js

@@ -1,78 +0,0 @@
-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;
-  });
-
-  it("should be Bearer", async () => {
-    const res = await app.fetch(url("Basic REqA2l022l8Q0tuIRtqLOPUy"));
-    expect(await res.text()).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");
-  });
-
-  it("can get the nested get", async () => {
-    const res = await app.fetch(url("Bearer REqA2l022l8Q0tuIRtqLOPUy"));
-    expect(await res.text()).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"]);
-
-      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,
-      ]);
-    });
-  });
-});