[노드 1팀] 9장. 익스프레스로 SNS 서비스 만들기

24-25/Node.js 1

by gooroominuna 2025. 1. 3. 10:00

728x90

📌 이번 장에서는 로그인, 이미지 업로드, 게시글 작성, 해시태그 검색, 팔로잉 등의 기능이 있는 SNS 서비스를 만든다.

9.1. 프로젝트 구조 갖추기

다음과 같이 앱명인 'nodebird'라는 이름으로 폴더를 만들고 package.json을 생성한다.
시퀄라이즈도 설치한다.

$ npm init
$ npm i sequelize mysql2 sequelize-cli
$ npx sequelize init

다음과 같이 폴더의 구조를 갖춘다.

nodebird
> config
> migrations
> models
> node_modules
> passport
> public
> routes
> seeders
> views
.env
app.js
{ } package-lock.json
{ } package.json

그다음, 필요한 npm 패키지를 설치한 후

$ npm i express cookie-parser express-session morgan multer dotenv nunjucks
$ npm i -D nodemon

다음과 같이 app.js를 작성한다.

const express = require('express');
const cookieParser = require('cookie-parser');
const morgan = require('morgan');
const path = require('path');
const session = require('express-session');
const nunjucks = require('nunjucks');
const dotenv = require('dotenv');

dotenv.config();
const pageRouter = require('./routes/page');

const app = express();
app.set('port', process.env.PORT || 8001); // 앱을 8001번 포트에 연결
app.set('view engine', 'html');
nunjucks.configure('views', {
  express: app,
  watch: true,
});

app.use(morgan('dev'));
app.use(express.static(path.join(__dirname, 'public')));
app.use(express.json());
app.use(express.urlencoded({ extended: false }));
app.use(cookieParser(process.env.COOKIE_SECRET));
app.use(session({
  resave: false,
  saveUninitialized: false,
  secret: process.env.COOKIE_SECRET,
  cookie: {
    httpOnly: true,
    secure: false,
  },
}));

app.use('/', pageRouter);

app.use((req, res, next) => {
  const error =  new Error(`${req.method} ${req.url} 라우터가 없습니다.`);
  error.status = 404; // 라우터가 없을 시 404 에러 반환
  next(error);
});

app.use((err, req, res, next) => {
  res.locals.message = err.message;
  res.locals.error = process.env.NODE_ENV !== 'production' ? err : {};
  res.status(err.status || 500);
  res.render('error');
});

app.listen(app.get('port'), () => {
  console.log(app.get('port'), '번 포트에서 대기중');
});

아래는 기본적인 라우터와 템플릿 엔진이다.

const express = require('express');
const { renderProfile, renderJoin, renderMain } = require('../controllers/page');

const router = express.Router();

router.use((req, res, next) => {
  res.locals.user = null;
  res.locals.followerCount = 0;
  res.locals.followingCount = 0;
  res.locals.followingIdList = [];
  next();
});

router.get('/profile', renderProfile);

router.get('/join', renderJoin);

router.get('/', renderMain);

module.exports = router;

위 코드를 살펴보면, router.use로 라우터용 미들웨어를 만들어 템플릿 엔진에서 사용할 user, followingCount, followerCount, followingIdList 변수를 res.locals로 설정한다. 여기서 이전과는 다르게 라우터의 미들웨어를 다른 곳에서 불러오고 있다는 점을 주목해야 한다.

컨트롤러

: 아래 renderProfile, renderJoin, renderMain과 같이 라우터 마지막에 위치해 클라이언트에 응답을 보내는 미들웨어를 말한다.

exports.renderProfile = (req, res) => {
  res.render('profile', { title: '내 정보 - NodeBird' });
};

exports.renderJoin = (req, res) => {
  res.render('join', { title: '회원가입 - NodeBird' });
};

exports.renderMain = (req, res, next) => {
  const twits = [];
  res.render('main', {
    title: 'NodeBird',
    twits,
  });
};

