refactor

Author: kentloog

config.ts

@@ -1,12 +1,4 @@
 import { config as configDev } from './config/config.development';
 import { config as configProd } from './config/config.production';
 
-let config;
-
-if (process.env.NODE_ENV === 'production') {
-    config = configProd;
-} else {
-    config = configDev;
-}
-
-export default config;
+export default process.env.NODE_ENV === 'production' ? configProd : configDev;

src/database/database.providers.ts

@@ -7,18 +7,7 @@ export const databaseProviders = [
     {
         provide: 'SEQUELIZE',
         useFactory: async (configService: ConfigService) => {
-            const { database, username, password, dialect, host, port, logging } = configService.sequelizeOrmConfig;
-            const sequelize = new Sequelize(
-                database,
-                username,
-                password,
-                {
-                    dialect,
-                    host,
-                    port,
-                    logging
-                }
-            );
+            const sequelize = new Sequelize(configService.sequelizeOrmConfig);
             sequelize.addModels([User, Post]);
             await sequelize.sync();
             return sequelize;

src/posts/posts.controller.ts

@@ -22,7 +22,6 @@ import { PostsService } from './posts.service';
 import { AuthGuard } from '@nestjs/passport';
 import { Post as PostEntity } from './post.entity';
 import { PostDto } from './dto/post.dto';
-import { Request } from 'express';
 import { UpdatePostDto } from './dto/update-post.dto';
 
 @Controller('posts')

src/posts/posts.service.ts

@@ -12,45 +12,36 @@ export class PostsService {
         private readonly postsRepository: typeof Post,
     ) {}
 
-    async findAll(): Promise<PostDto[]> {
+    async findAll() {
         const posts = await this.postsRepository.findAll<Post>({
             include: [User],
         });
-        return posts.map(post => {
-            return new PostDto(post);
-        });
+        return posts.map(post => new PostDto(post));
     }
 
-    async findOne(id: number): Promise<PostDto> {
+    async findOne(id: number) {
         const post = await this.postsRepository.findByPk<Post>(id, {
             include: [User],
         });
         if (!post) {
             throw new HttpException('No post found', HttpStatus.NOT_FOUND);
         }
-
         return new PostDto(post);
     }
 
-    async create(userId: string, createPostDto: CreatePostDto): Promise<Post> {
+    async create(userId: string, createPostDto: CreatePostDto) {
         const post = new Post();
         post.userId = userId;
         post.title = createPostDto.title;
         post.content = createPostDto.content;
-
-        try {
-            return await post.save();
-        } catch (err) {
-            throw new HttpException(err, HttpStatus.INTERNAL_SERVER_ERROR);
-        }
+        return post.save();
     }
 
-    private async getUserPost(id: number, userId: string): Promise<Post> {
+    private async getUserPost(id: number, userId: string) {
         const post = await this.postsRepository.findByPk<Post>(id);
         if (!post) {
             throw new HttpException('No post found', HttpStatus.NOT_FOUND);
         }
-
         if (post.userId !== userId) {
             throw new HttpException(
                 'You are unauthorized to manage this post',
@@ -61,24 +52,14 @@ export class PostsService {
         return post;
     }
 
-    async update(
-        id: number,
-        userId: string,
-        updatePostDto: UpdatePostDto,
-    ): Promise<Post> {
+    async update(id: number, userId: string, updatePostDto: UpdatePostDto) {
         const post = await this.getUserPost(id, userId);
-
         post.title = updatePostDto.title || post.title;
         post.content = updatePostDto.content || post.content;
-
-        try {
-            return await post.save();
-        } catch (err) {
-            throw new HttpException(err, HttpStatus.INTERNAL_SERVER_ERROR);
-        }
+        return post.save();
     }
 
-    async delete(id: number, userId: string): Promise<Post> {
+    async delete(id: number, userId: string) {
         const post = await this.getUserPost(id, userId);
         await post.destroy();
         return post;

src/shared/config/config.service.ts

@@ -1,5 +1,4 @@
 import { Injectable } from '@nestjs/common';
-import { JwtConfig } from './interfaces/jwt-config.interface';
 import config from '../../../config';
 
 @Injectable()
@@ -8,9 +7,7 @@ export class ConfigService {
         return config.database;
     }
 
-    get jwtConfig(): JwtConfig {
-        return {
-            privateKey: config.jwtPrivateKey,
-        };
+    get jwtConfig() {
+        return { privateKey: config.jwtPrivateKey };
     }
 }

src/shared/config/interfaces/jwt-config.interface.ts

@@ -22,32 +22,29 @@ export class UsersService {
         this.jwtPrivateKey = this.configService.jwtConfig.privateKey;
     }
 
-    async findAll(): Promise<UserDto[]> {
+    async findAll() {
         const users = await this.usersRepository.findAll<User>();
-        return users.map(user => {
-            return new UserDto(user);
-        });
+        return users.map(user => new UserDto(user));
     }
 
-    async getUser(id: string): Promise<UserDto> {
+    async getUser(id: string) {
         const user = await this.usersRepository.findByPk<User>(id);
         if (!user) {
             throw new HttpException(
                 'User with given id not found',
                 HttpStatus.NOT_FOUND,
             );
         }
-
         return new UserDto(user);
     }
 
-    async getUserByEmail(email: string): Promise<User> {
+    async getUserByEmail(email: string) {
         return await this.usersRepository.findOne<User>({
             where: { email },
         });
     }
 
-    async create(createUserDto: CreateUserDto): Promise<UserLoginResponseDto> {
+    async create(createUserDto: CreateUserDto) {
         try {
             const user = new User();
             user.email = createUserDto.email.trim().toLowerCase();
@@ -76,9 +73,7 @@ export class UsersService {
         }
     }
 
-    async login(
-        userLoginRequestDto: UserLoginRequestDto,
-    ): Promise<UserLoginResponseDto> {
+    async login(userLoginRequestDto: UserLoginRequestDto) {
         const email = userLoginRequestDto.email;
         const password = userLoginRequestDto.password;
 
@@ -102,7 +97,7 @@ export class UsersService {
         return new UserLoginResponseDto(user, token);
     }
 
-    async update(id: string, updateUserDto: UpdateUserDto): Promise<UserDto> {
+    async update(id: string, updateUserDto: UpdateUserDto) {
         const user = await this.usersRepository.findByPk<User>(id);
         if (!user) {
             throw new HttpException('User not found.', HttpStatus.NOT_FOUND);
@@ -121,18 +116,17 @@ export class UsersService {
         }
     }
 
-    async delete(id: string): Promise<UserDto> {
+    async delete(id: string) {
         const user = await this.usersRepository.findByPk<User>(id);
         await user.destroy();
         return new UserDto(user);
     }
 
-    async signToken(user: User): Promise<string> {
+    async signToken(user: User) {
         const payload: JwtPayload = {
             email: user.email,
         };
 
-        const token = sign(payload, this.jwtPrivateKey, {});
-        return token;
+        return sign(payload, this.jwtPrivateKey, {});
     }
 }