bajo 0.0.1 → 0.1.0

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,58 @@
+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 (isFunction(mod.class)) mod = new mod.class(this)
+      else {
+        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

package/boot/lib/parse-args-argv.js

@@ -0,0 +1,75 @@
+import yargs from 'yargs'
+import { Parser } from 'yargs/helpers'
+import flat from 'flat'
+import isSet from '../helper/is-set.js'
+import dotenvParseVariables from 'dotenv-parse-variables'
+import importModule from '../helper/import-module.js'
+import { find, each, set, camelCase, forOwn } from 'lodash-es'
+import fs from 'fs-extra'
+import currentLoc from '../helper/current-loc.js'
+
+const { unflatten } = flat
+
+const parseItem = (data, delimiter) => {
+  return unflatten(data, {
+    delimiter,
+    safe: true,
+    overwrite: true,
+  })
+}
+
+const parseWithParser = async () => {
+  return Parser(process.argv.slice(2), {
+    configuration: {
+      'camel-case-expansion': false
+    }
+  })
+}
+
+const parseWithYargs = async () => {
+  const parser = './app/bajo/argv-parser.js'
+  if (fs.existsSync(parser)) {
+    const mod = await importModule(parser)
+    return await mod(yargs)
+  }
+  const pkg = fs.readJSONSync(`${currentLoc(import.meta).dir}/../../package.json`)
+  let name = `node ${pkg.main}`
+  if (pkg.bin) name = path.basename(pkg.bin, '.js')
+  const cli = yargs(process.argv.slice(2))
+    .usage('Usage: $0 [args...]')
+    .scriptName(name)
+    .positional('args', {
+      describe: 'Optional one or more arguments'
+    })
+    .parserConfiguration({
+      'camel-case-expansion': false
+    })
+    .version().alias('version', 'v')
+    .help().alias('help', 'h')
+    .alias('tool', 't')
+    if (pkg.homepage) cli.epilog(`For more information please visit ${pkg.homepage}`)
+  return cli.argv
+}
+
+async function parseArgsArgv ({ delimiter = '-', splitter = '--', useParser } = {}) {
+  if (!isSet(useParser)) useParser = find(process.argv, a => a.startsWith('--spawn'))
+  let argv = useParser ? await parseWithParser() : await parseWithYargs()
+  const args = argv._
+  delete argv._
+  delete argv.$0
+  argv = dotenvParseVariables(argv)
+
+  const all = { root: {} }
+  each(argv, (v, k) => {
+    const parts = k.split(splitter)
+    if (!parts[1]) all.root[parts[0]] = v
+    else set(all, `${camelCase(parts[0])}.${parts[1]}`, v)
+  })
+  const result = {}
+  forOwn(all, (v, k) => {
+    result[k] = parseItem(v, delimiter)
+  })
+  return { args, argv: result }
+}
+
+export default parseArgsArgv

package/boot/lib/parse-env.js

@@ -0,0 +1,36 @@
+import dotenvParseVariables from 'dotenv-parse-variables'
+import flat from 'flat'
+import dotEnv from 'dotenv'
+import { each, set, camelCase, forOwn } from 'lodash-es'
+const { unflatten } = flat
+
+const parse = (data, delimiter) => {
+  return unflatten(data, {
+    delimiter,
+    safe: true,
+    overwrite: true,
+    transformKey: k => k.toLowerCase()
+  })
+}
+
+export default function ({ delimiter = '_', splitter = '__' } = {}) {
+  let env
+  try {
+    env = dotEnv.config()
+    if (env.error) throw env.error
+  } catch (err) {
+    env = { parsed: {} }
+  }
+  env = dotenvParseVariables(env.parsed, { assignToProcessEnv: false })
+  const all = { root: {} }
+  each(env, (v, k) => {
+    const parts = k.split(splitter)
+    if (!parts[1]) all.root[parts[0]] = v
+    else set(all, `${camelCase(parts[0])}.${parts[1]}`, v)
+  })
+  const result = {}
+  forOwn(all, (v, k) => {
+    result[k] = parse(v, delimiter)
+  })
+  return result
+}

package/boot/lib/shim.js

@@ -0,0 +1,14 @@
+// taken from: https://vanillajstoolkit.com/polyfills/stringreplaceall/
+
+function shim () {
+  if (!String.prototype.replaceAll) {
+    String.prototype.replaceAll = function(str, newStr){
+      if (Object.prototype.toString.call(str).toLowerCase() === '[object regexp]') {
+        return this.replace(str, newStr)
+      }
+      return this.replace(new RegExp(str, 'g'), newStr)
+    }
+  }
+}
+
+export default shim

package/boot/plugins/attach-helper.js

@@ -0,0 +1,20 @@
+import buildHelper from '../lib/build-helper.js'
+import { keys } from 'lodash-es'
+
+async function runner (plugin, pkg) {
+  const { log, freeze } = this.bajo.helper
+  const dir = pkg === 'app' ? (this.bajo.config.dir.base + '/app') : this.bajo.helper.getModuleDir(pkg)
+  this[plugin].helper = await buildHelper.call(this, `${dir}/bajo/helper`, { pkg })
+  freeze(this[plugin].helper, true)
+  log.trace('Attach helper: %s (%d)', plugin, keys(this[plugin].helper).length)
+}
+
+async function attachHelper () {
+  const { log, eachPlugins } = this.bajo.helper
+  log.debug('Attach helpers')
+  await eachPlugins(async function ({ plugin, pkg }) {
+    await runner.call(this, plugin, pkg)
+  })
+}
+
+export default attachHelper

package/boot/plugins/build-config.js

@@ -0,0 +1,75 @@
+import { camelCase, pick, isString, omit, pull, each } from 'lodash-es'
+import fs from 'fs-extra'
+import lockfile from 'proper-lockfile'
+import omittedPluginKeys from '../lib/omitted-plugin-keys.js'
+
+export async function readAllConfigs (base, name) {
+  const { readConfig, getConfig } = this.bajo.helper
+  const config = getConfig()
+  let cfg = {}
+  try {
+    cfg = await readConfig(`${base}-${config.env}.*`)
+  } catch (err) {
+    if (['BAJO_CONFIG_NO_PARSER'].includes(err.code)) throw err
+    if (['BAJO_CONFIG_FILE_NOT_FOUND'].includes(err.code)) {
+      try {
+        cfg = await readConfig(`${base}.*`)
+      } catch (err) {
+        if (!['BAJO_CONFIG_FILE_NOT_FOUND'].includes(err.code)) throw err
+      }
+    }
+  }
+  cfg.name = name
+  return cfg
+}
+
+async function runner (pkg, { singles, argv, env }) {
+  const { log, getConfig, getModuleDir, readConfig, error, readJson, defaultsDeep } = this.bajo.helper
+  const config = getConfig()
+  const name = camelCase(pkg)
+  log.trace('Read configuration: %s', name)
+  const dir = pkg === 'app' ? (config.dir.base + '/app') : getModuleDir(pkg)
+  if (pkg !== 'app' && !fs.existsSync(`${dir}/bajo`)) throw error('Package \'%s\' isn\'t a valid Bajo package', pkg, { code: 'BAJO_INVALID_PACKAGE' })
+  let cfg = await readAllConfigs.call(this, `${dir}/bajo/config`, name)
+  cfg.dir = dir
+  const pkgJson = await readJson(`${dir + (pkg === 'app' ? '/..' : '')}/package.json`)
+  cfg.pkg = pick(pkgJson,
+    ['name', 'version', 'description', 'author', 'license', 'homepage'])
+  if (cfg.name === 'app') cfg.alias = 'app'
+  else if (!isString(cfg.alias)) cfg.alias = pkg.slice(0, 5) === 'bajo-' ? pkg.slice(5).toLowerCase() : pkg // fix. can't be overriden
+  // merge with config from datadir
+  try {
+    const altCfg = await readConfig(`${config.dir.data}/config/${cfg.name}.*`)
+    cfg = defaultsDeep({}, omit(altCfg, omittedPluginKeys), cfg)
+  } catch (err) {}
+  const envArgv = defaultsDeep({}, omit(env[cfg.name] ?? {}, omittedPluginKeys) ?? {}, omit(argv[cfg.name] ?? {}, omittedPluginKeys) ?? {})
+  cfg = defaultsDeep({}, envArgv ?? {}, cfg ?? {})
+  cfg.dependencies = cfg.dependencies ?? []
+  if (isString(cfg.dependencies)) cfg.dependencies = [cfg.dependencies]
+  if (cfg.single) {
+    const lockfileDir = `${config.dir.tmp}/lock`
+    const lockfilePath = `${lockfileDir}/${name}.lock`
+    fs.ensureDirSync(lockfileDir)
+    const file = `${cfg.dir}/package.json`
+    try {
+      await lockfile.lock(file, { lockfilePath })
+    } catch (err) {
+      singles.push(pkg)
+    }
+  }
+  if (!this[name]) this[name] = {}
+  this[name].config = cfg
+}
+
+async function buildConfig ({ singles, argv, env }) {
+  const { log, freeze } = this.bajo.helper
+  log.debug('Read configurations')
+  for (const pkg of this.bajo.config.plugins) {
+    await runner.call(this, pkg, { singles, argv, env })
+  }
+  pull(this.bajo.config.plugins, ...singles)
+  each(singles, s => delete this[camelCase(s)])
+  freeze(this.bajo.config)
+}
+
+export default buildConfig

package/boot/plugins/check-clash.js

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

package/boot/plugins/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 ({ plugin, pkg, dependencies }) {
+  const { log, getConfig, error } = this.bajo.helper
+  log.trace('Checking dependencies: %s', plugin)
+  const config = getConfig()
+  const odep = reduce(dependencies, (o, k) => {
+    const item = map(k.split('@'), m => trim(m))
+    o[item[0]] = item[1]
+    return o
+  }, {})
+  const deps = keys(odep)
+  if (deps.length > 0) {
+    if (intersection(config.plugins, deps).length !== deps.length) {
+      throw error('Dependency for \'%s\' unfulfilled: %s', pkg, deps.join(', '), { code: 'BAJO_DEPENDENCY' })
+    }
+    each(deps, d => {
+      if (!odep[d]) return
+      const ver = get(this[camelCase(d)], 'config.pkg.version')
+      if (!ver) return
+      if (!semver.satisfies(ver, odep[d])) {
+        throw error('Semver check \'%s\' against \'%s\' failed', pkg, `${d}@${odep[d]}`, { code: 'BAJO_DEPENDENCY_SEMVER' })
+      }
+    })
+  }
+}
+
+async function checkDependency () {
+  const { log, eachPlugins } = this.bajo.helper
+  log.debug('Checking dependencies')
+  await eachPlugins(async function ({ plugin, pkg, dependencies }) {
+    await runner.call(this, { plugin, pkg, dependencies })
+  })
+}
+
+export default checkDependency

package/boot/plugins/collect-config-handlers.js

@@ -0,0 +1,25 @@
+import { isFunction, isPlainObject, map } from 'lodash-es'
+import fs from 'fs-extra'
+
+async function collectConfigHandlers (pkg) {
+  const { getModuleDir, importModule, log } = this.bajo.helper
+  for (const pkg of this.bajo.config.plugins) {
+    let dir
+    try {
+      dir = getModuleDir(pkg)
+    } catch (err) {}
+    if (!dir) continue
+    const file = `${dir}/bajo/extend/read-config.js`
+    if (!fs.existsSync(file)) continue
+    try {
+      let mod = await importModule(file)
+      if (isFunction(mod)) mod = await mod.call(this)
+      if (isPlainObject(mod)) mod = [mod]
+      this.bajo.configHandlers.concat(mod)
+    } catch (err) {}
+  }
+  const exts = map(this.bajo.configHandlers, 'ext')
+  log.trace('Config handlers: %s', exts.join(', '))
+}
+
+export default collectConfigHandlers

package/boot/plugins/collect-exit-handlers.js

@@ -0,0 +1,23 @@
+import {} from 'lodash-es'
+import fs from 'fs-extra'
+
+async function collectExitHandlers () {
+  const { importModule, log, eachPlugins, getConfig, print } = this.bajo.helper
+  const config = getConfig()
+  if (!config.exitHandler) return
+  this.bajo.exitHandler = this.bajo.exitHandler ?? {}
+  const names = []
+  await eachPlugins(async function ({ plugin, dir }) {
+    const file = `${dir}/bajo/exit.js`
+    if (!fs.existsSync(file)) return undefined
+    try {
+      const mod = await importModule(file)
+      this.bajo.exitHandler[plugin] = mod
+      names.push(plugin)
+    } catch (err) {
+    }
+  })
+  log.trace('Exit handlers: %s', names.length === 0 ? print.__('none') : names.join(', '))
+}
+
+export default collectExitHandlers

package/boot/plugins/collect-hooks.js

@@ -0,0 +1,33 @@
+import { map, camelCase, merge, filter, groupBy } from 'lodash-es'
+
+async function collectHooks () {
+  const { eachPlugins, log, runHook, isLogInRange, importModule } = this.bajo.helper
+  this.bajo.hooks = this.bajo.hooks ?? []
+  log.debug('Collect hooks')
+  // collects
+  await eachPlugins(async function ({ plugin, dir, file }) {
+    const hookName = (file.slice(dir.length + 1) ?? '').split('/')[1]
+    let [ns, path] = map(hookName.replace('.js', '').split('@'), e => camelCase(e))
+    if (!path) {
+      path = ns
+      ns = plugin
+    }
+    const mod = await importModule(file, { asHandler: true })
+    if (!mod) return undefined
+    merge(mod, { ns, path })
+    this.bajo.hooks.push(mod)
+  }, { glob: 'hook/**/*.js', insideBajo: true })
+  await runHook('bajo:afterCollectHooks')
+  // for log trace purpose only
+  if (!isLogInRange('trace')) return
+  await eachPlugins(async function ({ plugin }) {
+    const hooks = filter(this.bajo.hooks, { ns: plugin })
+    if (hooks.length === 0) return undefined
+    const items = groupBy(hooks, 'path')
+    for (const hook of hooks) {
+      log.trace('Collect hook: %s:%s (%d)', hook.ns, hook.path, items[hook.path].length)
+    }
+  })
+}
+
+export default collectHooks

package/boot/plugins/extend-config.js

@@ -0,0 +1,21 @@
+import { isArray, each, isPlainObject, has, merge, concat } from 'lodash-es'
+import { readAllConfigs } from './build-config.js'
+
+async function extendConfig () {
+  const { eachPlugins } = this.bajo.helper
+  await eachPlugins(async function (opts) {
+    if (!opts.cfg.mergeProps) return undefined
+    await eachPlugins(async function ({ dir, plugin }) {
+      const cfg = await readAllConfigs.call(this, `${dir}/${opts.plugin}/config`, opts.plugin)
+      each(opts.cfg.mergeProps, p => {
+        if (!has(cfg, p)) return undefined
+        if (isArray(opts.cfg[p])) this[opts.plugin].config[p] = concat(opts.cfg[p], cfg[p])
+        else if (isPlainObject(opts.cfg[p])) this[opts.plugin].config[p] = merge(opts.cfg[p], cfg[p])
+        else this[opts.plugin].config[p] = cfg[p]
+      })
+    })
+    delete this[opts.plugin].config.mergeProps
+  })
+}
+
+export default extendConfig