Merge pull request #322 from snack-25/feature/management-memberOnlyList

devkdb · web-flow · commit 04470656d669 · 2025-04-11T11:24:00.000+09:00
[back] Feature/management member only list
diff --git a/src/auth/auth.service.ts b/src/auth/auth.service.ts
@@ -1,6 +1,7 @@
 import {
   BadRequestException,
   ConflictException,
+  HttpException,
   Injectable,
   InternalServerErrorException,
   Logger,
@@ -45,11 +46,18 @@ export class AuthService {
   // 사용자 ID로 사용자 정보 조회
   public async getUserById(
     userId: string,
-  ): Promise<Pick<User, 'id' | 'name' | 'email' | 'role' | 'refreshToken'> | null> {
+  ): Promise<Pick<User, 'id' | 'name' | 'email' | 'role' | 'refreshToken' | 'companyId'> | null> {
     try {
       const user = await this.prisma.user.findUnique({
         where: { id: userId },
-        select: { id: true, name: true, email: true, role: true, refreshToken: true },
+        select: {
+          id: true,
+          name: true,
+          email: true,
+          role: true,
+          refreshToken: true,
+          companyId: true, // ✅ 필수!
+        },
       });
       return user;
     } catch (error) {
@@ -70,11 +78,34 @@ export class AuthService {
 
       if (!invitation) return null;
 
+      // ✅ 초대 만료 체크 추가
+      if (invitation.expiresAt < new Date()) {
+        console.warn('[초대 만료]', {
+          email: invitation.email,
+          token: invitation.token,
+          expiresAt: invitation.expiresAt.toISOString(),
+          now: new Date().toISOString(),
+        });
+        throw new UnauthorizedException('초대 토큰이 만료되었습니다.');
+      }
+
+      if (invitation.status === 'ACCEPTED') {
+        console.warn('[초대 재사용 시도]', {
+          email: invitation.email,
+          token: invitation.token,
+          status: invitation.status,
+        });
+        throw new UnauthorizedException('이미 사용된 초대 링크입니다.');
+      }
+
       return {
         ...invitation,
         companyName: invitation.company?.name || '', // ✅ 회사명 함께 전달
       };
     } catch (err) {
+      if (err instanceof HttpException) {
+        throw err;
+      }
       throw new BadRequestException('초대 코드가 유효하지 않습니다: ' + err);
     }
   }
@@ -89,6 +120,8 @@ export class AuthService {
           email: true,
           name: true,
           role: true,
+          status: true,
+          expiresAt: true,
           company: {
             select: {
               id: true,
@@ -98,11 +131,25 @@ export class AuthService {
         },
       });
 
-      // 2. 초대 코드가 유효하지 않으면 예외 처리
+      // 초대 코드가 유효하지 않으면 예외 처리
       if (!invitation) {
         throw new BadRequestException('초대 코드가 유효하지 않습니다');
       }
 
+      if (invitation.status === 'ACCEPTED') {
+        throw new UnauthorizedException('이미 사용된 초대 링크입니다.');
+      }
+
+      // 초대 토큰 만료 여부 확인
+      const now = new Date();
+      if (invitation.expiresAt < now) {
+        throw new BadRequestException('초대 토큰이 만료되었습니다.');
+      }
+
+      // if (dto.email !== invitation.email) {
+      //   throw new BadRequestException('초대된 이메일과 일치하지 않습니다.');
+      // }
+
       const existingUser = await this.prisma.user.findUnique({
         where: { email: invitation.email },
       });
@@ -431,19 +478,39 @@ export class AuthService {
 
   // accessToken 생성 (payload에 userId 포함)
   private async generateAccessToken(userId: string): Promise<string> {
+    // Step 1: 유저 정보 조회 (companyId 포함)
+    const user = await this.prisma.user.findUnique({
+      where: { id: userId },
+      select: {
+        id: true,
+        email: true,
+        role: true,
+        companyId: true, // ✅ 핵심: companyId 추가
+      },
+    });
+
+    if (!user) {
+      throw new NotFoundException('사용자를 찾을 수 없습니다');
+    }
+
+    // Step 2: 토큰 payload 구성
     const payload: TokenRequestDto = {
-      sub: userId,
-      type: 'access', // 토큰 타입은 액세스 토큰
+      sub: user.id, // JWT 표준 subject (userId)
+      email: user.email,
+      role: user.role,
+      companyId: user.companyId, // ✅ 핵심: payload에 companyId 포함
+      type: 'access',
     };
 
     // 만료 시간을 명시적으로 설정 (현재 시간 + JWT_EXPIRES_IN)
     const expiresIn = this.configService.getOrThrow<string>('JWT_EXPIRES_IN');
 
     this.logger.debug(`토큰 생성: 만료 시간 ${expiresIn}`);
 
+    // Step 3: accessToken 발급
     return this.jwtService.signAsync(payload, {
       secret: this.configService.getOrThrow<string>('JWT_SECRET'),
-      expiresIn: expiresIn,
+      expiresIn: this.configService.getOrThrow<string>('JWT_EXPIRES_IN'),
     });
   }
 
diff --git a/src/auth/dto/auth.dto.ts b/src/auth/dto/auth.dto.ts
@@ -48,8 +48,11 @@ export class SigninResponseDto {
 
 // 토큰 생성 요청 DTO
 export class TokenRequestDto {
-  public sub: string;
-  public type: 'access' | 'refresh';
+  public sub: string; // 사용자 ID (JWT 표준 필드)
+  public email?: string; // 이메일 (선택)
+  public role?: UserRole; // 역할 (예: USER, ADMIN)
+  public companyId?: string; // ✅ 회사 ID
+  public type: 'access' | 'refresh'; // access 또는 refresh 토큰 구분
 }
 
 // 토큰 생성 응답 DTO
diff --git a/src/auth/jwt.strategy.ts b/src/auth/jwt.strategy.ts
@@ -5,9 +5,12 @@ import { ExtractJwt, Strategy } from 'passport-jwt';
 
 // JWT payload의 타입을 정의
 interface JwtPayload {
-  sub: string; // 사용자 ID (주로 'sub'에 저장)
-  email: string; // 사용자 이메일
-  iat: number; // 토큰 발행 시간 (Unix timestamp)
+  sub: string;
+  email: string;
+  role: string;
+  companyId: string;
+  type: 'access' | 'refresh';
+  iat: number;
 }
 
 // `cookies` 속성을 명시적으로 정의
@@ -32,8 +35,18 @@ export class JwtStrategy extends PassportStrategy(Strategy, 'jwt-access') {
   }
 
   // validate 메서드에서 반환 타입 명시
-  public validate(payload: JwtPayload): { email: string; expires: number } {
+  public validate(payload: JwtPayload): { email: string; expires: number; companyId: string } {
     // payload에서 email과 iat(발행 시간)을 반환
-    return { email: payload.email, expires: payload.iat };
+    const result = {
+      email: payload.email,
+      expires: payload.iat,
+      companyId: payload.companyId,
+    };
+
+    // ✅ 로그 찍기
+    // console.log('🔑 [JwtStrategy] 토큰 payload 정보:', payload);
+    // console.log('📦 [JwtStrategy] validate() 리턴값:', result);
+
+    return result;
   }
 }
diff --git a/src/invitations/invitations.service.ts b/src/invitations/invitations.service.ts
@@ -1,6 +1,7 @@
 /* eslint-disable no-console */
 import {
   BadRequestException,
+  ConflictException,
   HttpStatus,
   Injectable,
   InternalServerErrorException,
@@ -12,7 +13,7 @@ import { PrismaClientKnownRequestError } from '@prisma/client/runtime/library';
 import { PrismaService } from '@src/shared/prisma/prisma.service';
 import { DateUtil } from '@src/shared/utils/date.util';
 import * as crypto from 'crypto';
-import { addHours } from 'date-fns';
+import { addHours, addSeconds } from 'date-fns';
 import nodemailer from 'nodemailer';
 import {
   GenerateTokenResponseDto,
@@ -103,14 +104,45 @@ export class InvitationsService {
       if (dto.role === UserRole.SUPERADMIN) {
         throw new UnauthorizedException('최고관리자는 초대할 수 없습니다.');
       }
+      // 이미 초대한 이메일인지 확인 (초대 상태가 PENDING이고, 아직 가입되지 않은 경우)
+      // 회원가입 이후 삭제되지 않고, 상태(status)가 'ACCEPTED'로 변경 됨.
+      const existing = await this.prisma.invitation.findFirst({
+        where: {
+          email: dto.email,
+          status: 'PENDING',
+        },
+      });
+
+      if (existing) {
+        throw new ConflictException('이미 초대된 이메일입니다. 기존 초대를 확인해주세요.');
+      }
+
+      // 이미 가입된 유저인지 확인
+      const existingUser = await this.prisma.user.findUnique({
+        where: { email: dto.email },
+      });
+
+      if (existingUser) {
+        throw new ConflictException('이미 가입된 이메일입니다.');
+      }
 
       // 초대 토큰 생성
       const { token } = this.generateToken();
       // 초대 토큰 만료 시간 설정(토큰 생성 24시간 후)
       const expiresAt = addHours(new Date(), 24);
 
+      // 테스트용 (5초 후 만료)
+      // const expiresAt = addSeconds(new Date(), 5);
+      // console.log(
+      //   '\x1b[33m[초대 생성] 만료 시간:',
+      //   expiresAt.toISOString(),
+      //   '| 로컬 시간:',
+      //   expiresAt.toLocaleString(),
+      //   '\x1b[0m',
+      // );
+
       // 초대 생성 후 이메일 발송 처리되도록 트랜잭션 처리
-      // const invitation = await this.prisma.$transaction(async tx => {
+      // const invitation = await this.pris```ma.$transaction(async tx => {
       //   // 테이블에 초대 정보 생성(id, email, name, token, role, expiresAt, companyId, inviterId)
 
       //   const createdInvitation = await tx.invitation.create({
@@ -148,6 +180,17 @@ export class InvitationsService {
       };
     } catch (error) {
       console.error(`초대 생성 에러: ${error}`);
+
+      // ConflictException, BadRequestException 등은 그대로 다시 던지기
+      if (
+        error instanceof ConflictException ||
+        error instanceof BadRequestException ||
+        error instanceof UnauthorizedException
+      ) {
+        throw error;
+      }
+
+      // 나머지는 내부 서버 에러로 처리
       throw new InternalServerErrorException(`초대 생성에 실패했습니다.`);
     }
   }
@@ -191,40 +234,50 @@ export class InvitationsService {
   }
 
   //TODO: 초대 조회하기
-  public async getInvitation(token: Token): Promise<Invitation | Error> {
+  public async getInvitation(token: Token): Promise<Invitation> {
     try {
-      const invitation = await this.verifyToken(token);
-      // 초대 정보가 없으면 에러 발생
-      if (invitation instanceof Error) {
-        throw new InternalServerErrorException(`초대 조회에 실패했습니다.`);
-      }
-      console.log(`\x1b[32m초대 조회: ${JSON.stringify(invitation)}\x1b[0m`);
-      return invitation;
+      console.log('[Service] getInvitation 진입:', token);
+
+      return await this.verifyToken(token);
     } catch (error) {
       console.error(`초대 조회 에러: ${error}`);
-      throw new InternalServerErrorException(`초대 조회에 실패했습니다.`);
+
+      // ✅ 받은 에러를 그대로 던져서 HTTP status 유지
+      if (error instanceof UnauthorizedException || error instanceof NotFoundException) {
+        throw error;
+      }
+
+      // 그 외의 예외는 500 에러로 던지기
+      throw new InternalServerErrorException('초대 조회에 실패했습니다.');
     }
   }
 
   //TODO: 초대 토큰 만료 시간 검증
   public isTokenExpired(invitation: Invitation): boolean {
+    console.log('[Service] isTokenExpired:', invitation.expiresAt, '| 현재시간:', new Date());
     const now = new Date();
     const isExpired = now > invitation.expiresAt;
     console.log(`토큰 만료여부: ${isExpired ? '만료' : '유효'}`);
+    console.log('[Service] isExpired 판별 결과:', isExpired);
     return isExpired;
   }
 
   //TODO: 초대 토큰 검증(만료 시간 확인 포함)
-  public async verifyToken(token: Token): Promise<Invitation | Error> {
+  public async verifyToken(token: Token): Promise<Invitation> {
     try {
+      console.log('[Service] verifyToken 진입:', token);
+
       const invitation = await this.getInvitationByToken(token);
       if (!invitation) {
         throw new BadRequestException('초대 토큰이 없습니다.');
       }
+
       const isExpired = this.isTokenExpired(invitation);
       if (isExpired) {
+        console.log('[Service] 만료됨 → UnauthorizedException 던짐');
         throw new UnauthorizedException('초대 토큰이 만료되었습니다.');
       }
+
       return invitation;
     } catch (error) {
       console.error(`토큰 검증 에러: ${error}`);
@@ -246,6 +299,10 @@ export class InvitationsService {
   //TODO: 초대 메일 템플릿
   public mailTemplate(name: string, token: Token): string {
     const url = process.env.FRONTEND_HOST;
+
+    // const fullLink = `${url}/auth/signup?token=${token}`;
+    // console.log('\x1b[36m[초대 링크]', fullLink, '\x1b[0m');
+
     return `
     <h1>초대 메일</h1>
     <p>안녕하세요. ${name}님 초대합니다.</p>
diff --git a/src/users/users.service.ts b/src/users/users.service.ts
@@ -43,6 +43,8 @@ export class UsersService {
       }),
     };
 
+    //console.log('🔥 유저 리스트 조회 조건:', where);
+
     const [totalCount, users] = await this.prisma.$transaction([
       this.prisma.user.count({ where }),
       this.prisma.user.findMany({
@@ -60,6 +62,12 @@ export class UsersService {
       }),
     ]);
 
+    // console.log('✅ 필터링된 사용자 수:', totalCount);
+    // console.log(
+    //   '👤 사용자 목록:',
+    //   users.map(u => u.email),
+    // );
+
     return {
       totalCount,
       users,
@@ -105,6 +113,17 @@ export class UsersService {
       await this.prisma.user.delete({
         where: { id: userId },
       });
+
+      // 관련 초대 상태 변경 (조건: 동일한 이메일 + PENDING 상태)
+      await this.prisma.invitation.updateMany({
+        where: {
+          email: user.email,
+          status: 'PENDING', // 아직 가입 안한 상태. 사용 안 된 초대만 만료 처리 한다.
+        },
+        data: {
+          status: 'EXPIRED',
+        },
+      });
     } catch (error) {
       // ✅ Prisma 클라이언트 오류 또는 기타 에러 처리
       console.error('❌ 사용자 삭제 중 오류 발생:', error);
