issue #

- 서버 호스트 0.0.0.0 설정

.env.common

@@ -1,6 +1,3 @@
-# Nestjs 서버 포트
-PORT=3000
-
 # Gmail SMTP 설정
 GMAIL_USER=bkd.scheduler@gmail.com
 GMAIL_PASS= # 앱 비밀번호 또는 OAuth2 토큰
@@ -13,3 +10,5 @@ SMTP_AUTH=true
 SMTP_STARTTLS_ENABLE=true
 SMTP_STARTTLS_REQUIRED=true
 SMTP_AUTH_MECHANISMS=XOAUTH2
+
+JWT_SECRET=96612b08364bbd9f275f29f86d39c18225e3cb3f31551434d5a84a88f5b01e627b5aafac902e0769bda4f1574b2f84ffb26e659b1a672182015a180c086cb911

.env.dev

@@ -1,3 +1,5 @@
+PORT=8088
+
 # PostgreSQL 설정
 PGHOST=bkdhome.p-e.kr
 PGPORT=15454
@@ -8,5 +10,5 @@ PG_DATABASE_URL=postgres://baekyangdan:qwas745478!@bkdhome.p-e.kr:15454/schedule
 
 # Redis 설정
 RD_HOST=bkdhome.p-e.kr
-RD_PORT=6779
+RD_PORT=16779
 RD_URL=redis://bkdhome.p-e.kr:16779

.env.local

@@ -1,12 +1,12 @@
+HOST=0.0.0.0
+PORT=3000
+
 # PostgreSQL 설정
-PGHOST=bkdhome.p-e.kr
-PGPORT=15454
-PGDATABASE=scheduler
 PGUSER=baekyangdan
 PGPASSWORD=qwas745478!
-PG_DATABASE_URL=postgres://192.168.219.107:5454/scheduler
+PG_DATABASE_URL=postgres://192.168.219.103:5454/scheduler
 
 # Redis 설정
-RD_HOST=bkdhome.p-e.kr
+RD_HOST=192.168.219.103
 RD_PORT=6779
-RD_URL=redis://192.168.219.107:6779
+RD_URL=redis://192.168.219.103:6779

.env.prod

@@ -1,3 +1,5 @@
+PORT=3000
+
 # PostgreSQL 설정
 PGHOST=db
 PGPORT=5454

.gitea/workflows/gitea-ci.yml

@@ -6,7 +6,7 @@ on:
 
 jobs:
   build:
-    runs-on: runner
+    runs-on: rpi5
 
     env:
       DOCKER_VOLUME: ${{ vars.DOCKER_VOLUME }}
@@ -17,21 +17,37 @@ jobs:
 
     - name: Check PWD
       run: |
-        echo $DOCKER_VOLUME
-        echo $PWD
-        ls .
+        echo "Docker volume: $DOCKER_VOLUME"
+        echo "PWD: $PWD"
+        ls -lRa ./.yarn
 
-    - name: Restore node_modules
-      id: cache-node
+    - name: Validate Node and Yarn Environment
+      run: |
+        if ! command -v node &> /dev/null
+        then
+          echo "Error: Node.js not found"
+          exit 1
+        fi
+        echo "Node.js version: $(node -v)"
+
+        if ! command -v yarn &> /dev/null
+        then
+          echo "Error: Yarn.js not found"
+          exit 1
+        fi
+        echo "yarn version: $(yarn -v)"
+
+    - name: Restore Yarn cache
       uses: actions/cache@v4
       with:
-        path: node_modules
-        key: ${{ runner.os }}-yarn-v1-${{ hashFiles('**/yarn.lock') }}
-        restore-keys: |
-          ${{ runner.os }}-yarn-v1-
+        path: |
+          .yarn/cache
+          .yarn/unplugged
+          .yarn/install-state.gz
+          .pnp.cjs
+        key: ${{ runner.os }}-yarn-${{ hashFiles('yarn.lock','package.json') }}
 
     - name: Install Dependencies with yarn
-      if: steps.cache-node.outputs.cache-hit != 'true'
       run: |
         yarn install --immutable
         ls .
@@ -46,8 +62,4 @@ jobs:
         cp -r dist $DOCKER_VOLUME/scheduler/back/
         cp -r node_modules $DOCKER_VOLUME/scheduler/back/
         ls $DOCKER_VOLUME/scheduler/back
-
-    - name: Clean project
-      run: |
-        rm -rf node_modules
-        rm -rf dist
+        docker exec -it scheduler_back pm2 reload scheduler-back

.gitignore

@@ -12,7 +12,6 @@ package-lock.json
 !.yarn/releases
 !.yarn/sdks
 !.yarn/versions
-
 .pnp.*
 # .pnp.loader.mjs
 # .yarn/install-state.gz

nest-cli.json

@@ -1,8 +1,5 @@
 {
   "$schema": "https://json.schemastore.org/nest-cli",
   "collection": "@nestjs/schematics",
-  "sourceRoot": "src",
-  "compilerOptions": {
-    "deleteOutDir": true
-  }
+  "sourceRoot": "src"
 }

package.json

