bajo 0.3.10 → 1.0.2

package/boot/class/bajo-core.js

@@ -0,0 +1,30 @@
+import Plugin from './plugin.js'
+import dayjs from '../lib/dayjs.js'
+import importModule from './bajo-core/method/import-module.js'
+import readJson from './bajo-core/method/read-json.js'
+
+import { isFunction } from 'lodash-es'
+
+async function defConfigHandler (file, opts) {
+  let mod = await importModule(file)
+  if (isFunction(mod)) mod = await mod.call(this, opts)
+  return mod
+}
+
+class BajoCore extends Plugin {
+  constructor (app) {
+    super('bajo', app)
+    this.runAt = new Date()
+    this.mainNs = 'main'
+    this.lib.dayjs = dayjs
+    this.applets = []
+    this.pluginPkgs = []
+    this.pluginNames = []
+    this.configHandlers = [
+      { ext: '.js', readHandler: defConfigHandler },
+      { ext: '.json', readHandler: readJson }
+    ]
+  }
+}
+
+export default BajoCore

package/boot/class/bajo-plugin/helper/attach-method.js

@@ -0,0 +1,14 @@
+import createMethod from '../../../lib/create-method.js'
+
+async function attachMethod () {
+  const { eachPlugins } = this.bajo
+  const me = this
+  me.bajo.log.debug('Attach methods')
+  await eachPlugins(async function ({ ns, pkgName }) {
+    const dir = ns === me.bajo.mainNs ? (`${me.bajo.dir.base}/${me.bajo.mainNs}`) : me.bajo.getModuleDir(pkgName)
+    const num = await createMethod.call(me[ns], `${dir}/bajo/method`, pkgName)
+    me.bajo.log.trace('- %s (%d)', ns, num)
+  })
+}
+
+export default attachMethod

package/boot/class/bajo-plugin/helper/build-config.js

@@ -0,0 +1,10 @@
+import { camelCase } from 'lodash-es'
+
+async function buildConfig () {
+  this.bajo.log.debug('Read configurations')
+  for (const pkg of this.bajo.pluginPkgs) {
+    await this[camelCase(pkg)].loadConfig()
+  }
+}
+
+export default buildConfig

package/boot/class/bajo-plugin/helper/check-clash.js

@@ -0,0 +1,16 @@
+import { find } from 'lodash-es'
+
+async function checkAlias () {
+  const { eachPlugins } = this.bajo
+  this.bajo.log.debug('Checking alias & name clashes')
+  const refs = []
+  await eachPlugins(async function ({ ns, pkgName, alias }) {
+    let item = find(refs, { ns })
+    if (item) throw this.error('Plugin name clash: \'%s (%s)\' with \'%s (%s)\'', ns, pkgName, item.ns, item.pkgName, { code: 'BAJO_NAME_CLASH' })
+    item = find(refs, { alias })
+    if (item) throw this.error('Plugin alias clash: \'%s (%s)\' with \'%s (%s)\'', alias, pkgName, item.alias, item.pkgName, { code: 'BAJO_ALIAS_CLASH' })
+    refs.push({ ns, alias, pkgName })
+  })
+}
+
+export default checkAlias

package/boot/class/bajo-plugin/helper/check-dependency.js

