apemandb/lib/modeling/from_files.js

Database for apeman project.

/**
 * Create models from files.
 * @function fromFiles
 */
'use strict'

const path = require('path')
const { pascalcase, camelcase, snakecase } = require('stringcase')
const createModel = require('./create_model')
const aglob = require('aglob')

/** @lends fromFiles */
function fromFiles (db, pattern) {
  /**
   * Model resolver
   * @param {string} name - Name of the model.
   * @returns {Object} - Found model
   */
  function models (name) {
    let model = models[ name ]
    if (!model) {
      throw new Error(`Unknown name: ${name}`)
    }
    return model
  }

  // noinspection Eslint
  models.__proto__ = Object.assign(new Function(), {
    toJSON () {
      return Object.assign({}, models)
    }
  })

  let config = aglob.sync(pattern)
    .map((filename) => {
      let basename = path.basename(filename, path.extname(filename))
      let config = require(path.resolve(filename))
      config.$name = config.$name || pascalcase(basename)
      return config
    })

  config
    .forEach((config) => {
      let { $name } = config
      let model = createModel(db, config)
      if (model) {
        models[ $name ] = model
      }
    })

  let _foreignKey = (model, as) => ({
    name: camelcase(model.nameForeignKey(as)),
    field: snakecase(model.nameForeignKey(as))
  })

  Object.keys(models).forEach((name) => {
    let model = models(name)

    let { $belongsTo, $hasOne, $hasMany, $belongsToMany } = model
    Object.keys($belongsTo || {})
      .filter((as) => !!$belongsTo[ as ])
      .forEach((as) => {
        let modelName = $belongsTo[ as ]
        let foreignKey = _foreignKey(models(modelName), as)
        model.belongsTo(models(modelName), { as, foreignKey })
      })
    Object.keys($hasOne || {})
      .filter((as) => !!$hasOne[ as ])
      .forEach((as) => {
        let modelName = $hasOne[ as ]
        let foreignKey = _foreignKey(model)
        model.hasOne(models(modelName), { as, foreignKey })
      })
    Object.keys($hasMany || {})
      .filter((as) => !!$hasMany[ as ])
      .forEach((as) => {
        let modelName = $hasMany[ as ]
        let foreignKey = _foreignKey(model)
        model.hasMany(models(modelName), { as, foreignKey })
      })
    Object.keys($belongsToMany || {})
      .filter((as) => !!$belongsToMany[ as ])
      .forEach((as) => {
        let [through, modelName] = $belongsToMany[ as ].split(':')
        let foreignKey = _foreignKey(model)
        let throughModel = models(through)
        model.belongsToMany(models(modelName), { through, as, foreignKey, throughModel })
      })
  })
  return models
}

module.exports = fromFiles