bajo 0.0.1 → 0.2.0

package/boot/helper/is-empty-dir.js

@@ -0,0 +1,9 @@
+import emptyDir from 'empty-dir'
+import fs from 'fs-extra'
+
+const isEmptyDir = async (dir) => {
+  await fs.exists(dir)
+  return await emptyDir(dir)
+}
+
+export default isEmptyDir

package/boot/helper/is-log-in-range.js

@@ -0,0 +1,10 @@
+import logLevels from './log-levels.js'
+import { keys, indexOf } from 'lodash-es'
+
+function isLogInRange (level) {
+  const levels = keys(logLevels)
+  const logLevel = indexOf(levels, this.bajo.config.log.level)
+  return indexOf(levels, level) >= logLevel
+}
+
+export default isLogInRange

package/boot/helper/is-set.js

@@ -0,0 +1,5 @@
+const isSet = (input) => {
+  return ![null, undefined].includes(input)
+}
+
+export default isSet

package/boot/helper/is-valid-app.js

@@ -0,0 +1,12 @@
+import fs from 'fs-extra'
+import resolvePath from './resolve-path.js'
+
+const isValidApp = (dir) => {
+  if (!dir) dir = process.env.BAJOCWD
+  dir = resolvePath(dir)
+  const hasAppDir = fs.existsSync(`${dir}/app/bajo`)
+  const hasPackageJson = fs.existsSync(`${dir}/package.json`)
+  return hasAppDir && hasPackageJson
+}
+
+export default isValidApp

package/boot/helper/is-valid-plugin.js

@@ -0,0 +1,12 @@
+import fs from 'fs-extra'
+import resolvePath from './resolve-path.js'
+
+const isValidPlugin = (dir) => {
+  if (!dir) dir = process.env.BAJOCWD
+  dir = resolvePath(dir)
+  const hasBajoDir = fs.existsSync(`${dir}/bajo`)
+  const hasPackageJson = fs.existsSync(`${dir}/package.json`)
+  return hasBajoDir && hasPackageJson
+}
+
+export default isValidPlugin

package/boot/helper/log-levels.js

@@ -0,0 +1,19 @@
+/**
+ * Supported logger levels including its level priority
+ *
+ * @memberof module:helper
+ * @type Object
+ * @instance
+ */
+
+const logLevels = {
+  trace: 10,
+  debug: 20,
+  info: 30,
+  warn: 40,
+  error: 50,
+  fatal: 60,
+  silent: 99
+}
+
+export default logLevels

package/boot/helper/paginate.js

@@ -0,0 +1,26 @@
+import { isEmpty, isPlainObject, orderBy, forOwn } from 'lodash-es'
+
+function paginate (collection, { page = 1, limit = 25, sort } = {}) {
+  const count = collection.length
+  const offset = (page - 1) * limit
+  const fields = []
+  const dirs = []
+  if (isPlainObject(sort)) {
+    forOwn(sort, (v, k) => {
+      fields.push(k)
+      dirs.push(v < 0 ? 'desc' : 'asc')
+    })
+  }
+  if (!isEmpty(fields)) collection = orderBy(collection, fields, dirs)
+  const data = collection.slice(offset, offset + limit)
+
+  return {
+    data,
+    page,
+    limit,
+    count,
+    pages: Math.ceil(collection.length / limit)
+  }
+}
+
+export default paginate

package/boot/helper/pascal-case.js

@@ -0,0 +1,7 @@
+import { camelCase, upperFirst } from 'lodash-es'
+
+const pascalCase = (text) => {
+  return upperFirst(camelCase(text))
+}
+
+export default pascalCase

package/boot/helper/print.js