@@ -0,0 +1,37 @@
+import { reduce, map, trim, keys, intersection, each, camelCase, get } from 'lodash-es'
+import semver from 'semver'
+
+async function runner ({ ns, pkgName }) {
+  const { join } = this.app.bajo
+  this.app.bajo.log.trace('- %s', ns)
+  const odep = reduce(this.dependencies, (o, k) => {
+    const item = map(k.split('@'), m => trim(m))
+    if (k[0] === '@') o['@' + item[1]] = item[2]
+    else o[item[0]] = item[1]
+    return o
+  }, {})
+  const deps = keys(odep)
+  if (deps.length > 0) {
+    if (intersection(this.app.bajo.pluginPkgs, deps).length !== deps.length) {
+      throw this.error('Dependency for \'%s\' unfulfilled: %s', pkgName, join(deps), { code: 'BAJO_DEPENDENCY' })
+    }
+    each(deps, d => {
+      if (!odep[d]) return
+      const ver = get(this.app[camelCase(d)], 'config.pkg.version')
+      if (!ver) return
+      if (!semver.satisfies(ver, odep[d])) {
+        throw this.error('Semver check \'%s\' against \'%s\' failed', pkgName, `${d}@${odep[d]}`, { code: 'BAJO_DEPENDENCY_SEMVER' })
+      }
+    })
+  }
+}
+
+async function checkDependency () {
+  const { eachPlugins } = this.bajo
+  this.bajo.log.debug('Checking dependencies')
+  await eachPlugins(async function ({ ns, pkgName, config }) {
+    await runner.call(this, { ns, pkgName, config })
+  })
+}
+
+export default checkDependency

package/boot/class/bajo-plugin/helper/collect-exit-handlers.js

@@ -0,0 +1,14 @@
+async function collectExitHandlers () {
+  const { importModule, eachPlugins, print, join } = this.bajo
+  if (!this.bajo.config.exitHandler) return
+  const nss = []
+  await eachPlugins(async function ({ ns, dir }) {
+    const mod = await importModule(`${dir}/bajo/exit.js`)
+    if (!mod) return undefined
+    this.app[ns].exitHandler = mod
+    nss.push(ns)
+  })
+  this.bajo.log.trace('Exit handlers: %s', nss.length === 0 ? print.write('none') : join(nss))
+}
+
+export default collectExitHandlers

package/boot/class/bajo-plugin/helper/collect-hooks.js

@@ -0,0 +1,29 @@
+import { merge, forOwn, groupBy } from 'lodash-es'
+
+async function collectHooks () {
+  const { eachPlugins, runHook, isLogInRange, importModule, breakNsPathFromFile } = this.bajo
+  const me = this
+  me.bajo.hooks = this.bajo.hooks ?? []
+  me.bajo.log.debug('Collect hooks')
+  // collects
+  await eachPlugins(async function ({ ns, dir, file }) {
+    const { fullNs, path } = breakNsPathFromFile({ file, dir, baseNs: ns, suffix: '/hook/' })
+    const mod = await importModule(file, { asHandler: true })
+    if (!mod) return undefined
+    merge(mod, { ns: fullNs, path, src: ns })
+    me.bajo.hooks.push(mod)
+  }, { glob: 'hook/**/*.js', prefix: me.bajo.name })
+  // for log trace purpose only
+  if (!isLogInRange('trace')) return
+  const items = groupBy(me.bajo.hooks, 'ns')
+  forOwn(items, (v, k) => {
+    const hooks = groupBy(v, 'path')
+    forOwn(hooks, (v1, k1) => {
+      me.bajo.log.trace('- %s:%s (%d)', k, k1, v1.length)
+    })
+  })
+  // run handler
+  await runHook('bajo:afterCollectHooks')
+}
+
+export default collectHooks

package/boot/class/bajo-plugin/helper/run.js

@@ -0,0 +1,20 @@
+import { camelCase, map } from 'lodash-es'
+
+async function run () {
+  const me = this
+  const { runHook, eachPlugins, join } = me.bajo
+  const methods = ['init']
+  if (!me.bajo.applet) methods.push('start')
+  for (const method of methods) {
+    await runHook(`bajo:${camelCase(`before ${method} all plugins`)}`)
+    await eachPlugins(async function ({ ns }) {
+      await runHook(`${ns}:${camelCase(`before ${method}`)}`)
+      await me[ns][method]()
+      await runHook(`${ns}:${camelCase(`after ${method}`)}`)
+    })
+    await runHook(`bajo:${camelCase(`after ${method} all plugins`)}`)
+  }
+  me.bajo.log.debug('Loaded plugins: %s', join(map(me.bajo.pluginPkgs, b => camelCase(b))))
+}
+
+export default run

