[node.js] sequelize(시퀄라이즈)를 사용해서 rdb와 통신하기

// [/routes/languages/index.js]
// name : languages
// desc : 프로그래밍 언어
// end-point : /languages

const controller = require('./languages.controller');
const router = require('express').Router();

router.get('/', controller.getLanguagesAll); //모든 language를 리턴
router.get('/:id', controller.getLanguagesOne); //특정 language를 리턴
router.post('/', controller.createLanguages); //language를 추가
router.put('/', controller.updateLanguages); //language를 수정
router.delete('/:id', controller.deleteLanguages); //특정 language를 삭제

module.exports = router;

// [/routes/languages/languages.controller.js]
// language service logic
exports.getLanguagesAll = (req, res, next) => {
    // db select logic
}

exports.getLanguagesOne = (req, res, next) => {
    // db select logic
}

exports.createLanguages = (req, res, next) => {
    // db insert logic
}

exports.updateLanguages = (req, res, next) => {
    // db update logic
}

exports.deleteLanguages = (req, res, next) => {
    // db delete logic
}

// [/routes/books/index.js]
// name : books
// desc : 프로그래밍 언어 관련 책
// end-point : /books

const controller = require('./books.controller');
const router = require('express').Router();

router.get('/', controller.getBookAll); //모든 book을 리턴
router.post('/', controller.createBook); //book을 추가
router.put('/', controller.updateBook); //book을 수정
router.delete('/:id', controller.deleteBook); //book을 삭제

module.exports = router;

// [/routes/books/books.controller.js]
// book service logic

exports.getBookAll = (req, res, next) => {
    // db select logic
}

exports.createBook = (req, res, next) => {
    // db insert logic
}

exports.updateBook = (req, res, next) => {
    // db update logic
}

exports.deleteBook = (req, res, next) => {
    // db delete logic
}

const express = require('express');
const app = express();
const routes = require('./routes');

app.set('port', 3000);
app.use(express.json());
app.use('/', routes);

//404 미들웨어
app.use((req, res, next) => {
    res.status(404).send(`${req.method} ${req.url} API not found !`);
});

//에러처리 미들웨어
app.use((err, req, res, next) => {
    res.status(500).json({
        message : err.message
    })
});

app.listen(app.get('port'), () => {
    console.log('Server is running on ', app.get('port'));
})

'use strict';

const fs = require('fs'); //파일시스템 읽고 쓰기위한 라이브러리
const path = require('path'); //로컬 경로 탐색을 위한 라이브러리
const Sequelize = require('sequelize'); // Sequelize 클래스 라이브러리
const basename = path.basename(__filename); // 현재 이 파일이름 'index.js' (아래에서 현재 파일을 제외하기 위해 사용)
const env = process.env.NODE_ENV || 'development'; // 현재 node 실행 환경을 가져옴
const config = require(__dirname + '/../config/config.json')[env]; // 위에서 정의한 db접속 환경설정(config.json)이 담긴 object를 가져옴
const db = {}; // 빈 오브젝트 선언

let sequelize; // 빈 변수 선언 (세션이 담길 변수)
if (config.use_env_variable) { // db 환경설정 파일(config.json)에서 (보안등의 이유로) 접속 정보를 환경변수에 담아 이 것을 읽어올 것인지 정의할 수 있음.
  sequelize = new Sequelize(process.env[config.use_env_variable], config); //db와 새로운 세션을 맺는다. (환경변수 읽음)
} else {
  sequelize = new Sequelize(config.database, config.username, config.password, config); //db와 새로운 세션을 맺는다. (config.json 읽음)
}

// 모델 생성 ! (모델은 데이터베이스의 테이블 정보임)
fs
  .readdirSync(__dirname) // 현재 디렉터리의 파일들을 모두 읽어옴.
  .filter(file => {
	  // .으로 시작하지 않고 (숨김파일) && index.js(자기자신)파일이 아니고 && .js 확장자를 가진 파일만 남긴다.
    return (file.indexOf('.') !== 0) && (file !== basename) && (file.slice(-3) === '.js'); 
  })
  .forEach(file => {  // 남은 파일들은 모델(Model)이라고 간주하고 하나씩 불러와서 db object에 담는다.
    const model = require(path.join(__dirname, file))(sequelize, Sequelize.DataTypes); // << ES6 문법임 !!!  
    db[model.name] = model;  // 오브젝트에 모델들을 담는다.
  });

// 각 모델들을 돌면서 모델간의 관계를 정의하는 함수를 동작시킴. (associate)
Object.keys(db).forEach(modelName => { 
  if (db[modelName].associate) {
    db[modelName].associate(db); // 관계를 정의하기 위해선 다른 모델을 참고해야하기 때문에 모델들이 담긴 db를 파라미터로 넘긴다.
  }
});