컨트롤러는 실무에서 코드를 편리하게 관리하기 위해 사용한다고 보면 된다.

그 외에 필요한 html, css 코드는 https://github.com/ZeroCho/nodejs-book/tree/master 에서 참조하기 바란다.

9.2. 데이터베이스 세팅하기

📌 사용자 테이블, 게시글 테이블, 해시태그 테이블

models
> user.js
> post.js
> hashtag.js

사용자 테이블(models/user.js)

사용자 정보(이메일, 닉네임, 비밀번호)를 저장하는 테이블이다. 이는 로그인 기능에 사용된다.

const Sequelize = require('sequelize');

class User extends Sequelize.Model {
  static initiate(sequelize) {
    User.init({
      email: {
        type: Sequelize.STRING(40),
        allowNull: true,
        unique: true,
      },
      nick: {
        type: Sequelize.STRING(15),
        allowNull: false,
      },
      password: {
        type: Sequelize.STRING(100),
        allowNull: true,
      },
      provider: { // SNS 로그인을 했을 경우 저장
        type: Sequelize.ENUM('local', 'kakao'),
        allowNull: false,
        defaultValue: 'local',
      },
      snsId: { // SNS 로그인을 했을 경우 저장
        type: Sequelize.STRING(30),
        allowNull: true,
      },
    }, {
      sequelize, // 테이블 옵션
      timestamps: true,
      underscored: false,
      modelName: 'User',
      tableName: 'users',
      paranoid: true,
      charset: 'utf8',
      collate: 'utf8_general_ci',
    });
  }
  
  static associate(db) {}
};

module.exports = User;

게시글 테이블 (models/post.js)

게시글 내용과 이미지 경로를 저장한다.

const Sequelize = require('sequelize');

class Post extends Sequelize.Model {
  static initiate(sequelize) {
    Post.init({
      content: {
        type: Sequelize.STRING(140),
        allowNull: false,
      },
      img: {
        type: Sequelize.STRING(200),
        allowNull: true,
      },
    }, {
      sequelize,
      timestamps: true,
      underscored: false,
      modelName: 'Post',
      tableName: 'posts',
      paranoid: false,
      charset: 'utf8mb4',
      collate: 'utf8mb4_general_ci',
    });
  }
  
  static associate(db) {
    db.Post.belongsTo(db.User);
    db.Post.belongsToMany(db.Hashtag, {through: 'PostHashtag'});
  }
}

module.exports = Post;

해시태그 테이블 (models/hashtag.js)

태그 이름을 저장한다.

const Sequelize = require('sequelize');

class Hashtag extends Sequelize.Model {
  static initiate(sequelize) {
    Hashtag.init({
      title: {
        type: Sequelize.STRING(15),
        allowNull: false,
        unique: true,
      },
    }, {
      sequelize,
      timestamps: true,
      underscored: false,
      modelName: 'Hashtag',
      tableName: 'hashtags',
      paranoid: false,
      charset: 'utf8mb4',
      collate: 'utf8mb4_general_ci',
    });
  }

  static associate(db) {
    db.Hashtag.belongsToMany(db.Post, { through: 'PostHashtag' });
  }
};

module.exports = Hashtag;

시퀄라이즈 (models/index.js)

위에서 생성한 모델을 시퀄라이즈에 등록한 후, 각각의 모델을 시퀄라이즈 객체에 연결한다.

const Sequelize = require('sequelize');
const fs = require('fs');
const path = require('path');
const env = process.env.NODE_ENV || 'development';
const config = require('../config/config')[env];

const db = {};
const sequelize = new Sequelize(
  config.database, config.username, config.password, config,
);

db.sequelize = sequelize;