@@ -0,0 +1,99 @@
+import bora from '../lib/bora.js'
+import Sprintf from 'sprintf-js'
+import { last, isPlainObject, get, merge, upperFirst } from 'lodash-es'
+import defaultsDeep from './defaults-deep.js'
+import getPluginName from './get-plugin-name.js'
+
+const { sprintf } = Sprintf
+
+function prep (args) {
+  let opts = { type: 'bora', exit: false, skipSilent: false }
+  const l = last(args)
+  if (isPlainObject(l)) opts = defaultsDeep(args.pop(), opts)
+  const [pkg, msg, ...params] = args
+  opts.pkg = pkg
+  opts.ns = pkg === 'bajo' ? 'bajoI18N' : pkg
+  return { ns: opts.ns, pkg, msg, params, opts }
+}
+
+function format (...args) {
+  const { ns, msg, params, opts } = prep(args)
+  if (!msg) return ''
+  const i18n = get(this, 'bajoI18N.instance')
+  if (i18n) {
+    if (isPlainObject(params[0])) {
+      const ctx = merge({}, params[0] ?? {}, { ns })
+      if (msg.startsWith('validation') && ctx.message && !i18n.exists(msg, { ns })) {
+        const message = ctx.message
+          .replace(/".*?" /, '')
+          .replace(/^is /, '')
+        return upperFirst(message)
+      }
+      if (msg === 'field.username') console.log(ctx)
+      return i18n.t(msg, ctx)
+    }
+    return i18n.t(msg, { ns, pkg: opts.pkg, postProcess: 'sprintf', sprintf: params })
+  }
+  return sprintf(msg, ...params)
+}
+
+const print = {
+  __: function (...args) {
+    const [msg, ...params] = args
+    const pkg = getPluginName.call(this, 2)
+    return format.call(this, pkg, msg, ...params)
+  },
+  _format: format,
+  fail: function (...args) {
+    args.unshift(getPluginName.call(this, 2))
+    const { ns, opts, msg, params } = prep(args)
+    if (msg) {
+      if (opts.type === 'bora') bora.call(this, ns, opts).fail(msg, ...params)
+      else console.error(format.call(this, ns, msg, ...params))
+    }
+    if (opts.exit) process.exit(1)
+  },
+  succeed: function (...args) {
+    args.unshift(getPluginName.call(this, 2))
+    const { ns, opts, msg, params } = prep(args)
+    if (msg) {
+      if (opts.type === 'bora') bora.call(this, ns, opts).succeed(msg, ...params)
+      else console.log(format.call(this, ns, msg, ...params))
+    }
+    if (opts.exit) process.exit(0)
+  },
+  warn: function (...args) {
+    args.unshift(getPluginName.call(this, 2))
+    const { ns, opts, msg, params } = prep(args)
+    if (msg) {
+      if (opts.type === 'bora') bora.call(this, ns, opts).warn(msg, ...params)
+      else console.log(format.call(this, ns, msg, ...params))
+    }
+    if (opts.exit) process.exit(0)
+  },
+  info: function (...args) {
+    args.unshift(getPluginName.call(this, 2))
+    const { ns, opts, msg, params } = prep(args)
+    if (msg) {
+      if (opts.type === 'bora') bora.call(this, ns, opts).info(msg, ...params)
+      else console.log(format.call(this, ns, msg, ...params))
+    }
+    if (opts.exit) process.exit(0)
+  },
+  fatal: function (...args) {
+    args.unshift(getPluginName.call(this, 2))
+    const { ns, opts, msg, params } = prep(args)
+    if (msg) {
+      if (opts.type === 'bora') bora.call(this, ns, opts).fatal(msg, ...params)
+      else console.error(format.call(this, ns, msg, ...params))
+    }
+    process.exit(0)
+  },
+  bora: function (...args) {
+    let ns = getPluginName.call(this, 2)
+    if (ns === 'bajo') ns = 'bajoI18N'
+    return bora.call(this, ns, ...args)
+  }
+}
+
+export default print

package/boot/helper/read-config.js

