Merge pull request #10 from wafflestudio/Feature/#9

Modify entities to conform to strict rules

Author: eldpswp99

src/app.module.ts

@@ -16,7 +16,7 @@ import {
   UserTag,
 } from './department/department.entity';
 
-const ENV: string = process.env.NODE_ENV;
+const ENV: string | undefined = process.env.NODE_ENV;
 
 @Module({
   imports: [
@@ -27,7 +27,7 @@ const ENV: string = 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/auth/auth.service.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';
@@ -8,15 +8,20 @@ import { Payload } from '../types/custom-type';
 export class AuthService {
   constructor(private jwtService: JwtService) {}
 
-  async validateUser(username: string, password: string): Promise<User> {
+  async validateUser(
+    username: string,
+    password: string,
+  ): Promise<User | undefined> {
     const user = await User.findOne({ username });
     if (user && (await bcrypt.compare(password, user.password))) {
       return user;
     }
-    return null;
+    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, {
@@ -28,10 +33,12 @@ export class AuthService {
     });
     user.refreshToken = await bcrypt.hash(
       refreshToken,
-      +process.env.SALT_ROUND,
+      +process.env.SALT_ROUND!,
     );
     await User.save(user);
     user = await User.findOneWithKeyword({ id: user.id });
+
+    if (!user) throw new UnauthorizedException();
     user.access_token = accessToken;
     user.refresh_token = refreshToken;
 

src/auth/jwt-access.strategy.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-refresh.strategy.ts

@@ -19,8 +19,12 @@ 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,
     );

src/auth/local.strategy.ts

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

src/department/department.entity.ts

@@ -13,28 +13,28 @@ import { Expose, Transform } from 'class-transformer';
 @Entity()
 export class Department extends BaseEntity {
   @PrimaryGeneratedColumn()
-  id: number;
+  id!: number;
 
   @Column()
-  name: string;
+  name!: string;
 
   @OneToMany(() => Notice, (notice) => notice.department)
-  notices: Notice[];
+  notices!: Notice[];
 
-  @Transform((tags) => tags.value.map((tag) => tag.name))
+  @Transform((tags) => tags.value.map((tag: Tag) => tag.name))
   @OneToMany(() => Tag, (tag) => tag.department)
-  tags: Tag[];
+  tags!: Tag[];
 
   follow?: string[];
 }
 
 @Entity()
 export class Tag extends BaseEntity {
   @PrimaryGeneratedColumn()
-  id: number;
+  id!: number;
 
   @Column()
-  name: string;
+  name!: string;
 
   @ManyToOne(() => Department, (department) => department.tags, {
     nullable: false,
@@ -43,16 +43,16 @@ export class Tag extends BaseEntity {
   department!: Department;
 
   @OneToMany(() => UserTag, (userTag) => userTag.tag)
-  userTags: UserTag[];
+  userTags!: UserTag[];
 
   @OneToMany(() => NoticeTag, (noticeTag) => noticeTag.tag)
-  noticeTags: NoticeTag[];
+  noticeTags!: NoticeTag[];
 }
 
 @Entity()
 export class UserTag extends BaseEntity {
   @PrimaryGeneratedColumn()
-  id: number;
+  id!: number;
 
   @ManyToOne(() => User, (user) => user.userTags, {
     nullable: false,
@@ -70,11 +70,11 @@ export class UserTag extends BaseEntity {
 @Entity()
 export class NoticeTag extends BaseEntity {
   @PrimaryGeneratedColumn()
-  id: number;
+  id!: number;
 
   @ManyToOne(() => Notice, (notice) => notice.noticeTags)
-  notice: Notice;
+  notice!: Notice;
 
   @ManyToOne(() => Tag, (tag) => tag.noticeTags)
-  tag: Tag;
+  tag!: Tag;
 }

src/department/department.init.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.service.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';
@@ -33,7 +34,7 @@ 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) {
@@ -44,8 +45,12 @@ export class DepartmentService {
     return department;
   }
 
-  async getFollow(department: Department, user: User): Promise<string[]> {
+  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,23 +70,24 @@ 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,
     });
@@ -95,7 +101,7 @@ export class DepartmentService {
   }
 
   async createFollow(
-    @Req() req,
+    req: UserRequest,
     id: number,
     followData: FollowDto,
   ): Promise<Department> {
@@ -120,7 +126,7 @@ export class DepartmentService {
   }
 
   async deleteFollow(
-    @Req() req,
+    req: UserRequest,
     id: number,
     followData: FollowDto,
   ): Promise<Department> {

src/department/dto/follow.dto.ts

@@ -2,5 +2,5 @@ import { IsString } from 'class-validator';
 
 export class FollowDto {
   @IsString()
-  follow: string;
+  follow!: string;
 }

src/notice/notice.entity.ts

@@ -12,22 +12,22 @@ import { Department, NoticeTag } from '../department/department.entity';
 @Entity()
 export class Notice extends BaseEntity {
   @PrimaryGeneratedColumn()
-  id: number;
+  id!: number;
 
   @Column()
-  title: string;
+  title!: string;
 
   @Column({ length: 10000 })
-  content: string;
+  content!: string;
 
   @Column({ type: 'timestamp' })
-  createdAt: Date;
+  createdAt!: Date;
 
   @Column({ default: false })
-  isPinned: boolean;
+  isPinned!: boolean;
 
   @Column()
-  link: string;
+  link!: string;
 
   @ManyToOne(() => Department, (department) => department.notices, {
     nullable: false,
@@ -36,25 +36,25 @@ export class Notice extends BaseEntity {
   department!: Department;
 
   @OneToMany(() => UserNotice, (userNotice) => userNotice.notice)
-  userNotices: UserNotice[];
+  userNotices!: UserNotice[];
 
   @OneToMany(() => File, (file) => file.notice)
-  files: File[];
+  files!: File[];
 
   @OneToMany(() => NoticeTag, (noticeTag) => noticeTag.notice)
-  noticeTags: NoticeTag[];
+  noticeTags!: NoticeTag[];
 }
 
 @Entity()
 export class File extends BaseEntity {
   @PrimaryGeneratedColumn()
-  id: number;
+  id!: number;
 
   @Column()
-  name: string;
+  name!: string;
 
   @Column()
-  link: string;
+  link!: string;
 
   @ManyToOne(() => Notice, (notice) => notice.files, {
     nullable: false,
@@ -66,10 +66,10 @@ export class File extends BaseEntity {
 @Entity()
 export class UserNotice extends BaseEntity {
   @PrimaryGeneratedColumn()
-  id: number;
+  id!: number;
 
   @Column()
-  isScrapped: boolean;
+  isScrapped!: boolean;
 
   @ManyToOne(() => User, (user) => user.userNotices, {
     nullable: false,

src/types/custom-type.ts

@@ -3,17 +3,17 @@ import { User } from '../user/user.entity';
 import { Department, Tag, UserTag } from '../department/department.entity';
 
 export class Payload {
-  username: string;
-  id: number;
+  username!: string;
+  id!: number;
 }
 
 export interface UserRequest extends Request {
-  user?: User;
+  user: User;
 }
 
 export interface PreFollow {
   department: Department;
   tag: Tag;
   user: User;
-  userTag: UserTag;
+  userTag?: UserTag;
 }

src/user/dto/auth-user.dto.ts

@@ -3,17 +3,17 @@ import { NotDefinedValidator } from '../user.validator';
 
 export class AuthDto {
   @IsIn(['password', 'refresh_token'])
-  grant_type: string;
+  grant_type!: string;
 
   @ValidateIf((o) => o.grant_type === 'refresh_token')
   @Validate(NotDefinedValidator, {
     message: 'only refresh_token should be given to the header, not username',
   })
-  username: string;
+  username!: string;
 
   @ValidateIf((o) => o.grant_type === 'refresh_token')
   @Validate(NotDefinedValidator, {
     message: 'only refresh_token should be given to the header, not password',
   })
-  password: string;
+  password!: string;
 }