• 카테고리

    질문 & 답변

  • 세부 분야

    풀스택

  • 해결 여부

    미해결

passport 사용 시 localstrategy 부분에서 오류가 나는 것 같습니다

22.02.07 00:16 작성 조회수 332

0

안녕하세요. passport local 로그인 실습을 하다가 막히는 부분이 있어 질문드립니다.

현재 postman으로 실험 시 회원가입은 정상적으로 진행이 되는 것 같은데,  postman으로 로그인 시도 시 다음과 같은 오류코드가 발생합니다.

Error: Invalid value <ref *1> IncomingMessage {

  _readableState: ReadableState {

    objectMode: false,

    highWaterMark: 16384,

    buffer: BufferList { head: null, tail: null, length: 0 },

    length: 0,

    pipes: [],

    flowing: true,

    ended: true,

    endEmitted: true,

    reading: false,

    sync: false,

    needReadable: false,

    emittedReadable: false,

    readableListening: false,

    resumeScheduled: false,

    errorEmitted: false,

    emitClose: true,

    autoDestroy: false,

    destroyed: false,

    errored: null,

    closed: false,

    closeEmitted: false,

    defaultEncoding: 'utf8',

    awaitDrainWriters: null,

    multiAwaitDrain: false,

    readingMore: false,

    decoder: null,

    encoding: null,

    [Symbol(kPaused)]: false

  },

  _events: [Object: null prototype] { end: [Function: clearRequestTimeout] },

  _eventsCount: 1,

  _maxListeners: undefined,

  socket: Socket {

    connecting: false,

    _hadError: false,

    _parent: null,

    _host: null,

    _readableState: [ReadableState],

    _events: [Object: null prototype],

    _eventsCount: 8,

    _maxListeners: undefined,

    _writableState: [WritableState],

    allowHalfOpen: true,

    _sockname: null,

    _pendingData: null,

    _pendingEncoding: '',

    server: [Server],

    _server: [Server],

    parser: [HTTPParser],

    on: [Function: socketListenerWrap],

    addListener: [Function: socketListenerWrap],

    prependListener: [Function: socketListenerWrap],

    _paused: false,

    _httpMessage: [ServerResponse],

    _peername: [Object],

    [Symbol(async_id_symbol)]: 78,

    [Symbol(kHandle)]: [TCP],

    [Symbol(kSetNoDelay)]: false,

    [Symbol(lastWriteQueueSize)]: 0,

    [Symbol(timeout)]: null,

    [Symbol(kBuffer)]: null,

    [Symbol(kBufferCb)]: null,

    [Symbol(kBufferGen)]: null,

    [Symbol(kCapture)]: false,

    [Symbol(kBytesRead)]: 0,

    [Symbol(kBytesWritten)]: 0,

    [Symbol(RequestTimeout)]: undefined

  },

  httpVersionMajor: 1,

  httpVersionMinor: 1,

  httpVersion: '1.1',

  complete: true,

  headers: {

    'content-type': 'application/json',

    'user-agent': 'PostmanRuntime/7.29.0',

    accept: '*/*',

    'postman-token': '667cd00d-55cb-434f-80ee-6800fe7e4d60',

    host: 'localhost:3000',

    'accept-encoding': 'gzip, deflate, br',

    connection: 'keep-alive',

    'content-length': '76',

    cookie: 'connect.sid=s%3Atv5OOUthLZaPN8ZQChSAm4qaJB0CZbgU.MrtvXtMcWOoYkXGY0dY4H%2F6tGs25VsY8vJoRPQvx%2FMI'

  },

  rawHeaders: [

    'Content-Type',

    'application/json',

    'User-Agent',

    'PostmanRuntime/7.29.0',

    'Accept',

    '*/*',

    'Postman-Token',

    '667cd00d-55cb-434f-80ee-6800fe7e4d60',

    'Host',

    'localhost:3000',

    'Accept-Encoding',

    'gzip, deflate, br',

    'Connection',

    'keep-alive',

    'Content-Length',

    '76',

    'Cookie',

    'connect.sid=s%3Atv5OOUthLZaPN8ZQChSAm4qaJB0CZbgU.MrtvXtMcWOoYkXGY0dY4H%2F6tGs25VsY8vJoRPQvx%2FMI'

  ],

  trailers: {},

  rawTrailers: [],

  aborted: false,

  upgrade: false,

  url: '/login',

  method: 'POST',

  statusCode: null,

  statusMessage: null,

  client: Socket {

    connecting: false,

    _hadError: false,

    _parent: null,

    _host: null,

    _readableState: [ReadableState],

    _events: [Object: null prototype],

    _eventsCount: 8,

    _maxListeners: undefined,

    _writableState: [WritableState],

    allowHalfOpen: true,

    _sockname: null,

    _pendingData: null,

    _pendingEncoding: '',

    server: [Server],

    _server: [Server],

    parser: [HTTPParser],

    on: [Function: socketListenerWrap],

    addListener: [Function: socketListenerWrap],

    prependListener: [Function: socketListenerWrap],

    _paused: false,

    _httpMessage: [ServerResponse],

    _peername: [Object],

    [Symbol(async_id_symbol)]: 78,

    [Symbol(kHandle)]: [TCP],

    [Symbol(kSetNoDelay)]: false,

    [Symbol(lastWriteQueueSize)]: 0,

    [Symbol(timeout)]: null,

    [Symbol(kBuffer)]: null,

    [Symbol(kBufferCb)]: null,

    [Symbol(kBufferGen)]: null,

    [Symbol(kCapture)]: false,

    [Symbol(kBytesRead)]: 0,

    [Symbol(kBytesWritten)]: 0,

    [Symbol(RequestTimeout)]: undefined

  },

  _consuming: true,

  _dumped: false,

  next: [Function: next],

  baseUrl: '/auth',

  originalUrl: '/auth/login',

  _parsedUrl: Url {

    protocol: null,

    slashes: null,

    auth: null,

    host: null,

    port: null,

    hostname: null,

    hash: null,

    search: null,

    query: null,

    pathname: '/login',

    path: '/login',

    href: '/login',

    _raw: '/login'

  },

  params: {},

  query: {},

  res: ServerResponse {

    _events: [Object: null prototype],

    _eventsCount: 2,

    _maxListeners: undefined,

    outputData: [],

    outputSize: 0,

    writable: true,

    destroyed: false,

    _last: false,

    chunkedEncoding: false,

    shouldKeepAlive: true,

    _defaultKeepAlive: true,

    useChunkedEncodingByDefault: true,

    sendDate: true,

    _removedConnection: false,

    _removedContLen: false,

    _removedTE: false,

    _contentLength: null,

    _hasBody: true,

    _trailer: '',

    finished: false,

    _headerSent: false,

    socket: [Socket],

    _header: null,

    _keepAliveTimeout: 5000,

    _onPendingData: [Function: bound updateOutgoingData],

    _sent100: false,

    _expect_continue: false,

    req: [Circular *1],

    locals: [Object: null prototype] {},

    _startAt: undefined,

    _startTime: undefined,

    writeHead: [Function: writeHead],

    __onFinished: [Function],

    end: [Function: end],

    [Symbol(kCapture)]: false,

    [Symbol(kNeedDrain)]: false,

    [Symbol(corked)]: 0,

    [Symbol(kOutHeaders)]: [Object: null prototype]

  },

  _startAt: [ 779390, 642704127 ],

  _startTime: 2022-02-06T14:57:51.132Z,

  _remoteAddress: '::1',

  body: { email: 's2s2ss@naver.com', name: 'ddd', password: '12343' },

  _body: true,

  length: undefined,

  secret: 'nodepracticesecret',

  cookies: {},

  signedCookies: [Object: null prototype] {

    'connect.sid': 'tv5OOUthLZaPN8ZQChSAm4qaJB0CZbgU'

  },

  _parsedOriginalUrl: Url {

    protocol: null,

    slashes: null,

    auth: null,

    host: null,

    port: null,

    hostname: null,

    hash: null,

    search: null,

    query: null,

    pathname: '/auth/login',

    path: '/auth/login',

    href: '/auth/login',

    _raw: '/auth/login'

  },

  sessionStore: MemoryStore {

    _events: [Object: null prototype],

    _eventsCount: 2,

    _maxListeners: undefined,

    sessions: [Object: null prototype] {},

    generate: [Function (anonymous)],

    [Symbol(kCapture)]: false

  },

  sessionID: '8oW9NcDPX2SJzfB5KT6guRURg59uUftq',

  session: Session { cookie: [Object] },

  flash: [Function: _flash],

  _passport: { instance: [Authenticator] },

  logIn: [Function (anonymous)],

  login: [Function (anonymous)],

  logOut: [Function (anonymous)],

  logout: [Function (anonymous)],

  isAuthenticated: [Function (anonymous)],

  isUnauthenticated: [Function (anonymous)],

  _sessionManager: SessionManager {

    _key: 'passport',

    _serializeUser: [Function: bound ]

  },

  route: Route { path: '/login', stack: [Array], methods: [Object] },

  [Symbol(kCapture)]: false,

  [Symbol(RequestTimeout)]: undefined

}

    at Object.escape (/Users/macintosh/Desktop/node_practice/node_practice/node_modules/sequelize/dist/lib/sql-string.js:52:11)

    at MySQLQueryGenerator.escape (/Users/macintosh/Desktop/node_practice/node_practice/node_modules/sequelize/dist/lib/dialects/abstract/query-generator.js:709:22)

    at MySQLQueryGenerator.whereItemQuery (/Users/macintosh/Desktop/node_practice/node_practice/node_modules/sequelize/dist/lib/dialects/abstract/query-generator.js:1733:102)

    at /Users/macintosh/Desktop/node_practice/node_practice/node_modules/sequelize/dist/lib/dialects/abstract/query-generator.js:1646:25

    at Array.forEach (<anonymous>)

    at MySQLQueryGenerator.whereItemsQuery (/Users/macintosh/Desktop/node_practice/node_practice/node_modules/sequelize/dist/lib/dialects/abstract/query-generator.js:1644:35)

    at /Users/macintosh/Desktop/node_practice/node_practice/node_modules/sequelize/dist/lib/dialects/abstract/query-generator.js:1752:30

    at Array.map (<anonymous>)

    at MySQLQueryGenerator._whereGroupBind (/Users/macintosh/Desktop/node_practice/node_practice/node_modules/sequelize/dist/lib/dialects/abstract/query-generator.js:1751:21)

    at MySQLQueryGenerator.whereItemQuery (/Users/macintosh/Desktop/node_practice/node_practice/node_modules/sequelize/dist/lib/dialects/abstract/query-generator.js:1702:19)