package/boot/class/bajo-plugin.js

@@ -0,0 +1,78 @@
+import Plugin from './plugin.js'
+import { pick, isString, omit, camelCase } from 'lodash-es'
+import omittedPluginKeys from '../lib/omitted-plugin-keys.js'
+import readAllConfigs from '../lib/read-all-configs.js'
+import titleize from './bajo-core/method/titleize.js'
+import fs from 'fs-extra'
+
+class BajoPlugin extends Plugin {
+  constructor (pkgName, app) {
+    super(pkgName, app)
+    this.state = {}
+  }
+
+  async loadConfig () {
+    const { log, getModuleDir, readJson, defaultsDeep } = this.app.bajo
+    log.trace('- %s', this.name)
+    const dir = this.name === this.app.bajo.mainNs ? (`${this.app.bajo.dir.base}/${this.app.bajo.mainNs}`) : getModuleDir(this.pkgName)
+    let cfg = await readAllConfigs.call(this.app, `${dir}/bajo/config`)
+    this.alias = this.pkgName.slice(0, 5) === 'bajo-' ? this.pkgName.slice(5).toLowerCase() : this.name.toLowerCase()
+    const aliasFile = `${dir}/bajo/.alias`
+    if (fs.existsSync(aliasFile)) this.alias = fs.readFileSync(aliasFile, 'utf8')
+    this.alias = camelCase(this.alias)
+
+    this.dir = {
+      pkg: dir,
+      data: `${this.app.bajo.dir.data}/plugins/${this.name}`
+    }
+    const file = `${dir + (this.name === this.app.bajo.mainNs ? '/..' : '')}/package.json`
+    const pkgJson = await readJson(file)
+    this.pkg = pick(pkgJson,
+      ['name', 'version', 'description', 'author', 'license', 'homepage'])
+    if (this.name === this.app.bajo.mainNs) {
+      this.alias = this.app.bajo.mainNs
+      this.title = 'Main'
+    }
+    // merge with config from datadir
+    try {
+      const altCfg = await readAllConfigs.call(this.app, `${this.app.bajo.dir.data}/config/${this.name}`)
+      cfg = defaultsDeep({}, omit(altCfg, omittedPluginKeys), cfg)
+    } catch (err) {}
+    const envArgv = defaultsDeep({}, omit(this.app.env[this.name] ?? {}, omittedPluginKeys) ?? {}, omit(this.app.argv[this.name] ?? {}, omittedPluginKeys) ?? {})
+    cfg = defaultsDeep({}, envArgv ?? {}, cfg ?? {})
+    this.title = this.title ?? cfg.title ?? titleize(this.alias)
+    this.dependencies = cfg.dependencies ?? []
+    if (isString(this.dependencies)) this.dependencies = [this.dependencies]
+    this.config = omit(cfg, ['title', 'dependencies'])
+  }
+
+  async _onoff (item, text, ...args) {
+    this.state[item] = false
+    const { runHook, importModule } = this.app.bajo
+    const { camelCase } = this.app.bajo.lib._
+    const mod = await importModule(`${this.dir.pkg}/bajo/${item}.js`)
+    if (mod) {
+      this.log.trace(text)
+      await runHook(`${this.name}:${camelCase(`before ${item}`)}`)
+      await mod.call(this, ...args)
+      await runHook(`${this.name}:${camelCase(`after ${item}`)}`)
+    }
+    this.state[item] = true
+  }
+
+  async init () {
+    await this._onoff('init', 'Init plugin...')
+  }
+
+  async start (...args) {
+    const { freeze } = this.app.bajo
+    freeze(this.config)
+    await this._onoff('start', 'Start plugin...', ...args)
+  }
+
+  async stop () {
+    await this._onoff('stop', 'Stop plugin...')
+  }
+}
+
+export default BajoPlugin

package/boot/class/error.js

