@server/next 0.20.7 → 0.20.8

package/package.json

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

@@ -28,42 +28,51 @@ describe("auth", () => {
     expect(await res.text()).toBe("Bearer REqA2l022l8Q0tuIRtqLOPUy");
   });
 
-  describe.skip("user creation flow", () => {
-    const url = (path, options = {}) =>
+  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,
         },
-        ...options,
-        body: JSON.stringify(options.body),
+        method: "POST",
+        body: JSON.stringify(body),
       });
 
     const store = kv(new Map());
-    const app = server({ auth: "email", store });
+    const app = server({ auth: { type: "token", providers: "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" },
-        })
+      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 })
       );
-      console.log(registered);
-      console.log(Object.fromEntries(await store.entries()));
-      console.log(await registered.text());
-      expect(registered.status).toBe(201);
+      expect(logoutReq.status).toBe(200);
+      expect(await store.keys()).toEqual(["auth:abc@test.com"]);
 
-      const login = await app.fetch(
-        url("/login", {
-          method: "POST",
-          body: { email: "abc@test.com", password: "11111111" },
-        })
+      const loginReq = await app.fetch(
+        url("/auth/login/email", { email: EMAIL, password: PASS })
       );
-      console.log(login);
-      console.log(Object.fromEntries(await store.entries()));
-      console.log(await login.text());
-      expect(login.status).toBe(200);
+      const login = await loginReq.json();
+      expect(loginReq.status).toBe(200);
+      expect(await store.keys()).toEqual([
+        "auth:abc@test.com",
+        "session:" + login.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/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

package/src/reply.js

@@ -2,9 +2,12 @@ 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 () {
@@ -49,7 +52,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 +77,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,4 +1,4 @@
-import server, { router } from "./index.js";
+import server, { router, status } from "./index.js";
 
 const url = (path, options = {}) =>
   new Request("http://localhost:3000" + path, options);
@@ -44,4 +44,15 @@ describe("can route properly", () => {
     const res = await app.fetch(url("/api/hello", { method: "POST" }));
     expect(await res.text()).toBe("Hello /api/hello");
   });
+
+  it("no status reuse", async () => {
+    const app = 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);
+  });
 });