@stanlemon/server-with-auth 0.1.5 → 0.1.8

package/jest.config.js

@@ -0,0 +1 @@
+export { default } from "@stanlemon/webdev/jest.config.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stanlemon/server-with-auth",
-  "version": "0.1.5",
+  "version": "0.1.8",
   "description": "A basic express web server setup with authentication baked in.",
   "author": "Stan Lemon <stanlemon@users.noreply.github.com>",
   "license": "MIT",
@@ -14,21 +14,24 @@
     "start": "NODE_ENV=development nodemon --ignore db.json ./app.js",
     "lint": "eslint --ext js,jsx,ts,tsx ./",
     "lint:format": "eslint --fix --ext js,jsx,ts,tsx ./",
-    "test": "NODE_OPTIONS=--experimental-vm-modules jest --detectOpenHandles",
-    "test:watch": "NODE_OPTIONS=--experimental-vm-modules jest --detectOpenHandles --watch"
+    "test": "jest --detectOpenHandles",
+    "test:coverage": "jest --detectOpenHandles --coverage",
+    "test:watch": "jest --detectOpenHandles --watch"
   },
   "dependencies": {
     "@stanlemon/server": "*",
+    "@stanlemon/webdev": "*",
     "bcryptjs": "^2.4.3",
     "jsonwebtoken": "^8.5.1",
     "lowdb": "^3.0.0",
-    "passport": "^0.5.2",
+    "passport": "^0.6.0",
     "passport-jwt": "^4.0.0",
     "shortid": "^2.2.16",
     "uuid": "^8.3.2"
   },
   "devDependencies": {
     "@stanlemon/eslint-config": "*",
+    "@types/supertest": "^2.0.12",
     "nodemon": "^2.0.16",
     "supertest": "^6.2.3"
   }

package/src/createAppServer.js

@@ -5,6 +5,7 @@ import {
 } from "@stanlemon/server";
 import passport from "passport";
 import { Strategy as JwtStrategy, ExtractJwt } from "passport-jwt";
+import shortid from "shortid";
 import defaultUserSchema from "./schema/user.js";
 import checkAuth from "./checkAuth.js";
 import auth from "./routes/auth.js";
@@ -39,13 +40,17 @@ export default function createAppServer(options) {
     updateUser,
   } = { ...DEFAULTS, ...options };
 
+  const app = createBaseAppServer({ port, webpack, start });
+
+  if (process.env.NODE_ENV === "test") {
+    return app;
+  }
+
   if (!process.env.JWT_SECRET) {
     console.warn("You need to specify a secret.");
   }
 