@@ -0,0 +1,46 @@
+import path from 'path'
+import resolvePath from './resolve-path.js'
+import readJson from './read-json.js'
+import { find, map, isEmpty } from 'lodash-es'
+import error from './error.js'
+import fg from 'fast-glob'
+
+async function readConfig (file, { pattern, globOptions = {}, ignoreError, defValue = {} } = {}) {
+  file = resolvePath(file)
+  let ext = path.extname(file)
+  const fname = path.dirname(file) + '/' + path.basename(file, ext)
+  ext = ext.toLowerCase()
+  if (['.mjs', '.js'].includes(ext)) {
+    const { handler } = find(this.bajo.configHandlers, { ext })
+    return await handler.call(this, file)
+  }
+  if (ext === '.json') return await readJson(file)
+  if (!['', '.*'].includes(ext)) {
+    const item = find(this.bajo.configHandlers, { ext })
+    if (!item) {
+      if (!ignoreError) throw error.call(this, 'Can\'t parse \'%s\'', file, { code: 'BAJO_CONFIG_NO_PARSER' })
+      return defValue
+    }
+    return item.handler.call(this, file)
+  }
+  const item = pattern ?? `${fname}.{${map(map(this.bajo.configHandlers, 'ext'), k => k.slice(1)).join(',')}}`
+  const files = await fg(item, globOptions)
+  if (files.length === 0) {
+    if (!ignoreError) throw error.call(this, 'No config file found', { code: 'BAJO_CONFIG_FILE_NOT_FOUND' })
+    return defValue
+  }
+  let config = defValue
+  for (const f of files) {
+    const ext = path.extname(f).toLowerCase()
+    const item = find(this.bajo.configHandlers, { ext })
+    if (!item) {
+      if (!ignoreError) throw error.call(this, 'Can\'t parse \'%s\'', f, { code: 'BAJO_CONFIG_NO_PARSER' })
+      continue
+    }
+    config = await item.handler.call(this, f)
+    if (!isEmpty(config)) break
+  }
+  return config
+}
+
+export default readConfig

package/boot/helper/read-json.js

@@ -0,0 +1,10 @@
+import fs from 'fs-extra'
+import { isEmpty } from 'lodash-es'
+
+const readJson = (file) => {
+  let resp = fs.readFileSync(file, 'utf8')
+  if (isEmpty(resp)) resp = '{}'
+  return JSON.parse(resp)
+}
+
+export default readJson

package/boot/helper/resolve-path.js

@@ -0,0 +1,15 @@
+import path from 'path'
+import { fileURLToPath } from 'url'
+import os from 'os'
+
+const resolvePath = (item, asFileUrl) => {
+  if (item.startsWith('file://')) item = fileURLToPath(item)
+  item = path.resolve(item)
+  if (os.platform() === 'win32') {
+    item = item.replace(/\\/g, '/')
+  }
+  if (asFileUrl) item = `file:///${item}`
+  return item
+}
+
+export default resolvePath

package/boot/helper/resolve-tpl-path.js

@@ -0,0 +1,15 @@
+import { trim } from 'lodash-es'
+import fs from 'fs-extra'
+
+function resolveTplPath (name, baseTpl, extTpl = '') {
+  const { getConfig, breakNsPath } = this.bajo.helper
+  const [ns, path] = breakNsPath(name)
+  const cfgNs = getConfig(ns, { full: true })
+  const cfgApp = getConfig('app', { full: true })
+  let file = `${cfgNs.dir.pkg}/${baseTpl}/${trim(path, '/')}${extTpl}`
+  const override = `${cfgApp.dir.pkg}/${baseTpl}/override/${ns}/${trim(path, '/')}${extTpl}`
+  if (fs.existsSync(override)) file = override
+  return file
+}
+
+export default resolveTplPath

package/boot/helper/run-hook.js

@@ -0,0 +1,46 @@
+import { filter, isEmpty, orderBy } from 'lodash-es'
+
+/**
+ * @module helper/runHook
+ */
+
+/**
+ * Set hook defined by parameter ```hookName```. Hook name should be in this following format:
+ * ```<namespace>:<identifier>``` - where namespace is a valid Bajo name and
+ * identifier is a unique string set by Bajo developer to identify a hook inside a Bajo
+ *
+ * @instance
+ * @async
+ * @param {string} hookName - Hook's name
+ *
+ * @example
+ * const { runHook } = this.bajo.helper
+ * await runHook('myBajo:afterStartApp')
+ */
+
+async function runHook (hookName, ...args) {
+  // const { log } = this.bajo.helper
+  // log.trace('Run hook: %s', hookName)
+  const [ns, path] = (hookName ?? '').split(':')
+  let fns = filter(this.bajo.hooks, { ns, path })
+  if (isEmpty(fns)) return
+  fns = orderBy(fns, ['level'])
+  const results = []
+  for (const i in fns) {
+    const fn = fns[i]
+    /*
+    if (config.log.report.includes(id)) {
+      log.trace({ args }, 'Call hook: %s', id)
+    }
+    */
+    const res = await fn.handler.call(this, ...args)
+    results.push({
+      hook: hookName,
+      tag: fn.tag,
+      resp: res
+    })
+  }
+  return results
+}
+
+export default runHook