@@ -6,13 +6,15 @@
   "private": true,
   "license": "UNLICENSED",
   "scripts": {
-    "build": "NODE_ENV=prod nest build",
+    "build": "cross-env NODE_ENV=prod nest build",
+    "build:local": "cross-env NODE_ENV=local nest build",
+    "build:dev": "cross-env NODE_ENV=dev nest build",
     "format": "prettier --write \"src/**/*.ts\" \"test/**/*.ts\"",
     "start": "nest start",
-    "start:local": "NODE_ENV=local nest start --watch",
-    "start:dev": "NODE_ENV=dev nest start --watch",
+    "start:local": "cross-env NODE_ENV=local nest start --watch",
+    "start:dev": "cross-env NODE_ENV=dev nest start --watch",
     "start:debug": "nest start --debug --watch",
-    "start:prod": "NODE_ENV=prod node dist/main",
+    "start:prod": "cross-env NODE_ENV=prod node dist/main",
     "lint": "eslint \"{src,apps,libs,test}/**/*.ts\" --fix",
     "test": "jest",
     "test:watch": "jest --watch",
@@ -26,14 +28,21 @@
     "@nestjs/common": "^11.0.1",
     "@nestjs/config": "^4.0.2",
     "@nestjs/core": "^11.0.1",
+    "@nestjs/jwt": "^11.0.1",
+    "@nestjs/passport": "^11.0.5",
     "@nestjs/platform-express": "^11.0.1",
+    "@nestjs/platform-fastify": "^11.1.9",
     "bcrypt": "^6.0.0",
     "dotenv": "^17.2.3",
     "drizzle-kit": "^0.31.7",
     "drizzle-orm": "^0.44.7",
+    "fastify": "^5.6.2",
+    "fastify-cors": "^6.1.0",
     "googleapis": "^166.0.0",
     "ioredis": "^5.8.2",
     "nodemailer": "^7.0.10",
+    "passport": "^0.7.0",
+    "passport-jwt": "^4.0.1",
     "pg": "^8.16.3",
     "reflect-metadata": "^0.2.2",
     "rxjs": "^7.8.1"
@@ -50,8 +59,11 @@
     "@types/jest": "^30.0.0",
     "@types/node": "^22.10.7",
     "@types/nodemailer": "^7.0.4",
+    "@types/passport": "^0",
+    "@types/passport-jwt": "^4.0.1",
     "@types/pg": "^8.15.6",
     "@types/supertest": "^6.0.2",
+    "cross-env": "^10.1.0",
     "eslint": "^9.18.0",
     "eslint-config-prettier": "^10.0.1",
     "eslint-plugin-prettier": "^5.2.2",

src/app.service.ts

@@ -3,6 +3,6 @@ import { Injectable } from '@nestjs/common';
 @Injectable()
 export class AppService {
   getHello(): string {
-    return 'Hello World!';
+    return 'Hello World!\nReload Test!';
   }
 }

src/common/decorators/public.decorator.ts

@@ -0,0 +1,5 @@
+import { SetMetadata } from "@nestjs/common";
+
+export const IS_PUBLIC_KEY = 'isPublic345827';
+
+export const Public = () => SetMetadata(IS_PUBLIC_KEY, true);

src/common/filters/all-exceptions.filter.ts

@@ -0,0 +1,39 @@
+import {
+  ExceptionFilter,
+  Catch,
+  ArgumentsHost,
+  HttpException,
+  HttpStatus
+} from '@nestjs/common';
+import { FastifyReply, FastifyRequest } from 'fastify';
+
+@Catch()
+export class AllExceptionsFilter implements ExceptionFilter {
+  catch(exception: unknown, host: ArgumentsHost) {
+    const ctx = host.switchToHttp();
+    const response = ctx.getResponse<FastifyReply>();
+    const request = ctx.getRequest<FastifyRequest>();
+
+    let status =
+      exception instanceof HttpException
+      ? exception.getStatus()
+      : HttpStatus.INTERNAL_SERVER_ERROR;
+
+    let message =
+      exception instanceof HttpException
+      ? exception.getResponse()
+      : 'Internal server error';
+
+    if (typeof message === 'object' && (message as any).message) {
+      message = (message as any).message;
+    }
+
+    response.status(status).send({
+      success: false,
+      timestamp: new Date().toISOString(),
+      path: request.url,
+      statusCode: status,
+      error: message
+    });
+  }
+}

src/config/config.module.ts

@@ -1,13 +1,14 @@
 import { Module } from "@nestjs/common";
 import { ConfigModule } from '@nestjs/config';
+import dotenv from 'dotenv';
 
 @Module({
   imports: [
     ConfigModule.forRoot({
       isGlobal: true,
       envFilePath: [
-        '.env.common',
-        `.env.${process.env.NODE_ENV}`
+        `.env.${process.env.NODE_ENV}`,
+        '.env.common'
       ]
     })
   ]

src/const/HttpResponse.ts

@@ -0,0 +1,42 @@
+export const HttpResponse: Record<string, {code: number, title: string, message: string}> = {
+  "ACCESS_TOKEN_EXPIRED": {
+    code: 401,
+    title: "ACCESS_TOKEN_EXPIRED",
+    message: "ACCESS TOKEN EXPIRED"
+  },
+  "INVALID_TOKEN": {
+    code: 401,
+    title: "INVALID_TOKEN",
+    message: "INVALID TOKEN"
+  },
+  "REFRESH_TOKEN_EXPIRED": {
+    code: 401,
+    title: "REFRESH_TOKEN_EXPIRED",
+    message: "REFRESH TOKEN EXPIRED"
+  },
+  "UNAUTHORIZED": {
+    code: 401,
+    title: "UNAUTHORIZED",
+    message: "UNAUTHORIZED"
+  },
+  "OK": {
+    code: 200,
+    title: "OK",
+    message: "OK"
+  },
+  "CREATED": {
+    code: 201,
+    title: "CREATED",
+    message: "CREATED"
+  },
+  "BAD_REQUEST": {
+    code: 400,
+    title: "BAD_REQUEST",
+    message: "BAD REQUEST"
+  },
+  "INTERNAL_SERVER_ERROR": {
+    code: 500,
+    title: "INTERNAL_SERVER_ERROR",
+    message: "INTERNAL SERVER ERROR"
+  }
+} as const;

src/main.ts

@@ -1,18 +1,23 @@
 import { NestFactory } from '@nestjs/core';
 import { AppModule } from './app.module';
-import dotenv from 'dotenv';
-
-dotenv.config();
+import {
+  FastifyAdapter,
+  NestFastifyApplication
+} from '@nestjs/platform-fastify';
+import { AllExceptionsFilter } from './common/filters/all-exceptions.filter';
 
 async function bootstrap() {
-  const app = await NestFactory.create(AppModule);
+  const app = await NestFactory.create<NestFastifyApplication>(
+    AppModule,
+    new FastifyAdapter()
+  );
   app.enableCors({
     origin: (origin, callback) => {
       // origin이 없는 경우(local file, curl 등) 허용
       if (!origin) return callback(null, true);
 
       // 특정 도메인만 막고 싶은 경우 whitelist 가능
-      const whitelist = ["http://localhost:5173", "https://scheduler.bkdhome.p-e.kr"];
+      const whitelist = ["http://localhost:5173", "http://192.168.219.105:5185", "https://scheduler.bkdhome.p-e.kr"];
       if (whitelist.includes(origin)) {
         return callback(null, true);
       }
@@ -24,8 +29,8 @@ async function bootstrap() {
   });
 
   app.enableShutdownHooks();
-
-  await app.listen(process.env.PORT ?? 3000);
+  app.useGlobalFilters(new AllExceptionsFilter());
+  await app.listen(process.env.PORT ?? 3000, '0.0.0.0', () => { process.env.NODE_ENV !== 'prod' && console.log(`servier is running on ${process.env.PORT}`) });
 
 }
 bootstrap();

src/middleware/auth/auth.module.ts

@@ -0,0 +1,24 @@
+import { forwardRef, Module } from '@nestjs/common';
+import { AuthService } from './auth.service';
+import { JwtModule } from '@nestjs/jwt';
+import { ConfigModule, ConfigService } from '@nestjs/config';
+import { AccountModule } from 'src/modules/account/account.module';
+import { JwtAccessStrategy } from './strategy/access-token.strategy';
+import { JwtRefreshStrategy } from './strategy/refresh-token.strategy';
+@Module({
+  imports: [
+    ConfigModule,
+    JwtModule.registerAsync({
+      imports: [ConfigModule],
+      inject: [ConfigService],
+      useFactory: (config: ConfigService) => ({
+        secret: config.get<string>('JWT_SECRET')!,
+        signOptions: { expiresIn: '1h' }
+      })
+    }),
+    forwardRef(() => AccountModule)
+  ],
+  providers: [AuthService, JwtAccessStrategy, JwtRefreshStrategy],
+  exports: [AuthService]
+})
+export class AuthModule{}

src/middleware/auth/auth.service.ts

@@ -0,0 +1,23 @@
+import { Injectable, UnauthorizedException } from '@nestjs/common';
+import { JwtService } from '@nestjs/jwt';
+
+@Injectable()
+export class AuthService {
+  constructor(private readonly jwtService: JwtService) {}
+
+  generateTokens(payload: any) {
+    const accessToken = this.jwtService.sign(payload, { expiresIn: '5s' });
+    const refreshToken = this.jwtService.sign({id: payload.id}, { expiresIn: '7d' });
+
+    return { accessToken, refreshToken };
+  }
+
+  refreshTokens(refreshToken: string) {
+    try {
+      const payload = this.jwtService.verify(refreshToken);
+      return this.generateTokens(payload);
+    } catch (e) {
+      throw new UnauthorizedException('Invalid Refresh Token');
+    }
+  }
+}

src/middleware/auth/guard/access-token.guard.ts

@@ -0,0 +1,45 @@
+import { ExecutionContext, Injectable, UnauthorizedException } from "@nestjs/common";
+import { Reflector } from "@nestjs/core";
+import { TokenExpiredError } from "@nestjs/jwt";
+import { AuthGuard } from "@nestjs/passport";
+import { IS_PUBLIC_KEY } from "src/common/decorators/public.decorator";
+
+@Injectable()
+export class JwtAccessAuthGuard extends AuthGuard('access-token') {
+  constructor(private reflector: Reflector) {
+    super();
+  }
+
+  canActivate(context: ExecutionContext) {
+    const isPublic = this.reflector.getAllAndOverride<boolean>(IS_PUBLIC_KEY, [
+      context.getHandler(),
+      context.getClass()
+    ]);
+
+    if (isPublic) {
+      return true;
+    }
+
+    return super.canActivate(context);
+  }
+
+  handleRequest(err: any, user:any, info:any) {
+    if (info instanceof TokenExpiredError) {
+      throw new UnauthorizedException({
+        statusCode: 401,
+        message: 'Access Token Expired',
+        code: 'AccessTokenExpired'
+      });
+    }
+
+    if (err || !user) {
+      throw new UnauthorizedException({
+        statusCode: 401,
+        message: 'Invalid Token',
+        code: 'InvalidToken'
+      });
+    }
+
+    return user;
+  }
+}

src/middleware/auth/guard/refresh-token.guard.ts

@@ -0,0 +1,45 @@
+import { ExecutionContext, Injectable, UnauthorizedException } from "@nestjs/common";
+import { Reflector } from "@nestjs/core";
+import { TokenExpiredError } from "@nestjs/jwt";
+import { AuthGuard } from "@nestjs/passport";
+import { IS_PUBLIC_KEY } from "src/common/decorators/public.decorator";
+
+@Injectable()
+export class JwtRefreshAuthGuard extends AuthGuard('refresh-token') {
+  constructor(private reflector: Reflector) {
+    super();
+  }
+
+  canActivate(context: ExecutionContext) {
+    const isPublic = this.reflector.getAllAndOverride<boolean>(IS_PUBLIC_KEY, [
+      context.getHandler(),
+      context.getClass()
+    ]);
+
+    if (isPublic) {
+      return true;
+    }
+
+    return super.canActivate(context);
+  }
+
+  handleRequest(err: any, user:any, info:any) {
+    if (info instanceof TokenExpiredError) {
+      throw new UnauthorizedException({
+        statusCode: 401,
+        message: 'Refresh Token Expired',
+        code: 'RefreshTokenExpired'
+      });
+    }
+
+    if (err || !user) {
+      throw new UnauthorizedException({
+        statusCode: 401,
+        message: 'Invalid Token',
+        code: 'InvalidToken'
+      });
+    }
+
+    return user;
+  }
+}

src/middleware/auth/strategy/access-token.strategy.ts

@@ -0,0 +1,22 @@
+import { Injectable, UnauthorizedException } from "@nestjs/common";
+import { ConfigService } from "@nestjs/config";
+import { PassportStrategy } from "@nestjs/passport";
+import { ExtractJwt, Strategy } from "passport-jwt";
+
+@Injectable()
+export class JwtAccessStrategy extends PassportStrategy(Strategy, "access-token") {
+  constructor(configService: ConfigService) {
+    super({
+      jwtFromRequest: ExtractJwt.fromAuthHeaderAsBearerToken(),
+      secretOrKey: configService.get<string>('JWT_SECRET')!
+    });
+  }
+
+  async validate(payload: any) {
+    const token = ExtractJwt.fromAuthHeaderAsBearerToken();
+    if (!token) {
+      throw new UnauthorizedException();
+    }
+    return { id: payload.id };
+  }
+}

src/middleware/auth/strategy/refresh-token.strategy.ts

@@ -0,0 +1,26 @@
+import { Injectable, UnauthorizedException } from '@nestjs/common';
+import { ConfigService } from '@nestjs/config';
+import { PassportStrategy } from '@nestjs/passport';
+import { ExtractJwt, Strategy } from 'passport-jwt';
+
+@Injectable()
+export class JwtRefreshStrategy extends PassportStrategy(Strategy, 'refresh-token') {
+  constructor(configService: ConfigService) {
+    super({
+      jwtFromRequest: ExtractJwt.fromAuthHeaderAsBearerToken(),
+      secretOrKey: configService.get<string>('JWT_SECRET')!,
+      passReqToCallback: true
+    });
+  }
+
+  async validate(payload: any) {
+    const token = ExtractJwt.fromAuthHeaderAsBearerToken();
+
+    if (!token) throw new UnauthorizedException('Invalid Refresh Token');
+
+    return {
+      id: payload.id,
+      token
+    };
+  }
+}

src/modules/account/account.controller.ts

@@ -1,13 +1,11 @@
-import { Body, Controller, Get, Post, Query } from "@nestjs/common";
+import { Body, Controller, Get, Headers, Post, Query, Req, UseGuards } from "@nestjs/common";
 import { AccountService } from "./account.service";
-import { 
-  CheckDuplicationRequest, CheckDuplicationResponse,
-  SendVerificationCodeRequest, SendVerificationCodeResponse,
-  VerifyCodeRequest, VerifyCodeResponse,
-  LoginRequest, LoginResponse,
-  SignupRequest, SignupResponse
-} from "./dto";
+import * as DTO from "./dto";
+import { JwtAccessAuthGuard } from "src/middleware/auth/guard/access-token.guard";
+import { Public } from "src/common/decorators/public.decorator";
+import { JwtRefreshAuthGuard } from "src/middleware/auth/guard/refresh-token.guard";
 
+@UseGuards(JwtAccessAuthGuard)
 @Controller('account')
 export class AccountController {
   constructor(private readonly accountService: AccountService) {}
@@ -17,27 +15,68 @@ export class AccountController {
     return "Test"
   }
 
+  @Public()
   @Get('check-duplication')
-  async checkDuplication(@Query() query: CheckDuplicationRequest): Promise<CheckDuplicationResponse> {
+  async checkDuplication(@Query() query: DTO.CheckDuplicationRequest): Promise<DTO.CheckDuplicationResponse> {
     return await this.accountService.checkDuplication(query);
   }
 
-  @Post('send-verification-code')
-  async sendVerificationCode(@Body() body: SendVerificationCodeRequest): Promise<SendVerificationCodeResponse> {
+  @Public()
+  @Post('send-email-verification-code')
+  async sendEmailVerificationCode(@Body() body: DTO.SendEmailVerificationCodeRequest): Promise<DTO.SendEmailVerificationCodeResponse> {
     const result = await this.accountService.sendVerificationCode(body);
     return result;
   }
 
-  @Post('verify-code')
-  async verifyCode(@Body() body: VerifyCodeRequest): Promise<VerifyCodeResponse> {
-    console.log(body.email);
+  @Public()
+  @Post('verify-email-verification-code')
+  async verifyCode(@Body() body: DTO.VerifyEmailVerificationCodeRequest): Promise<DTO.VerifyEmailVerificationCodeResponse> {
     const result = await this.accountService.verifyCode(body);
     return result;
   }
 
+  @Public()
+  @Post('send-reset-password-code')
+  async sendResetPasswordCode(@Body() body: DTO.SendResetPasswordCodeRequest): Promise<DTO.SendResetPasswordCodeResponse> {
+    const result = await this.accountService.sendResetPasswordCode(body);
+    return result;
+  }
+
+  @Public()
+  @Post('verify-reset-password-code')
+  async verifyResetPasswordCode(@Body() body: DTO.VerifyResetPasswordCodeRequest): Promise<DTO.VerifyResetPasswordCodeResponse> {
+    const result = await this.accountService.verifyResetPasswordCode(body);
+    return result;
+  }
+
+  @Public()
+  @Post('reset-password')
+  async resetPassword(@Body() body: DTO.ResetPasswordRequest): Promise<DTO.ResetPasswordResponse> {
+    const result = await this.accountService.resetPassword(body);
+    return result;
+  }
+
+  @Public()
   @Post('signup')
-  async signup(@Body() body: SignupRequest): Promise<LoginResponse> {
+  async signup(@Body() body: DTO.SignupRequest): Promise<DTO.SignupResponse> {
     const result = await this.accountService.signup(body);
     return result;
   }
+
+  @Public()
+  @Post('login')
+  async login(@Body() body: DTO.LoginRequest): Promise<DTO.LoginResponse> {
+    console.log('a');
+    const result = await this.accountService.login(body);
+    return result;
+  }
+
+  @Public()
+  @UseGuards(JwtRefreshAuthGuard)
+  @Get('refresh-access-token')
+  async refreshAccessToken(@Req() req): Promise<DTO.RefreshAccessTokenResponse> {
+    const id = req.user.id;
+    const newAccessToken = this.accountService.refreshAccessToken(id);
+    return newAccessToken;
+  }
 }

src/modules/account/account.module.ts

@@ -1,11 +1,12 @@
-import { Module } from "@nestjs/common";
+import { forwardRef, Module } from "@nestjs/common";
 import { AccountController } from "./account.controller";
 import { AccountRepo } from "./account.repo";
 import { AccountService } from "./account.service";
-
+import { AuthModule } from 'src/middleware/auth/auth.module';
 @Module({
+  imports: [forwardRef(() => AuthModule)],
   controllers: [AccountController],
   providers: [AccountService, AccountRepo],
   exports: [AccountService, AccountRepo]
 })
-export class AccountModule {}
+export class AccountModule {}

src/modules/account/account.repo.ts

@@ -1,13 +1,13 @@
 import { Inject, Injectable } from "@nestjs/common";
 import * as schema from "drizzle/schema";
-import { countDistinct, and, eq } from 'drizzle-orm';
+import { countDistinct, and, eq, not } from 'drizzle-orm';
 import { NodePgDatabase } from "drizzle-orm/node-postgres";
 
 @Injectable()
 export class AccountRepo {
   constructor(@Inject('DRIZZLE') private readonly db: NodePgDatabase<typeof schema>) {}
 
-  async checkDuplication(type: 'email' | 'accountId', value: string) {
+  async checkIdExists(type: 'email' | 'accountId', value: string) {
     const result = await this
     .db
     .select({ count: countDistinct(schema.account[type])})
@@ -38,5 +38,48 @@ export class AccountRepo {
     });
   }
 
-  async 
+  async login(
+    type: 'email' | 'accountId'
+    , id: string
+  ) {
+    return this
+    .db
+    .select()
+    .from(schema.account)
+    .where(
+      and(
+        eq(schema.account[type], id),
+        eq(schema.account.isDeleted, false),
+        eq(schema.account.status, 'active')
+      )
+    );
+  }
+
+  async findById(id: string) {
+    return await this
+    .db
+    .select()
+    .from(schema.account)
+    .where(
+      and(
+        eq(schema.account.id, id),
+        eq(schema.account.isDeleted, false)
+      )
+    )
+  }
+
+  async updatePassword(type: 'email' | 'accountId', id: string, value: string) {
+    return await this
+    .db
+    .update(schema.account)
+    .set({
+      password: value
+    })
+    .where(
+      and(
+        eq(schema.account[type], id),
+        eq(schema.account.isDeleted, false)
+      )
+    );
+  }
 }

src/modules/account/account.service.ts

@@ -5,23 +5,25 @@ import { MailerService } from "src/util/mailer/mailer.service";
 import { Generator } from "src/util/generator";
 import Redis from "ioredis";
 import { Converter } from "src/util/converter";
+import { AuthService } from "src/middleware/auth/auth.service";
 
 @Injectable()
 export class AccountService {
   constructor(
     private readonly accountRepo: AccountRepo
     , private readonly mailerService: MailerService
+    , private readonly authService: AuthService
     , @Inject("REDIS") private readonly redis: Redis
   ) {}
 
   async checkDuplication(data: DTO.CheckDuplicationRequest): Promise<DTO.CheckDuplicationResponse> {
     const { type, value } = data;
-    const count = await this.accountRepo.checkDuplication(type, value);
+    const count = await this.accountRepo.checkIdExists(type, value);
 
-    return { isDuplicated: count > 0 };
+    return { isDuplicated: count > 0, success: true };
   }
 
-  async sendVerificationCode(data: DTO.SendVerificationCodeRequest): Promise<DTO.SendVerificationCodeResponse> {
+  async sendVerificationCode(data: DTO.SendEmailVerificationCodeRequest): Promise<DTO.SendEmailVerificationCodeResponse> {
     const { email } = data;
     const code = Generator.getVerificationCode();
     const html = `<p>Your verification code is: <strong style="font-size:16px;">${code}</strong></p>`;
@@ -36,20 +38,20 @@ export class AccountService {
     }
   }
 
-  async verifyCode(data: DTO.VerifyCodeRequest): Promise<DTO.VerifyCodeResponse> {
+  async verifyCode(data: DTO.VerifyEmailVerificationCodeRequest): Promise<DTO.VerifyEmailVerificationCodeResponse> {
     const { email, code } = data;
 
     const storedCode = await this.redis.get(`verify:${email}`);
 
     if (!storedCode) {
-      return { verified: false, error: '잘못된 이메일이거나 코드가 만료되었습니다.'};
+      return { verified: false, success: true, error: '잘못된 이메일이거나 코드가 만료되었습니다.'};
     }
     if (storedCode !== code) {
-      return { verified: false, error: "잘못된 코드입니다." };
+      return { verified: false, success: true, error: "잘못된 코드입니다." };
     }
 
     await this.redis.del(`verify:${email}`);
-    return { verified: true, message: "이메일 인증이 완료되었습니다." };
+    return { verified: true, success: true, message: "이메일 인증이 완료되었습니다." };
   }
 
   async signup(data: DTO.SignupRequest): Promise<DTO.SignupResponse> {
@@ -70,4 +72,133 @@ export class AccountService {
     }
     
   }
+
+  async login(data: DTO.LoginRequest): Promise<DTO.LoginResponse> {
+    const { type, id, password } = data;
+    const queryResult = await this.accountRepo.login(type, id);
+    const typeValue = type === 'email' ? '이메일' : '아이디';
+
+    if (!queryResult || (queryResult.length < 1)) {
+      return {
+        success: false,
+        message: `존재하지 않는 ${typeValue} 입니다.`
+      };
+    }
+
+    const hashedPassword = queryResult[0].password;
+    const isPasswordMatch = Converter.comparePassword(password, hashedPassword);
+    if (!isPasswordMatch) {
+      return {
+        success: false,
+        message: `비밀번호가 맞지 않습니다.`
+      };
+    }
+
+    {
+      const { id, accountId, status, isDeleted, birthday } = queryResult[0];
+      
+      const payload = {
+        id, accountId, status, isDeleted, birthday
+      };
+      
+      const { accessToken, refreshToken } = this.authService.generateTokens(payload);
+
+      return {
+        success: true,
+        accessToken: accessToken,
+        refreshToken: refreshToken
+      };
+    }
+  }
+
+  async refreshAccessToken(id: string): Promise<DTO.RefreshAccessTokenResponse> {
+    const { accessToken, refreshToken } = this.authService.refreshTokens(id);
+    return {
+      accessToken: accessToken,
+      refreshToken: refreshToken,
+      success: true
+    };
+  }
+
+  async sendResetPasswordCode(data: DTO.SendResetPasswordCodeRequest): Promise<DTO.SendResetPasswordCodeResponse> {
+    const { email } = data;
+
+    const count = await this.accountRepo.checkIdExists('email', email);
+
+    if (count === 0) {
+      return {
+        success: false,
+        error: "찾을 수 없는 사용자"
+      };
+    }
+
+    const code = Generator.getResetPasswordCode();
+
+    const html = 
+    `<p>Your Password Reset Code is: <strong>${code}</strong></p>`
+    + `<p>Please Enter this code in 5 minutes.</p>`;
+    const result = await this.mailerService.sendMail(email, "<Scheduler> 비밀번호 초기화 코드", html);
+
+    if (result.rejected.length > 0) {
+      return {
+        success: false,
+        error: result.response
+      };
+    }
+
+    await this.redis.set(`resetPassword:${email}`, code, 'EX', 300);
+
+    return {
+      success: true,
+      message: "비밀번호 초기화 코드 발송 완료"
+    };
+  }
+
+  async verifyResetPasswordCode(data: DTO.VerifyResetPasswordCodeRequest): Promise<DTO.VerifyResetPasswordCodeResponse> {
+    const { email, code } = data;
+
+    const storedCode = await this.redis.get(`resetPassword:${email}`);
+
+    if (!storedCode) {
+      return {
+        success: false,
+        verified: false,
+        error: "잘못된 이메일이거나 코드가 만료되었습니다."
+      };
+    }
+
+    if (storedCode !== code) {
+      return {
+        success: false,
+        verified: false,
+        error: "잘못된 코드입니다."
+      };
+    }
+
+    await this.redis.del(`resetPassword:${email}`);
+
+    return {
+      success: true,
+      verified: true,
+      message: "비밀번호 초기화 코드 인증 완료"
+    };
+  }
+
+  async resetPassword(data: DTO.ResetPasswordRequest): Promise<DTO.ResetPasswordResponse> {
+    const { email, password } = data;
+    const hashedPassword = Converter.getHashedPassword(password);
+    const result = await this.accountRepo.updatePassword('email', email, hashedPassword);
+
+    if (!result.rowCount || result.rowCount === 0) {
+      return {
+        success: false,
+        error: "비밀번호 초기화 실패"
+      };
+    }
+
+    return {
+      success: true,
+      message: "비밀번호 초기화 성공"
+    };
+  }
 }

src/modules/account/dto/base-response.dto.ts

@@ -1,4 +1,4 @@
-export class SendVerificationCodeResponseDto {
+export class BaseResponseDto {
   success: boolean;
   message?: string;
   error?: string;

src/modules/account/dto/checkDuplication/check-duplication-response.dto.ts

@@ -1,3 +1,5 @@
-export class CheckDuplicationResponseDto {
+import { BaseResponseDto } from "../base-response.dto";
+
+export class CheckDuplicationResponseDto extends BaseResponseDto {
   isDuplicated: boolean;
 }

src/modules/account/dto/index.ts

@@ -1,14 +1,27 @@
+import { ResetPasswordRequestDto } from './resetPassword/reset-password-request.dto';
+
 export { CheckDuplicationRequestDto as CheckDuplicationRequest } from './checkDuplication/check-duplication-request.dto';
 export { CheckDuplicationResponseDto as CheckDuplicationResponse } from './checkDuplication/check-duplication-response.dto';
 
-export { SendVerificationCodeRequestDto as SendVerificationCodeRequest } from './sendVerification/send-verification-code-request.dto';
-export { SendVerificationCodeResponseDto as SendVerificationCodeResponse } from './sendVerification/send-verification-code-response.dto';
+export { SendEmailVerificationCodeRequestDto as SendEmailVerificationCodeRequest } from './sendEmailVerificationCode/send-email-verification-code-request.dto';
+export { SendEmailVerificationCodeResponseDto as SendEmailVerificationCodeResponse } from './sendEmailVerificationCode/send-email-verification-code-response.dto';
 
-export { VerifyCodeRequestDto as VerifyCodeRequest } from './verifyCode/verify-code-request.dto';
-export { VerifyCodeResponseDto as VerifyCodeResponse } from './verifyCode/verify-code-response.dto';
+export { VerifyEmailVerificationCodeRequestDto as VerifyEmailVerificationCodeRequest } from './verifyEmailVerificationCode/verify-email-verification-code-request.dto';
+export { VerifyEmailVerificationCodeResponseDto as VerifyEmailVerificationCodeResponse } from './verifyEmailVerificationCode/verify-email-verification-code-response.dto';
 
 export { SignupRequestDto as SignupRequest } from './signup/signup-request.dto';
 export { SignupResponseDto as SignupResponse } from './signup/signup-response.dto';
 
 export { LoginRequestDto as LoginRequest } from './login/login-request.dto';
-export { LoginResponseDto as LoginResponse } from './login/login-response.dto'
+export { LoginResponseDto as LoginResponse } from './login/login-response.dto'
+
+export { RefreshAccessTokenResponseDto as RefreshAccessTokenResponse } from './refreshAccessToken/refresh-access-token-response.dto';
+
+export { SendResetPasswordCodeRequestDto as SendResetPasswordCodeRequest } from './sendResetPasswordCode/send-reset-password-code-request.dto';
+export { SendResetPasswordCodeResponseDto as SendResetPasswordCodeResponse } from './sendResetPasswordCode/send-reset-password-code-response.dto';
+
+export { VerifyResetPasswordCodeRequestDto as VerifyResetPasswordCodeRequest } from './verifyResetPasswordCode/verify-reset-password-code-request.dto';
+export { VerifyResetPasswordCodeResponseDto as VerifyResetPasswordCodeResponse } from './verifyResetPasswordCode/verify-reset-password-code-response.dto'
+
+export { ResetPasswordRequestDto as ResetPasswordRequest } from './resetPassword/reset-password-request.dto';
+export { ResetPasswordResponseDto as ResetPasswordResponse } from './resetPassword/reset-password-response.dto';

src/modules/account/dto/login/login-response.dto.ts

@@ -1,5 +1,6 @@
-export class LoginResponseDto {
-  success: boolean;
-  message?: string;
-  error?: string;
+import { BaseResponseDto } from "../base-response.dto";
+
+export class LoginResponseDto extends BaseResponseDto {
+  accessToken?: string;
+  refreshToken?: string;
 }

src/modules/account/dto/refreshAccessToken/refresh-access-token-response.dto.ts

@@ -0,0 +1,6 @@
+import { BaseResponseDto } from "../base-response.dto";
+
+export class RefreshAccessTokenResponseDto extends BaseResponseDto{
+  accessToken: string;
+  refreshToken: string;
+}

src/modules/account/dto/resetPassword/reset-password-request.dto.ts

@@ -0,0 +1,9 @@
+import { IsEmail, IsString } from "@nestjs/class-validator";
+
+export class ResetPasswordRequestDto {
+  @IsEmail()
+  email: string;
+
+  @IsString()
+  password: string;
+}

src/modules/account/dto/resetPassword/reset-password-response.dto.ts

@@ -0,0 +1,5 @@
+import { BaseResponseDto } from "../base-response.dto";
+
+export class ResetPasswordResponseDto extends BaseResponseDto {
+  
+}

src/modules/account/dto/sendEmailVerificationCode/send-email-verification-code-request.dto.ts

@@ -0,0 +1,6 @@
+import { IsEmail } from "@nestjs/class-validator";
+
+export class SendEmailVerificationCodeRequestDto {
+  @IsEmail()
+  email: string;
+}

src/modules/account/dto/sendEmailVerificationCode/send-email-verification-code-response.dto.ts

@@ -0,0 +1,4 @@
+import { BaseResponseDto } from "../base-response.dto";
+
+export class SendEmailVerificationCodeResponseDto extends BaseResponseDto{
+}

src/modules/account/dto/sendResetPasswordCode/send-reset-password-code-request.dto.ts

@@ -1,6 +1,6 @@
 import { IsEmail } from "@nestjs/class-validator";
 
-export class SendVerificationCodeRequestDto {
+export class SendResetPasswordCodeRequestDto {
   @IsEmail()
   email: string;
 }

src/modules/account/dto/sendResetPasswordCode/send-reset-password-code-response.dto.ts

@@ -0,0 +1,4 @@
+import { BaseResponseDto } from "../base-response.dto";
+
+export class SendResetPasswordCodeResponseDto extends BaseResponseDto {
+}

src/modules/account/dto/signup/signup-response.dto.ts

@@ -1,5 +1,4 @@
-export class SignupResponseDto {
-  success: boolean;
-  message?: string;
-  error?: string;
+import { BaseResponseDto } from "../base-response.dto";
+
+export class SignupResponseDto extends BaseResponseDto {
 }

src/modules/account/dto/verifyCode/verify-code-response.dto.ts

@@ -1,5 +0,0 @@
-export class VerifyCodeResponseDto {
-  verified: boolean;
-  message?: string;
-  error?: string;
-}

src/modules/account/dto/verifyEmailVerificationCode/verify-email-verification-code-request.dto.ts

@@ -1,6 +1,6 @@
 import { IsEmail, IsString } from "@nestjs/class-validator";
 
-export class VerifyCodeRequestDto {
+export class VerifyEmailVerificationCodeRequestDto {
   @IsEmail()
   email: string;
 

src/modules/account/dto/verifyEmailVerificationCode/verify-email-verification-code-response.dto.ts

@@ -0,0 +1,5 @@
+import { BaseResponseDto } from "../base-response.dto";
+
+export class VerifyEmailVerificationCodeResponseDto extends BaseResponseDto{
+  verified: boolean;
+}

src/modules/account/dto/verifyResetPasswordCode/verify-reset-password-code-request.dto.ts

@@ -0,0 +1,9 @@
+import { IsEmail, IsString } from "@nestjs/class-validator"
+
+export class VerifyResetPasswordCodeRequestDto {
+  @IsEmail()
+  email: string;
+
+  @IsString()
+  code: string;
+}

src/modules/account/dto/verifyResetPasswordCode/verify-reset-password-code-response.dto.ts

@@ -0,0 +1,5 @@
+import { BaseResponseDto } from "../base-response.dto";
+
+export class VerifyResetPasswordCodeResponseDto extends BaseResponseDto {
+  verified: boolean;
+}

src/util/generator.ts

@@ -2,4 +2,36 @@ export class Generator {
   static getVerificationCode() {
     return Math.random().toString().slice(2, 8);
   }
+
+  private static getRandomCharacter(string: string) {
+    return string[Math.floor(Math.random() * string.length)];
+  }
+
+  private static getShuffledString(string: string) {
+    let arr = string.split('');
+    
+    for (let i = arr.length - 1; i > 0; i--) {
+      const j = Math.floor(Math.random() * (i + 1));
+      [arr[i], arr[j]] = [arr[j], arr[i]];
+    }
+
+    return arr.join('');
+  }
+  
+  static getResetPasswordCode() {
+    const alphabets = 'abcdefghijklmnopqrstuvwxyz';
+    const numbers = '0123456789';
+    const specials = '!@#$%^';
+    const all = alphabets + numbers + specials;
+
+    let resetPasswordCode = Generator.getRandomCharacter(alphabets);
+    let requiredNumber = Generator.getRandomCharacter(numbers);
+    let requiredSpecial = Generator.getRandomCharacter(specials);
+
+    let shuffledRestPart = Generator.getShuffledString(all).slice(0, 5);
+
+    let shuffledRestCode = Generator.getShuffledString(requiredNumber + requiredSpecial + shuffledRestPart);
+
+    return resetPasswordCode + shuffledRestCode;
+  }
 }

tsconfig.build.json

@@ -2,8 +2,10 @@
   "compilerOptions": {
     "noEmitOnError": true,
     "sourceMap": false,
-    "incremental": true,
-    "tsBuildInfoFile": ".tsbuildinfo"
+    "incremental": false,
+    "noEmit": false,
+    "tsBuildInfoFile": ".tsbuildinfo",
+    "outDir": "./dist"
   },
   "extends": "./tsconfig.json",
   "exclude": ["node_modules", "test", "dist", "**/*spec.ts"]

tsconfig.json

@@ -14,12 +14,13 @@
     "sourceMap": true,
     "outDir": "./dist",
     "baseUrl": "./",
-    "incremental": true,
+    "incremental": false,
     "skipLibCheck": true,
     "strictNullChecks": true,
     "forceConsistentCasingInFileNames": true,
     "noImplicitAny": false,
     "strictBindCallApply": false,
-    "noFallthroughCasesInSwitch": false
+    "noFallthroughCasesInSwitch": false,
+    "noEmit": false
   }
 }