Add eslint rule and fix as many issues as possible

backend/src/controllers/v1/authController.ts

@@ -1,36 +1,36 @@
-import { Request, Response } from 'express';
-import fs from 'fs';
-import path from 'path';
-import jwt from 'jsonwebtoken';
-import * as bigintConversion from 'bigint-conversion';
+import { Request, Response } from "express";
+import fs from "fs";
+import path from "path";
+import jwt from "jsonwebtoken";
+import * as bigintConversion from "bigint-conversion";
 // eslint-disable-next-line @typescript-eslint/no-var-requires
-const jsrp = require('jsrp');
+const jsrp = require("jsrp");
 import { 
-  User, 
-  LoginSRPDetail,
-  TokenVersion
-} from '../../models';
-import { createToken, issueAuthTokens, clearTokens } from '../../helpers/auth';
-import { checkUserDevice } from '../../helpers/user';
+  LoginSRPDetail, 
+  TokenVersion,
+  User,
+} from "../../models";
+import { clearTokens, createToken, issueAuthTokens } from "../../helpers/auth";
+import { checkUserDevice } from "../../helpers/user";
 import {
   ACTION_LOGIN,
   ACTION_LOGOUT,
-  AUTH_MODE_JWT
-} from '../../variables';
+  AUTH_MODE_JWT,
+} from "../../variables";
 import { 
   BadRequestError,
-  UnauthorizedRequestError
-} from '../../utils/errors';
-import { EELogService } from '../../ee/services';
-import { getChannelFromUserAgent } from '../../utils/posthog';
+  UnauthorizedRequestError,
+} from "../../utils/errors";
+import { EELogService } from "../../ee/services";
+import { getChannelFromUserAgent } from "../../utils/posthog";
 import {
-  getJwtRefreshSecret,
+  getHttpsEnabled,
   getJwtAuthLifetime,
   getJwtAuthSecret,
-  getHttpsEnabled
-} from '../../config';
+  getJwtRefreshSecret,
+} from "../../config";
 
