bajo 1.2.8 → 2.0.0

package/class/base/print.js

@@ -0,0 +1,272 @@
+import ora from 'ora'
+import lodash from 'lodash'
+import fs from 'fs-extra'
+import Sprintf from 'sprintf-js'
+const { sprintf } = Sprintf
+let unknownLangWarning = false
+
+const { isString, last, isPlainObject, get, without, reverse, map } = lodash
+
+/**
+ * Print class. Use sprintf to interpolate pattern and variable. Support
+ * many methods to display things on screen including {@link https://github.com/sindresorhus/ora|ora} based spinner.
+ *
+ * It also serve as the foundation of Bajo's I18n lightweight system.
+ *
+ * @class
+ */
+class Print {
+  /**
+   * Class constructor
+   *
+   * @param {Object} plugin - Plugin instance
+   * @param {Object} [opts={}] - Options to pass to {@link https://github.com/sindresorhus/ora|ora}
+   */
+  constructor (plugin, opts = {}) {
+    this.opts = opts
+    this.plugin = plugin
+    this.startTime = this.plugin.app.bajo.lib.dayjs()
+    this.setOpts()
+    this.ora = ora(this.opts)
+    this.intl = {}
+  }
+
+  /**
+   * Initialize print engine and read plugin's translation files
+   *
+   * @method
+   */
+  init = () => {
+    for (const l of this.plugin.app.bajo.config.intl.supported) {
+      this.intl[l] = {}
+      const path = `${this.plugin.dir.pkg}/extend/bajo/intl/${l}.json`
+      if (!fs.existsSync(path)) continue
+      const trans = fs.readFileSync(path, 'utf8')
+      try {
+        this.intl[l] = JSON.parse(trans)
+      } catch (err) {}
+    }
+  }
+
+  /**
+   * Interpolate and translate text according to the chosen language
+   *
+   * @method
+   * @param {string} text - Text pattern to translate. See {@link https://github.com/alexei/sprintf.js|sprintf} for all supported token & format
+   * @param {...any} [args] - Variables to interpolate with text pattern above. If the last argument is an object, it will be use to override default translation option. Example: to force language to 'id', pass the last argument as "{ lang: 'id' }"
+   * @returns {string} Interpolated & translated text
+   */
+  write = (text, ...args) => {
+    const opts = last(args)
+    let lang = this.plugin.app.bajo.config.lang
+    if (isPlainObject(opts)) {
+      args.pop()
+      if (opts.lang) lang = opts.lang
+    }
+    const { fallback, supported } = this.plugin.app.bajo.config.intl
+    if (!unknownLangWarning && !supported.includes(lang)) {
+      unknownLangWarning = true
+      this.plugin.app.bajo.log.warn('unsupportedLangFallbackTo%s', fallback)
+    }
+    const plugins = reverse(without([...this.plugin.app.bajo.pluginNames], this.plugin.name))
+    plugins.unshift(this.plugin.name)
+    plugins.push('bajo')
+
+    let trans
+    for (const p of plugins) {
+      const root = get(this, `plugin.app.${p}.print.intl.${lang}`, {})
+      trans = get(root, text)
+      if (trans) break
+    }
+    if (!trans) {
+      for (const p of plugins) {
+        const root = get(this, `plugin.app.${p}.print.intl.${fallback}`, {})
+        trans = get(root, text)
+        if (trans) break
+      }
+    }
+    if (!trans) trans = text
+    const params = map(args, a => {
+      if (!isString(a)) return a
+      return a
+    })
+    return sprintf(trans, ...params)
+  }
+
+  /**
+   * Set spinner options
+   *
+   * @method
+   * @param {any[]} [args=[]] - Array of options. If the last argument is an object, it will be used to override ora options
+   */
+  setOpts = (args = []) => {
+    const config = this.plugin.app.bajo.config
+    let opts = {}
+    if (isPlainObject(args.slice(-1)[0])) opts = args.pop()
+    this.opts.isSilent = !!(config.silent || this.opts.isSilent)
+    this.opts = this.plugin.lib.aneka.defaultsDeep(opts, this.opts)
+  }
+
+  /**
+   * Set spinner text
+   *
+   * @method
+   * @param {string} text - Text to use
+   * @param {...any} [args] - Any variable to interpolate text. If the last argument is an object, it will be used to override ora options
+   * @returns {Object} Return itself, usefull to chain methods
+   */
+  setText = (text, ...args) => {
+    text = this.write(text, ...args)
+    this.setOpts(args)
+    const prefixes = []
+    const texts = []
+    if (this.opts.showDatetime) prefixes.push('[' + this.plugin.app.bajo.lib.dayjs().toISOString() + ']')
+    if (this.opts.showCounter) texts.push('[' + this.getElapsed() + ']')
+    if (prefixes.length > 0) this.ora.prefixText = this.ora.prefixText + prefixes.join(' ')
+    if (texts.length > 0) text = texts.join(' ') + ' ' + text
+    this.ora.text = text
+    return this
+  }
+
+  /**
+   * Get elapsed time since print instance is created
+   *
+   * @method
+   * @param {string} [unit=hms] - Unit's time. Put 'hms' (default) to get hour, minute, second format or of any format supported by {@link https://day.js.org/docs/en/display/difference|dayjs}
+   * @returns {string} Elapsed time since start
+   */
+  getElapsed = (unit = 'hms') => {
+    const u = unit === 'hms' ? 'second' : unit
+    const elapsed = this.plugin.lib.dayjs().diff(this.startTime, u)
+    return unit === 'hms' ? this.plugin.lib.aneka.secToHms(elapsed) : elapsed
+  }
+
+  /**
+   * Start the spinner
+   *
+   * @method
+   * @param {string} text - Text to use
+   * @param {...any} [args] - Any variable to interpolate text. If the last argument is an object, it will be used to override ora options
+   * @returns {Object} Return itself, usefull to chain methods
+   */
+  start = (text, ...args) => {
+    this.setOpts(args)
+    this.setText(text, ...args)
+    this.ora.start()
+    return this
+  }
+
+  /**
+   * Stop the spinner
+   *
+   * @method
+   * @returns {Object} Return itself, usefull to chain methods
+   */
+  stop = () => {
+    this.ora.stop()
+    return this
+  }
+
+  /**
+   * Print success message, prefixed with a check icon
+   *
+   * @method
+   * @param {string} text - Text to use
+   * @param {...any} [args] - Any variable to interpolate text. If the last argument is an object, it will be used to override ora options
+   * @returns {Object} Return itself, usefull to chain methods
+   */
+  succeed = (text, ...args) => {
+    this.setText(text, ...args)
+    this.ora.succeed()
+    return this
+  }
+
+  /**
+   * Print failed message, prefixed with a cross icon
+   *
+   * @method
+   * @param {string} text - Text to use
+   * @param {...any} [args] - Any variable to interpolate text. If the last argument is an object, it will be used to override ora options
+   * @returns {Object} Return itself, usefull to chain methods
+   */
+  fail = (text, ...args) => {
+    this.setText(text, ...args)
+    this.ora.fail()
+    return this
+  }
+
+  /**
+   * Print warning message, prefixed with a warn icon
+   *
+   * @method
+   * @param {string} text - Text to use
+   * @param {...any} [args] - Any variable to interpolate text. If the last argument is an object, it will be used to override ora options
+   * @returns {Object} Return itself, usefull to chain methods
+   */
+  warn = (text, ...args) => {
+    this.setText(text, ...args)
+    this.ora.warn()
+    return this
+  }
+
+  /**
+   * Print failed message, prefixed with an info icon
+   *
+   * @method
+   * @param {string} text - Text to use
+   * @param {...any} [args] - Any variable to interpolate text. If the last argument is an object, it will be used to override ora options
+   * @returns {Object} Return itself, usefull to chain methods
+   */
+  info = (text, ...args) => {
+    this.setText(text, ...args)
+    this.ora.info()
+    return this
+  }
+
+  /**
+   * Clear spinner text
+   *
+   * @method
+   * @returns {Object} Return itself, usefull to chain methods
+   */
+  clear = () => {
+    this.ora.clear()
+    return this
+  }
+
+  /**
+   * Force render spinner
+   *
+   * @method
+   * @returns {Object} Return itself, usefull to chain methods
+   */
+  render = () => {
+    this.ora.render()
+    return this
+  }
+
+  /**
+   * Print failed message, prefixed with a cross icon and terminate the app process
+   *
+   * @method
+   * @param {string} text - Text to use
+   * @param {...any} [args] - Any variable to interpolate text. If the last argument is an object, it will be used to override ora options
+   */
+  fatal = (text, ...args) => {
+    this.setText(text, ...args)
+    this.ora.fail()
+    process.kill(process.pid, 'SIGINT')
+  }
+
+  /**
+   * Create a new spinner
+   *
+   * @method
+   * @returns {Object} Return new instance
+   */
+  spinner = () => {
+    return new Print(this.plugin)
+  }
+}
+
+export default Print