const basename = path.basename(__filename);
fs
  .readdirSync(__dirname) // 현재 폴더의 모든 파일을 조회
  .filter(file => { // 숨김 파일, index.js, js 확장자가 아닌 파일 필터링
    return (file.indexOf('.') !== 0) && (file !== basename) && (file.slice(-3) === '.js');
  })
  .forEach(file => { // 해당 파일의 모델 불러와서 init
    const model = require(path.join(__dirname, file));
    console.log(file, model.name);
    db[model.name] = model;
    model.initiate(sequelize);
  });

Object.keys(db).forEach(modelName => { // associate 호출
  if (db[modelName].associate) {
    db[modelName].associate(db);
  }
});

module.exports = db;

각 모델 간의 관계를 models/user.js 속 associate 함수 내에 정의한다.

  static associate(db) {
    db.User.hasMany(db.Post);
    db.User.belongsToMany(db.User, {
      foreignKey: 'followingId',
      as: 'Followers',
      through: 'Follow',
    });
    db.User.belongsToMany(db.User, {
      foreignKey: 'followerId',
      as: 'Followings',
      through: 'Follow',
    });
  }
};

N:M 관계

위 모델들은 N:M 관계를 가진다.

하나의 사용자가 다른 사용자와 관계를 맺을 수 있는 관계를 N:M 관계라고 하는데, 팔로잉 기능이 대표적이다.

동일한 테이블을 참조하는 관계를 구분하기 위해서는 as 옵션을 사용한다.

followerId: 팔로우를 한 사용자 ID
followingId: 팔로우를 받은 사용자 ID
foreignKey가 followerId라는 것은 팔로우를 한 사용자를 나타내므로, 이를 구분하기 위해 as를 'Followings'로 설정한다.
foreignKey가 followingId라는 것은 팔로우를 받은 사용자를 나타내므로, 이를 구분하기 위해 as를 'Followers'로 설정한다.

데이터베이스를 모두 설정한 후에는 다음과 같이 app.js에 모델을 서버와 연결한다.

...
dotenv.config();
const pageRouter = require('./routes/page');
**const { sequelize } = require('./models');**

const app = express();
app.set('port', process.env.PORT || 8001);
app.set('view engine', 'html');
nunjucks.configure('views', {
  express: app,
  watch: true,
});
**sequelize.sync({ force: false })
  .then(() => {
    console.log('데이터베이스 연결 성공');
  })
  .catch((err) => {
    console.error(err);
  });**

app.use(morgan('dev'));
...

9.3. Passport 모듈로 로그인 구현하기

📌 로그인 기능

복잡한 작업을 직접 구현하기보단, 이미 검증된 모듈인 Passport 모듈을 이용해 로그인 기능을 구현한다.

먼저 Passport 관련 패키지를 설치한다.

$ npm i passport passport-local passport-kakao bcrypt

Passport (passport/index.js)

const passport = require('passport');
const local = require('./localStrategy');
const kakao = require('./kakaoStrategy');
const User = require('../models/user');

module.exports = () => {
  passport.serializeUser((user, done) => {
    done(null, user.id);
  });

  passport.deserializeUser((id, done) => {
    User.findOne({ where: { id } })
      .then(user => done(null, user))
      .catch(err => done(err));
  });

  local();
  kakao();
};

위 코드에서

serializeUser: 사용자 정보 객체에서 아이디를 추려 세션에 저장한다. 로그인 시 실행되며, req.session 객체에 어떤 데이터를 저장할지 정한다.
deserializeUser: 세션에 불필요한 데이터를 담아두지 않기 위해, 세션에 저장한 아이디를 통해 사용자 정보 객체 불러온다.

로그인 과정은 다음과 같다.

1. /auth/login 라우터를 통해 로그인 요청이 들어옴
2. 라우터에서 passport.authenticate 메서드 호출
3. 로그인 로직 수행
4. 로그인 성공 시 사용자 정보 객체와 함께 req.login 호출
5. req.login 메서드가 passport/serializeUser 호출
6. req.session에 사용자 아이디만 저장해서 세션 생성
7. express-session에 설정한 대로 브라우저에 connect.sid 세션 쿠키 전송
8. 로그인 완료

