changed code according to eslint

Author: maxeth

server/src/db/index.ts

@@ -1,15 +1,15 @@
-import { createConnection } from "typeorm";
+import { createConnection } from 'typeorm';
 
-export default async function establishConnection() {
+export default async function establishConnection(): Promise<void> {
   let reconnectionCount = 0;
-  const establishDbConnection = async () => {
+  const establishDbConnection = async (): Promise<void> => {
     if (reconnectionCount > 5) {
-      console.log("Failed connection to db after 5 total attempts.");
+      console.log('Failed connection to db after 5 total attempts.');
       return;
     }
     try {
       await createConnection();
-      console.log("Established Typeorm connection to postgres");
+      console.log('Established Typeorm connection to postgres');
     } catch (err) {
       console.log(
         `Failed connecting to db. attempts left:${5 - reconnectionCount}`

server/src/entity/User/User.ts

@@ -1,9 +1,9 @@
-import { Entity, PrimaryGeneratedColumn, Column, BaseEntity } from "typeorm";
-import isValidEmail from "../../helpers/is-valid-email";
-import { ObjectType, Field, Int } from "type-graphql";
+import { Entity, PrimaryGeneratedColumn, Column, BaseEntity } from 'typeorm';
+import isValidEmail from '../../helpers/is-valid-email';
+import { ObjectType, Field, Int } from 'type-graphql';
 
 @ObjectType() // for gql
-@Entity("users")
+@Entity('users')
 export class User extends BaseEntity {
   @Field(() => Int) // for gql
   @PrimaryGeneratedColumn()
@@ -16,14 +16,14 @@ export class User extends BaseEntity {
   lastName?: string;
 
   @Field()
-  @Column("text")
+  @Column('text')
   email: string;
 
   @Field()
-  @Column("text", { nullable: true })
+  @Column('text', { nullable: true })
   username?: string;
 
-  @Column("text")
+  @Column('text')
   password: string;
 
   constructor(email: string, password: string, username?: string) {
@@ -34,45 +34,44 @@ export class User extends BaseEntity {
   }
 }
 
-export function validateUser(userInfo: User): Promise<User> {
-  return new Promise(async (resolve, reject) => {
+export function validateUser(
+  userInfo: User
+): Promise<User | Record<string, unknown>> {
+  return new Promise((resolve, reject) => {
     const { password, email } = userInfo;
     if (!password || !email) {
-      reject({ emailOrPassword: "Email and password required." });
+      reject({ emailOrPassword: 'Email and password required.' });
     }
 
-    let validPassword;
-    try {
-      validPassword = await validatePassword(password);
-    } catch (err) {
-      // err is of format {field: "errorMsg"}
-      return reject(err);
-    }
-    let validEmail;
-    try {
-      validEmail = await validateEmail(email);
-    } catch (err) {
-      return reject(err);
-    }
+    (async () => {
+      // dont use async as promise executor, e.g. async (resolve, reject) => ...
+      await validatePassword(password).catch((err) => reject(err));
+
+      await validateEmail(email).catch((err) => reject(err));
+    })();
 
     return resolve(userInfo);
   });
 }
 
-function validatePassword(password: string) {
+function validatePassword(
+  password: string
+): Promise<string | Record<string, unknown>> {
   return new Promise((resolve, reject) => {
     if (!password || password.length < 6) {
-      console.log("password error");
-      reject({ password: "Password must be at least 6 characters long." });
+      console.log('password error');
+      reject({ password: 'Password must be at least 6 characters long.' });
     }
     resolve(password);
   });
 }
 
-function validateEmail(email: string) {
+function validateEmail(
+  email: string
+): Promise<string | Record<string, unknown>> {
   return new Promise((resolve, reject) => {
     if (!email || !isValidEmail(email)) {
-      reject({ email: "Invalid email" });
+      reject({ email: 'Invalid email' });
     }
     resolve(email);
   });

server/src/entity/User/makeUserManager.ts

@@ -1,5 +1,8 @@
-import { User } from "./User";
-export default function makeUserManager() {
+import { User } from './User';
+export default function makeUserManager(): Readonly<{
+  insert: (user: User) => Promise<void>;
+  findByEmail: (email: string) => Promise<User | null>;
+}> {
   return Object.freeze({
     insert,
     findByEmail,
@@ -9,16 +12,20 @@ export default function makeUserManager() {
     // update,
   });
 
-  async function insert(user: User) {
-    User.insert({ ...user });
+  async function insert(user: User): Promise<void> {
+    try {
+      User.insert({ ...user });
+    } catch (err) {
+      console.log(err);
+    }
   }
-  async function findByEmail(email: string) {
+  async function findByEmail(email: string): Promise<User | null> {
     let response;
     try {
       const res = await User.findOne({ where: { email } });
       response = res;
-    } catch (e) {
-      console.log(e);
+    } catch (err) {
+      console.log(err);
     }
     return response || null;
   }

server/src/helpers/auth.ts

@@ -1,37 +1,37 @@
-import { User } from "../entity/User/User";
-import { sign, verify } from "jsonwebtoken";
-import { MyContext } from "../types/MyContext";
+import { User } from '../entity/User/User';
+import { sign, verify } from 'jsonwebtoken';
+import { MyContext } from '../types/MyContext';
 
 const jwtSecret = process.env.JWT_SECRET as string;
 
-export const createRefreshToken = (user: User) => {
+export const createRefreshToken = (user: User): string | null => {
   let signedString = null;
   try {
     signedString = sign(
       { userId: user.id, email: user.email },
       process.env.JWT_REFRESH_SECRET as string,
-      { expiresIn: "14d" }
+      { expiresIn: '14d' }
     );
   } catch (err) {
     console.log(err);
   }
   return signedString;
 };
 
-export const createAccessToken = (user: User) => {
+export const createAccessToken = (user: User): string => {
   console.log(jwtSecret);
   return sign({ userId: user.id, email: user.email }, jwtSecret, {
-    expiresIn: "15m",
+    expiresIn: '15m',
   });
 };
 export const verifyToken = (
   jwtToken: string
-): MyContext["jwtPayload"] | null => {
+): MyContext['jwtPayload'] | null => {
   let payload = null;
   try {
     payload = verify(jwtToken, jwtSecret);
   } catch (err) {
     return null;
   }
-  return payload as MyContext["jwtPayload"];
+  return payload as MyContext['jwtPayload'];
 };

server/src/helpers/errors/errors.ts

@@ -2,25 +2,27 @@ import {
   UserInputError,
   ApolloError,
   AuthenticationError,
-} from "apollo-server-express";
+} from 'apollo-server-express';
 
-export const makeAuthenticationError = () => {
-  return new AuthenticationError("Not authorized. Login required.");
+export const makeAuthenticationError = (): AuthenticationError => {
+  return new AuthenticationError('Not authorized. Login required.');
 };
 
-export const makeLoginError = () => {
-  const validationErrors = { input: "Password and Email not matching" };
-  return new UserInputError("Login failed.", { validationErrors });
+export const makeLoginError = (): UserInputError => {
+  const validationErrors = { input: 'Password and Email not matching' };
+  return new UserInputError('Login failed.', { validationErrors });
 };
 
-export const serverError = new ApolloError("Internal server error.");
+export const serverError = new ApolloError('Internal server error.');
 
-export const makeUserInputError = (errorFields?: {}) => {
+export const makeUserInputError = (
+  errorFields?: Record<string, unknown>
+): UserInputError => {
   const validationErrors = errorFields ? { ...errorFields } : null;
   if (errorFields) {
-    return new UserInputError("Bad User input.", { validationErrors });
+    return new UserInputError('Bad User input.', { validationErrors });
   }
-  return new UserInputError("Bad User input.");
+  return new UserInputError('Bad User input.');
 };
 
 export class UniqueConstraintError extends Error {

server/src/helpers/is-valid-email.ts

@@ -1,4 +1,4 @@
-export default function isValidEmail(email: string) {
+export default function isValidEmail(email: string): boolean {
   const valid = new RegExp(/^[^@\s]+@[^@\s]+\.[^@\s]+$/);
   return valid.test(email);
 }

server/src/index.ts

@@ -1,25 +1,25 @@
-import "reflect-metadata";
-require("dotenv-safe").config();
-
-import establishDbConnection from "./db";
-import { ApolloServer } from "apollo-server-express";
-import { buildSchema } from "type-graphql";
-import express from "express";
-import { UserResolver } from "./resolvers/UserResolver";
-import cors from "cors";
+import 'reflect-metadata';
+import dotenv from 'dotenv';
+dotenv.config();
+import establishDbConnection from './db';
+import { ApolloServer } from 'apollo-server-express';
+import { buildSchema } from 'type-graphql';
+import express from 'express';
+import { UserResolver } from './resolvers/UserResolver';
+import cors from 'cors';
 
 (async () => {
   await establishDbConnection();
 
   const app = express();
 
-  app.set("trust proxy", 1);
+  app.set('trust proxy', 1);
   // for cookie forwarding since server sits behind the nginx proxy
 
   app.use(cors());
 
-  app.get("/state/pulse", (_req, res) => res.send({ alive: true }));
-  app.get("/");
+  app.get('/state/pulse', (_req, res) => res.send({ alive: true }));
+  app.get('/');
 
   const apolloServer = new ApolloServer({
     schema: await buildSchema({
@@ -31,6 +31,6 @@ import cors from "cors";
   apolloServer.applyMiddleware({ app, cors: false });
 
   app.listen(8080, () => {
-    console.log("express server started");
+    console.log('express server started');
   });
 })();

server/src/resolvers/UserResolver.ts

@@ -1,23 +1,23 @@
-import { validateUser, User } from "../entity/User/User";
+import { validateUser, User } from '../entity/User/User';
 import {
   Resolver,
   Query,
   Mutation,
   Arg,
   Ctx,
   UseMiddleware,
-} from "type-graphql";
-import argon2, { hash } from "argon2";
-import makeUserManager from "../entity/User/makeUserManager";
-import { LoginResponse } from "../entity/User/responses";
-import { MyContext } from "../types/MyContext";
-import { createRefreshToken, createAccessToken } from "../helpers/auth";
+} from 'type-graphql';
+import argon2 from 'argon2';
+import makeUserManager from '../entity/User/makeUserManager';
+import { LoginResponse } from '../entity/User/responses';
+import { MyContext } from '../types/MyContext';
+import { createRefreshToken, createAccessToken } from '../helpers/auth';
 import {
   makeLoginError,
   serverError,
   makeUserInputError,
-} from "../helpers/errors/errors";
-import { isAuth } from "../middleware/isAuth";
+} from '../helpers/errors/errors';
+import { isAuth } from '../middleware/isAuth';
 
 // require("dotenv-safe").config();
 
@@ -27,28 +27,30 @@ const UserManager = makeUserManager();
 export class UserResolver {
   @Query(() => User, { nullable: true })
   @UseMiddleware(isAuth)
-  async user(@Ctx() { jwtPayload }: MyContext) {
-    const user = await UserManager.findByEmail(jwtPayload!.email);
+  async user(@Ctx() { jwtPayload }: MyContext): Promise<User | null> {
+    if (!jwtPayload) return null;
+    const user = await UserManager.findByEmail(jwtPayload.email);
     if (!user) return null;
     return user;
   }
 
   @Mutation(() => Boolean)
   async register(
-    @Arg("email") email: string,
-    @Arg("password") password: string
-  ) {
+    @Arg('email') email: string,
+    @Arg('password') password: string
+  ): Promise<boolean> {
     const user = await validateUser(new User(email, password)).catch((err) => {
       throw makeUserInputError(err);
     });
 
     const existingUser = await UserManager.findByEmail(email).catch((err) => {
+      console.log(err);
       throw serverError;
     });
 
     if (existingUser) {
       throw makeUserInputError({
-        email: "Account with this Email already exists",
+        email: 'Account with this Email already exists',
       });
     }
 
@@ -64,9 +66,9 @@ export class UserResolver {
 
   @Mutation(() => LoginResponse)
   async login(
-    @Arg("email") email: string,
-    @Arg("password") password: string,
-    @Ctx() { req, res }: MyContext
+    @Arg('email') email: string,
+    @Arg('password') password: string,
+    @Ctx() { res }: MyContext
   ): Promise<LoginResponse> {
     let user = null;
 
@@ -86,7 +88,7 @@ export class UserResolver {
     try {
       if (await argon2.verify(user.password, password)) {
         const token = createAccessToken(user);
-        res.cookie("jt", createRefreshToken(user), { httpOnly: true });
+        res.cookie('jt', createRefreshToken(user), { httpOnly: true });
         return { accessToken: token };
       } else {
         throw makeLoginError();

server/src/types/MyContext.ts

@@ -1,5 +1,5 @@
-import { Request, Response } from "express";
-import { JwtPayload } from "./JwtPayload";
+import { Request, Response } from 'express';
+import { JwtPayload } from './JwtPayload';
 export type MyContext = {
   req: Request;
   res: Response;