@stanlemon/server-with-auth 0.2.12 → 0.3.0

package/src/data/lowdb-user-dao.js

@@ -4,11 +4,11 @@ import { v4 as uuidv4 } from "uuid";
 import bcrypt from "bcryptjs";
 import UserDao from "./user-dao.js";
 
-export function createInMemoryDb() {
+export function createInMemoryLowDb() {
   return new LowSync(new MemorySync(), {});
 }
 
-export function createJsonFileDb(filename = "./db.json") {
+export function createJsonFileLowDb(filename = "./db.json") {
   return new LowSync(new JSONFileSync(filename), {});
 }
 
@@ -17,16 +17,16 @@ export function createJsonFileDb(filename = "./db.json") {
  * Test environment (NODE_ENV=test) will use {MemorySync}.
  * @returns {LowSync} Database
  */
-export function createDb() {
+export function createLowDb() {
   return process.env.NODE_ENV === "test"
-    ? createInMemoryDb()
-    : createJsonFileDb();
+    ? createInMemoryLowDb()
+    : createJsonFileLowDb();
 }
 
 export default class LowDBUserDao extends UserDao {
   #db;
 
-  constructor(db = createDb()) {
+  constructor(db = createLowDb()) {
     super();
 
     if (!(db instanceof LowSync)) {
@@ -42,72 +42,86 @@ export default class LowDBUserDao extends UserDao {
 
   /** @inheritdoc */
   getUserById(userId) {
-    return this.#db.data.users
-      .filter((user) => {
-        // This one can get gross with numerical ids
-        // eslint-disable-next-line eqeqeq
-        return user.id == userId;
-      })
-      .shift();
+    return new Promise((resolve) => {
+      resolve(
+        this.#db.data.users
+          .filter((user) => {
+            // This one can get gross with numerical ids
+            // eslint-disable-next-line eqeqeq
+            return user.id == userId;
+          })
+          .shift()
+      );
+    });
   }
 
   /** @inheritdoc */
   getUserByUsername(username) {
-    return this.#db.data.users
-      .filter((user) => {
-        return user.username === username;
-      })
-      .shift();
+    return new Promise((resolve) => {
+      resolve(
+        this.#db.data.users
+          .filter((user) => {
+            return user.username === username;
+          })
+          .shift()
+      );
+    });
   }
 
   /** @inheritdoc */
   getUserByUsernameAndPassword(username, password) {
     // Treat this like a failed login.
     if (!username || !password) {
-      return false;
-    }
-
-    const user = this.getUserByUsername(username);
-
-    if (!user || !bcrypt.compareSync(password, user.password)) {
-      return false;
+      return new Promise((resolve) => {
+        resolve(false);
+      });
     }
 
-    return user;
+    return this.getUserByUsername(username).then((user) => {
+      if (!user || !bcrypt.compareSync(password, user.password)) {
+        return false;
+      }
+      return user;
+    });
   }
 
   /** @inheritdoc */
   getUserByVerificationToken(token) {
-    return this.#db.data.users
-      .filter((user) => user.verification_token === token)
-      .shift();
+    return new Promise((resolve) => {
+      resolve(
+        this.#db.data.users
+          .filter((user) => user.verification_token === token)
+          .shift()
+      );
+    });
   }
 
   /** @inheritdoc */
   createUser(user) {
-    const existing = this.getUserByUsername(user.username);
+    return this.getUserByUsername(user.username).then((existing) => {
+      if (existing) {
+        throw new Error("This username is already taken.");
+      }
 
-    if (existing) {
-      throw new Error("This username is already taken.");
-    }
+      const now = new Date();
 
-    const now = new Date();
-    const data = {
-      ...user,
-      password: bcrypt.hashSync(user.password, 10),
-      id: uuidv4(),
-      verification_token: uuidv4(),
-      created_at: now,
-      last_updated: now,
-    };
-    this.#db.data.users.push(data);
-    this.#db.write();
-    return data;
+      const data = {
+        ...user,
+        password: bcrypt.hashSync(user.password, 10),
+        id: uuidv4(),
+        verification_token: uuidv4(),
+        created_at: now,
+        last_updated: now,
+      };
+      this.#db.data.users.push(data);
+      this.#db.write();
+
+      return data;
+    });
   }
 
   /** @inheritdoc */
   updateUser(userId, user) {
-    const now = new Date();
     this.#db.data.users = this.#db.data.users.map((u) => {
       if (u.id === userId) {
         // If the password has been set, encrypt it
@@ -119,19 +133,35 @@ export default class LowDBUserDao extends UserDao {
           ...u,
           ...user,
           id: userId,
-          last_updated: now,
+          last_updated: new Date(),
+          created_at: u.created_at, // Always preserve created_at
         };
       }
       return u;
     });
     this.#db.write();
-    return this.getUserById(userId);
+
+    return new Promise((resolve) => {
+      resolve(this.getUserById(userId));
+    });
   }
 
   /** @inheritdoc */
   deleteUser(userId) {
     this.#db.data.users = this.#db.data.users.filter((u) => u.id !== userId);
     this.#db.write();
-    return true;
+    return new Promise((resolve) => {
+      resolve(true);
+    });
   }
+
+  /** @inheritdoc */
+  getAllUsers() {
+    return new Promise((resolve) => {
+      resolve(this.#db.data.users || []);
+    });
+  }
+
+  /** @inheritdoc */
+  close() {}
 }

package/src/data/user-dao.js

@@ -1,3 +1,14 @@
+/**
+ * @typedef User
+ * @property {string|int} id Identifier
+ * @property {string} username Username
+ * @property {string} password Password
+ * @property {string} verification_token Verification token
+ * @property {date} verify_at Date verified
+ * @property {date} last_logged_in Date last logged in
+ * @property {date} created_at Date created
+ * @property {date} last_updated Date last updated
+ */
 export default class UserDao {
   constructor() {}
 
@@ -9,9 +20,9 @@ export default class UserDao {
 
   /**
    * Get user by id.
-   * @param {*} userId Identifier to get user by
+   * @param {string|int} userId Identifier to get user by
+   * @returns {Promise<User|boolean>} User object or false
    */
-  // eslint-disable-next-line no-unused-vars
   getUserById(userId) {
     this.#error();
   }
@@ -19,8 +30,8 @@ export default class UserDao {
   /**
    * Get user by username.
    * @param {string} username Username
+   * @returns {Promise<User|boolean>} User object or false
    */
-  // eslint-disable-next-line no-unused-vars
   getUserByUsername(username) {
     this.#error();
   }
@@ -29,8 +40,8 @@ export default class UserDao {
    * Get user by username and password.
    * @param {string} username Username
    * @param {string} password Password
+   * @returns {Promise<User|boolean>} User object or false
    */
-  // eslint-disable-next-line no-unused-vars
   getUserByUsernameAndPassword(username, password) {
     this.#error();
   }
@@ -38,36 +49,52 @@ export default class UserDao {
   /**
    * Get user by verification token.
    * @param {string} token User verification token
+   * @returns {Promise<User|boolean>} User object or false
    */
-  // eslint-disable-next-line no-unused-vars
   getUserByVerificationToken(token) {
     this.#error();
   }
 
   /**
    * Create a new user.
-   * @param {object} user User
+   * @param {User} user User
+   * @returns {Promise<User|boolean>} User object or false
    */
-  // eslint-disable-next-line no-unused-vars
   createUser(user) {
     this.#error();
   }
 
   /**
    * Update an existing user.
-   * @param {*} userId User identifier
-   * @param {object} user User object
+   * @param {string|int} userId User identifier
+   * @param {User} user User object
+   * @returns {Promise<User>} User object
    */
-  // eslint-disable-next-line no-unused-vars
   updateUser(userId, user) {
     this.#error();
   }
 
   /**
    * Delete a user.
-   * @param {*} userId User identifier
+   * @param {string|int} userId User identifier
+   * @return {Promise<boolean>} True if successful, false if not
    */
   deleteUser(userId) {
     this.#error();
   }
+
+  /**
+   * Get all users in the database.
+   * @return {Promise<User[]|false>} True if successful, false if not
+   */
+  getAllUsers() {
+    this.#error();
+  }
+
+  /**
+   * Close the dao and do any necessary cleanup.
+   */
+  close() {
+    this.#error();
+  }
 }

package/src/data/user-dao.test.js

@@ -0,0 +1,156 @@
+/**
+ * @jest-environment node
+ */
+import LowDBUserDao, { createInMemoryLowDb } from "./lowdb-user-dao.js";
+import KnexUserDao, { createBetterSqlite3Db } from "./knex-user-dao.js";
+
+describe("user-dao", () => {
+  createUserDaoTests("lowdb-user-dao", async () => {
+    return new Promise((resolve) => {
+      resolve(new LowDBUserDao(createInMemoryLowDb()));
+    });
+  });
+
+  createUserDaoTests("knex-user-dao", async () => {
+    return new KnexUserDao(await createBetterSqlite3Db());
+  });
+});
+
+/**
+ *
+ * @param {String} name Name of the user dao implementation
+ * @param {*} createDao A function to create a user dao implementation
+ */
+function createUserDaoTests(name, createDao) {
+  describe(`${name}`, () => {
+    // This is a user that we will reuse in our tests
+    const data = {
+      username: "test",
+      password: "password",
+    };
+
+    /** @type {LowDBUserDao} */
+    let dao;
+
+    beforeEach(async () => {
+      // Before each test reset our users database
+      dao = await createDao();
+    });
+
+    afterEach(async () => {
+      dao.close();
+    });
+
+    it("creates a user", async () => {
+      let user = await dao.createUser(data);
+
+      expect(user.username).toEqual(data.username);
+      // The value should be encrypted now
+      expect(user.password).not.toEqual(data.password);
+      // These fields are added by the create process
+      expect(user.verification_token).not.toBeUndefined();
+
+      const refresh = await dao.getUserByUsername(data.username);
+
+      // If we retrieve the user by username, it matches the object we got when we created it
+      expect(refresh).toMatchObject(user);
+    });
+
+    it("creates a user with an existing username errors", async () => {
+      let hasError = false;
+
+      try {
+        // Create the user
+        await dao.createUser(data);
+        // Attempt to create the user again, this will fail
+        await dao.createUser(data);
+      } catch (err) {
+        hasError = err;
+      }
+
+      expect(hasError).not.toBe(false);
+      expect(hasError.message).toEqual("This username is already taken.");
+    });
+
+    it("retrieve user by username and password", async () => {
+      const user1 = await dao.createUser(data);
+
+      const user2 = await dao.getUserByUsernameAndPassword(
+        data.username,
+        data.password
+      );
+
+      expect(user1).toMatchObject(user2);
+    });
+
+    it("retrieve user by username and wrong password fails", async () => {
+      await dao.createUser(data);
+
+      const user2 = await dao.getUserByUsernameAndPassword(
+        data.username,
+        "wrong password"
+      );
+
+      expect(user2).toBe(false);
+    });
+
+    it("retrieve user by username and undefined password fails", async () => {
+      await dao.createUser(data);
+
+      const user2 = await dao.getUserByUsernameAndPassword(
+        data.username,
+        undefined
+      );
+
+      expect(user2).toBe(false);
+    });
+
+    it("retrieve user by username that does not exist fails", async () => {
+      const user = await dao.getUserByUsernameAndPassword(
+        "notarealuser",
+        "password"
+      );
+
+      expect(user).toBe(false);
+    });
+
+    it("retrieve user by username that is undefined fails", async () => {
+      const user = await dao.getUserByUsernameAndPassword(
+        undefined,
+        "password"
+      );
+
+      expect(user).toBe(false);
+    });
+
+    it("updates a user", async () => {
+      const user = await dao.createUser(data);
+
+      expect(user.name).toBeFalsy();
+
+      const name = "Test User";
+
+      await dao.updateUser(user.id, { name: name });
+
+      const reloaded = await dao.getUserById(user.id);
+
+      expect(reloaded.name).toEqual(name);
+    });
+
+    it("deletes a user by id", async () => {
+      const user = await dao.createUser(data);
+
+      expect(await dao.getAllUsers()).toHaveLength(1);
+
+      const deleted = await dao.deleteUser(user.id);
+
+      expect(deleted).toBe(true);
+
+      const reloaded = await dao.getUserById(user.id);
+
+      expect(reloaded).toBeUndefined();
+
+      expect(await dao.getAllUsers()).toHaveLength(0);
+    });
+  });
+}

package/src/index.js

@@ -11,11 +11,12 @@ export {
 } from "@stanlemon/server";
 export { default as checkAuth } from "./checkAuth.js";
 export { default as createAppServer } from "./createAppServer.js";
-export { default as schema } from "./schema/user.js";
+export { default as SCHEMAS, PASSWORD, createSchemas } from "./schema/index.js";
 export { default as SimpleUsersDao } from "./data/simple-users-dao.js";
+export { EVENTS, ROUTES, HIDDEN_FIELDS } from "./constants.js";
 export {
   default as LowDBUserDao,
-  createDb,
-  createInMemoryDb,
-  createJsonFileDb,
+  createLowDb,
+  createInMemoryLowDb,
+  createJsonFileLowDb,
 } from "./data/lowdb-user-dao.js";