로그인 이후의 과정은 다음과 같다.

1. 요청이 들어옴
2. 라우터에 요청이 도달하기 전에 passport.session 미들웨어가 passport.deserializeUser 메서드 호출
3. connect.sid 세션 쿠키를 읽고 세션 객체를 찾아서 req.session으로 만듦
4. req.session에 저장된 아이디로 데이터베이스에서 사용자 조회
5. 조회된 사용자 정보를 req.user에 저장(deserializeUser)
6. 라우터에서 req.user 객체 사용 가능

9.3.1. 로컬 로그인 구현하기

📌 자체적으로 회원 가입 후 로그인하는 것 (아이디/비밀번호 or 이메일/비밀번호로 로그인)

passport-local 모듈을 사용하여 구현한다.

회원 가입, 로그인, 로그아웃 라우터 만들기

로그인한 사용자: 회원 가입과 로그인 라우터에 접근하면 안 된다.
로그인하지 않은 사용자: 로그아웃 라우터에 접근하면 안 된다.

-> 접근 권한을 제한하는 미들웨어가 필요 (middlewares/index.js)

exports.isLoggedIn = (req, res, next) => {
  if (req.isAuthenticated()) { // 로그인 x 상태
    next();
  } else {
    res.status(403).send('로그인 필요');
  }
};

exports.isNotLoggedIn = (req, res, next) => {
  if (!req.isAuthenticated()) { // 로그인 o 상태
    next();
  } else {
    const message = encodeURIComponent('로그인한 상태입니다.');
    res.redirect(`/?error=${message}`);
  }
};

이 미들웨어가 page 라우터에 다음과 같이 적용된다. (routes/page.js)

const express = require('express');
const { isLoggedIn, isNotLoggedIn } = require('../middlewares');
const { renderProfile, renderJoin, renderMain } = require('../controllers/page');

const router = express.Router();

router.use((req, res, next) => {
  res.locals.user = req.user;
  res.locals.followerCount = 0;
  res.locals.followingCount = 0;
  res.locals.followingIdList = [];
  next();
});

router.get('/profile', isLoggedIn, renderProfile);

router.get('/join', isNotLoggedIn, renderJoin);

router.get('/', renderMain);

module.exports = router;

위처럼 접근 설정을 완료하였으면, 회원 가입, 로그인, 로그아웃 라우터를 작성한다. (routes/auth.js)

const express = require('express');
const passport = require('passport');

const { isLoggedIn, isNotLoggedIn } = require('../middlewares');
const { join, login, logout } = require('../controllers/auth');

const router = express.Router();

// POST /auth/join
router.post('/join', isNotLoggedIn, join); 

// POST /auth/login
router.post('/login', isNotLoggedIn, login);

// GET /auth/logout
router.get('/logout', isLoggedIn, logout);

// GET /auth/kakao
router.get('/kakao', passport.authenticate('kakao'));

// GET /auth/kakao/callback
router.get('/kakao/callback', passport.authenticate('kakao', {
  failureRedirect: '/?error=카카오로그인 실패',
}), (req, res) => {
  res.redirect('/'); // 성공 시에는 /로 이동
});

module.exports = router;

회원 가입, 로그인, 로그아웃 컨트롤러도 작성한다. (controllers/auth.js)

const bcrypt = require('bcrypt');
const passport = require('passport');
const User = require('../models/user');

// 회원 가입 컨트롤러
exports.join = async (req, res, next) => {
  const { email, nick, password } = req.body;
  try {
    const exUser = await User.findOne({ where: { email } });
    if (exUser) {
      return res.redirect('/join?error=exist');
    }
    const hash = await bcrypt.hash(password, 12);
    await User.create({
      email,
      nick,
      password: hash,
    });
    return res.redirect('/');
  } catch (error) {
    console.error(error);
    return next(error);
  }
}