@@ -0,0 +1,59 @@
+import { isPlainObject, each, isArray, get, isEmpty, merge } from 'lodash-es'
+
+Error.stackTraceLimit = 15
+
+class BajoError {
+  constructor (plugin, msg, ...args) {
+    this.plugin = plugin
+    this.payload = args.length > 0 && isPlainObject(args[args.length - 1]) ? args[args.length - 1] : {}
+    this.orgMessage = msg
+    this.message = this.plugin.print.write(msg, ...args)
+    this.write()
+  }
+
+  write (fatal) {
+    let err
+    if (this.payload.class) err = this.payload.class(this.message)
+    else err = Error(this.message)
+    delete this.payload.class
+    const stacks = err.stack.split('\n')
+    stacks.splice(1, 1)
+    stacks.splice(1, 1)
+    err.stack = stacks.join('\n')
+    const values = {}
+    for (const key in this.payload) {
+      const value = this.payload[key]
+      if (key === 'details' && isArray(value)) {
+        const result = this.formatErrorDetails(value)
+        if (result) merge(values, result)
+      }
+      err[key] = value
+    }
+    if (!isEmpty(values)) err.values = values
+    return err
+  }
+
+  formatErrorDetails (value) {
+    const { isString } = this.plugin.app.bajo.lib._
+    const result = {}
+    const me = this
+    each(value, (v, i) => {
+      const print = me.plugin.print
+      if (isString(v)) v = { error: v }
+      if (!v.context) return undefined
+      v.context.message = v.message
+      if (v.type === 'any.only') v.context.ref = print.write(`field.${get(v, 'context.valids.0.key')}`)
+      const field = get(v, 'context.key')
+      const val = get(v, 'context.value')
+      value[i] = {
+        field,
+        error: print.write(`validation.${v.type}`, v.context),
+        value: val,
+        ext: { type: v.type, context: v.context }
+      }
+    })
+    return result
+  }
+}
+
+export default BajoError

package/boot/class/log.js

@@ -0,0 +1,67 @@
+import os from 'os'
+import { isEmpty, without, merge, upperFirst } from 'lodash-es'
+import levels from './bajo-core/method/log-levels.js'
+import isLogInRange from './bajo-core/method/is-log-in-range.js'
+import translate from '../lib/translate.js'
+import dayjs from 'dayjs'
+
+class Log {
+  constructor (plugin) {
+    this.plugin = plugin
+    this.format = 'YYYY-MM-DDTHH:mm:ss.SSS[Z]'
+  }
+
+  init () {
+    this.bajoLog = this.plugin.app.bajo.config.log.logger ?? 'bajoLogger'
+  }
+
+  write (text, ...args) {
+    return translate.call(this.plugin, null, text, ...args)
+  }
+
+  isExtLogger () {
+    return this.plugin.app[this.bajoLog] && this.plugin.app[this.bajoLog].logger
+  }
+
+  child () {
+    if (this.isExtLogger()) return this.plugin.app[this.bajoLog].logger.child()
+    return this.plugin.app
+  }
+
+  formatMsg (level, ...params) {
+    if (this.plugin.app.bajo.config.log.level === 'silent') return
+    if (!isLogInRange.call(this.plugin.app.bajo, level)) return
+    let [data, msg, ...args] = params
+    if (typeof data === 'string') {
+      args.unshift(msg)
+      msg = data
+      data = null
+    }
+    args = without(args, undefined)
+    msg = this.write(`[%s] ${msg}`, this.plugin.name, ...args)
+    if (this.plugin.app[this.bajoLog] && this.plugin.app[this.bajoLog].logger) {
+      this.plugin.app[this.bajoLog].logger[level](data, msg, ...args)
+    } else {
+      let text
+      const dt = new Date()
+      if (this.plugin.app.bajo.config.env === 'prod') {
+        const json = { level: levels[level], time: dt.valueOf(), pid: process.pid, hostname: os.hostname() }
+        if (!isEmpty(data)) merge(json, data)
+        merge(json, { msg })
+        text = JSON.stringify(json)
+      } else {
+        text = `[${dayjs(dt).utc(true).format(this.format)}] ${upperFirst(level)}: ${msg}`
+        if (!isEmpty(data)) text += '\n' + JSON.stringify(data)
+      }
+      console.log(text)
+    }
+  }
+}
+
+Object.keys(levels).forEach(level => {
+  Log.prototype[level] = function (...params) {
+    this.formatMsg(level, ...params)
+  }
+})
+
+export default Log