package/class/helper/bajo.js

@@ -0,0 +1,344 @@
+import readAllConfigs from '../../lib/read-all-configs.js'
+import currentLoc from '../../lib/current-loc.js'
+import resolvePath from '../../lib/resolve-path.js'
+import omitDeep from 'omit-deep'
+import os from 'os'
+import fs from 'fs-extra'
+import lodash from 'lodash'
+import {
+  buildConfigs,
+  checkDependencies,
+  checkNameAliases,
+  attachMethods,
+  collectHooks,
+  run
+} from './plugin.js'
+
+const {
+  reduce,
+  isNaN,
+  forOwn,
+  orderBy,
+  isFunction,
+  isPlainObject,
+  map,
+  pick,
+  values,
+  keys,
+  set,
+  get,
+  isString,
+  filter,
+  trim,
+  without,
+  uniq,
+  camelCase,
+  isEmpty,
+  omit
+} = lodash
+
+const omitted = ['spawn', 'cwd', 'name', 'alias', 'applet', 'a', 'plugins']
+
+const defConfig = {
+  log: {
+    dateFormat: 'YYYY-MM-DDTHH:MM:ss.SSS[Z]',
+    plain: false,
+    applet: false,
+    traceHook: false
+  },
+  lang: Intl.DateTimeFormat().resolvedOptions().lang ?? 'en-US',
+  intl: {
+    supported: ['en-US', 'id'],
+    fallback: 'en-US',
+    lookupOrder: [],
+    format: {
+      emptyValue: '',
+      datetime: { dateStyle: 'medium', timeStyle: 'short' },
+      date: { dateStyle: 'medium' },
+      time: { timeStyle: 'short' },
+      float: { maximumFractionDigits: 2 },
+      double: { maximumFractionDigits: 5 },
+      smallint: {},
+      integer: {}
+    },
+    unitSys: {
+      'en-US': 'imperial',
+      id: 'metric'
+    }
+  },
+  exitHandler: true
+}
+
+/**
+ * @module
+ */
+
+/**
+ * Building bajo base config. Mostly dealing with directory setups:
+ * - determine base directory
+ * - check whether data directory is valid
+ * - ensure data config directory is there
+ *
+ * @async
+ */
+export async function buildBaseConfig () {
+  const { defaultsDeep } = this.lib.aneka
+  this.applet = this.app.argv._.applet
+  this.config = defaultsDeep({}, this.app.env._, this.app.argv._)
+  this.alias = this.name
+  set(this, 'dir.base', this.app.dir)
+  const path = currentLoc(import.meta).dir + '/../../..'
+  set(this, 'dir.pkg', this.resolvePath(path))
+  if (!get(this, 'dir.data')) set(this, 'dir.data', `${this.dir.base}/data`)
+  this.dir.data = this.resolvePath(this.dir.data)
+  if (!fs.existsSync(this.dir.data)) {
+    console.log('Data directory (%s) doesn\'t exist yet', this.dir.data)
+    process.exit(1)
+  }
+  fs.ensureDirSync(`${this.dir.data}/config`)
+  if (!this.dir.tmp) {
+    this.dir.tmp = `${this.resolvePath(os.tmpdir())}/${this.name}`
+    fs.ensureDirSync(this.dir.tmp)
+  }
+  this.app.addPlugin(this)
+}
+
+/**
+ * Building all plugins:
+ * - read the list of plugins from ```.plugins``` file
+ * - iterate through the list and build related plugins
+ * - attach these plugins to the app instance
+ *
+ * @async
+ */
+export async function buildPlugins () {
+  let pluginPkgs = this.config.plugins ?? []
+  if (isString(pluginPkgs)) pluginPkgs = [pluginPkgs]
+  const pluginsFile = `${this.dir.data}/config/.plugins`
+  if (fs.existsSync(pluginsFile)) {
+    pluginPkgs = pluginPkgs.concat(filter(map(trim(fs.readFileSync(pluginsFile, 'utf8')).split('\n'), p => trim(p)), b => !isEmpty(b)))
+  }
+  this.pluginPkgs = map(filter(without(uniq(pluginPkgs), this.mainNs), p => {
+    return p[0] !== '#'
+  }), p => {
+    return trim(p.split('#')[0])
+  })
+  this.pluginPkgs.push(this.mainNs)
+  for (const pkg of this.pluginPkgs) {
+    const ns = camelCase(pkg)
+    let dir
+    if (ns === 'main') {
+      dir = `${this.dir.base}/${this.mainNs}`
+      fs.ensureDirSync(dir)
+      fs.ensureDirSync(`${dir}/plugin`)
+    } else dir = this.getModuleDir(pkg)
+    let plugin
+    const factory = `${dir}/index.js`
+    if (fs.existsSync(factory)) {
+      const { default: builder } = await import(resolvePath(factory, true))
+      const FactoryClass = await builder.call(this, pkg)
+      plugin = new FactoryClass()
+      if (!(plugin instanceof this.lib.Plugin)) throw new Error(`Plugin package '${pkg}' should be an instance of BajoPlugin`)
+    } else {
+      plugin = new this.lib.Plugin(pkg, this.app)
+    }
+    this.pluginNames.push(plugin.name)
+    this.app.addPlugin(plugin)
+  }
+  this.config = omit(this.config, this.pluginNames)
+}
+
+/**
+ * Collect all config handlers, including the one provided by plugins
+ *
+ * @async
+ */
+export async function collectConfigHandlers () {
+  for (const pkg of this.pluginPkgs) {
+    let dir
+    try {
+      dir = this.getModuleDir(pkg)
+    } catch (err) {}
+    if (!dir) continue
+    const file = `${dir}/extend/bajo/config-handlers.js`
+    let mod = await this.importModule(file)
+    if (!mod) continue
+    if (isFunction(mod)) mod = await mod.call(this.app[camelCase(pkg)])
+    if (isPlainObject(mod)) mod = [mod]
+    this.configHandlers = this.configHandlers.concat(mod)
+  }
+}
+
+/**
+ * Bajo extra config:
+ * - reading config file
+ * - merge config with arguments & environments values
+ * - Set environment (```dev``` or ```prod```)
+ *
+ * @async
+ */
+export async function buildExtConfig () {
+  // config merging
+  const { defaultsDeep } = this.lib.aneka
+  let resp = await readAllConfigs.call(this.app, `${this.dir.data}/config/${this.name}`)
+  resp = omitDeep(pick(resp, ['log', 'exitHandler', 'env']), omitted)
+  this.config = defaultsDeep({}, this.config, resp, defConfig)
+  this.config.env = (this.config.env ?? 'dev').toLowerCase()
+  if (values(this.envs).includes(this.config.env)) this.config.env = this.lib.aneka.getKeyByValue(this.envs, this.config.env)
+  if (!keys(this.envs).includes(this.config.env)) throw new Error(`Unknown environment '${this.config.env}'. Supported: ${this.join(keys(this.envs))}`)
+  process.env.NODE_ENV = this.envs[this.config.env]
+  if (!this.config.log.level) this.config.log.level = this.config.env === 'dev' ? 'debug' : 'info'
+  if (this.config.silent) this.config.log.level = 'silent'
+  if (this.applet) {
+    if (!this.pluginPkgs.includes('bajo-cli')) throw new Error('Applet needs to have \'bajo-cli\' loaded first')
+    if (!this.config.log.applet) this.config.log.level = 'silent'
+    this.config.exitHandler = false
+  }
+  const exts = map(this.configHandlers, 'ext')
+  this.initPrint()
+  this.initLog()
+  this.log.debug('configHandlers%s', this.join(exts))
+  this.config = this.parseObject(this.config, { parseValue: true })
+}
+
+/**
+ * Setup plugins boot orders by reading plugin's ```.bootorder``` file if provided.
+ *
+ * @async
+ */
+export async function bootOrder () {
+  this.log.debug('setupBootOrder')
+  const order = reduce(this.pluginPkgs, (o, k, i) => {
+    const key = map(k.split(':'), m => trim(m))
+    if (key[1] && !isNaN(Number(key[1]))) o[key[0]] = Number(key[1])
+    else o[key[0]] = 10000 + i
+    return o
+  }, {})
+  const norder = {}
+  for (let n of this.pluginPkgs) {
+    n = map(n.split(':'), m => trim(m))[0]
+    const dir = n === this.mainNs ? (`${this.dir.base}/${this.mainNs}`) : this.getModuleDir(n)
+    if (n !== this.mainNs && !fs.existsSync(dir)) throw this.error('packageNotFoundOrNotBajo%s', n)
+    norder[n] = NaN
+    try {
+      norder[n] = Number(trim(await fs.readFile(`${dir}/.bootorder`, 'utf8')))
+    } catch (err) {}
+  }
+  const result = []
+  forOwn(order, (v, k) => {
+    const item = { k, v: isNaN(norder[k]) ? v : norder[k] }
+    result.push(item)
+  })
+  this.pluginPkgs = map(orderBy(result, ['v']), 'k')
+  this.log.info('runInEnv%s', this.print.write(this.envs[this.config.env]))
+  // misc
+  this.freeze(this.config)
+}
+
+/**
+ * Iterate through all plugins loaded and do:
+ * 1. {@link module:class/helper/bajo-plugin.buildConfigs|build configs}
+ * 2. {@link module:class/helper/bajo-plugin.checkNameAliases|ensure names & aliases uniqueness}
+ * 3. {@link module:class/helper/bajo-plugin.checkDependencies|ensure dependencies are met}
+ * 4. {@link module:class/helper/bajo-plugin.attachMethods|build and attach dynamic methods}
+ * 5. {@link module:class/helper/bajo-plugin.collectHooks|collect hooks}
+ * 6. {@link module:class/helper/bajo-plugin.run|run plugins}
+ *
+ * @async
+ */
+export async function bootPlugins () {
+  await buildConfigs.call(this.app)
+  await checkNameAliases.call(this.app)
+  await checkDependencies.call(this.app)
+  await attachMethods.call(this.app)
+  await collectHooks.call(this.app)
+  await run.call(this.app)
+}
+
+/**
+ * Attach plugins exit handlers and make sure the app shutdowns gracefully
+ *
+ * @async
+ */
+export async function exitHandler () {
+  if (!this.config.exitHandler) return
+
+  async function exit (signal) {
+    const { eachPlugins } = this
+    this.log.warn('signalReceived%s', signal)
+    await eachPlugins(async function () {
+      try {
+        await this.stop()
+      } catch (err) {}
+      this.log.trace('exited')
+    })
+    this.log.debug('appShutdown')
+    process.exit(0)
+  }
+
+  process.on('SIGINT', async () => {
+    await exit.call(this, 'SIGINT')
+  })
+
+  process.on('SIGTERM', async () => {
+    await exit.call(this, 'SIGTERM')
+  })
+
+  process.on('uncaughtException', (error, origin) => {
+    setTimeout(() => {
+      console.error(error)
+      // process.exit(1)
+    }, 50)
+  })
+
+  process.on('unhandledRejection', (reason, promise) => {
+    const stackFile = reason.stack.split('\n')[1]
+    let file
+    const info = stackFile.match(/\((.*)\)/) // file is in (<file>)
+    if (info) file = info[1]
+    else if (stackFile.startsWith('    at ')) file = stackFile.slice(7) // file is stackFile itself
+    if (!file) return
+    const parts = file.split(':')
+    const column = parseInt(parts[parts.length - 1])
+    const line = parseInt(parts[parts.length - 2])
+    parts.pop()
+    parts.pop()
+    file = parts.join(':')
+    this.log.error({ file, line, column }, '%s', reason.message)
+  })
+
+  process.on('warning', warning => {
+    this.log.error('%s', warning.message)
+  })
+}
+
+/**
+ * If app is in ```applet``` mode, this little helper should take care plugin's applet boot process
+ *
+ * @async
+ */
+export async function runAsApplet () {
+  const { isString, map, find } = this.lib._
+  await this.eachPlugins(async function ({ file }) {
+    const { name: ns, alias } = this
+    this.app.bajo.applets.push({ ns, file, alias })
+  }, { glob: 'applet.js', prefix: 'bajoCli' })
+
+  this.log.debug('appletModeActivated')
+  this.print.info('appRunningAsApplet')
+  if (this.applets.length === 0) this.print.fatal('noAppletLoaded')
+  let name = this.applet
+  if (!isString(this.applet)) {
+    const select = await this.importPkg('bajoCli:@inquirer/select')
+    name = await select({
+      message: this.print.write('Please select:'),
+      choices: map(this.applets, t => ({ value: t.ns }))
+    })
+  }
+  const [ns, path] = name.split(':')
+  const applet = find(this.applets, a => (a.ns === ns || a.alias === ns))
+  if (!applet) this.print.fatal('notFound%s%s', this.print.write('applet'), name)
+  await this.runHook(`${this.app[applet.ns]}:beforeAppletRun`)
+  await this.app.bajoCli.runApplet(applet, path, ...this.app.args)
+  await this.runHook(`${this.app[applet.ns]}:afterAppletRun`)
+}