// 로그인 컨트롤러
exports.login = (req, res, next) => {
  passport.authenticate('local', (authError, user, info) => {
    if (authError) {
      console.error(authError);
      return next(authError);
    }
    if (!user) {
      return res.redirect(`/?error=${info.message}`);
    }
    return req.login(user, (loginError) => {
      if (loginError) {
        console.error(loginError);
        return next(loginError);
      }
      return res.redirect('/');
    });
  })(req, res, next); // 미들웨어 내의 미들웨어에는 (req, res, next)를 붙입니다.
};

// 로그아웃 컨트롤러
exports.logout = (req, res) => {
  req.logout(() => {
    res.redirect('/');
  });
};

마지막으로 로그인 전략을 구현하면 된다. (passport/localStrategy.js)

const passport = require('passport');
const LocalStrategy = require('passport-local').Strategy;
const bcrypt = require('bcrypt');

const User = require('../models/user');

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

전략은 다음과 같은 로직을 가진다.

9.3.2. 카카오 로그인 구현하기

📌 로그인 인증 과정을 카카오에 맡기는 것

passport-kakao 모듈로부터 Strategy 생성자를 불러와 전략을 구현한다.

카카오 로그인 전략 작성하기 (passport/kakaoStrategy.js)

const passport = require('passport');
const KakaoStrategy = require('passport-kakao').Strategy;

const User = require('../models/user');

// 카카오 로그인에 대한 설정
module.exports = () => {
  passport.use(new KakaoStrategy({
    clientID: process.env.KAKAO_ID,
    callbackURL: '/auth/kakao/callback',
  }, async (accessToken, refreshToken, profile, done) => { // 카카오 회원가입 여부 조회
    console.log('kakao profile', profile);
    try {
      const exUser = await User.findOne({
        where: { snsId: profile.id, provider: 'kakao' },
      });
      if (exUser) {
        done(null, exUser);
      } else { // 카카오 회원이 아니라면 회원가입 진행
        const newUser = await User.create({
          email: profile._json?.kakao_account?.email,
          nick: profile.displayName,
          snsId: profile.id,
          provider: 'kakao',
        });
        done(null, newUser);
      }
    } catch (error) {
      console.error(error);
      done(error);
    }
  }));
};

카카오 로그인 라우터 작성하기 (routes/auth.js)

...
router.get('/logout', isLoggedIn, logout);

// GET /auth/kakao -> 카카오 로그인 전략 수행
router.get('/kakao', passport.authenticate('kakao'));

// GET /auth/kakao/callback -> 로그인 후 성공 여부 결과를 받음
router.get('/kakao/callback', passport.authenticate('kakao', {
  failureRedirect: '/?error=카카오로그인 실패',
}), (req, res) => {
  res.redirect('/'); // 성공 시에는 /로 이동
});

module.exports = router;

위 라우터 작성 후 app.js에 연결하면 된다.
그 후 https://developers.kakao.com/ 접속 후 clientID를 발급받고 카카오 개발자 계정과 카카오 로그인용 애플리케이션을 등록하여 작동하는 것을 확인하면 된다.

9.4. multer 패키지로 이미지 업로드 구현하기

📌 multer 모듈을 사용해 멀티 파트 형식의 이미지 업로드 기능 구현

먼저 패키지를 설치한 후

$ npm i multer

post 라우터(routes/post.js)와

const express = require('express');
const multer = require('multer');
const path = require('path');
const fs = require('fs');

const { afterUploadImage, uploadPost } = require('../controllers/post');
const { isLoggedIn } = require('../middlewares');

const router = express.Router();

try {
  fs.readdirSync('uploads');
} catch (error) {
  console.error('uploads 폴더가 없어 uploads 폴더를 생성합니다.');
  fs.mkdirSync('uploads');
}