package/boot/class/plugin.js

@@ -0,0 +1,51 @@
+import { get, isEmpty, cloneDeep, omit, isPlainObject, camelCase } from 'lodash-es'
+import omittedPluginKeys from '../lib/omitted-plugin-keys.js'
+import Log from './log.js'
+import Print from './print.js'
+import BajoError from './error.js'
+
+class Plugin {
+  constructor (pkgName, app) {
+    this.pkgName = pkgName
+    this.name = camelCase(pkgName)
+    this.app = app
+    this.config = {}
+    this.lib = {}
+    this.exitHandler = undefined
+    this.initLog()
+  }
+
+  getConfig (path, options = {}) {
+    let obj = isEmpty(path) ? this.config : get(this.config, path, options.defValue)
+    options.omit = options.omit ?? omittedPluginKeys
+    if (isPlainObject(obj) && !isEmpty(options.omit)) obj = omit(obj, options.omit)
+    if (!options.noclone) obj = cloneDeep(obj)
+    return obj
+  }
+
+  initLog () {
+    this.log = new Log(this)
+  }
+
+  initPrint (opts) {
+    this.print = new Print(this, opts)
+  }
+
+  error (msg, ...args) {
+    if (!this.print) return new Error(msg, ...args)
+    const error = new BajoError(this, msg, ...args)
+    return error.write()
+  }
+
+  fatal (msg, ...args) {
+    let e
+    if (this.print) {
+      const error = new BajoError(this, msg, ...args)
+      e = error.write(true)
+    } else e = new Error(msg, ...args)
+    console.error(e)
+    process.kill(process.pid, 'SIGINT')
+  }
+}
+
+export default Plugin

package/boot/class/print.js

@@ -0,0 +1,103 @@
+import ora from 'ora'
+import { isPlainObject } from 'lodash-es'
+import defaultsDeep from './bajo-core/method/defaults-deep.js'
+import translate from '../lib/translate.js'
+
+class Print {
+  constructor (plugin, opts = {}) {
+    this.opts = opts
+    this.plugin = plugin
+    this.startTime = this.plugin.app.bajo.lib.dayjs()
+    this.setOpts()
+    this.ora = ora(this.opts)
+  }
+
+  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 = defaultsDeep(opts, this.opts)
+  }
+
+  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
+  }
+
+  write (text, ...args) {
+    return translate.call(this.plugin, null, text, ...args)
+  }
+
+  getElapsed (unit = 'hms') {
+    const u = unit === 'hms' ? 'second' : unit
+    const elapsed = this.plugin.app.bajo.lib.dayjs().diff(this.startTime, u)
+    return unit === 'hms' ? this.plugin.app.bajo.secToHms(elapsed) : elapsed
+  }
+
+  start (text, ...args) {
+    this.setOpts(args)
+    this.setText(text, ...args)
+    this.ora.start()
+    return this
+  }
+
+  stop () {
+    this.ora.stop()
+    return this
+  }
+
+  succeed (text, ...args) {
+    this.setText(text, ...args)
+    this.ora.succeed()
+    return this
+  }
+
+  fail (text, ...args) {
+    this.setText(text, ...args)
+    this.ora.fail()
+    return this
+  }
+
+  warn (text, ...args) {
+    this.setText(text, ...args)
+    this.ora.warn()
+    return this
+  }
+
+  info (text, ...args) {
+    this.setText(text, ...args)
+    this.ora.info()
+    return this
+  }
+
+  clear () {
+    this.ora.clear()
+    return this
+  }
+
+  render () {
+    this.ora.render()
+    return this
+  }
+
+  fatal (text, ...args) {
+    this.setText(text, ...args)
+    this.ora.fail()
+    process.kill(process.pid, 'SIGINT')
+  }
+
+  spinner () {
+    return new Print(this.plugin)
+  }
+}
+
+export default Print