-  const secret = process.env.JWT_SECRET || "YouNeedASecret";
-
-  const app = createBaseAppServer({ port, webpack, start });
+  const secret = process.env.JWT_SECRET || shortid.generate();
 
   passport.use(
     "jwt",

package/src/data/simple-users-dao.js

@@ -1,19 +1,36 @@
-import { Low, JSONFile } from "lowdb";
+import { LowSync, JSONFileSync, MemorySync } from "lowdb";
 import { v4 as uuidv4 } from "uuid";
 import shortid from "shortid";
 import bcrypt from "bcryptjs";
 
+const DEFAULT_ADAPTER =
+  process.env.NODE_ENV === "test"
+    ? new MemorySync()
+    : new JSONFileSync("./db.json");
+
 export default class SimpleUsersDao {
-  constructor(seeds = [], adapter = new JSONFile("./db.json")) {
-    this.db = new Low(adapter);
+  constructor(seeds = [], adapter = DEFAULT_ADAPTER) {
+    this.db = new LowSync(adapter);
 
-    this.db.read().then(() => {
-      this.db.data ||= { users: [] };
+    this.db.read();
 
-      if (seeds.length > 0) {
-        seeds.forEach((user) => this.createUser(user));
-      }
-    });
+    this.db.data ||= { users: [] };
+
+    if (seeds.length > 0) {
+      seeds.forEach((user) => this.createUser(user));
+    }
+  }
+
+  getDb() {
+    return this.db;
+  }
+
+  generateId() {
+    return uuidv4();
+  }
+
+  generateVerificationToken() {
+    return shortid.generate();
   }
 
   getUserById = (userId) => {
@@ -55,7 +72,7 @@ export default class SimpleUsersDao {
       .shift();
   };
 
-  createUser = async (user) => {
+  createUser = (user) => {
     const existing = this.getUserByUsername(user.username);
 
     if (existing) {
@@ -66,17 +83,17 @@ export default class SimpleUsersDao {
     const data = {
       ...user,
       password: bcrypt.hashSync(user.password, 10),
-      id: uuidv4(),
-      verification_token: shortid.generate(),
+      id: this.generateId(),
+      verification_token: this.generateVerificationToken(),
       created_at: now,
       last_updated: now,
     };
     this.db.data.users.push(data);
-    await this.db.write();
+    this.db.write();
     return data;
   };
 
-  updateUser = async (userId, user) => {
+  updateUser = (userId, user) => {
     const now = new Date();
     this.db.data.users = this.db.data.users.map((u) => {
       if (u.id === userId) {
@@ -94,7 +111,7 @@ export default class SimpleUsersDao {
       }
       return u;
     });
-    await this.db.write();
+    this.db.write();
     return this.getUserById(userId);
   };
 }

package/src/data/simple-users-dao.test.js

@@ -1,4 +1,7 @@
-import { Memory } from "lowdb";
+/**
+ * @jest-environment node
+ */
+import { MemorySync } from "lowdb";
 import SimpleUsersDao from "./simple-users-dao.js";
 
 describe("simple-users-dao", () => {
@@ -12,7 +15,7 @@ describe("simple-users-dao", () => {
 
   beforeEach(() => {
     // Before each test reset our users database
-    users = new SimpleUsersDao([], new Memory());
+    users = new SimpleUsersDao([], new MemorySync());
   });
 
   it("creates a user", async () => {

package/src/routes/auth.js

@@ -21,40 +21,33 @@ export default function authRoutes({
 }) {
   const router = Router();
 
-  router.get("/auth/session", (req, res, next) => {
-    /* look at the 2nd parameter to the below call */
-    passport.authenticate("jwt", { session: false }, (err, userId) => {
-      if (err) {
-        return next(err);
-      }
+  router.get(
+    "/auth/session",
+    passport.authenticate("jwt", { session: false }),
+    async (req, res) => {
+      const userId = req.user;
+
       if (!userId) {
-        return res.status(401).json({
+        res.status(401).json({
           token: false,
           user: false,
         });
+        return;
       }
 
-      req.logIn(userId, async (err) => {
-        if (err) {
-          return next(err);
-        }
-
-        const user = await getUserById(userId);
-
-        if (!user) {
-          return res.status(401).json({
-            token: false,
-            user: false,
-          });
-        } else {
-          const token = jwt.sign(user.id, secret);
-          res
-            .status(200)
-            .json({ token, user: formatOutput(user, ["password"]) });
-        }
-      });
-    })(req, res, next);
-  });
+      const user = await getUserById(userId);
+
+      if (!user) {
+        res.status(401).json({
+          token: false,
+          user: false,
+        });
+      } else {
+        const token = jwt.sign(user.id, secret);
+        res.status(200).json({ token, user: formatOutput(user, ["password"]) });
+      }
+    }
+  );
 
   router.post("/auth/login", async (req, res) => {
     const user = await getUserByUsernameAndPassword(

package/src/routes/auth.test.js

@@ -1,14 +1,20 @@
+/**
+ * @jest-environment node
+ */
 import request from "supertest";
-import { Memory } from "lowdb";
+import { MemorySync } from "lowdb";
 import createAppServer from "../createAppServer";
 import SimpleUsersDao from "../data/simple-users-dao.js";
 
 // This suppresses a warning we don't need in tests
 process.env.JWT_SECRET = "SECRET";
 
-let users = new SimpleUsersDao([], new Memory());
+let users = new SimpleUsersDao([], new MemorySync());
 
+// We want to explicitly test functionality we disable during testing
+process.env.NODE_ENV = "override";
 const app = createAppServer({ ...users, start: false });
+process.env.NODE_ENV = "test";
 
 describe("/auth", () => {
   let userId;