refactor code

.prettierrc

@@ -1,9 +1,9 @@
 {
-  "singleQuote": true,
-  "trailingComma": "all",
-  "printWidth": 80,
-  "tabWidth": 4,
-  "semi": false,
-  "arrowParens": "avoid",
-  "endOfLine": "auto"
+    "singleQuote": true,
+    "trailingComma": "all",
+    "printWidth": 80,
+    "tabWidth": 4,
+    "semi": true,
+    "arrowParens": "avoid",
+    "endOfLine": "auto"
 }

.vscode/settings.json

@@ -1,10 +1,11 @@
 {
-  "search.exclude": {
-    "**/.yarn": true,
-    "**/.pnp.*": true
-  },
-  "eslint.nodePath": ".yarn/sdks",
-  "prettier.prettierPath": ".yarn/sdks/prettier/index.js",
-  "typescript.tsdk": ".yarn/sdks/typescript/lib",
-  "typescript.enablePromptUseWorkspaceTsdk": true
+    "search.exclude": {
+        "**/.yarn": true,
+        "**/.pnp.*": true
+    },
+    "eslint.nodePath": ".yarn/sdks",
+    "prettier.prettierPath": ".yarn/sdks/prettier/index.js",
+    "typescript.tsdk": ".yarn/sdks/typescript/lib",
+    "typescript.enablePromptUseWorkspaceTsdk": true,
+    "cSpell.words": ["ectx"]
 }

src/app/app.controller.spec.ts

@@ -1,24 +1,24 @@
-import { Test, TestingModule } from '@nestjs/testing'
+import { Test, TestingModule } from '@nestjs/testing';
 
-import { AppController } from './app.controller'
-import { AppService } from './app.service'
+import { AppController } from './app.controller';
+import { AppService } from './app.service';
 
 describe('AppController', () => {
-    let app: TestingModule
+    let app: TestingModule;
 
     beforeAll(async () => {
         app = await Test.createTestingModule({
             controllers: [AppController],
             providers: [AppService],
-        }).compile()
-    })
+        }).compile();
+    });
 
     describe('getData', () => {
         it('should return "Hello World!"', () => {
-            const appController = app.get<AppController>(AppController)
+            const appController = app.get<AppController>(AppController);
             expect(appController.getHello()).toEqual({
                 message: 'Hello World!',
-            })
-        })
-    })
-})
+            });
+        });
+    });
+});

src/app/app.controller.ts

@@ -1,13 +1,13 @@
-import { Controller, Get } from '@nestjs/common'
+import { Controller, Get } from '@nestjs/common';
 
-import { AppService } from './app.service'
+import { AppService } from './app.service';
 
 @Controller()
 export class AppController {
     constructor(private readonly appService: AppService) {}
 
     @Get()
     getHello() {
-        return this.appService.getHello()
+        return this.appService.getHello();
     }
 }

src/app/app.module.ts

@@ -1,19 +1,19 @@
-import { MorganMiddleware } from '@nest-middlewares/morgan'
+import { MorganMiddleware } from '@nest-middlewares/morgan';
 import {
     MiddlewareConsumer,
     Module,
     NestModule,
     ValidationPipe,
-} from '@nestjs/common'
-import { ConfigModule } from '@nestjs/config'
-import { APP_PIPE } from '@nestjs/core'
-import { MongooseModule } from '@nestjs/mongoose'
+} from '@nestjs/common';
+import { ConfigModule } from '@nestjs/config';
+import { APP_PIPE } from '@nestjs/core';
+import { MongooseModule } from '@nestjs/mongoose';
 
-import { AuthModule } from '../auth/auth.module'
-import { TransactionRoomModule } from '../transaction-room/transaction-room.module'
-import { TransactionModule } from '../transaction/transaction.module'
-import { AppController } from './app.controller'
-import { AppService } from './app.service'
+import { AuthModule } from '../auth/auth.module';
+import { TransactionRoomModule } from '../transaction-room/transaction-room.module';
+import { TransactionModule } from '../transaction/transaction.module';
+import { AppController } from './app.controller';
+import { AppService } from './app.service';
 
 @Module({
     imports: [
@@ -36,14 +36,14 @@ import { AppService } from './app.service'
                     transform: true,
                     forbidNonWhitelisted: true,
                     transformOptions: { enableImplicitConversion: true },
-                })
+                });
             },
         },
     ],
 })
 export class AppModule implements NestModule {
     configure(consumer: MiddlewareConsumer) {
-        MorganMiddleware.configure('dev')
-        consumer.apply(MorganMiddleware).forRoutes('*')
+        MorganMiddleware.configure('dev');
+        consumer.apply(MorganMiddleware).forRoutes('*');
     }
 }