const upload = multer({
  storage: multer.diskStorage({
    destination(req, file, cb) {
      cb(null, 'uploads/');
    },
    filename(req, file, cb) {
      const ext = path.extname(file.originalname);
      cb(null, path.basename(file.originalname, ext) + Date.now() + ext);
    },
  }),
  limits: { fileSize: 5 * 1024 * 1024 },
});

// POST /post/img -> 이미지를 업로드 받은 후 이미지의 저장 경로를 클라이언트로 응답
router.post('/img', isLoggedIn, upload.single('img'), afterUploadImage);

// POST /post -> 게시글 업로드를 처리하는 라우터
const upload2 = multer();
router.post('/', isLoggedIn, upload2.none(), uploadPost);

module.exports = router;

컨트롤러(controllers/post.js)를 작성한다.

const { Post, Hashtag } = require('../models');

exports.afterUploadImage = (req, res) => {
  console.log(req.file);
  res.json({ url: `/img/${req.file.filename}` });
};

exports.uploadPost = async (req, res, next) => {
  try {
    const post = await Post.create({
      content: req.body.content,
      img: req.body.url,
      UserId: req.user.id,
    });
    const hashtags = req.body.content.match(/#[^\s#]*/g);
    if (hashtags) {
      const result = await Promise.all(
        hashtags.map(tag => {
          return Hashtag.findOrCreate({
            where: { title: tag.slice(1).toLowerCase() },
          })
        }),
      );
      await post.addHashtags(result.map(r => r[0]));
    }
    res.redirect('/');
  } catch (error) {
    console.error(error);
    next(error);
  }
};

위의 과정을 통해 게시글 작성 기능이 추가되었으므로 메인 페이지 로딩 시 메인 페이지와 게시글이 함께 로딩되도록 controllers/page.js를 추가한다.

const { User, Post } = require('../models');

exports.renderProfile = (req, res) => {
  res.render('profile', { title: '내 정보 - NodeBird' });
};

exports.renderJoin = (req, res) => {
  res.render('join', { title: '회원가입 - NodeBird' });
};

exports.renderMain = async (req, res, next) => {
  try {
    const posts = await Post.findAll({
      include: {
        model: User,
        attributes: ['id', 'nick'],
      },
      order: [['createdAt', 'DESC']],
    });
    res.render('main', {
      title: 'NodeBird',
      twits: posts,
    });
  } catch (err) {
    console.error(err);
    next(err);
  }
}

9.5. 프로젝트 마무리하기

📌 팔로잉 기능과 해시태그 검색 기능

늘 그랬듯이 라우터(routes/user.js)를 먼저 구현하고

const express = require('express');

const { isLoggedIn } = require('../middlewares');
const { follow } = require('../controllers/user');

const router = express.Router();

// POST /user/:id/follow
router.post('/:id/follow', isLoggedIn, follow);

module.exports = router;

컨트롤러(controllers/user.js)를 구현한다.

const User = require('../models/user');

exports.follow = async (req, res, next) => {
  try {
    const user = await User.findOne({ where: { id: req.user.id } });
    if (user) { // req.user.id가 followerId, req.params.id가 followingId
      await user.addFollowing(parseInt(req.params.id, 10));
      res.send('success');
    } else {
      res.status(404).send('no user');
    }
  } catch (error) {
    console.error(error);
    next(error);
  }
};

팔로잉 관계가 생겼으므로 req.user에도 팔로워와 팔로잉 목록을 저장한다. (passport/index.js)

...
passport.deserializeUser((id, done) => {
    console.log('deserialize');
    User.findOne({
      where: { id },
      include: [{
        model: User,
        attributes: ['id', 'nick'],
        as: 'Followers',
      }, {
        model: User,
        attributes: ['id', 'nick'],
        as: 'Followings',
      }],
    })
      .then(user => {
        console.log('user', user);
        done(null, user);
       })
      .catch(err => done(err));
  });
  ...

routes/page.js도 다음과 같이 수정한다.

const express = require('express');
const { isLoggedIn, isNotLoggedIn } = require('../middlewares');
const {
  renderProfile, renderJoin, renderMain, renderHashtag,
} = require('../controllers/page');

const router = express.Router();

router.use((req, res, next) => {
  res.locals.user = req.user;
  res.locals.followerCount = req.user?.Followers?.length || 0;
  res.locals.followingCount = req.user?.Followings?.length || 0;
  res.locals.followingIdList = req.user?.Followings?.map(f => f.id) || [];
  next();
});

router.get('/profile', isLoggedIn, renderProfile);

router.get('/join', isNotLoggedIn, renderJoin);

router.get('/', renderMain);

router.get('/hashtag', renderHashtag);

module.exports = router;

마지막으로 컨트롤러(controllers/page.js)도 작성한 후

const { User, Post, Hashtag } = require('../models');

exports.renderProfile = (req, res) => {
  res.render('profile', { title: '내 정보 - NodeBird' });
};

exports.renderJoin = (req, res) => {
  res.render('join', { title: '회원가입 - NodeBird' });
};

exports.renderMain = async (req, res, next) => {
  try {
    const posts = await Post.findAll({
      include: {
        model: User,
        attributes: ['id', 'nick'],
      },
      order: [['createdAt', 'DESC']],
    });
    res.render('main', {
      title: 'NodeBird',
      twits: posts,
    });
  } catch (err) {
    console.error(err);
    next(err);
  }
}

exports.renderHashtag = async (req, res, next) => {
  const query = req.query.hashtag;
  if (!query) {
    return res.redirect('/');
  }
  try {
    const hashtag = await Hashtag.findOne({ where: { title: query } });
    let posts = [];
    if (hashtag) {
      posts = await hashtag.getPosts({ include: [{ model: User }] });
    }

    return res.render('main', {
      title: `${query} | NodeBird`,
      twits: posts,
    });
  } catch (error) {
    console.error(error);
    return next(error);
  }
};

라우터를 app.js에 연결하면 끝난다.

...
const pageRouter = require('./routes/page');
const authRouter = require('./routes/auth');
const postRouter = require('./routes/post');
const userRouter = require('./routes/user');
const { sequelize } = require('./models');
const passportConfig = require('./passport');
...
app.use(morgan('dev'));
app.use(express.static(path.join(__dirname, 'public')));
app.use('/img', express.static(path.join(__dirname, 'uploads')));
app.use(express.json());
...
app.use('/', pageRouter);
app.use('/auth', authRouter);
app.use('/post', postRouter);
app.use('/user', userRouter);
...

Quiz

1. ( 컨트롤러 )는 라우터 마지막에 위치해 클라이언트에 응답을 보내는 미들웨어이다.
2. 하나의 사용자가 다른 사용자와 관계를 맺을 수 있는 관계를 ( N:M 관계 )라고 부른다.
3. N:M 관계에서 동일한 테이블을 참조하는 관계를 구분하기 위해서는 ( as ) 옵션을 사용한다.
4. 로그인 기능을 구현할 때 사용할 수 있는 모듈에는 ( Passport )가 있다.
5. 로컬 로그인이 아닌 카카오 로그인을 하기 위해서는 ( passport-kakao ) 모듈을 사용한다.
6. 이미지 업로드를 위해서는 ( multer ) 모듈을 사용한다.
7. 팔로잉 기능을 구현할 때 팔로워와 팔로잉 목록은 ( req.user )에 저장해야 한다.
8. 라우터를 구현한 후에는 반드시 ( app.js )에 해당 라우터를 추가해야 한다.

Programming Quiz

1. 로그인 라우터를 구현하기 전, 접근 권한을 제어하는 미들웨어를 작성하려 한다. 빈칸을 채우시오.

exports.isLoggedIn = (req, res, next) => {
  if (                ) { // (1)
    next();
  } else {
    res.status(403).send('로그인 필요');
  }
};

exports.isNotLoggedIn = (req, res, next) => {
  if (                 ) { // (2) 
    next();
  } else {
    const message = encodeURIComponent('로그인한 상태입니다.');
    res.redirect(`/?error=${message}`);
  }
};

2. Passport 모듈로 로그인 기능을 구현하고자 한다. 다음 passport/index.js 코드의 빈칸을 채우시오.

const passport = require('passport');
const local = require('./localStrategy');
const kakao = require('./kakaoStrategy');
const User = require('../models/user');

module.exports = () => {
   // (1)
   
  });

  // (2)
  
  
  
  });

  local();
  kakao();
};

