NestJS 기반 블로그 백엔드 개발 프로젝트

// 토큰 발급
// src/auth/services/auth.service.ts

private async createTokens(member: AuthMember, clientType: ClientType, keepLoggedIn:boolean) {
  const payload: JwtPayload = { 
    sub: member.uuid,
    role: member.role,
    tokenVersion: member.tokenVersion,
    keepLoggedIn: keepLoggedIn,
  };
  
  // 짧은 수명의 액세스 토큰 (15분)
  const accessToken = await this.jwtService.signAsync(payload, {
    expiresIn: '15m',
  });
  
  // 긴 수명의 리프레시 토큰 (자동 로그인 여부에 따라 7일 또는 24시간)
  const refreshToken = await this.jwtService.signAsync(payload, {
    expiresIn: keepLoggedIn ? '7d' : '24h',
  });
  
  // 리프레시 토큰 DB 저장 (기존 토큰 무효화 + 새 토큰 발급)
  await this.authRepository.saveRefreshToken(member.id, refreshToken, keepLoggedIn);
  
  return {
    access_token: accessToken,
    refresh_token: refreshToken,
    keepLoggedIn: keepLoggedIn,
  };
}

// 토큰 갱신
// src/auth/services/auth.service.ts
async refreshAccessToken(refreshToken: string, clientType: ClientType): Promise<any> {
  // 토큰 검증
  const payload = await this.jwtService.verifyAsync(refreshToken);
  
  // DB에서 리프레시 토큰 조회 및 유효성 확인
  const tokenData = await this.authRepository.findByRefreshToken(refreshToken);
  
  if (!tokenData || tokenData.revoked) {
    throw new InvalidRefreshTokenException();
  }

  // 회원 정보 불일치 확인
  if (payload.sub !== tokenData.member.uuid) {
    throw new UnauthorizedException('Invalid token ownership');
  }

  // 새 토큰 발급 시 tokenData.member의 정보 사용
  const authMember: AuthMember = {
    id: tokenData.member.id,
    uuid: tokenData.member.uuid,
    // ... 기타 회원 정보
    tokenVersion: tokenData.tokenVersion
  };

  // 새 액세스 토큰과 리프레시 토큰 모두 재발급 (로테이션)
  return this.createTokens(authMember, clientType, tokenData.keepLoggedIn);
}

// 토큰 저장소 관리
// src/auth/repositories/auth.repository.ts
async saveRefreshToken(memberId: number, token: string, keepLoggedIn: boolean): Promise<void> {
  await this.refreshTokenRepository.manager.transaction(async transactionalEntityManager => {
    // 회원 정보 조회
    const member = await transactionalEntityManager.getRepository(Member).findOne({
      where: { id: memberId },
      // ... 필요한 회원 정보 필드들
    });

    // 기존 토큰 무효화 (로테이션)
    await transactionalEntityManager
      .createQueryBuilder()
      .update(RefreshToken)
      .set({
        revoked: true,
        revokedAt: new Date(),
        revokedReason: 'NEW_TOKEN_ISSUED'
      })
      .where('member = :memberId AND revoked = :revoked', { 
        memberId: member.id, 
        revoked: false 
      })
      .execute();

    // 새 토큰 저장
    const tokenEntity = new RefreshToken();
    tokenEntity.token = token;
    tokenEntity.member = member;
    tokenEntity.tokenVersion = member.tokenVersion;
    tokenEntity.keepLoggedIn = keepLoggedIn;
    tokenEntity.expiresAt = new Date(Date.now() + (keepLoggedIn ? 7 * 24 * 60 * 60 * 1000 : 24 * 60 * 60 * 1000));

    await transactionalEntityManager.save(RefreshToken, tokenEntity);
  });
}

// 토큰 저장소 관리
// src/common/interceptors/auth-response.interceptor.ts
@Injectable()
export class AuthResponseInterceptor implements NestInterceptor {
  intercept(context: ExecutionContext, next: CallHandler): Observable<any> {
    return next.handle().pipe(
      map(data => {
        const request = context.switchToHttp().getRequest();
        const response = context.switchToHttp().getResponse();
        const clientType = request.body.clientType || request.headers['x-client-type'];

        if (clientType === ClientType.WEB) {
          if (data.refresh_token) {
            // 리프레시 토큰은 HttpOnly 쿠키로 전송
            response.cookie('refresh_token', data.refresh_token, {
              httpOnly: true,
              secure: true,
              sameSite: 'strict',
              // 자동 로그인 여부에 따라 쿠키 만료 시간 설정
              maxAge: data.keepLoggedIn ? 7 * 24 * 60 * 60 * 1000 : undefined,
            });
            // 응답 객체에서는 리프레시 토큰 삭제
            delete data.refresh_token;
            delete data.keepLoggedIn;
          }
        }
        // 액세스 토큰은 JSON 응답으로 전송 (data.access_token)
        return data;
      }),
    );
  }
}

 // 크론잡을 이용한 만료 토큰 삭제