package/boot/index.js

@@ -1,59 +1,12 @@
-/**
- * Boot process:
- * 1. [Creating scope]{@link module:boot/createScope}
- * 2. [Building config object]{@link module:boot/buildConfig}
- * 3. Attaching helpers
- * 4. Attaching system report
- * 5. Determine boot orders
- * 6. Register plugins
- * 7. Attaching exit handlers
- * @module boot
- */
-
-import createScope from './create-scope.js'
-import buildConfig from './build-config.js'
-import attachHelper from './attach-helper.js'
-import bootOrder from './boot-order.js'
-import bootPlugins from './plugins/index.js'
-import exitHandler from './exit-handler.js'
-import runTool from './run-tool.js'
+import App from './class/app.js'
 import shim from './lib/shim.js'
-import { last } from 'lodash-es'
-import resolvePath from './helper/resolve-path.js'
 
 shim()
 
-/**
- * The entry point to boot Bajo based application
- *
- * @instance
- * @async
- * @returns {Object} scope
- */
-
 async function boot (cwd) {
-  if (!cwd) cwd = process.cwd()
-  const l = last(process.argv)
-  if (l.startsWith('--cwd')) {
-    const parts = l.split('=')
-    cwd = parts[1]
-  }
-  cwd = resolvePath(cwd)
-  process.env.BAJOCWD = cwd
-  const scope = createScope()
-  await buildConfig.call(scope, cwd)
-  await attachHelper.call(scope)
-  await bootOrder.call(scope)
-  await bootPlugins.call(scope)
-  await exitHandler.call(scope)
-  // boot complete
-  const { runHook, log } = scope.bajo.helper
-  await runHook('bajo:bootComplete')
-  const elapsed = new Date() - scope.bajo.runAt
-  log.info('Boot process completed in %s', scope.bajo.helper.secToHms(elapsed, true))
-  // run tool
-  await runTool.call(scope)
-  return scope
+  const app = new App(cwd)
+  await app.boot()
+  return app
 }
 
 export default boot

package/boot/lib/create-method.js

@@ -0,0 +1,30 @@
+import fastGlob from 'fast-glob'
+import path from 'path'
+import { camelCase, isFunction, isPlainObject, forOwn } from 'lodash-es'
+import resolvePath from '../class/bajo-core/method/resolve-path.js'
+import importModule from '../class/bajo-core/method/import-module.js'
+import readJson from '../class/bajo-core/method/read-json.js'
+
+export default async function (dir, pkg = 'bajo') {
+  dir = resolvePath(dir)
+  const files = await fastGlob([`!${dir}/**/_*.{js,json}`, `${dir}/**/*.{js,json}`])
+  for (const f of files) {
+    const ext = path.extname(f)
+    const base = f.replace(dir, '').replace(ext, '')
+    const name = camelCase(base)
+    let mod
+    if (ext === '.json') mod = readJson(f)
+    else mod = await importModule(f)
+    if (isFunction(mod)) {
+      mod = mod.bind(this)
+    } else if (isPlainObject(mod)) {
+      if (!mod.exec) { // mod.exec offer unbind, nacked function people can bind to anything else later
+        forOwn(mod, (v, k) => {
+          if (isFunction(v)) mod[k] = v.bind(this)
+        })
+      }
+    }
+    this[name] = mod
+  }
+  return files.length
+}

package/boot/{helper → lib}/current-loc.js

@@ -1,5 +1,5 @@
 import path from 'path'
-import resolvePath from './resolve-path.js'
+import resolvePath from '../class/bajo-core/method/resolve-path.js'
 import { fileURLToPath } from 'url'
 
 const currentLoc = (meta) => {