Answer

1.
(1) req.isAuthenticated()
(2) !req.isAuthenticated()
2.
(1) passport.serializeUser((user, done) => {
    done(null, user.id);
(2) passport.deserializeUser((id, done) => {
    User.findOne({ where: { id } })
      .then(user => done(null, user))
      .catch(err => done(err));

출처 : 조현영, 『 Node.js 교과서 개정 3판』, 길벗(2022)

Corner Node.js 1
Editor : 빠다코코넛

728x90

'24-25 > Node.js 1' 카테고리의 다른 글

[노드 1팀] 8장. 몽고디비 (0)	2024.12.27
[노드 1팀] 7장. MySQL (0)	2024.11.29
[노드 1팀] 6장. 익스프레스 웹 서버 만들기 (0)	2024.11.22
[노드 1팀] 5장. 패키지 매니저 (0)	2024.11.15
[노드 1팀] 4장. http 모듈로 서버 만들기 (0)	2024.11.15

고정 헤더 영역

메뉴 레이어

메뉴 리스트

검색 레이어

검색 영역

상세 컨텐츠

본문 제목

본문

9.1. 프로젝트 구조 갖추기

컨트롤러

9.2. 데이터베이스 세팅하기

사용자 테이블(models/user.js)

게시글 테이블 (models/post.js)

해시태그 테이블 (models/hashtag.js)

시퀄라이즈 (models/index.js)

N:M 관계

9.3. Passport 모듈로 로그인 구현하기

Passport (passport/index.js)

9.3.1. 로컬 로그인 구현하기

회원 가입, 로그인, 로그아웃 라우터 만들기

9.3.2. 카카오 로그인 구현하기

카카오 로그인 전략 작성하기 (passport/kakaoStrategy.js)

카카오 로그인 라우터 작성하기 (routes/auth.js)

9.4. multer 패키지로 이미지 업로드 구현하기

9.5. 프로젝트 마무리하기

Quiz

Programming Quiz

Answer

'24-25 > Node.js 1' 카테고리의 다른 글

관련글 더보기

추가 정보

인기글

최신글

티스토리툴바

고정 헤더 영역

메뉴 레이어

메뉴 리스트

검색 레이어

검색 영역

상세 컨텐츠

본문 제목

본문

9.1. 프로젝트 구조 갖추기

컨트롤러

9.2. 데이터베이스 세팅하기

사용자 테이블(models/user.js)

게시글 테이블 (models/post.js)

해시태그 테이블 (models/hashtag.js)

시퀄라이즈 (models/index.js)

N:M 관계

9.3. Passport 모듈로 로그인 구현하기

Passport (passport/index.js)

9.3.1. 로컬 로그인 구현하기

회원 가입, 로그인, 로그아웃 라우터 만들기

9.3.2. 카카오 로그인 구현하기

카카오 로그인 전략 작성하기 (passport/kakaoStrategy.js)

카카오 로그인 라우터 작성하기 (routes/auth.js)

9.4. multer 패키지로 이미지 업로드 구현하기

9.5. 프로젝트 마무리하기

Quiz

Programming Quiz

Answer

'24-25 > Node.js 1' 카테고리의 다른 글

관련글 더보기

추가 정보

인기글

최신글

티스토리툴바

N:M 관계