Merge pull request #67 from oslabs-beta/Carter/specTest

Carter/spec test

Author: Suigin1

server/config/passport.js

@@ -1,8 +1,15 @@
+/**  using import statements in the electron / node files breaks npm start and nodepty 
+* - types are left in place in these files for future iteration alternate import method is required for them to function
+*/
+// import { TablePaginationUnstyledSpacerSlotProps } from "@mui/base";
+// import { Error } from "mongoose";
+// import { Authenticator, Profile } from "passport";
+
 const GitHubStrategy = require('passport-github2').Strategy;
 const GoogleStrategy = require('passport-google-oauth20').Strategy;
 const { GithubUser, GoogleUser } = require('../models/userModel.js');
 
-module.exports = function (passport) {
+module.exports = function (passport/*:  Authenticator */) {
   passport.use(
     new GitHubStrategy(
       {
@@ -11,10 +18,10 @@ module.exports = function (passport) {
         callbackURL: 'http://localhost:3001/auth/github/callback',
       },
 
-      (accessToken, refreshToken, profile, done) => {
+      (accessToken/* : String */, refreshToken/* : (String | undefined) */, profile/* : Profile */, done/* : Function */)/* : void */ => {
         //console.log('this is our accessToken:', accessToken);
         // we are checking if the github profile is in our monogDB
-        GithubUser.findOne({ githubId: profile.id }, (err, result) => {
+        GithubUser.findOne({ githubId: profile.id }, (err/* : Error */, result/* : { githubId: String, username: String } */)/* : void */ => {
           if (result) {
             // already have this user
             //console.log('user is: ', result);
@@ -27,7 +34,7 @@ module.exports = function (passport) {
               username: profile.displayName,
             })
               .save()
-              .then((newUser) => {
+              .then((newUser)/* : void  */=> {
                 //console.log('created new user: ', newUser);
                 //   res.locals.userId = newUser._id
                 done(null, newUser);
@@ -48,10 +55,10 @@ module.exports = function (passport) {
         callbackURL: 'http://localhost:3001/auth/google/callback',
       },
 
-      (accessToken, refreshToken, profile, done) => {
+      (accessToken/* : String */, refreshToken/* : (String | undefined) */, profile/* : Profile */, done/* : Function */)/* : void  */=> {
         //console.log('this is our accessToken:', accessToken);
         // we are checking if the google profile is in our monogDB
-        GoogleUser.findOne({ googleId: profile.id }, (err, result) => {
+        GoogleUser.findOne({ googleId: profile.id }, (err/* : Error */, result/* : {googleId: String, username: String} */) => {
           if (result) {
             // already have this user
             //console.log('user is: ', result);
@@ -63,7 +70,7 @@ module.exports = function (passport) {
               googleId: profile.id,
             })
               .save()
-              .then((newUser) => {
+              .then((newUser)/* : void  */=> {
                 //console.log('created new user: ', newUser);
                 //   res.locals.userId = newUser._id
                 done(null, newUser);
@@ -76,11 +83,11 @@ module.exports = function (passport) {
     )
   );
 
-  passport.serializeUser((user, done) => {
+  passport.serializeUser((user, done)/* : void  */=> {
     done(null, user);
   });
 
-  passport.deserializeUser((obj, done) => {
+  passport.deserializeUser((obj/* : (false | Express.User | null | undefined) */, done)/* : void */ => {
     done(null, obj);
   });
 };

server/controllers/cookieController.js

@@ -1,15 +1,21 @@
-const cookieController = {};
+/**  using import statements in the electron / node files breaks npm start and nodepty 
+* - types are left in place in these files for future iteration alternate import method is required for them to function
+*/
+// import { NextFunction, Request, Response } from "express";
+// import { cookieControllerType } from "../utils/backendTypes";
+
+const cookieController /*: cookieControllerType*/ = {};
 
 // Middleware to initialize a cookie when user logs in
-cookieController.setSSIDCookie = (req, res, next) => {
+cookieController.setSSIDCookie = (req/*: Request*/, res/*: Response*/, next/*: NextFunction*/)/*: void*/ => {
   // eslint-disable-next-line no-useless-escape
   //removing double quotes with Regex?
   res.cookie('ssid', JSON.stringify(res.locals.userId).replace(/\"/g, ''));
   return next();
 };
 
 // Middleware to delete a cookie upon user logging out
-cookieController.deleteCookie = (req, res, next) => {
+cookieController.deleteCookie = (req/*: Request*/, res/*: Response*/, next/*: NextFunction*/)/*: void*/ => {
   res.clearCookie('ssid');
   return next();
 };

server/controllers/sessionController.js

@@ -1,28 +1,35 @@
+/**  using import statements in the electron / node files breaks npm start and nodepty 
+* - types are left in place in these files for future iteration alternate import method is required for them to function
+*/
+// import { ErrorRequestHandler, NextFunction, Request, Response } from "express";
+// import { MongoError, FindCursor } from "mongodb";
+// import { sessionControllerType } from "../utils/backendTypes";
+
 // Import the session model that defines schema of session
 const Session = require('../models/sessionModel');
 
-const sessionController = {};
+const sessionController /*:sessionControllerType*/ = {};
 
 // Middleware to initialize a session upon successful login
-sessionController.startSession = (req, res, next) => {
-  Session.create({ cookieId: res.locals.userId }, (err, result) => {
+sessionController.startSession = (req /* : Request */, res /* : Response */, next /* : NextFunction */) /* : void */ => {
+  Session.create({ cookieId: res.locals.userId }, (err /* : MongoError */, result /* : void */) /* : void */ => {
     if (err && err.code !== 11000) return next(err);
     res.locals.ssid = res.locals.userId;
     return next();
   });
 };
 
 // Middleware to end currently active sessions, if any
-sessionController.endSession = (req, res, next) => {
-  Session.deleteMany({ cookieId: req.cookies.ssid }, (err) => {
+sessionController.endSession = (req /* : Request */, res /*: Response */, next /* : NextFunction */)/*: void*/ => {
+  Session.deleteMany({ cookieId: req.cookies.ssid }, (err /* : ErrorRequestHandler */) /* void */ => {
     if (err) return next(err);
     return next();
   });
 };
 
 // Middleware to check if entered user is currently already logged in
-sessionController.isLoggedIn = (req, res, next) => {
-  Session.find({ cookieId: req.cookies.ssid }, (err, data) => {
+sessionController.isLoggedIn = (req /* :Request*/, res /* Response*/, next /* : NextFunction */) /* void */ => {
+  Session.find({ cookieId: req.cookies.ssid }, (err /* : ErrorRequestHandler */, data /* : Array<{cookieId: String, createdAt: Date}> */) /* void */ => {
     if (err) return next(err);
     if (data.length === 0) return next('User Not Logged In');
     return next();

server/controllers/testStateController.js

@@ -1,29 +1,37 @@
+/**  using import statements in the electron / node files breaks npm start and nodepty 
+* - types are left in place in these files for future iteration alternate import method is required for them to function
+*/
+// import { ErrorRequestHandler, NextFunction, Request, Response } from "express";
+// import { FindCursor } from "mongodb";
+// import { testStateControllerType } from "../utils/backendTypes";
+
 // Import test state model that defines the structure of test stored in DB
 const TestState = require('../models/testStateModel');
-const testStateController = {};
+const testStateController /* :testStateControllerType */ = {};
 
 // Middleware to upload a passed test into DB
-testStateController.upload = (req, res, next) => {
-  const { testName, testType, testState } = req.body;
-  const userId = req.cookies.ssid;
+testStateController.upload = (req /* : Request */, res /* : Response */, next /* : NextFunction */) /* : void */ => {
+  const { testName, testType, testState }/*: 
+  { testName : string, testType : string, testState : Object }*/ = req.body;
+  const userId /* : number */ = req.cookies.ssid;
 
   TestState.create(
     {
-      userId,
-      testName,
-      testType,
-      testState
+      userId: String,
+      testName: String,
+      testType: String,
+      testState: Object
     },
-    (err) => {
+    (err /* : Error */) /* : void */ => {
       if (err) return next('Upload Failed');
       return next();
     }
   );
 };
 
 // Middleware too get all saved tests of current user and of selected type
-testStateController.getTests = (req, res, next) => {
-  TestState.find({ userId: req.cookies.ssid, testType: req.params.testType }, (err, result) => {
+testStateController.getTests = (req /* : Request */, res /* : Response */, next /* : NextFunction */) => {
+  TestState.find({ userId: req.cookies.ssid, testType: req.params.testType }, (err /* : ErrorRequestHandler */, result /* : FindCursor */) /* : void */ => {
     // If an error occurs, invoke error handler with err object
     if (err) return next(err);
     // Save resulting tests array to locals object

server/controllers/userController.js

@@ -1,89 +1,108 @@
+/**  using import statements in the electron / node files breaks npm start and nodepty 
+* - types are left in place in these files for future iteration alternate import method is required for them to function
+*/
+
+// import { expression } from "@babel/template";
+// import { ErrorRequestHandler, NextFunction, Request, Response } from "express";
+// import { Cursor } from "mongoose";
+// import { BasicGroupByOptions } from "rxjs";
+// import { userControllerType } from "../utils/backendTypes";
+
+/**
+ * Errors on lines 89-90 and 97-98 are due to Typescript not recognizing inherent _id property on MongoDB collections.
+ */
+
+
 const { User } = require('../models/userModel');
 const bcrypt = require('bcryptjs');
 
-const userController = {};
+const userController/*: userControllerType*/ = {
 
-// Middleware to encrypt passwords using bcrypt
-userController.bcrypt = (req, res, next) => {
-  // The cost factor determines how much time is needed to calculate a single bcrypt hash
-  const saltRounds = 10;
-  // Destructure password from request body
-  const { password } = req.body;
-  // Generate the salt by passing in saltRounds (cost factor)
-  bcrypt.genSalt(saltRounds, (err, salt) => {
-    // Hash a password by passing in the plaintext into the hash function
-    bcrypt.hash(password, salt, (err, hash) => {
-      // Save encrypted password into res.locals to be accessed later
-      res.locals.encryptedPassword = hash;
-      return next();
+  // Middleware to encrypt passwords using bcrypt
+  bcrypt: (req/*: Request*/, res/*: Response*/, next/*: NextFunction*/)/*: void*/ => {
+    // The cost factor determines how much time is needed to calculate a single bcrypt hash
+    const saltRounds = 10;
+    // Destructure password from request body
+    const { password }/*: { password: String }*/ = req.body;
+    // Generate the salt by passing in saltRounds (cost factor)
+    bcrypt.genSalt(saltRounds, (err/*: ErrorRequestHandler*/, salt/*: String*/)/*: void*/ => {
+      // Hash a password by passing in the plaintext into the hash function
+      bcrypt.hash(password, salt, (err/*: ErrorRequestHandler*/, hash/*: String*/)/*: void*/ => {
+        // Save encrypted password into res.locals to be accessed later
+        res.locals.encryptedPassword = hash;
+        return next();
+      });
     });
-  });
-};
+  },
+
+  // Middleware to save user information in database
+  signup: (req/*: Request*/, res/*: Response*/, next/*: NextFunction*/)/*: (void | Response)*/ => {
+    // collection.create method to insert new user
+    User.create(
+      // Pass in username from request body and encrypted password
+      { username/*: req.body.username*/, password/*: res.locals.encryptedPassword*/ },
+      // Callback to handle results of query
+      (err/*: ErrorRequestHandler*/, newUser/*: (null | undefined | { _id: number })*/) => {
+        if (!newUser) return res.status(400).json("Username already exists, please choose another one.");
+        // If there is an error, invoke global error handler
+        if (err) return next(err);
+        // Save user ID into response locals
+        res.locals.userId = newUser._id;
+        // Inovke next middleware
+        return next();
+      }
+    );
+  },
 
-// Middleware to save user information in database
-userController.signup = (req, res, next) => {
-  // collection.create method to insert new user
-  User.create(
-    // Pass in username from request body and encrypted password
-    { username: req.body.username, password: res.locals.encryptedPassword },
-    // Callback to handle results of query
-    (err, newUser) => {
-      if (!newUser) return res.status(400).json("Username already exists, please choose another one.");
+  // Middleware to check credentials and log user into application
+  login: (req/*: Request*/, res/*: Response*/, next/*: NextFunction*/)/*: void*/ => {
+    // Collection.find method to look for all user instances with passed username
+    User.find({ username/*: req.body.username*/ }, (err/*: ErrorRequestHandler*/, 
+      result/*: Array<{ _id: number, username: String, password: String }>*/)/*: void*/ => {
       // If there is an error, invoke global error handler
       if (err) return next(err);
-      // Save user ID into response locals
-      res.locals.userId = newUser._id;
-      // Inovke next middleware
-      return next();
-    }
-  );
-};
+      // If there are no matching usernames, invoke global error handler
+      if (result.length === 0) return next('Incorrect username/password combo');
+      // If there is a user with passed username, use the bcrypt.compare method to compare plaintext password with encrypted password
+      bcrypt.compare(req.body.password, result[0].password, (err/*: ErrorRequestHandler*/, match/*: boolean*/) => {
+        // If an error occurs in the compare method, invoke global error handler
+        if (err) return next(err);
+        // If there is a match, invoke next middleware
+        if (match) {
+          res.locals.userId = result[0]._id;
+          return next();
+        }
+        // If there is no match, invoke global error handler
+        return next('Incorrect username/password combination');
+      });
+    });
+  },
 
-// Middleware to check credentials and log user into application
-userController.login = (req, res, next) => {
-  // Collection.find method to look for all user instances with passed username
-  User.find({ username: req.body.username }, (err, result) => {
-    // If there is an error, invoke global error handler
-    if (err) return next(err);
-    // If there are no matching usernames, invoke global error handler
-    if (result.length === 0) return next('Incorrect username/password combo');
-    // If there is a user with passed username, use the bcrypt.compare method to compare plaintext password with encrypted password
-    bcrypt.compare(req.body.password, result[0].password, (err, match) => {
-      // If an error occurs in the compare method, invoke global error handler
+  getUsers: (req/*: Request*/, res/*: Response*/, next/*: NextFunction*/)/*: void*/ => {
+    // Collection.find method to look for all user instances with passed username
+    User.find({}, (err/*: ErrorRequestHandler*/, result/*: Array<{ _id: number, username: String, password: String }>*/) => {
+      // If there is an error, invoke global error handler
       if (err) return next(err);
-      // If there is a match, invoke next middleware
-      if (match) {
-        res.locals.userId = result[0]._id;
-        return next();
-      }
-      // If there is no match, invoke global error handler
-      return next('Incorrect username/password combination');
+      res.locals.users = result;
+      return next();
     });
-  });
-};
+  },
 
-userController.getUsers = (req, res, next) => {
-  // Collection.find method to look for all user instances with passed username
-  User.find({}, (err, result) => {
-    // If there is an error, invoke global error handler
-    if (err) return next(err);
-    res.locals.users = result;
-    return next();
-  });
-};
-
-userController.githubLogin = (req, res, next) => {
-  // store user._id in res.locals
-  res.locals.userId = req.user._id;
+  githubLogin: (req/*: Request*/, res/*: Response*/, next/*: NextFunction*/)/*: void*/ => {
+    // store user._id in res.locals
+    if(!req.user || !req.user._id) throw new Error("User or user ID not defined.")
+    res.locals.userId = req.user._id;
 
-  return next();
-};
+    return next();
+  },
 
-userController.googleLogin = (req, res, next) => {
-  // store user._id in res.locals
-  res.locals.userId = req.user._id;
+  googleLogin: (req/*: Request*/, res/*: Response*/, next/*: NextFunction*/)/*: void*/ => {
+    // store user._id in res.locals
+    if(!req.user || !req.user._id) throw new Error("User or user ID not defined.")
+    res.locals.userId = req.user._id;
 
-  return next();
+    return next();
+  }
 };
 
 module.exports = userController;

server/models/sessionModel.js

@@ -1,10 +1,16 @@
+/**  using import statements in the electron / node files breaks npm start and nodepty 
+* - types are left in place in these files for future iteration alternate import method is required for them to function
+*/
+
+// import { Schema as SchemaType } from "mongoose";
+
 // Import mongoose for MongoDB object modeling
 const mongoose = require('mongoose');
 // Schema constructor
 const Schema = mongoose.Schema;
 
 // Initialize a new schema object for collection 'session'
-const sessionSchema = new Schema({
+const sessionSchema/* : SchemaType */ = new Schema({
   // Save user ID
   cookieId: { type: String, required: true, unique: true },
   createdAt: { type: Date, default: Date.now },