db.sequelize = sequelize; // 세션과
db.Sequelize = Sequelize; // Class를 db에 추가

module.exports = db; // export

const model = require(path.join(__dirname, file))(sequelize, Sequelize.DataTypes); // << ES6 문법임 !!!  

const model = require(path.join(__dirname, file)).init(sequelize, Sequelize.DataTypes); // 이렇게 변경해주자.

const { Sequelize, DataTypes } = require('sequelize');
const sequelize = new Sequelize({접속 정보});

// sequelize.define('모델이름', attributes, options) (모델을 반환한다.)
const User = sequelize.define('User', {
  // 테이블의 컬럼정보(attribute)를 정의
  column1: {
    type: DataTypes.INTEGER.UNSIGNED,  // 컬럼의 데이터타입
    allowNull: false // Null 허용여부
  },
  column2: {
    type: DataTypes.STRING(20)    
    // allowNull 의 기본값은 true다.
  }
}, {
  // 테이블 속성 및 모델 옵션 정의  
});

const { Sequelize, DataTypes, Model } = require('sequelize');
const sequelize = new Sequelize({접속 정보});

// 1. Model을 상속받은 class를 만들고 
// 2. init(attributes, options)를 호출한다.
// **3. 모델 이름과, 세션인스턴스(sequelize)는 options에 들어감.

class User extends Model {} //Sequelize Model 클래스를 상속받은 클래스 작성

//클래스의 init함수 호출 (모델을 반환한다.)
const User = User.init({ 
  // 테이블의 컬럼정보(attribute)를 정의
  column1: {
    type: DataTypes.STRING, // 컬럼의 데이터타입
    allowNull: false // Null 허용여부
  },
  column2: {
    type: DataTypes.STRING
    // allowNull 의 기본값은 true다.
  }
}, {
  // 테이블 속성 및 모델 옵션 정의  
  sequelize, // define과 다르게 sequelize의 함수를 사용하는게 아니기 때문에, 세션 instance를 넘겨줘야한다.
  modelName: 'User' // 모델 이름을 설정해줘야한다. define은 첫번째 파라미터로 설정했음.
}); 

const Sequelize = require('sequelize');

module.exports = class Language extends Sequelize.Model {    //모델을 상속받은 클래스를 만든다. 
    static init(sequelize, DataTypes) { // Model 클래스 안에 정의되어 있는 함수를 override한다.
        return super.init({
            // id 컬럼은 자동으로 Sequelize가 만들어준다.
            name : {
                type : DataTypes.STRING(64), //VARCHAR(64)
                allowNull : false, // NOT NULL
            },
            wiki_url : {
                type : DataTypes.STRING(128), //VERCHAR(128)
                allowNull : true, 
            }
        }, {
            sequelize, 
            timestamps: false,  // true : 생성된 시간과 수정된 시간을 자동으로 등록해주는 createdAt, updatedAt 컬럼을 자동 추가해준다.
            underscored : true, // true : 자동으로 추가되는 컬럼들의 이름을 스네이크케이스(created_at)로 만든다. / false : 카멜케이스(createdAt) 
            modelName : 'Language', // 모델 이름 정의 (보통 단수형 파스칼케이스로 정의한다.)
            tableName : 'languages', // 테이블 이름 (따로 정의하지 않으면 모델명의 복수형 단어로 만듬)
            paranoid : false, // true : deletedAt 컬럼을 만들고 삭제될 때, 실제로 삭제하지 않고 deletedAt에 값을 준다.
            charset : 'utf8', 
            collate : 'utf8_general_ci'
        });
    }
}

const Sequelize = require('sequelize');

module.exports = class Book extends Sequelize.Model {    
    static init(sequelize, DataTypes) {
        return super.init({
            name : {
                type : DataTypes.STRING(64),
                allowNull : false,
            },
            writter : {
                type : DataTypes.STRING(64),
                allowNull : false,
            },
            price : {
                type : Sequelize.INTEGER,
                allowNull : false,
                defaultValue : 0, //미지정시 기본값 0
            }
            // 외래키는 여기서 정의하지 않고. associate 함수를 통해 만든다. 
        }, {
            sequelize,
            timestamps: false,
            underscored : true,
            modelName : 'Book',
            tableName : 'books',
            paranoid : false,
            charset : 'utf8',
            collate : 'utf8_general_ci'
        });
    }
}

// 1:1 관계 (1:1 관계이더라도 부모자식 관계가 있음. 외래키가 정의된 테이블이 자식테이블임)
ParentModel.hasOne(ChildModel, { foreignKey : 'fk_name', sourceKey : 'parent_tables_pk' }); //부모 모델
ChildModel.belongsTo(ParentModel, { foreignKey : 'fk_name', targetKey : 'parent_tables_pk' }); //자식 모델

