@motif/api/lib/Model.js

"use strict"

const DAO = require("@motif/dao")
const _ = require("lodash")

class Model {

  get design() {
    return {
      type: "unset"
    }
  }

  get connection() {
    if (this._collection) {
      return this._collection.connection
    }

    return null
  }

  get db() {
    if (this._dao) {
      return this._dao.db
    }
    if (this._collection) {
      return this._collection.db
    }
    return null
  }

  get config() {
    return this._config
  }

  constructor({ collection, design, config }) {
    this._collection = collection || null
    this._dao = design || null
    this._config = config
  }

  createDesign() {
    let designConfig = this.design

    if (designConfig && designConfig.type !== "unset") {
      this._dao = new DAO.Design(designConfig)
    }

    return this._dao
  }

  setCollection(collection) {
    this._collection = collection
  }

  setConnection(connection) {
    if (this._dao) {
      let collection = this._dao.createCollection(connection)
      this.setCollection(collection)
    }
  }

  initialize() {
    if (this._dao) {
      return this._dao.initialize({
        autoCreate: process.motif.context.initMode ? true : false
      })
    }
    return false
  }

  constants(key) {
    let constants = process.motif.constants || {}
    return constants[key.toUpperCase()] || {}
  }

  model(key, connection = null) {
    let models = process.motif.models
    let modelData = models[key]
    if (!modelData) {
      return null
    }

    let config = this.config
    let design = modelData.design
    let model = new modelData.constructor({ config, design })
    if (connection) {
      model.setCollection(design.createCollection(connection))
    }

    return model
  }

  defaultTable() {
    let db = this.db
    if (this._dao && this._dao.defaultSchema && this._dao.defaultSchema.name) {
      return db.table(this._dao.defaultSchema.name)
    }
    return db.table()
  }

  filterData( origin, options = {} ) {
    let res = options.excludesAll === true ? {} : origin
    let mapKeys = _.isObject(options.mapKeys) ? options.mapKeys : {}
    let includes = _.isObject(options.includes) ? options.includes : {}
    let excludes = _.isArray(options.excludes) ? options.excludes : []

    if (options.includes) {
      _.forEach(includes, (value, key) => {
        if (_.isFunction(value)) {
          res[key] = value(origin)
        }
        else {
          res[key] = value
        }
      })
    }

    if (_.isObject(res)) {
      if (options.mapKeys) {
        res = _.mapKeys(res, (value, key ) => {
          let newKey = key
          if (mapKeys[key]) {
            newKey = mapKeys[key]
          }
          return newKey
        })
      }

      if (options.excludes) {
        _.forEach(res, (value, key) => {
          if (value === null || _.includes(excludes, key)) {
            delete res[key]
          }
        })
      }
    }

    if (options.sortKeys) {
      const data = {};
      Object.keys(res).sort().forEach(function(key) {
        data[key] = res[key];
      })
      return data
    }

    return Object.assign({}, res)
  }

  findOne( res, defaultValue = null ) {
    return (res && res.length > 0) ? res[0] : defaultValue
  }

  getTotal( res, field = "total", defaultValue = 0 ) {
    return (res && res.length > 0) ? res[0][field] : defaultValue
  }

  async dbTask(_arg1, _arg2) {
    let models = arguments.length === 2 && _.isArray(_arg1) ? _arg1 : arguments.length === 2 && [_arg1] || []
    let callback = arguments.length === 2 && _.isFunction(_arg2) ? _arg2 : _.isFunction(_arg1) && _arg1

    return await this.db.task(async connection => {
      this.setConnection(connection)
      _.forEach(models, model => {
        model.setConnection(connection)
      })
      return await callback(connection)
    })
  }

  async dbTransaction(_arg1, _arg2) {
    let models = arguments.length === 2 && _.isArray(_arg1) ? _arg1 : arguments.length === 2 && [_arg1] || []
    let callback = arguments.length === 2 && _.isFunction(_arg2) ? _arg2 : _.isFunction(_arg1) && _arg1

    return await this.db.transaction(async connection => {
      this.setConnection(connection)
      _.forEach(models, model => {
        model.setConnection(connection)
      })
      return await callback(connection)
    })
  }

  static dbConnection(connectionName) {
    return DAO.connection(connectionName)
  }

  static get prefix() {
    return process.motif.context.prefix
  }
}

module.exports = Model