초기 세팅

Node.js로 ES6 코드 실행(babel사용)

npm i -D @babel/core @babel/cli @babel/preset-env @babel/node express dotenv

@babel/core : 핵심 패키지

@babel/cli : babel 커맨드 사용 할 수 있음(선택)

@babel/preset-env : ES2015 이상의 최신 자바스크립트 문법을 해석 할 수 있음

@babel/node : 코드를 transpile후 바로 실행 해줌

.babelrc

{
  "presets": ["@babel/preset-env"],
}

package.json

{
"start": "nodemon --exec babel-node ./src/app.js"
"createdb": "nodemon --exec babel-node ./src/config/createdb.js"
}

추가 app.js 세팅 후 mysql 시퀄라이즈 연결

npm i sequelize mysql2

//./src/config/createdb.js
//데이터베이스 생성
import { Sequelize } from 'sequelize';
import dotenv from 'dotenv';
dotenv.config();
//데이터베이스 옵션
const createDBOptions = {
    username : process.env.DATABASE_USERNAME || 'root',
    password : process.env.DATABASE_PASSWORD || 'root',
    host : process.env.DATABASE_HOST || 3306,
    dialect : process.env.DATABASE_DIALECT,
}
console.log(createDBOptions)
//DB_NAME 없을시 new DateBase 생성
let db_name = process.env.DATABASE_NAME || 'devdatabase';
//시퀄라이즈 생성 메서드
const dbCreateSequelize = new Sequelize(createDBOptions);

console.log(`======Create DataBase : ${db_name}======`);
//데이터베이스 생성 메서드
dbCreateSequelize
  .getQueryInterface() //인스턴스 반환
  .createDatabase(db_name)
  .then(() => {
    console.log('✅db create success!');
  })
  .catch((e) => {
    console.log('❗️error in create db : ', e);
  });

//app.js


import model  from './models'
model.sequelize
  .sync({ force: false }) // true 로 설정 시 서버 실행 시마다 테이블 재생성
  .then(() => {
    console.log('데이터베이스 연결 성공');
  })
  .catch(err => {
    console.error('ERR~~', err);
  })

//model/index.js


'use strict';

import fs from 'fs';
import path from 'path';
import Sequelize from 'sequelize';
const basename = path.basename(__filename);
const env = process.env.NODE_ENV || 'development';
//데이터베이스 연결하기위한 설정파일
const {config} = require('../../env/database.config');

const db = {};
// const isLogging =
//   !process.env.DB_LOG || process.env.DB_LOG !== 'true' ? false : true;
let sequelize;
if (config.use_env_variable) {
  sequelize = new Sequelize(process.env[config.use_env_variable], config);
} else {
  sequelize = new Sequelize(config.database, config.username, config.password, {
    host: config.host,
    port: config.port,
    database: config.database,
    username: config.username,
    password: config.password,
    dialect: config.dialect,
    timezone: "Asia/Seoul",
    // logging: isLogging,
    //connection pool
    pool: {
      //풀의 최대 연결 수
      max: 50,
      //풀의 최소 연결 수
      min: 0,
      //오류를 발생시키기 전에 풀에서 연결을 시도하는 최대 시간(밀리초)
      acquire: 60000,
      //연결이 해제되기 전에 유휴 상태로 있을 수 있는 최대 시간(밀리초)
      idle: 30000,
    },
  });
}

fs.readdirSync(__dirname)
  .filter((file) => {
    /* 
    file = models 폴더 안 파일
    basename = index.js
    file !== basename -> index.js 파일 아닌거 찾기
    file.indexOf('.') !== 0 -> . 인덱스 찾기(젤 처음만 아니면 됨)
    file.slice(-9, -3) === .model -> .model로 시작할것
    file.slice(-3) === '.js -> .js로 끝날것
    */
    return (
      file.indexOf('.') !== 0 &&
      file !== basename &&
      file.slice(-9, -3) === '.model' &&
      file.slice(-3) === '.js'
    );
  })
  .forEach((file) => {
    // const model = sequelize['import'](path.join(__dirname, file));
    const model = require(path.join(__dirname, file))(sequelize, Sequelize);
    db[model.name] = model;
  });

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

db.sequelize = sequelize;
db.Sequelize = Sequelize;

module.exports = db;

//env/database.config.js


import dotenv from 'dotenv'
dotenv.config()
export const config = {
    host: process.env.DATABASE_HOST,
    port: process.env.DATABASE_PORT,
    database: process.env.DATABASE_NAME,
    username: process.env.DATABASE_USERNAME,
    password: process.env.DATABASE_PASSWORD,
    dialect: process.env.DATABASE_DIALECT
}

define() : 모듈을 정의 할 때 사용

//model/user.model.js

'use strict';
module.exports = (sequelize, DataTypes) => {
    const user = sequelize.define(
        /* model name */
        'user',
        /* Properties */
        {
            user_idx :{
                type: DataTypes.INTEGER,
                primaryKey: true,
                autoIncrement: true,
            },
            admin_id: {
                type: DataTypes.STRING(40),
                notNull: true,
                /* commnent 쿼리문 조회 */
                comment: '',
            },
            password: {
                type: DataTypes.STRING(50),
                notNull: false,
                comment: '',
            },
        },
        /* options */
        {
            tableName:'user', /* 데이터베이스의 테이블 이름. */
            charset: "utf8", // 한국어 설정
            collate: "utf8_general_ci", // 한국어 설정
            freezeTableName : false,/* true 전역으로 테이블 이름이 모델과 같게됨 */
            underscored: true,/* true시 camel case를 snake case로 바꿈 createdAt => created_at */
            timestamps: false, /* true : 각각 레코드가 생성, 수정될 때의 시간이 자동으로 입력된다. */
            hooks: {
            beforeCreate: (e) => {
            e.admin_id = 123456777
            },
                /* 생성전이나 생성후 함수 실행 할 때
                    afterCreate 생성후 실행, beforeCreate 생성전 실행 
                */
            },
        }
    );

    /* asoociate */
    user.associate = (models) => {
        user.hasMany(models.post, {
            foreignKey: 'user_idx',
            sourceKey: 'user_idx',
          });
        //   user.belongsTo(models.post, {
        //      foreignKey: 'department_idx',
        //      sourceKey: 'department_idx',
        //   });

    }
        return user
}