@iin-mdc/koa-utils/initializers/models-initializer.js

"use strict"

const fs   = require("fs")
const path = require("path")
const _    = require("lodash")

const HighResDate = require("../lib/high-res-date")

class ModelsInitializer {
  constructor(logger, uri, Sequelize, {modelsDir, sequelizeOptions, disableHighResDate, disableVirtualJson, disableStatusJson}) {
    this.Sequelize  = Sequelize
    this.uri        = uri
    this.logger     = logger
    this.modelsDir  = modelsDir || "app/models"
    this.models     = {}
    this.options    = {
      disableHighResDate: !!disableHighResDate,
      disableVirtualJson: !!disableVirtualJson,
      disableStatusJson:  !!disableStatusJson
    }
    this.sequelizeOptions = Object.assign({}, {
      timestamps: false,
      operatorsAliases: Sequelize.Op,
      benchmark: true,
      logging: (sql, time) => logger.debug(`${sql} [${time}ms]`)
    }, sequelizeOptions || {})
  }

  async initializeModels() {
    this._extendDataTypes()
    this._createConnection()
    this._importModels()
  }

  async destroy() {
    await this.sequelize.close()
  }

  _extendDataTypes() {
    if (!this.options.disableVirtualJson) this._extendWithVirutalJson()
    if (!this.options.disableStatusJson)  this._extendWithStatusJson()
    if (!this.options.disableHighResDate) this._monkeypatchDateType()
  }

  _createConnection() {
    let Sequelize  = this.Sequelize
    this.sequelize = new Sequelize(this.uri, this.sequelizeOptions)
  }

  _importModels() {
    fs.readdirSync(this.modelsDir)
      .filter((file) => (file.indexOf(".") !== 0) && (file.slice(-3) === ".js"))
      .forEach((file) => {
        let model = this.sequelize["import"](path.join(this.modelsDir, file))
        this.models[model.name] = model
        this[model.name] = model
      })

    Object.keys(this.models).forEach((modelName) => {
      if (this.models[modelName].associate) {
        this.models[modelName].associate(this.models)
      }
    })
  }

  _extendWithVirutalJson() {
    const hash = require("object-hash")

    this.Sequelize.DataTypes.VIRTUAL_JSON = (field, config = {}) => {
      let defaultValue = config.default ? JSON.stringify(config.default) : "{}"
      return ({
        type: this.Sequelize.DataTypes.TEXT("medium"),
        get: function() { return JSON.parse(this.getDataValue(field) || defaultValue)},
        set: function(json) {
          json = json || config.default
          this.setDataValue(field, JSON.stringify(json))
          if(config.hash) {
            this.setDataValue(config.hash, hash(json))
          }
        }
      })
    }
  }

  _extendWithStatusJson() {
    function statusJSON(json) {
      return _.mapValues(json || {}, (v) => {
        if (_.isString(v)) {
          try {
           return JSON.parse(v)
          } catch(e) {
           return null
          }
        }
        return v
      })
    }

    this.Sequelize.DataTypes.STATUS_JSON = (field, config = {}) => {
      let defaultValue = config.default ? JSON.stringify(config.default) : "{}"
      return ({
        type: this.Sequelize.DataTypes.TEXT("medium"),
        get: function() {
          return statusJSON(JSON.parse(this.getDataValue(field) || defaultValue))
        },
        set: function(json) {
          this.setDataValue(field, JSON.stringify(statusJSON(json)))
        }
      })
    }
  }

  _monkeypatchDateType() {
    let originalMethods = {
      parse:    this.Sequelize.DataTypes.mysql.DATE.parse,
      strigify: this.Sequelize.DataTypes.mysql.DATE.prototype._stringify
    }

    class HackieString extends String {
      string(){
        return this.toString()
      }
    }
    this.Sequelize.DataTypes.mysql.DATE.prototype._sanitize = function (value, options) {
      if ((!options || options && !options.raw) && !(value instanceof Date) && !!value) {
        return new HighResDate(value)
      }
      return value
    }
    this.Sequelize.DataTypes.mysql.DATE.prototype._isChanged = function (value, originalValue) {
      if (originalValue && !!value && (value === originalValue || HighResDate.equals(value, originalValue))) {        
        return false
      }
      // not changed when set to same empty value
      if (!originalValue && !value && originalValue === value) {
        return false
      }
      return true
    }

    this.Sequelize.DataTypes.mysql.DATE.parse = function(value, options) {
      let strValue = value.string()
      if (strValue === null) {
        return null
      }
      value = new HackieString(strValue)
      let res = originalMethods.parse.call(this, value, options)
      res = new HighResDate(res)
      res.parseFraction(value.string())
      return res
    }

    this.Sequelize.DataTypes.mysql.DATE.prototype._stringify = function(date, options) {
      let res = originalMethods.strigify.call(this, date, options)
      res = new HighResDate(res)
      if (date instanceof HighResDate) {
        res.fraction = date.fraction
      }
      return res.toSQL()
    }
  }
}

module.exports = ModelsInitializer