src/app/app.service.spec.ts

@@ -1,21 +1,21 @@
-import { Test } from '@nestjs/testing'
+import { Test } from '@nestjs/testing';
 
-import { AppService } from './app.service'
+import { AppService } from './app.service';
 
 describe('AppService', () => {
-    let service: AppService
+    let service: AppService;
 
     beforeAll(async () => {
         const app = await Test.createTestingModule({
             providers: [AppService],
-        }).compile()
+        }).compile();
 
-        service = app.get<AppService>(AppService)
-    })
+        service = app.get<AppService>(AppService);
+    });
 
     describe('getHello', () => {
         it('should return "Hello API"', () => {
-            expect(service.getHello()).toEqual({ message: 'Hello API' })
-        })
-    })
-})
+            expect(service.getHello()).toEqual({ message: 'Hello API' });
+        });
+    });
+});

src/app/app.service.ts

@@ -1,10 +1,10 @@
-import { Injectable } from '@nestjs/common'
+import { Injectable } from '@nestjs/common';
 
 @Injectable()
 export class AppService {
     getHello() {
         return {
             message: 'Hello World!',
-        }
+        };
     }
 }

src/auth/auth.module.ts

@@ -1,32 +1,21 @@
+// auth.module.ts
 import { Module } from '@nestjs/common';
-import { ConfigService } from '@nestjs/config';
-import { JwtModule } from '@nestjs/jwt';
-import { MongooseModule } from '@nestjs/mongoose';
 import { PassportModule } from '@nestjs/passport';
 
 import { AuthController } from './auth.controller';
-import { AuthService } from './auth.service';
+import { JwtConfigModule } from './jwt.config.module';
 import { JwtStrategy } from './jwt.strategy';
-import { User, UserSchema } from './schemas/user.schema';
+import { authProviders } from './providers';
+import { UserModule } from './user.module';
 
 @Module({
     imports: [
         PassportModule.register({ defaultStrategy: 'jwt' }),
-        JwtModule.registerAsync({
-            inject: [ConfigService],
-            useFactory: async (configService: ConfigService) => ({
-                secret: configService.get<string>('JWT_SECRET'),
-                signOptions: {
-                    expiresIn: configService.get<string | number>(
-                        'JWT_EXPIRES_IN',
-                    ),
-                },
-            }),
-        }),
-        MongooseModule.forFeature([{ name: User.name, schema: UserSchema }]),
+        JwtConfigModule,
+        UserModule,
     ],
     controllers: [AuthController],
-    providers: [AuthService, JwtStrategy],
+    providers: [...authProviders],
     exports: [JwtStrategy, PassportModule],
 })
 export class AuthModule {}

src/auth/auth.service.spec.ts

@@ -2,17 +2,17 @@ import { Test, TestingModule } from '@nestjs/testing';
 import { AuthService } from './auth.service';
 
 describe('AuthService', () => {
-  let service: AuthService;
+    let service: AuthService;
 
-  beforeEach(async () => {
-    const module: TestingModule = await Test.createTestingModule({
-      providers: [AuthService],
-    }).compile();
+    beforeEach(async () => {
+        const module: TestingModule = await Test.createTestingModule({
+            providers: [AuthService],
+        }).compile();
 
-    service = module.get<AuthService>(AuthService);
-  });
+        service = module.get<AuthService>(AuthService);
+    });
 
-  it('should be defined', () => {
-    expect(service).toBeDefined();
-  });
+    it('should be defined', () => {
+        expect(service).toBeDefined();
+    });
 });

src/auth/auth.service.ts

