reverted server TS files to JS and commented out type annotations

Author: Cartlong7

server/config/passport.ts renamed to server/config/passport.js

@@ -1,12 +1,15 @@
-import { TablePaginationUnstyledSpacerSlotProps } from "@mui/base";
-import { Error } from "mongoose";
-import { Authenticator, Profile } from "passport";
+/**  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: Authenticator) {
+module.exports = function (passport/*:  Authenticator */) {
   passport.use(
     new GitHubStrategy(
       {
@@ -15,10 +18,10 @@ module.exports = function (passport: Authenticator) {
         callbackURL: 'http://localhost:3001/auth/github/callback',
       },
 
-      (accessToken: String, refreshToken: (String | undefined), profile: Profile, done: Function): void => {
+      (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: Error, result: { githubId: String, username: String }): void => {
+        GithubUser.findOne({ githubId: profile.id }, (err/* : Error */, result/* : { githubId: String, username: String } */)/* : void */ => {
           if (result) {
             // already have this user
             //console.log('user is: ', result);
@@ -31,7 +34,7 @@ module.exports = function (passport: Authenticator) {
               username: profile.displayName,
             })
               .save()
-              .then((newUser): void => {
+              .then((newUser)/* : void  */=> {
                 //console.log('created new user: ', newUser);
                 //   res.locals.userId = newUser._id
                 done(null, newUser);
@@ -52,10 +55,10 @@ module.exports = function (passport: Authenticator) {
         callbackURL: 'http://localhost:3001/auth/google/callback',
       },
 
-      (accessToken: String, refreshToken: (String | undefined), profile: Profile, done: Function): void => {
+      (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: Error, result: {googleId: String, username: String}) => {
+        GoogleUser.findOne({ googleId: profile.id }, (err/* : Error */, result/* : {googleId: String, username: String} */) => {
           if (result) {
             // already have this user
             //console.log('user is: ', result);
@@ -67,7 +70,7 @@ module.exports = function (passport: Authenticator) {
               googleId: profile.id,
             })
               .save()
-              .then((newUser): void => {
+              .then((newUser)/* : void  */=> {
                 //console.log('created new user: ', newUser);
                 //   res.locals.userId = newUser._id
                 done(null, newUser);
@@ -80,11 +83,11 @@ module.exports = function (passport: Authenticator) {
     )
   );
 
-  passport.serializeUser((user, done): void => {
+  passport.serializeUser((user, done)/* : void  */=> {
     done(null, user);
   });
 
-  passport.deserializeUser((obj: (false | Express.User | null | undefined), done): void => {
+  passport.deserializeUser((obj/* : (false | Express.User | null | undefined) */, done)/* : void */ => {
     done(null, obj);
   });
 };

server/controllers/cookieController.js

@@ -0,0 +1,23 @@
+/**  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/*: 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/*: Request*/, res/*: Response*/, next/*: NextFunction*/)/*: void*/ => {
+  res.clearCookie('ssid');
+  return next();
+};
+
+module.exports = cookieController;

server/controllers/cookieController.ts

@@ -0,0 +1,39 @@
+/**  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 /*:sessionControllerType*/ = {};
+
+// Middleware to initialize a session upon successful login
+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 /* : 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 /* :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();
+  });
+};
+
+module.exports = sessionController;

server/controllers/sessionController.js

@@ -0,0 +1,43 @@
+/**  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 /* :testStateControllerType */ = {};
+
+// Middleware to upload a passed test into DB
+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: String,
+      testName: String,
+      testType: String,
+      testState: Object
+    },
+    (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 /* : 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
+    res.locals.tests = result;
+    return next();
+  });
+};
+
+module.exports = testStateController;

server/controllers/sessionController.ts

@@ -1,8 +1,12 @@
-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";
+/**  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.
@@ -12,18 +16,18 @@ import { userControllerType } from "../utils/backendTypes";
 const { User } = require('../models/userModel');
 const bcrypt = require('bcryptjs');
 
-const userController: userControllerType = {
+const userController/*: userControllerType*/ = {
 
   // Middleware to encrypt passwords using bcrypt
-  bcrypt: (req: Request, res: Response, next: NextFunction): void => {
+  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: number = 10;
+    const saltRounds = 10;
     // Destructure password from request body
-    const { password }: { password: String } = req.body;
+    const { password }/*: { password: String }*/ = req.body;
     // Generate the salt by passing in saltRounds (cost factor)
-    bcrypt.genSalt(saltRounds, (err: ErrorRequestHandler, salt: String): void => {
+    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 => {
+      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();
@@ -32,13 +36,13 @@ const userController: userControllerType = {
   },
 
   // Middleware to save user information in database
-  signup: (req: Request, res: Response, next: NextFunction): (void | Response) => {
+  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 },
+      { username/*: req.body.username*/, password/*: res.locals.encryptedPassword*/ },
       // Callback to handle results of query
-      (err: ErrorRequestHandler, newUser: (null | undefined | { _id: number })) => {
+      (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);
@@ -51,16 +55,16 @@ const userController: userControllerType = {
   },
 
   // Middleware to check credentials and log user into application
-  login: (req: Request, res: Response, next: NextFunction): void => {
+  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 => {
+    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);
       // 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) => {
+      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
@@ -74,25 +78,25 @@ const userController: userControllerType = {
     });
   },
 
-  getUsers: (req: Request, res: Response, next: NextFunction): void => {
+  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 }>) => {
+    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);
       res.locals.users = result;
       return next();
     });
   },
 
-  githubLogin: (req: Request, res: Response, next: NextFunction): void => {
+  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();
   },
 
-  googleLogin: (req: Request, res: Response, next: NextFunction): void => {
+  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;