-declare module 'jsonwebtoken' {
+declare module "jsonwebtoken" {
   export interface UserIDJwtPayload extends jwt.JwtPayload {
     userId: string;
     refreshVersion?: number;
@@ -46,20 +46,20 @@ declare module 'jsonwebtoken' {
 export const login1 = async (req: Request, res: Response) => {
   const {
     email,
-    clientPublicKey
+    clientPublicKey,
   }: { email: string; clientPublicKey: string } = req.body;
 
   const user = await User.findOne({
-    email
-  }).select('+salt +verifier');
+    email,
+  }).select("+salt +verifier");
 
-  if (!user) throw new Error('Failed to find user');
+  if (!user) throw new Error("Failed to find user");
 
   const server = new jsrp.server();
   server.init(
     {
       salt: user.salt,
-      verifier: user.verifier
+      verifier: user.verifier,
     },
     async () => {
       // generate server-side public key
@@ -73,7 +73,7 @@ export const login1 = async (req: Request, res: Response) => {
 
       return res.status(200).send({
         serverPublicKey,
-        salt: user.salt
+        salt: user.salt,
       });
     }
   );
@@ -89,10 +89,10 @@ export const login1 = async (req: Request, res: Response) => {
 export const login2 = async (req: Request, res: Response) => {
   const { email, clientProof } = req.body;
   const user = await User.findOne({
-    email
-  }).select('+salt +verifier +publicKey +encryptedPrivateKey +iv +tag');
+    email,
+  }).select("+salt +verifier +publicKey +encryptedPrivateKey +iv +tag");
 
-  if (!user) throw new Error('Failed to find user');
+  if (!user) throw new Error("Failed to find user");
 
   const loginSRPDetailFromDB = await LoginSRPDetail.findOneAndDelete({ email: email })
 
@@ -105,7 +105,7 @@ export const login2 = async (req: Request, res: Response) => {
     {
       salt: user.salt,
       verifier: user.verifier,
-      b: loginSRPDetailFromDB.serverBInt
+      b: loginSRPDetailFromDB.serverBInt,
     },
     async () => {
       server.setClientPublicKey(loginSRPDetailFromDB.clientPublicKey);
@@ -117,33 +117,33 @@ export const login2 = async (req: Request, res: Response) => {
         await checkUserDevice({
           user,
           ip: req.realIP,
-          userAgent: req.headers['user-agent'] ?? ''
+          userAgent: req.headers["user-agent"] ?? "",
         });
 
         const tokens = await issueAuthTokens({ 
           userId: user._id,
           ip: req.realIP,
-          userAgent: req.headers['user-agent'] ?? ''
+          userAgent: req.headers["user-agent"] ?? "",
         });
 
         // store (refresh) token in httpOnly cookie
-        res.cookie('jid', tokens.refreshToken, {
+        res.cookie("jid", tokens.refreshToken, {
           httpOnly: true,
-          path: '/',
-          sameSite: 'strict',
-          secure: await getHttpsEnabled()
+          path: "/",
+          sameSite: "strict",
+          secure: await getHttpsEnabled(),
         });
 
         const loginAction = await EELogService.createAction({
           name: ACTION_LOGIN,
-          userId: user._id
+          userId: user._id,
         });
 
         loginAction && await EELogService.createLog({
           userId: user._id,
           actions: [loginAction],
-          channel: getChannelFromUserAgent(req.headers['user-agent']),
-          ipAddress: req.realIP
+          channel: getChannelFromUserAgent(req.headers["user-agent"]),
+          ipAddress: req.realIP,
         });
 
         // return (access) token in response
@@ -152,12 +152,12 @@ export const login2 = async (req: Request, res: Response) => {
           publicKey: user.publicKey,
           encryptedPrivateKey: user.encryptedPrivateKey,
           iv: user.iv,
-          tag: user.tag
+          tag: user.tag,
         });
       }
 
       return res.status(400).send({
-        message: 'Failed to authenticate. Try again?'
+        message: "Failed to authenticate. Try again?",
       });
     }
   );
@@ -175,51 +175,51 @@ export const logout = async (req: Request, res: Response) => {
   }
 
   // clear httpOnly cookie
-  res.cookie('jid', '', {
+  res.cookie("jid", "", {
     httpOnly: true,
-    path: '/',
-    sameSite: 'strict',
-    secure: (await getHttpsEnabled()) as boolean
+    path: "/",
+    sameSite: "strict",
+    secure: (await getHttpsEnabled()) as boolean,
   });
 
   const logoutAction = await EELogService.createAction({
     name: ACTION_LOGOUT,
-    userId: req.user._id
+    userId: req.user._id,
   });
 
   logoutAction && await EELogService.createLog({
     userId: req.user._id,
     actions: [logoutAction],
-    channel: getChannelFromUserAgent(req.headers['user-agent']),
-    ipAddress: req.realIP
+    channel: getChannelFromUserAgent(req.headers["user-agent"]),
+    ipAddress: req.realIP,
   });
 
   return res.status(200).send({
-    message: 'Successfully logged out.'
+    message: "Successfully logged out.",
   });
 };
 
 export const getCommonPasswords = async (req: Request, res: Response) => {
   const commonPasswords = fs.readFileSync(
-		path.resolve(__dirname, '../../data/' + 'common_passwords.txt'),
-		'utf8'
-	).split('\n');	
+		path.resolve(__dirname, "../../data/" + "common_passwords.txt"),
+		"utf8"
+	).split("\n");	
 
   return res.status(200).send(commonPasswords);
 }
 
 export const revokeAllSessions = async (req: Request, res: Response) => {
   await TokenVersion.updateMany({
-    user: req.user._id
+    user: req.user._id,
   }, {
     $inc: {
       refreshVersion: 1,
-      accessVersion: 1
-    }
+      accessVersion: 1,
+    },
   });
 
   return res.status(200).send({
-    message: 'Successfully revoked all sessions.'
+    message: "Successfully revoked all sessions.",
   }); 
 }
 
@@ -231,7 +231,7 @@ export const revokeAllSessions = async (req: Request, res: Response) => {
  */
 export const checkAuth = async (req: Request, res: Response) => {
   return res.status(200).send({
-    message: 'Authenticated'
+    message: "Authenticated",
   });
 }
 
@@ -245,7 +245,7 @@ export const getNewToken = async (req: Request, res: Response) => {
   const refreshToken = req.cookies.jid;
 
   if (!refreshToken) {
-    throw new Error('Failed to find refresh token in request cookies');
+    throw new Error("Failed to find refresh token in request cookies");
   }
 
   const decodedToken = <jwt.UserIDJwtPayload>(
@@ -253,35 +253,35 @@ export const getNewToken = async (req: Request, res: Response) => {
   );
 
   const user = await User.findOne({
-    _id: decodedToken.userId
-  }).select('+publicKey +refreshVersion +accessVersion');
+    _id: decodedToken.userId,
+  }).select("+publicKey +refreshVersion +accessVersion");
 
-  if (!user) throw new Error('Failed to authenticate unfound user');
+  if (!user) throw new Error("Failed to authenticate unfound user");
   if (!user?.publicKey)
-    throw new Error('Failed to authenticate not fully set up account');
+    throw new Error("Failed to authenticate not fully set up account");
   
   const tokenVersion = await TokenVersion.findById(decodedToken.tokenVersionId);
 
   if (!tokenVersion) throw UnauthorizedRequestError({
-    message: 'Failed to validate refresh token'
+    message: "Failed to validate refresh token",
   });
 
   if (decodedToken.refreshVersion !== tokenVersion.refreshVersion) throw BadRequestError({
-    message: 'Failed to validate refresh token'
+    message: "Failed to validate refresh token",
   });
 
   const token = createToken({
     payload: {
       userId: decodedToken.userId,
       tokenVersionId: tokenVersion._id.toString(),
-      accessVersion: tokenVersion.refreshVersion
+      accessVersion: tokenVersion.refreshVersion,
     },
     expiresIn: await getJwtAuthLifetime(),
-    secret: await getJwtAuthSecret()
+    secret: await getJwtAuthSecret(),
   });
 
   return res.status(200).send({
-    token
+    token,
   });
 };