// src/auth/schedulers/token-cleanup.service.ts
@Injectable()
export class TokenCleanupService {
  constructor(
    @InjectRepository(RefreshToken)
    private refreshTokenRepository: Repository<RefreshToken>,
  ) {}

  @Cron('0 0 * * *') // 매일 자정에 실행
  async cleanupOldTokens() {
    const thirtyDaysAgo = new Date();
    thirtyDaysAgo.setDate(thirtyDaysAgo.getDate() - 30);

    await this.refreshTokenRepository.createQueryBuilder()
      .delete()
      .where('(revoked = :revoked AND revokedAt < :revokedAt)', {
        revoked: true,
        revokedAt: thirtyDaysAgo
      })
      .orWhere('expiresAt < :expiresAt', {
        expiresAt: new Date()
      })
      .execute();
  }
}

// src/members/members.service.ts의 create 메서드 일부

import * as bcrypt from 'bcrypt';  // 비밀번호 해시화를 위한 패키지

async create(createMemberDto: CreateMemberDto): Promise<MemberResponseDto> {
  // ...
  
  // 비밀번호 암호화: bcrypt를 사용한 단방향 해시화 (복호화 불가능)
  // 두 번째 파라미터 10은 해시 강도(salt rounds)로, 높을수록 보안성 증가하나 처리 시간도 증가
  // 솔트(salt)는 bcrypt 내부적으로 자동 생성되어 해시에 포함됨
  memberEntity.password = await bcrypt.hash(createMemberDto.password, 10);
  
  // ...
}

   // src/auth/services/auth.service.ts 파일의 일부
   private async validatePassword(password: string, hashedPassword: string): Promise<boolean> {
     // ...
     const result = await bcrypt.compare(password, hashedPassword);
     return result;
   }

   // src/common/utils/email-util.util.ts 파일의 일부
   private static getEncryptionConfig() {
     const key = process.env.EMAIL_ENCRYPTION_KEY;
     const salt = process.env.EMAIL_ENCRYPTION_SALT;
     // ...
     const derivedKey = crypto.scryptSync(key, salt, 32);
     return { key, salt, derivedKey };
   }

  /**
   * 소셜 로그인 제공자의 인증 URL 생성
   * @param provider 소셜 로그인 제공자 (예: GOOGLE)
   * @throws BadRequestException 지원하지 않는 제공자
   * @return 소셜 로그인 인증 URL
   */
  async getSocialLoginUrl(provider: AuthProvider): Promise<string> {
    const providerKey = provider.toUpperCase();
    let url = AuthProviderUrl[providerKey];
    
    if (!url) {
      throw new BadRequestException(`URL not found for provider: ${provider}`);
    }

    switch (provider) {
      case AuthProvider.GOOGLE:

        const params = new URLSearchParams({
          client_id: process.env.GOOGLE_CLIENT_ID,
          redirect_uri: process.env.GOOGLE_REDIRECT_URI,
          response_type: 'code', // 필수 파라미터
          // scope: 'openid email profile https://www.googleapis.com/auth/userinfo.profile https://www.googleapis.com/auth/userinfo.email',
          scope: 'openid profile email',
          access_type: 'offline',
          prompt: 'consent'
        });
        url = `${url}?${params.toString()}`;
        break;

      default:
        throw new BadRequestException(`Unsupported provider: ${provider}`);
    }

 // 멤버 삭제 (Soft Delete)
  async withdrawMember(member: Member, withdrawnMember: WithdrawnMember): Promise<boolean> {
    try {
      return await this.dataSource.transaction(async (manager) => {
        // 탈퇴 정보 저장
        await manager.save(WithdrawnMember, withdrawnMember);

        // 기존 회원 정보 삭제 처리
        await manager.update(Member, { uuid: member.uuid }, {
          email: `withdrawn_${member.uuid}@deleted.account`,  // not null 때문에 특수한 이메일 형식으로 변경
          hashedEmail: `withdrawn_${member.uuid}`,  // not null 때문에 해시된 이메일도 특수한 형식으로 변경
          name: '[withdrawn member]',
          nickname: '[withdrawn member]',
          phoneNumber: null,
          socialProfiles: null,
          status: MemberStatus.WITHDRAWAL,
          deletedAt: new Date(),
          // 추가적인 개인정보 필드들도 null 처리
          // 보안 관련 필드 초기화 추가
          password: null,
          passwordChangedAt: null,
          passwordResetToken: null,
          passwordResetTokenExpiresAt: null,
          verificationToken: null,
          verificationTokenExpiresAt: null,
          twoFactorSecret: null
        });

        return true;
      });
    } catch (error) { 
      // 에러 로깅
      this.logger.error(`Failed to withdraw member: ${member.uuid}`, error.stack);
      throw new InternalServerErrorException('회원 탈퇴 처리 중 오류가 발생했습니다.');
    }
  }