@@ -2,13 +2,13 @@ import {
     ConflictException,
     Injectable,
     UnauthorizedException,
-} from '@nestjs/common'
-import { JwtService } from '@nestjs/jwt'
-import { InjectModel } from '@nestjs/mongoose'
-import { Model } from 'mongoose'
+} from '@nestjs/common';
+import { JwtService } from '@nestjs/jwt';
+import { InjectModel } from '@nestjs/mongoose';
+import { Model } from 'mongoose';
 
-import { LoginDto, SignupDto } from './dto'
-import { User } from './schemas/user.schema'
+import { AuthError, LoginInfo, SignupInfo } from './interfaces/auth.interface';
+import { User } from './schemas/user.schema';
 
 @Injectable()
 export class AuthService {
@@ -19,25 +19,25 @@ export class AuthService {
     ) {}
 
     async signUp(
-        signupInfo: SignupDto,
+        signupInfo: SignupInfo,
     ): Promise<{ ok: boolean; data: { token: string } }> {
-        const { phone, password, name } = signupInfo
+        const { phone, password, name } = signupInfo;
 
         // Check if user with phone number already exists as registered user
-        const user = await this.userModel.findOne({ phone })
+        let user = await this.userModel.findOne({ phone });
         if (user && user.isReal) {
-            throw new ConflictException('phone number already in use')
+            throw new ConflictException(AuthError.PhoneAlreadyInUse);
         }
         if (user && !user.isReal) {
             // TODO: Send OTP to user and verify it to complete registration
             // sendOTP();
-            user.name = name
-            user.password = password
-            user.isReal = true
-            user.signedUpOn = new Date()
-            await user.save()
-            const token = this.jwtService.sign({ user_id: user._id })
-            return { ok: true, data: { token } }
+            user.name = name;
+            user.password = password;
+            user.isReal = true;
+            user.signedUpOn = new Date();
+            await user.save();
+            const token = this.jwtService.sign({ user_id: user._id });
+            return { ok: true, data: { token } };
         }
 
         // if user not found, create new user
@@ -47,32 +47,33 @@ export class AuthService {
             phone,
             isReal: true,
             signedUpOn: new Date(),
-        })
+        });
 
-        const token = this.jwtService.sign({ user_id: newUser._id })
+        const token = this.jwtService.sign({ user_id: newUser._id });
         return {
             ok: true,
             data: { token },
-        }
+        };
     }
 
-    async logIn(loginInfo: LoginDto) {
-        const { phone, password } = loginInfo
+    async logIn(loginInfo: LoginInfo) {
+        const { phone, password } = loginInfo;
 
         // Check if user with phone number already exists as registered user
-        const user = await this.userModel.findOne({ phone, isReal: true })
-        if (!user) throw new UnauthorizedException('Invalid credentials')
+        const user = await this.userModel.findOne({ phone, isReal: true });
+        if (!user)
+            throw new UnauthorizedException(AuthError.InvalidCredentials);
 
         // Check if password is correct
-        const isPasswordCorrect = await user.comparePassword(password)
+        const isPasswordCorrect = await user.comparePassword(password);
         if (!isPasswordCorrect)
-            throw new UnauthorizedException('Invalid credentials')
+            throw new UnauthorizedException(AuthError.InvalidCredentials);
 
         // Send jwt token back to user
-        const token = this.jwtService.sign({ user_id: user._id })
+        const token = this.jwtService.sign({ user_id: user._id });
         return {
             ok: true,
             data: { token },
-        }
+        };
     }
 }

src/auth/dto/login.dto.ts

@@ -18,6 +18,4 @@ export class LoginDto {
         example: 'Abcd@1234',
     })
     password: string;
-
-    // email?:
 }

src/auth/interfaces/auth.interface.ts

@@ -0,0 +1,19 @@
+export interface SignupInfo {
+    phone: string;
+    password: string;
+    name: string;
+}
+
+export interface LoginInfo {
+    phone: string;
+    password: string;
+}
+
+export interface JwtPayload {
+    user_id: string;
+}
+
+export enum AuthError {
+    PhoneAlreadyInUse = 'phone number already in use',
+    InvalidCredentials = 'Invalid credentials',
+}