(node:8940) UnhandledPromiseRejectionWarning: TypeError: done is not a function

    at Strategy._verify (/Users/macintosh/Desktop/node_practice/node_practice/passport/localStrategy.js:30:13)

(Use `node —trace-warnings …` to show where the warning was created)

(node:8940) UnhandledPromiseRejectionWarning: Unhandled promise rejection. This error originated either by throwing inside of an async function without a catch block, or by rejecting a promise which was not handled with .catch(). To terminate the node process on unhandled promise rejection, use the CLI flag `—unhandled-rejections=strict` (see https://nodejs.org/api/cli.html#cli_unhandled_rejections_mode). (rejection id: 2)

(node:8940) [DEP0018] DeprecationWarning: Unhandled promise rejections are deprecated. In the future, promise rejections that are not handled will terminate the Node.js process with a non-zero exit code.

 

PromiseRejectionWarning 부분이  async await 에러 핸들링을 안 해줘서 생긴다고 하는데, 교재에 나와있는대로 localstrategy부분의 에러 핸들링 부분은 교재와 비슷하게 적은 것 같은데...왜 오류가 나는지 잘 모르겠습니다ㅠㅠ

 

//localStrategy.js
const passport = require('passport');
const localStrategy = require('passport-local').Strategy;
const bcrypt = require('bcrypt');

const { user } = require('../models');

module.exports = () => {
    passport.use(new localStrategy({
        passReqToCallback : true,
        usernameField:'email',
        passwordField:'password',
    },
    async (email, password, done) => {
        try{
            const exUser = await user.findOne({where:{email}});
            if (exUser) {
                const result = await user.findOne({where:{password}});
                // const result = await bcrypt.compare(password, exUser.password);
                if(result){
                    done(null, exUser);
                } else {
                    done(null, false, {message:'비밀번호가 불일치'});
                }
            } else {
                done(null, false, {message:'가입되지 않은 회원입니다'});
            }
        } catch (err) {
            console.error(err);
            done(err);
        }
    }
    ));
};

위의 코드는 passport/localStrategy.js 파일이며,

 

아래 코드는 routes/auth.js 파일입니다.

const express = require('express');
const passport = require('passport');
const bcrypt = require('bcrypt');
const { isLoggedIn, isNotLoggedIn } = require('./middlewares');
const { user } = require('../models');

const router = express.Router();

//회원가입 라우터
router.post('/join', isNotLoggedIn, async (req,res,next) => {
    const { email, name, password } = req.body;
    try {
        const exUser = await user.findOne({where:{ email }});
        if (exUser) {
            req.flash('joinError', '이미 가입된 이메일입니다')
            return res.redirect('/join')
        }
        await user.create({
            email,
            name,
            password,
        });
        return res.redirect('/');
    } catch (error) {
        console.error(error);
        return next(error);
    }
});

//db 확인
router.get('/list', async(req,res)=>{
    try{
      const rows = await user.findAll();
      if (rows) return res.status(200).json({result : rows});
      else throw console.log(error);
    } catch(err){
      console.error(err);
    }
  });

//로그인 라우터
router.post('/login', isNotLoggedIn, (req,res,next)=>{
    //로컬 로그인 전략 성공 시 수행되는 매서드
    passport.authenticate('local', {session: false}, (authError, user, info)=>{
        if (authError){
            console.error(authError);
            return next(authError);
        }
        if (!user) {
            req.flash('login-error', info.message);
            return res.redirect('/');
        }
        console.log(user);
        return req.login(user, (loginError) =>{
            if (loginError) {
                console.error(loginError);
                return next(loginError);
            }
            return res.redirect('/');
        });
    })(req, res, next);
});

//로그아웃 라우터
router.get('/logout', isLoggedIn, (req,res)=>{
    req.logOut();
    req.session.destroy();
    res.redirect('/');
});

module.exports = router;

 

course-thumbnail

[리뉴얼] Node.js 교과서 - 기본부터 프로젝트 실습까지

답변 1

답변을 작성해보세요.

0

조현영님의 프로필

조현영

지식공유자

2022.02.07

passReqToCallback을 true로 하시면 (req, email, password, done) => { 이어야 합니다.

이게 req를 콜백에다가 추가하겠다는 의미라서요.

이 글과 비슷한 Q&A