// 1:N 관계
ParentModel.hasMany(ChildModel, { foreignKey : 'fk_name', sourceKey : 'parent_tables_pk' }); //부모 모델
ChildModel.belongsTo(ParentModel, { foreignKey : 'fk_name', targetKey : 'parent_tables_pk' }); //자식 모델

// N:N 관계 (1:1, 1:N과 다르게 관계 '테이블'을 생성함)
Model1.belongsToMany(Model2, { through : 'relation_table_name' }); 
Model2.belongsToMany(Model1, { through : 'relation_table_name' }); 

module.exports = class Language extends Sequelize.Model {    
    static init(sequelize, DataTypes) {
        //...
    }
    static associate(db) {
        db.Language.hasMany(db.Book, { foreignKey : 'language_id', sourceKey : 'id'}); //Language가 부모
    }
}

module.exports = class Book extends Sequelize.Model {    
    static init(sequelize, DataTypes) {
        //...
    }
    static associate(db) {
        db.Book.hasMany(db.Language, { foreignKey : 'language_id', targetKey : 'id', onDelete : 'cascade'}); 
      //Book은 자식 (onDelete : 'cascade' 옵션을 주어서 부모 객체가 삭제되었을 때 같이 삭제되도록 함.)
      //기본값 : ON DELETE SET NULL / ON UPDATE SET CASCADE
    }
}

...
const { sequelize } = require('./models'); // models/index.js 가 export한 db.sequelize를 가져옴. 
sequelize.sync({옵션}) // 동기화 및 연결
.then(()=> { // db와 connection을 맺는것은 비동기 작업이다.(불확실성) 따라서 Primise 를 리턴한다.
    console.log('데이터베이스가 연결됨 !');
}).catch((err)=>{
    console.log(err);
});
...

// Model.create({등록할 row의 attributes값}, { fields : [등록을 허용할 attributes]});
Model.create({
  attribute1 : 'value',
  attribute2 : 20,
  attribute3 : true,
},{ fields: ['attribute1, attribute2'] }); 
// INSERT INTO models (attribute1, attribute2) VALUES ('value', 20);

const { Op } = require('sequelize'); //Op = Operation
Model.findAll({
  attributes : ['attribute1', 'attribute2'],  // 조회 컬럼. 미지정시 * 
  where : {  // 조회 조건
    attribute2 : {
      [Op.gte] : 20  // attribute2 >= 20
    },
    attribute3 : true,     // where에 추가한 조건 만큼 AND 연산
  },
  order : [['attribute2', 'DESC'], ['attribute1', 'ASC']] //정렬순서. 2차원 배열로 정의
  limit : 10, //조회 행 수
  ofset : 1, //몇번째 행 부터 조회할 것인지
  
  // 관계쿼리 (fk 연결관계에 있는 테이블의 행을 함께 조회가능.) 
  // 여러 관계가 있을 수 있음으로 order와 마찬가지로 Array type임.
  include : [{ 
  	model : 'childOrParentModel', //관계된 모델명
  	attributes : ['id', 'name'],  //일반 select와 마찬가지로 attributes, where 추가 가능
  	where : {
  		id : 1
		}
	}]
});
// SELECT attribute1, attribute2 FROM models WHERE attribute2 >= 20 AND attribute3 = true
// ORDER BY attribute2 DESC, attribute1 ASC LIMIT 10 OFSET 1;

Model.findOne({}); // findOne 하면 조건에 부합하는 첫번째 행을 Object로 리턴. (findAll은 당연하게도 Array 리턴)

// ***다양한 논리연산자***
// ES6의 계산된 속성명 (Computered property names)을 이용해 각 논리 연산자를 사용할 수 있다.
Model.findAll({
  where: {
    [Op.and]: [{ a: 5 }, { b: 6 }],            // (a = 5) AND (b = 6) // where { a : 5, b : 6 } 으로 생략가능
    [Op.or]: [{ a: 5 }, { b: 6 }],             // (a = 5) OR (b = 6)
    c : [1, 2, 3],								 						 // c IN (1, 2, 3);
    someAttribute: {
      // 기본 논리연산자
      [Op.eq]: 3,                              // = 3
      [Op.ne]: 20,                             // != 20
      [Op.is]: null,                           // IS NULL
      [Op.not]: true,                          // IS NOT TRUE
      [Op.or]: [5, 6],                         // (someAttribute = 5) OR (someAttribute = 6)

      // 숫자 비교 연산자
      [Op.gt]: 6,                              // > 6
      [Op.gte]: 6,                             // >= 6
      [Op.lt]: 10,                             // < 10
      [Op.lte]: 10,                            // <= 10
      [Op.between]: [6, 10],                   // BETWEEN 6 AND 10
      [Op.notBetween]: [11, 15],               // NOT BETWEEN 11 AND 15

      // 그 외 자주사용하는 연산자
      [Op.all]: sequelize.literal('SELECT 1'), // > ALL (SELECT 1)
      [Op.in]: [1, 2],                         // IN [1, 2]
      [Op.notIn]: [1, 2],                      // NOT IN [1, 2]
      [Op.like]: '%hat',                       // LIKE '%hat'
    }
  }
});