package/boot/helper/save-as-download.js

@@ -0,0 +1,17 @@
+import fs from 'fs-extra'
+import path from 'path'
+import { trim } from 'lodash-es'
+import increment from 'add-filename-increment'
+
+async function saveAsDownload (file, obj, printSaved = true) {
+  const { print, getPluginName, getPluginDataDir } = this.bajo.helper
+  const plugin = getPluginName(4)
+  const fname = increment(`${getPluginDataDir(plugin)}/${trim(file, '/')}`, { fs: true })
+  const dir = path.dirname(fname)
+  if (!fs.existsSync(dir)) fs.ensureDirSync(dir)
+  await fs.writeFile(fname, obj, 'utf8')
+  if (printSaved) print.bora('Saved as \'%s\'', path.resolve(fname), { skipSilence: true }).succeed()
+  return fname
+}
+
+export default saveAsDownload

package/boot/helper/titleize.js

@@ -0,0 +1,14 @@
+import { words, upperFirst, map, isFunction, concat, uniq } from 'lodash-es'
+
+const defIgnores = ['or', 'and', 'of', 'with']
+
+function titleize (text, { transformer, ignores = [] } = {}) {
+  return map(words(text), t => {
+    if (isFunction(transformer)) return transformer.call(this, t)
+    ignores = uniq(concat(ignores, defIgnores))
+    if (ignores.includes(t)) return t
+    return upperFirst(t)
+  }).join(' ')
+}
+
+export default titleize

package/boot/helper/white-space.js

@@ -0,0 +1,3 @@
+const whiteSpace = [' ', '\t', '\n', '\r']
+
+export default whiteSpace

package/boot/index.js

