# express, sequelize, mysql2 라이브러리를 설치합니다.
> npm install express sequelize mysql2

# sequelize-cli, nodemon 라이브러리를 DevDependency로 설치합니다.
> npm install -D sequelize-cli nodemon

# 설치한 sequelize를 초기화 하여, sequelize를 사용할 수 있는 구조를 생성합니다.
> npx sequelize init 

내 프로젝트 폴더 이름
├── models
│   └── index.js
├── config
│   └── config.json
├── migrations
├── seeders
├── package-lock.json
└── package.json

// /config/config.json
"development": {
    "username": "계정명",
    "password": "계정 비밀번호",
    "database": "사용할 데이터베이스 명",
    "host": "RDS 엔드포인트 주소",
    "dialect": "mysql"
  },

> npx sequelize db:create

npx sequelize model:generate --name Posts --attributes title:string,content:string,password:string
# sequelize 를 이용해서
# model:generate --name Posts 모델(테이블)을 생성할 것이다. Posts라는 이름으로.
# --attributes 내부에 포함될 컬럼들 title:string,content:string,password:string

'use strict';
/** @type {import('sequelize-cli').Migration} */
module.exports = {
  async up(queryInterface, Sequelize) {
    await queryInterface.createTable('Posts', {
      id: {
        allowNull: false, // null값 미허용
        autoIncrement: true, // 1씩 증가
        primaryKey: true, // 기본키 설정
        type: Sequelize.INTEGER // 데이터 타입
      },
      title: {
        type: Sequelize.STRING // String(255)
        // defaultValue: "제목" // 값이 설정되지 않은 경우 기본값을 설정합니다.
        // unique : true // 고유한 값만 들어올 수 있도록 설정합니다.
      },
      content: {
        type: Sequelize.STRING
      },
      password: {
        type: Sequelize.STRING
      },
      createdAt: {
        allowNull: false,
        type: Sequelize.DATE
      },
      updatedAt: {
        allowNull: false,
        type: Sequelize.DATE
      }
    });
  },
  async down(queryInterface, Sequelize) {
    await queryInterface.dropTable('Posts');
  }
};

// /models/posts.js
'use strict';
const {
  Model
} = require('sequelize');
module.exports = (sequelize, DataTypes) => {
  class Posts extends Model {
    /**
     * Helper method for defining associations.
     * This method is not a part of Sequelize lifecycle.
     * The `models/index` file will call this method automatically.
     */
    static associate(models) {
      // define association here
    }
  }
  Posts.init({
    title: DataTypes.STRING,
    content: DataTypes.STRING,
    password: DataTypes.STRING
  }, {
    sequelize,
    modelName: 'Posts',
  });
  return Posts;
};

내 프로젝트 폴더 이름
├── models
│   ├── index.js
│   └── posts.js
├── config
│   └── config.json
├── migrations
│   └── 20230118144300-create-posts.js
├── seeders
├── package-lock.json
└── package.json

# migrations 폴더에 정의된 migration 파일들과 MySQL의 테이블을 맵핑시킵니다.
npx sequelize db:migrate

== 날짜-create-posts: migrating =======
== 날짜-create-posts: migrated (0.098s)

// migrations/날짜-create-posts
d: {
        allowNull: false, // null값 미허용
        autoIncrement: true, // 1씩 증가
        primaryKey: true, // 기본키 설정
        type: Sequelize.INTEGER // 데이터 타입
      },

'use strict';
/** @type {import('sequelize-cli').Migration} */
module.exports = {
  async up(queryInterface, Sequelize) {
    await queryInterface.createTable('Posts', {
      postId: {
        allowNull: false, // null값 미허용
        autoIncrement: true, // 1씩 증가
        primaryKey: true, // 기본키 설정
        type: Sequelize.INTEGER // 데이터 타입
      },
      title: {
        allowNull: false,
        type: Sequelize.STRING // String(255)
        // defaultValue: "제목" // 값이 설정되지 않은 경우 기본값을 설정합니다.
        // unique : true // 고유한 값만 들어올 수 있도록 설정합니다.
      },
      content: {
        allowNull: false,
        type: Sequelize.STRING
      },
      password: {
        allowNull: false,
        type: Sequelize.STRING
      },
      createdAt: {
        allowNull: false,
        type: Sequelize.DATE,
        defaultValue: Sequelize.fn("NOW") // 기본값으로 현재 시간 설정
      },
      updatedAt: {
        allowNull: false,
        type: Sequelize.DATE,
        defaultValue: Sequelize.fn("NOW") // 기본값으로 현재 시간 설정
      }
    });
  },
  async down(queryInterface, Sequelize) {
    await queryInterface.dropTable('Posts');
  }
};

# 가장 최근에 실행한 db:migrate를 취소합니다
> npx sequelize db:migrate:undo

# migrations 폴더에 존재하는 migration 파일을 기반으로 테이블을 생성합니다.
> npx sequelize db:migrate

// app.js
const { sequelize } = require("./models/index.js");