// Model.update({수정할 attributes}, {조건});
Model.update({
  attribute1 : 'newValue',
  attribute2 : 30,
  attribute3 : false,
}, {
  where : {
    attribute3 : true,
  }
});
// UPDATE models SET attribute1 = 'newValue', attribute2 = 30, attribute3 = false WHERE attribute3 = true;

// Model.destroy({조건});
Model.destroy({
  where : { //조건은 반드시 where 속성의 object안에 정의되어 있음을 주의.
    	attribute2 : {[Op.lt] : 20}
  }
});
// DELETE FROM models WHERE attribute2 < 20;

Model.destroy({
  truncate: true // truncate 해서 전부 삭제 가능(delete는 공간반납 X, truncate는 공간까지 반납. 조건못줌.)
})

const path = require('path');
const { Language, Book } = require(path.join(process.env.PWD, '/models'));

exports.getLanguagesAll = (req, res, next) => {
    Language.findAll({
        order : [['name', 'ASC']],
        include : [{
            model : Book,
            attributes : ['name'],
            order : [['price', 'ASC']],
            limit : 1,
        }],
    }).then((response) => {
        res.json({
            message : 'success',
            data_list : response,
        });
    }).catch((error) => {
        console.log(error);
        const err = new Error(error);
        next(err);
    });
}

exports.getLanguagesOne = (req, res, next) => {
    Language.findOne({
        where : {
            id : req.params.id,
        },  
        include : [{
            model : Book,            
        }],
    }).then((response) => {
        response.Books.sort((a, b) => a.price - b.price);
        res.json({
            message : 'success',
            data : response,
        });
    }).catch((error) => {
        console.log(error);
        const err = new Error(error);
        next(err);
    });
}

exports.createLanguages = (req, res, next) => {
    Language.create(req.body, {
        fields : ['name', 'wiki_url']
    }).then((response) => {
        res.json({
            message : 'success',
            data : response
        });
    }).catch((error) => {
        console.log(error);
        const err = new Error(error);
        next(err);
    });
}

exports.updateLanguages = (req, res, next) => {
    Language.update({
       name : req.body.name,
       wiki_url : req.body.wiki_url, 
    }, {
        where : {
            id : req.body.id,
        }
    }).then((response) => {
        res.json({
            message : 'success',
            count : response[0] //영향을 받은 행 수
        });
    }).catch((error) => {
        console.log(error);
        const err = new Error(error);
        next(err);
    });
}

exports.deleteLanguages = (req, res, next) => {
    Language.destroy({
        where : {
            id : req.params.id,
        }
    }).then((response) => {
        res.json({
            message : 'success',
            count : response //영향을 받은 행 수
        });
    }).catch((error) => {
        console.log(error);
        const err = new Error(error);
        next(err);
    });
}

const path = require('path');
const { Book } = require(path.join(process.env.PWD, '/models'));

exports.getBookAll = (req, res, next) => {
    Book.findAll({
        order : [['name', 'ASC']]
    }).then((response) => {
        res.json({
            message : 'success',
            data_list : response
        });
    }).catch((error) => {
        console.log(error);
        const err = new Error(error);
        next(err);
    })
}

exports.createBook = (req, res, next) => {
    Book.create(req.body
    , {
        fields : ['name', 'writter', 'price', 'language_id']
    }).then((response) => {
        res.json({
            message : 'success',
            data : response
        });
    }).catch((error) => {
        console.log(error);
        const err = new Error(error);
        next(err);
    })
}

exports.updateBook = (req, res, next) => {
    Book.update({
        name : req.body.name,
        writter : req.body.writter,
        price : req.body.price,
        language_id : req.body.language_id,
    }, {
        where : {
            id : req.body.id
        }
    }).then((response) => {
        res.json({
            message : 'success',
            count : response[0]
        });
    }).catch((error) => {
        console.log(error);
        const err = new Error(error);
        next(err);
    })
}

exports.deleteBook = (req, res, next) => {
    Book.destroy({
        where : {
            id : req.params.id,
        }
    }).then((response) => {
        res.json({
            message : 'success',
            count : response //영향을 받은 행 수
        });
    }).catch((error) => {
        console.log(error);
        const err = new Error(error);
        next(err);
    });
}