@motif/api/lib/Scheduler.js

const _ = require("lodash")
const path = require("path")
const glob = require("glob")
const schedule = require('node-schedule')
const Debugger = require("./Debugger")

const debug = new Debugger('motif:scheduler')

class Scheduler {
  get service() {
    return this._service
  }

  get config() {
    return this._service._config
  }

  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({design, config})
    if (connection) {
      model.setCollection(design.createCollection(connection))
    }

    return model
  }

  generateJobs(options) {
    const { jobs } = options

    jobs.map((jobOptions) => {
      let { rule, timezone, controllers } = jobOptions

      const tasks = controllers.map((handler) => {
        let spec = {}
        
        if (rule) { spec.rule = rule }
        if (timezone) { spec.tz = timezone }

        return schedule.scheduleJob(spec, (fireDate) => {
          let controller = async () => {
            try {
              await handler.call(this, fireDate)
            } catch (e) {
              console.error(e)
            }
          }

          controller.call(this, fireDate)
        })
      })
    })
  }

  constructor({ service }) {
    debug.log("scheduler", service)

    this._service = service
  }

  static __autoLoad( cwd, options = {}) {
    let handlers = []
    let { excludesAll, excludes, includes } = options
    let rule = options.rule || "jobs/*.js"
    let files = glob.sync(rule, { cwd: cwd })

    _.each(files, file => {
      let filePath = path.resolve(cwd, file)

      let isIgnore = excludesAll === true

      if (excludes) {
        _.forEach(excludes, exclude => {
          if (filePath.indexOf(exclude) !== -1) {
            isIgnore = true
          }
        })
      }

      if (includes) {
        _.forEach(includes || [], include => {
          if (filePath.indexOf(include) !== -1) {
            isIgnore = false
          }
        })
      }

      if (!isIgnore) {
        delete require.cache[filePath]
        let handler = require(filePath)
        handlers.push(handler)
      }
    })

    return handlers
  }
}

module.exports = Scheduler