async function main() {
  // sequelize에 테이블들이 존재하지 않는 경우 태이블을 생성합니다.
  await sequelize.sync();
}

main();

SELECT postId, title, content, createdAt, updatedAt
FROM Posts;

const { Posts } = require("./models");
const posts = Posts.findAll();

'use strict';
const {
  Model
} = require('sequelize');
module.exports = (sequelize, DataTypes) => {
  class Posts extends Model {
    /**
     * Helper method for defining associations.
     * This method is not a part of Sequelize lifecycle.
     * The `models/index` file will call this method automatically.
     */
    static associate(models) {
      // define association here
    }
  }
  Posts.init({
    title: DataTypes.STRING,  // 설정한 데이터 타입
    content: DataTypes.STRING,
    password: DataTypes.STRING
  }, {
    sequelize,
    modelName: 'Posts', // 모델(테이블) 이름
  });
  return Posts;
};

'use strict';
const {
  Model, Sequelize
} = require('sequelize');
module.exports = (sequelize, DataTypes) => {
  class Posts extends Model {
    /**
     * Helper method for defining associations.
     * This method is not a part of Sequelize lifecycle.
     * The `models/index` file will call this method automatically.
     */
    static associate(models) {
      // define association here
    }
  }
  Posts.init({
      postId: {
        allowNull: false,
        autoIncrement: true,
        primaryKey: true,
        type: DataTypes.INTEGER
      },
      title: {
        type: DataTypes.STRING,
        allowNull: false
      },
      content: {
        type: DataTypes.STRING,
        allowNull: false
      },
      password: {
        type: DataTypes.STRING,
        allowNull: false
      },
      createdAt: {
        allowNull: false,
        type: DataTypes.DATE,
        // DataTypes.NOW -> migration파일에서는 현재 이슈로 등록되어 NOW가 온전히 작동하고 있지 않습니다.
        defaultValue: DataTypes.NOW
      },
      updatedAt: {
        allowNull: false,
        type: DataTypes.DATE,
        defaultValue: DataTypes.NOW
      }
    }, {
    sequelize,
    modelName: 'Posts', // 모델(테이블) 이름
  });
  return Posts;
};

const express = require("express");
const postsRouter = require("./routes/posts.route");
const app = express();
const PORT = 3017;

app.use(express.json());
app.use('/api', [postsRouter]);

app.listen(PORT, () => {
  console.log(PORT, '포트 번호로 서버가 실행되었습니다.');
})

// routes/post.route.js

const express = require("express");
const { Posts } = require("../models");
const router = express.Router();

// routes/posts.route.js

// 게시글 생성
router.post('/posts', async (req, res) => {
  const { title, content, password } = req.body;
  const post = await Posts.create({ title, content, password });

  res.status(201).json({ data: post });
});

module.exports = router;

// 게시글 목록 조회 API
router.get("/posts", async(req, res) => {
  const posts = await Posts.findAll({
    attributes: ['postId', 'title', 'createdAt', 'UpdatedAt']
  }) // 해당 테이블에 게시글 컬럼을 제외한 모든 데이터를 가져온다.

  res.status(200).json({
    data: posts
  })
})

// 게시글 상세 조회 API
router.get("/posts/:postId", async(req, res) => {
  const { postId } = req.params;

  const post = await Posts.findOne({
    attributes: ["postId", "title", "content", "createdAt", "updatedAt"],
    where: { postId }
  }); // postId값이, 현재 전달받은 postId 변수 값과 일치하는 데이터를 찾아라

  res.status(200).json({
    data: post
  })
})

// routes/posts.route.js

const { Op } = require("sequelize");

// 게시글 수정
router.put('/posts/:postId', async (req, res) => {
  const { postId } = req.params;
  const { title, content, password } = req.body;

  const post = await Posts.findOne({ where: { postId } });
  if (!post) {
    return res.status(404).json({ message: '게시글이 존재하지 않습니다.' });
  } else if (post.password !== password) {
    return res.status(401).json({ message: '비밀번호가 일치하지 않습니다.' });
  }

  await Posts.update(
    { title, content }, // 수정할 데이터 컬럼
    {
      where: {
        // Op.and postId AND password 가 일치하는 데이터
        [Op.and]: [{ postId }, [{ password }]],
      }
    } // 어떤 데이터를 수정할 것인가.
  );

  res.status(200).json({ data: "게시글이 수정되었습니다." });
});

router.delete('/posts/:postId', async (req, res) => {
  const { postId } = req.params;
  const { password } = req.body;

  const post = await Posts.findOne({ where: { postId } });
  if (!post) {
    return res.status(404).json({ message: '게시글이 존재하지 않습니다.' });
  } else if (post.password !== password) {
    return res.status(401).json({ message: '비밀번호가 일치하지 않습니다.' });
  }

  await Posts.destroy({ 
    where: {
       [Op.and]: [{postId}, {password}] // 게시글의 비밀번호와, postId가 일치할 때, 삭제한다.
    },
  });

  res.status(200).json({ data: "게시글이 삭제되었습니다." });
});