@@ -0,0 +1,60 @@
+/**
+ * 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 shim from './lib/shim.js'
+import { last } from 'lodash-es'
+import path from 'path'
+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 = path.dirname(process.argv[1])
+  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).toLocaleString()
+  log.info('Boot process completed in %sms', elapsed)
+  // run tool
+  await runTool.call(scope)
+  return scope
+}
+
+export default boot

package/boot/lib/bora.js

@@ -0,0 +1,97 @@
+import Sprintf from 'sprintf-js'
+import ora from 'ora'
+import { last, isPlainObject, get, isString } from 'lodash-es'
+
+const { sprintf } = Sprintf
+
+class Bora {
+  constructor (ns, ...args) {
+    this.ns = ns
+    const l = last(args)
+    let opts = {}
+    if (isPlainObject(l)) opts = args.pop()
+    this.opts = opts
+    this.ora = ora(this.opts)
+    this.args = args
+  }
+
+  setScope (scope) {
+    this.scope = scope
+    const { getConfig } = this.scope.bajo.helper
+    const config = getConfig()
+    let silent = !!config.silent
+    if (this.opts.skipSilent) silent = false
+    this.ora.isSilent = silent
+    const [text, ...params] = this.args
+    this.setText(text, ...params)
+  }
+
+  setText (text, ...args) {
+    if (isString(text)) {
+      const i18n = get(this, 'scope.bajoI18N.instance')
+      if (i18n) {
+        if (isPlainObject(args[0])) text = i18n.t(text, args[0])
+        else text = i18n.t(text, { ns: this.ns, postProcess: 'sprintf', sprintf: args })
+      } else text = sprintf(text, ...args)
+      this.ora.text = text
+    }
+    return this
+  }
+
+  start (text, ...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.exit(1)
+  }
+}
+
+export default function (ns, ...args) {
+  const bora = new Bora(ns, ...args)
+  bora.setScope(this)
+  return bora
+}

package/boot/lib/build-helper.js

@@ -0,0 +1,57 @@
+import fastGlob from 'fast-glob'
+import { map, without, camelCase, isFunction, isPlainObject, forOwn } from 'lodash-es'
+import resolvePath from '../helper/resolve-path.js'
+import importModule from '../helper/import-module.js'
+
+function stackInfo (name, ...args) {
+  const { log, callsites } = this.bajo.helper
+  const config = this.bajo.config
+  if (config.env === 'prod') return
+  if (!config.log.report.includes(`helper:${name}`)) return
+  const info = callsites()[2]
+  const file = info.getFileName()
+  const line = info.getLineNumber()
+  log.trace({ line, file, args }, 'Call helper: %s()', name)
+}
+
+const wrapFn = function (name, handler, bind) {
+  return (...args) => {
+    stackInfo.call(this, name, ...args)
+    if (bind) return handler.call(this, ...args)
+    return handler(...args)
+  }
+}
+
+const wrapAsyncFn = function (name, handler, bind) {
+  return async (...args) => {
+    stackInfo.call(this, name, ...args)
+    if (bind) return await handler.call(this, ...args)
+    return await handler(...args)
+  }
+}
+
+export default async function (dir, { pkg = 'bajo', exclude = [] } = {}) {
+  dir = resolvePath(dir)
+  exclude = map(exclude, e => `${dir}/${e}`)
+  let files = await fastGlob(`${dir}/**/*.js`)
+  files = without(files, ...exclude)
+  const helper = {}
+  for (const f of files) {
+    const base = f.replace(dir, '').replace('.js', '')
+    const name = camelCase(base)
+    const fnName = pkg + '.' + name
+    let mod = await importModule(f)
+    if (isFunction(mod)) {
+      if (mod.constructor.name === 'AsyncFunction') mod = wrapAsyncFn.call(this, fnName, mod, true)
+      else mod = wrapFn.call(this, fnName, mod, true)
+    } else if (isPlainObject(mod)) {
+      if (!mod.exec) { // mod.exec offer unbind, nacked function people can band to anything else later
+        forOwn(mod, (v, k) => {
+          if (isFunction(v)) mod[k] = v.bind(this)
+        })
+      }
+    }
+    helper[name] = mod
+  }
+  return helper
+}

package/boot/lib/logger.js

@@ -0,0 +1,75 @@
+/**
+ * test test
+ *
+ * @kind function
+ * @name logger
+ * @returns {Object}
+ *
+ */
+
+import print from '../helper/print.js'
+import os from 'os'
+import { keys, each, isEmpty, without, merge, upperFirst, isString } from 'lodash-es'
+// import pretty from 'prettyjson'
+import getPluginName from '../helper/get-plugin-name.js'
+import levels from '../helper/log-levels.js'
+import isLogInRange from '../helper/is-log-in-range.js'
+import dayjs from 'dayjs'
+
+const levelList = keys(levels)
+
+/*
+const prettyOpts = {
+  noAlign: true,
+  defaultIndentation: 2,
+  renderUndefined: true
+}
+*/
+
+export default function logger () {
+  const config = this.bajo.config
+  // const format = config.log.dateFormat
+  const format = 'YYYY-MM-DDTHH:MM:ss.SSS[Z]'
+  const log = {}
+  const self = this
+  log.child = () => {
+    if (!config.log.logger) config.log.logger = 'bajoLogger'
+    if (self[config.log.logger] && self[config.log.logger].logger) return self[config.log.logger].logger.child()
+    return self
+  }
+  each(levelList, l => {
+    log[l] = (...params) => {
+      const config = this.bajo.config
+      if (config.log.level === 'silent') return
+      if (!isLogInRange.call(this, l)) return
+      let [data, msg, ...args] = params
+      if (isString(data)) {
+        args.unshift(msg)
+        msg = data
+        data = null
+      }
+      args = without(args, undefined)
+      const pkg = getPluginName.call(this)
+      msg = print._format(pkg, `[%s] ${msg}`, pkg, ...args)
+      const bajoLog = config.log.logger ?? 'bajoLogger'
+      if (this[bajoLog] && this[bajoLog].logger) {
+        this[bajoLog].logger[l](data, msg, ...args)
+      } else {
+        let text
+        const dt = new Date()
+        if (config.env === 'prod') {
+          const json = { level: levels[l], 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(format)}] ${upperFirst(l)}: ${msg}`
+          // if (!isEmpty(data)) text += '\n  ' + (pretty.render(data, prettyOpts).split('\n').join('\n  '))
+          if (!isEmpty(data)) text += '\n' + JSON.stringify(data)
+        }
+        console.log(text)
+      }
+    }
+  })
+  return log
+}

package/boot/lib/omitted-plugin-keys.js

@@ -0,0 +1,3 @@
+const omittedPluginKeys = ['name', 'dir', 'alias', 'pkg', 'dependencies']
+
+export default omittedPluginKeys