ts avoid using ! in function logic

Author: eldpswp99

package-lock.json

@@ -27,7 +27,7 @@ const ENV: string | undefined = process.env.NODE_ENV;
     TypeOrmModule.forRoot({
       type: 'mysql',
       host: process.env.DATABASE_HOST,
-      port: +process.env.DATABASE_PORT!,
+      port: +(process.env.DATABASE_PORT ?? 3306),
       username: process.env.DATABASE_USER,
       password: process.env.DATABASE_PASSWORD,
       database: process.env.DATABASE_DBNAME,

src/app.module.ts

@@ -1,4 +1,4 @@
-import { Injectable } from '@nestjs/common';
+import { Injectable, UnauthorizedException } from '@nestjs/common';
 import { JwtService } from '@nestjs/jwt';
 import * as bcrypt from 'bcrypt';
 import { User } from '../user/user.entity';
@@ -19,7 +19,9 @@ export class AuthService {
     return undefined;
   }
 
-  async login(user: User): Promise<User> {
+  async login(user: User | undefined): Promise<User> {
+    if (!user) throw new UnauthorizedException();
+
     const payload: Payload = { username: user.username, id: user.id };
 
     const accessToken = this.jwtService.sign(payload, {
@@ -34,7 +36,9 @@ export class AuthService {
       +process.env.SALT_ROUND!,
     );
     await User.save(user);
-    user = (await User.findOneWithKeyword({ id: user.id }))!;
+    user = await User.findOneWithKeyword({ id: user.id });
+
+    if (!user) throw new UnauthorizedException();
     user.access_token = accessToken;
     user.refresh_token = refreshToken;
 

src/auth/auth.service.ts

@@ -19,7 +19,7 @@ export class JwtAccessStrategy extends PassportStrategy(
   }
 
   async validate(payload: Payload): Promise<User> {
-    const user: User = (await User.findOne({ id: payload.id }))!;
+    const user: User | undefined = await User.findOne({ id: payload.id });
     if (!user) throw new UnauthorizedException();
     return user;
   }

src/auth/jwt-access.strategy.ts

@@ -19,11 +19,15 @@ export class JwtRefreshStrategy extends PassportStrategy(
   }
 
   async validate(request: Request, payload: Payload): Promise<User> {
-    const refreshToken = request.headers.authorization!.replace('Bearer ', '');
-    const user: User = (await User.findOneIfRefreshTokenMatches(
+    if (!request.headers.authorization) throw new UnauthorizedException();
+    const refreshToken: string = request.headers.authorization.replace(
+      'Bearer ',
+      '',
+    );
+    const user: User | undefined = await User.findOneIfRefreshTokenMatches(
       refreshToken,
       payload.id,
-    ))!;
+    );
     if (!user) throw new UnauthorizedException();
     return user;
   }

src/auth/jwt-refresh.strategy.ts

@@ -11,10 +11,10 @@ export class LocalStrategy extends PassportStrategy(Strategy) {
   }
 
   async validate(username: string, password: string): Promise<User> {
-    const user: User = (await this.authService.validateUser(
+    const user: User | undefined = await this.authService.validateUser(
       username,
       password,
-    ))!;
+    );
     if (!user) {
       throw new UnauthorizedException();
     }

src/auth/local.strategy.ts

@@ -5,14 +5,17 @@ export const departmentInit = async (): Promise<void> => {
   for (const departmentData of DEPARTMENTS) {
     const { name, tags } = departmentData;
 
-    let department: Department = (await Department.findOne({ name }))!;
+    let department: Department | undefined = await Department.findOne({ name });
     if (!department) {
       department = Department.create({ name });
       await Department.save(department);
     }
 
     for (const tagName of tags) {
-      let tag: Tag = (await Tag.findOne({ name: tagName, department }))!;
+      let tag: Tag | undefined = await Tag.findOne({
+        name: tagName,
+        department,
+      });
       if (!tag) {
         tag = Tag.create({ name: tagName, department });
         await Tag.save(tag);

src/department/department.init.ts

@@ -5,6 +5,7 @@ import {
   Injectable,
   NotFoundException,
   Req,
+  UnauthorizedException,
 } from '@nestjs/common';
 import { PreFollow, UserRequest } from '../types/custom-type';
 import { Department, Tag, UserTag } from './department.entity';
@@ -22,7 +23,7 @@ export class DepartmentService {
     return departments
       ? await Promise.all(
           departments.map(async (department) => {
-            department.follow = await this.getFollow(department, req.user!);
+            department.follow = await this.getFollow(department, req.user);
             return department;
           }),
         )
@@ -33,19 +34,23 @@ export class DepartmentService {
     @Req() req: UserRequest,
     id: number,
   ): Promise<Department> {
-    const department: Department = (await Department.findOne(id, {
+    const department: Department | undefined = await Department.findOne(id, {
       relations: ['tags'],
-    }))!;
+    });
     if (!department) {
       throw new NotFoundException('There is no department with the given id');
     }
 
-    department.follow = await this.getFollow(department, req.user!);
+    department.follow = await this.getFollow(department, req.user);
     return department;
   }
 
-  async getFollow(department: Department, user: User): Promise<string[]> {
-    user = (await User.findOne(user))!;
+  async getFollow(
+    department: Department,
+    user: User | undefined,
+  ): Promise<string[]> {
+    user = await User.findOne(user);
+    if (!user) throw new UnauthorizedException();
     const tags: Tag[] = await Tag.find({
       department,
     });
@@ -65,26 +70,27 @@ export class DepartmentService {
     id: number,
     followData: FollowDto,
   ): Promise<PreFollow> {
-    const department: Department = (await Department.findOne(id, {
+    const department: Department | undefined = await Department.findOne(id, {
       relations: ['tags'],
-    }))!;
+    });
     if (!department) {
       throw new NotFoundException('There is no department with the id');
     }
 
-    const tag: Tag = department.tags.find(
+    const tag: Tag | undefined = department.tags.find(
       (tag) => tag.name === followData.follow,
-    )!;
+    );
     if (!tag) {
       throw new BadRequestException(
         `There is no tag with the given name: ${followData.follow}`,
       );
     }
-    const user: User = (await User.findOne(req.user))!;
-    const userTag: UserTag = (await UserTag.findOne({
+    const user: User | undefined = await User.findOne(req.user);
+    if (!user) throw new UnauthorizedException();
+    const userTag: UserTag | undefined = await UserTag.findOne({
       user,
       tag,
-    }))!;
+    });
 
     return {
       department,

src/department/department.service.ts

@@ -8,12 +8,12 @@ export class Payload {
 }
 
 export interface UserRequest extends Request {
-  user?: User;
+  user: User;
 }
 
 export interface PreFollow {
   department: Department;
   tag: Tag;
   user: User;
-  userTag: UserTag;
+  userTag?: UserTag;
 }

src/types/custom-type.ts

@@ -34,8 +34,8 @@ export class UserController {
   async update(
     @Req() req: UserRequest,
     @Body() userData: UpdateUserDto,
-  ): Promise<User> {
-    return (await this.userService.update(req, userData))!;
+  ): Promise<User | undefined> {
+    return await this.userService.update(req, userData);
   }
 
   @Post()
@@ -59,7 +59,7 @@ export class UserController {
     @Req() req: UserRequest,
     @Body() keywordData: KeywordDto,
   ): Promise<User> {
-    return (await this.userService.createKeyword(req, keywordData))!;
+    return await this.userService.createKeyword(req, keywordData);
   }
 
   @UseGuards(JwtAccessGuard)
@@ -68,6 +68,6 @@ export class UserController {
     @Req() req: UserRequest,
     @Body() keyword: KeywordDto,
   ): Promise<User> {
-    return (await this.userService.deleteKeyword(req, keyword))!;
+    return await this.userService.deleteKeyword(req, keyword);
   }
 }

src/user/user.controller.ts

@@ -68,7 +68,8 @@ export class User extends BaseEntity {
     refreshToken: string,
     id: number,
   ): Promise<User | undefined> {
-    const user: User = (await this.findOne(id))!;
+    const user: User | undefined = await this.findOne(id);
+    if (!user) return undefined;
 
     if (await bcrypt.compare(refreshToken, user.refreshToken)) {
       return user;

src/user/user.entity.ts

@@ -1,8 +1,10 @@
 import {
   BadRequestException,
+  ForbiddenException,
   HttpException,
   HttpStatus,
   Injectable,
+  NotFoundException,
 } from '@nestjs/common';
 import { CreateUserDto } from './dto/create-user.dto';
 import { Keyword, User, UserKeyword } from './user.entity';
@@ -24,11 +26,11 @@ export class UserService {
   }
 
   async auth(req: UserRequest): Promise<User> {
-    return await this.authService.login(req.user!);
+    return await this.authService.login(req.user);
   }
 
   async getUserMe(req: UserRequest): Promise<User | undefined> {
-    return await User.findOneWithKeyword({ id: req.user!.id });
+    return await User.findOneWithKeyword({ id: req.user.id });
   }
 
   async update(
@@ -42,23 +44,23 @@ export class UserService {
       );
     }
     if (Object.keys(userData).length != 0) {
-      await User.update(req.user!, userData);
+      await User.update(req.user, userData);
     }
-    return User.findOneWithKeyword({ id: req.user!.id });
+    return User.findOneWithKeyword({ id: req.user.id });
   }
 
   async createKeyword(
     req: UserRequest,
     keywordData: KeywordDto,
-  ): Promise<User | undefined> {
-    let keyword: Keyword = (await Keyword.findOne({
+  ): Promise<User> {
+    let keyword: Keyword | undefined = await Keyword.findOne({
       name: keywordData.keyword,
-    }))!;
+    });
     if (keyword) {
-      const userKeyword: UserKeyword = (await UserKeyword.findOne({
+      const userKeyword: UserKeyword | undefined = await UserKeyword.findOne({
         user: req.user,
         keyword,
-      }))!;
+      });
       if (userKeyword)
         throw new BadRequestException('keyword already added to this user');
     } else {
@@ -71,23 +73,29 @@ export class UserService {
       keyword,
     });
     await UserKeyword.save(userKeyword);
-    return User.findOneWithKeyword({ id: req.user!.id });
+    const user: User | undefined = await User.findOneWithKeyword({
+      id: req.user.id,
+    });
+    if (!user) throw new BadRequestException();
+    return user;
   }
 
   async deleteKeyword(
     req: UserRequest,
     keywordData: KeywordDto,
-  ): Promise<User | undefined> {
-    let keyword: Keyword = (await Keyword.findOne({
+  ): Promise<User> {
+    let keyword: Keyword | undefined = await Keyword.findOne({
       name: keywordData.keyword,
-    }))!;
+    });
+
+    if (!keyword) throw new BadRequestException();
 
-    const userKeyword = keyword
+    const userKeyword: UserKeyword | undefined = keyword
       ? await UserKeyword.findOne({
           user: req.user,
           keyword: keyword,
         })
-      : null;
+      : undefined;
 
     if (!userKeyword) {
       throw new HttpException(
@@ -98,7 +106,7 @@ export class UserService {
       );
     }
     await UserKeyword.delete(userKeyword.id);
-    keyword = (await Keyword.findOne(keyword.id))!;
+    keyword = await Keyword.findOne(keyword.id);
     if (
       keyword &&
       !(await UserKeyword.findOne({
@@ -108,6 +116,11 @@ export class UserService {
       await Keyword.delete(keyword);
     }
 
-    return User.findOneWithKeyword({ id: req.user!.id });
+    const user: User | undefined = await User.findOneWithKeyword({
+      id: req.user.id,
+    });
+    if (!user) throw ForbiddenException;
+
+    return user;
   }
 }