yarn add @nestjs/passport
yarn add passport
yarn add passport-naver-v2

import { ExecutionContext, Injectable } from '@nestjs/common';
import { AuthGuard } from '@nestjs/passport';

@Injectable()
export class NaverAuthGuard extends AuthGuard('naver') {
  constructor() {
    super();
  }

  handleRequest<TUser = any>(err: any, user: any, info: any, context: ExecutionContext, status?: any): TUser {
    //에러가 존재하면 에러 처리로 넘긴다.
    if (err || !user) {
      throw err;
    }
    return user;
  }
}

export declare type IAuthGuard = CanActivate & {
  logIn<
    TRequest extends {
      logIn: Function;
    } = any,
  >(
    request: TRequest,
  ): Promise<void>;
  handleRequest<TUser = any>(err: any, user: any, info: any, context: ExecutionContext, status?: any): TUser;
  getAuthenticateOptions(context: ExecutionContext): IAuthModuleOptions | undefined;
};
export declare const AuthGuard: (type?: string | string[]) => Type<IAuthGuard>;

import { Inject, Injectable } from '@nestjs/common'
import { PassportStrategy } from '@nestjs/passport'
import { Request } from 'express'
import { Profile, Strategy } from 'passport-naver-v2'
import { AccountErrorCode } from 'src/domain/account/exceptions/account.error.code'
import { AccountException } from 'src/domain/account/exceptions/account.exception'
import {
  IsExistAccountInboundPort,
  IS_EXIST_ACCOUNT_INBOUND_PORT,
} from 'src/domain/account/ports/in/is.exist.account.inbound.port'
import {
  JoinAccountInboundPort,
  JOIN_ACCOUNT_INBOUND_PORT,
} from 'src/domain/account/ports/in/join.account.inbound.port'
import {
  LoginAccountInboundPort,
  LOGIN_ACCOUNT_INBOUND_PORT,
} from 'src/domain/account/ports/in/login.account.inbound.port'
import {
  ACCOUNT_FIND_TYPE,
  ACCOUNT_JOIN_TYPE,
  ACCOUNT_STATUS_TYPE,
} from 'src/domain/account/types/account.enums'
import {
  CreateJwtOutboundPort,
  CREATE_JWT_OUTBOUND_PORT,
} from '../ports/out/jwt/create.jwt.outbound.port'
import { SnsLoginOutputDto } from '../types/strategy.type'
import { snsAccountJoin } from './helper/join.account.helper'
import { snsLoginAccount } from './helper/sns.login.helper'
import { makeNickName } from 'src/domain/account/utils/make.nickname.util'
import {
  IsResignAccountInboundPort,
  IS_RESIGN_ACCOUNT_INBOUND_PORT,
} from 'src/domain/account/ports/in/is.resign.account.inbound.port'

@Injectable()
export class NaverOAuthStrategy extends PassportStrategy(Strategy, 'naver') {
  constructor(
    @Inject(JOIN_ACCOUNT_INBOUND_PORT)
    private readonly joinAccountOutboundPort: JoinAccountInboundPort,
    @Inject(LOGIN_ACCOUNT_INBOUND_PORT)
    private readonly loginAccountInboundPort: LoginAccountInboundPort,

    @Inject(IS_EXIST_ACCOUNT_INBOUND_PORT)
    private readonly isExistAccountInboundPort: IsExistAccountInboundPort,
    @Inject(CREATE_JWT_OUTBOUND_PORT)
    private readonly createJwtOutboundPort: CreateJwtOutboundPort,
    @Inject(IS_RESIGN_ACCOUNT_INBOUND_PORT)
    private readonly isResignAcountInbound: IsResignAccountInboundPort
  ) {
    super({
      clientID: process.env.NAVER_CLIENT_ID,
      clientSecret: process.env.NAVER_CLIENT_PW,
      callbackURL: process.env.NAVER_CALLBACK,
      passReqToCallback: true,
    })
  }

  async validate(
    req: Request,
    accessToken: string,
    refreshToken: string,
    profile: Profile
  ): Promise<SnsLoginOutputDto> {
    const { email } = profile

    if (email === undefined) {
      return {
        email: undefined,
        joinType: undefined,
        lastLoginInfo: undefined,
        accessToken: undefined,
        bcode: undefined,
      }
    }

    //탈퇴 6개월 이내를 체크한다.
    const isResignAccount = await this.isResignAcountInbound.excute({
      email,
      joinType: ACCOUNT_JOIN_TYPE.SNS_GOOGLE,
    })
    if (isResignAccount.isResign) {
      throw new AccountException(AccountErrorCode.AccessResignAccount())
    }

    //계정이 존재하는지 체크
    const isExistAccountType = await this.isExistAccountInboundPort.excute({
      email,
      joinType: ACCOUNT_JOIN_TYPE.SNS_NAVER,
    })

    //회원이 가입 안된 상태 => 회원 가입 진행
    if (isExistAccountType.findType === ACCOUNT_FIND_TYPE.NO_EXIST) {
      //회원가입 진행 로직 수행
      return snsAccountJoin({...})
    }
    //이미 계정이 존재 => 로그인
    else if (isExistAccountType.findType === ACCOUNT_FIND_TYPE.EXIST) {
      return snsLoginAccount({...})
    }
  }
}

super({
      clientID: process.env.NAVER_LOGIN_CLIENT_ID,
      clientSecret: process.env.NAVER_LOGIN_CLIENT_PW,
      callbackURL: process.env.NAVER_LOGIN_CALLBACK,
      passReqToCallback: true,
    })

req: Request,
accessToken: string,
refreshToken: string,
profile: Profile

export type Profile = {
  provider: 'naver';
  id: string;
  nickname?: string;
  profileImage?: string;
  age?: string;
  gender?: string;
  email?: string;
  mobile?: string;
  mobileE164?: string;
  name?: string;
  birthday?: string;
  birthYear?: string;
  _raw: string;
  _json: string;
};

import { Controller, Get, Inject, Req, Res, UseFilters, UseGuards } from '@nestjs/common';
import { Request, Response } from 'express';
import { AuthExceptionHandler } from 'src/domain/auth/exceptions/auth.exception.handle';
import { NaverAuthGuard } from 'src/domain/auth/guard/naver.guard';
import { CustomLoggerService } from 'src/domain/logger/services/custom.logger';
import { AccountExceptionHandler } from '../../exceptions/account.exception.handler';
import { ACCOUNT_JOIN_TYPE } from '../../types/account.enums';
import LoginControllerHelper from './login.controller.helper';

@Controller('account')
export class LoginSnsNaverController extends LoginControllerHelper {
  constructor(@Inject(CustomLoggerService) readonly logger: CustomLoggerService) {
    super(logger);
  }

  @Get('login/sns/naver')
  @UseGuards(NaverAuthGuard)
  async snsLogin4Naver() {}

  @Get('login/sns/naver/cb')
  @UseGuards(NaverAuthGuard)
  @UseFilters(AccountExceptionHandler)
  @UseFilters(AuthExceptionHandler)
  async snsLogin4NaverCallBack(@Req() req: any, @Res() res: Response) {
    const redirectUrl = this.loginCallback(req, res, ACCOUNT_JOIN_TYPE.SNS_NAVER);
    return res.redirect(redirectUrl);
  }
}

console.log('req = ', req.user);