bajo 2.0.1 → 2.1.0

package/class/bajo.js

@@ -1,5 +1,4 @@
 import Plugin from './plugin.js'
-import BasePlugin from './base/plugin.js'
 import increment from 'add-filename-increment'
 import fs from 'fs-extra'
 import path from 'path'
@@ -19,6 +18,15 @@ import resolvePath from '../lib/resolve-path.js'
 import importModule from '../lib/import-module.js'
 import logLevels from '../lib/log-levels.js'
 import { types as formatTypes, formats } from '../lib/formats.js'
+import {
+  buildBaseConfig,
+  buildExtConfig,
+  buildPlugins,
+  collectConfigHandlers,
+  bootOrder,
+  bootPlugins,
+  exitHandler
+} from './helper/bajo.js'
 
 const require = createRequire(import.meta.url)
 
@@ -31,67 +39,30 @@ const {
 
 /**
  * The Core. The main engine. The one and only plugin that control app's boot process and
- * making sure all other plugins working smoothly.
+ * making sure all other plugins working nicely.
  *
  * @class
  */
-class Bajo extends BasePlugin {
+class Bajo extends Plugin {
+  static alias = 'bajo'
   /**
-   * @param {Object} app
-   * @param {Object} app - App instance reference. Usefull to call app method inside a plugin
+   * @param {App} app - App instance. Usefull to call app method inside a plugin
    */
   constructor (app) {
     super('bajo', app)
+    this.whiteSpace = [' ', '\t', '\n', '\r']
     /**
-     * Date/time when your app start
-     * @type {Date}
-     */
-    this.runAt = new Date()
-
-    /**
-     * Your main namespace. And yes, you suppose NOT to change this
-     *
-     * @type {string}
-     */
-    this.mainNs = 'main'
-
-    /**
-     * Storage for applets
-     *
-     * @type {Array}
-     */
-    this.applets = []
-
-    /**
-     * List of all loaded plugin's package names
-     *
-     * @type {Array}
-     */
-    this.pluginPkgs = []
-
-    /**
-     * List of all loaded plugin's names
+     * Config object
      *
-     * @type {Array}
+     * @type {Object}
+     * @see {@tutorial config}
      */
-    this.pluginNames = []
+    this.config = {}
 
-    /**
-     * Storage for config handlers. By default there are only two handlers available: ```.js```
-     * and ```.json```.
-     *
-     * Use plugin to add more type - e.g: {@link https://github.com/ardhi/bajo-config|bajo-config}
-     * lets you to use ```.yaml``` and ```.toml```
-     *
-     * @type {Array}
-     */
-    this.configHandlers = [
+    app.configHandlers = [
       { ext: '.js', readHandler: this._defConfigHandler },
-      { ext: '.json', readHandler: this.readJson }
+      { ext: '.json', readHandler: this.fromJson, writeHandler: this.toJson }
     ]
-    this.whiteSpace = [' ', '\t', '\n', '\r']
-    this.envs = { dev: 'development', staging: 'staging', prod: 'production' }
-    this.lib.Plugin = Plugin
   }
 
   async _defConfigHandler (file, opts = {}) {
@@ -100,6 +71,30 @@ class Bajo extends BasePlugin {
     return mod
   }
 
+  /**
+   * Initialization:
+   *
+   * 1. Building {@link module:Helper/Bajo.buildBaseConfig|base config}
+   * 2. {@link module:Helper/Bajo.buildPlugins|Building plugins}
+   * 3. Collect all {@link module:Helper/Bajo.collectConfigHandlers|config handler}
+   * 4. Building {@link module:Helper/Bajo.buildExtConfig|extra config}
+   * 5. Setup {@link module:Helper/Bajo.bootOrder|boot order}
+   * 6. {@link module:Helper/Bajo.bootPlugins|Boot loaded plugins}
+   * 7. Attach {@link module:Helper/Bajo.exitHandler|exit handlers}
+   *
+   * @method
+   * @async
+   */
+  init = async () => {
+    await buildBaseConfig.call(this)
+    await collectConfigHandlers.call(this)
+    await buildExtConfig.call(this)
+    await buildPlugins.call(this)
+    await bootOrder.call(this)
+    await bootPlugins.call(this)
+    await exitHandler.call(this)
+  }
+
   /**
    * Resolve file name to filesystem's path. Windows path separator ```\```
    * is normalized to Unix's ```/```
@@ -117,10 +112,10 @@ class Bajo extends BasePlugin {
    * Freeze object
    *
    * @method
-   * @param {Object} obj - Object
-   * @param {boolean} [shallow=false] - If true (default), deep freeze object
+   * @param {Object} obj - Object to freeze
+   * @param {boolean} [shallow=false] - If ```false``` (default), deep freeze object
    */
-  freeze = (obj, shallow) => {
+  freeze = (obj, shallow = false) => {
     if (shallow) Object.freeze(obj)
     else deepFreeze(obj)
   }
@@ -151,6 +146,25 @@ class Bajo extends BasePlugin {
     return { ns, subNs, path: _path, fullNs: names.join('.'), type }
   }
 
+  /**
+   * Name based ```{ns}:{path}``` format
+   * @typedef {string} TNsPathPairs
+   * @see TNsPathResult
+   * @see Bajo#buildNsPath
+   * @see Bajo#breakNsPath
+   */
+
+  /**
+   * Build ns/path pairs
+   *
+   * @method
+   * @param {object} [options={}] - Options object
+   * @param {string} [options.ns=''] - Namespace
+   * @param {string} [options.subNs] - Sub namespace
+   * @param {string} [options.subSubNs] - Sub sub namespace
+   * @param {string} [options.path] - Path
+   * @returns {TNsPathPairs} - Ns/path pairs
+   */
   buildNsPath = ({ ns = '', subNs, subSubNs, path } = {}) => {
     if (subNs) ns += '.' + subNs
     if (subSubNs) ns += '.' + subSubNs
@@ -158,23 +172,26 @@ class Bajo extends BasePlugin {
   }
 
   /**
-   * Object returned by {@link BajoCore#breakNsPath|breakNsPath}
+   * Object returned by {@link Bajo#breakNsPath|bajo:breakNsPath}
    *
-   * @typedef {Object} NsPathType
+   * @typedef {Object} TNsPathResult
    * @property {string} ns - Namespace
    * @property {string} [subNs] - Sub namespace
    * @property {string} [subSubNs] - Sub of sub namespace
    * @property {string} path - Path without query string or hash
    * @property {string} fullPath - Full path, including query string and hash
+   * @see TNsPathPairs
+   * @see Bajo#buildNsPath
+   * @see Bajo#breakNsPath
    */
 
   /**
    * Break name to its namespace & path infos
    *
    * @method
-   * @param {string} name - Name to break
-   * @param {boolean} [checkNs=true] - If true (default), namespace will be checked for its validity
-   * @returns {NsPathType}
+   * @param {(TNsPathPairs|string)} name - Name to break
+   * @param {boolean} [checkNs=true] - If ```true``` (default), namespace will be checked for its validity
+   * @returns {TNsPathResult}
    */
   breakNsPath = (name = '', checkNs = true) => {
     let [ns, ...path] = name.split(':')
@@ -190,7 +207,7 @@ class Bajo extends BasePlugin {
     if (checkNs) {
       if (!this.app[ns]) {
         const plugin = this.getPlugin(ns)
-        if (plugin) ns = plugin.name
+        if (plugin) ns = plugin.ns
       }
       if (!this.app[ns]) throw this.error('unknownPluginOrNotLoaded%s')
     }
@@ -222,31 +239,39 @@ class Bajo extends BasePlugin {
   }
 
   /**
-   * Method to transform an array or object from config into an array of collection safely.
-   *
-   * Emitted hooks:
-   * 1. ```{ns}:beforeBuildCollection (container)``` - called before collection is built
-   * 2. ```{ns}:afterBuildCollection (container, items)``` - called after collection is built
+   * Method to transform config's array or object into an array of collection.
    *
    * @method
    * @async
    * @param {Object} options - Options
    * @param {string} [options.ns] - Namespace. If not provided, defaults to ```bajo```
    * @param {function} [options.handler] - Handler to call while building the collection item
-   * @param {Array} [options.dupChecks=[]] - Array of keys to check for duplicates
+   * @param {string[]} [options.dupChecks=[]] - Array of keys to check for duplicates
    * @param {string} options.container - Key used as container name
    * @param {boolean} [options.useDefaultName=true] - If true (default) and ```name``` key is not provided, returned collection will be named ```default```
-   * @returns {Array} The collection
+   * @fires bajo:beforeBuildCollection
+   * @fires bajo:afterBuildCollection
+   * @returns {Object[]} The collection
    */
   buildCollections = async (options = {}) => {
     let { ns, handler, dupChecks = [], container, useDefaultName } = options
     useDefaultName = useDefaultName ?? true
-    if (!ns) ns = this.name
+    if (!ns) ns = this.ns
     const cfg = this.app[ns].getConfig()
     let items = get(cfg, container, [])
     if (!isArray(items)) items = [items]
-    this.app[ns].log.trace('collecting%s', this.app[ns].print.write(container))
-    await this.runHook(`${ns}:${camelCase('beforeBuildCollection')}`, container)
+    this.app[ns].log.trace('collecting%s', this.t(container))
+
+    /**
+     * Run before collection is built
+     *
+     * @global
+     * @event bajo:beforeBuildCollection
+     * @param {string} container
+     * @see {@tutorial hook}
+     * @see Bajo#buildCollections
+     */
+    await this.runHook(`${ns}:beforeBuildCollection`, container)
     const deleted = []
     for (const index in items) {
       const item = items[index]
@@ -260,7 +285,7 @@ class Bajo extends BasePlugin {
       const result = await handler.call(this.app[ns], { item, index, cfg })
       if (result) items[index] = result
       else if (result === false) deleted.push(index)
-      if (this.app.bajo.applet && item.skipOnTool && !deleted.includes(index)) deleted.push(index)
+      if (this.app.applet && item.skipOnApplet && !deleted.includes(index)) deleted.push(index)
     }
     if (deleted.length > 0) pullAt(items, deleted)
 
@@ -272,13 +297,25 @@ class Bajo extends BasePlugin {
         if (checkers.includes(checker)) this.app[ns].fatal('oneOrMoreSharedTheSame%s%s', container, this.join(dupChecks.filter(i => !isFunction(i))))
       }
     }
-    await this.runHook(`${ns}:${camelCase('afterBuildCollection')}`, container, items)
-    this.app[ns].log.debug('collected%s%d', this.app[ns].print.write(container), items.length)
+
+    /**
+     * Run after collection is built
+     *
+     * @global
+     * @event bajo:afterBuildCollection
+     * @param {string} container
+     * @param {Object[]} items
+     * @see {@tutorial hook}
+     * @see Bajo#buildCollections
+     */
+    await this.runHook(`${ns}:afterBuildCollection`, container, items)
+    this.app[ns].log.debug('collected%s%d', this.t(container), items.length)
     return items
   }
 
   /**
-   * Calling any plugin's method by its name. Name format: ```ns:methodName```.
+   * Calling any plugin's method by its name:
+   *
    * - If name is a string, the corresponding plugin's method will be called with passed args as its parameters
    * - If name is a plugin instance, this will be used as the scope instead. The first args is now the handler name and the rest are its parameters
    * - If name is a function, this function will be run under scope with the remaining args
@@ -286,7 +323,7 @@ class Bajo extends BasePlugin {
    *
    * @method
    * @async
-   * @param {(string|Object|function)} name - Method's name, function handler, plain object or plugin instance
+   * @param {(TNsPathPairs|Object|function)} name - Method's name, function handler, plain object or plugin instance
    * @param  {...any} [args] - One or more arguments passed as parameter to the handler
    * @returns {any} Returned value
    */
@@ -299,10 +336,10 @@ class Bajo extends BasePlugin {
     }
     const bajo = scope.app.bajo
     if (isString(item)) {
-      if (item.startsWith('applet:') && bajo.applets.length > 0) {
+      if (item.startsWith('applet:') && bajo.app.applets.length > 0) {
         const [, ns, path] = item.split(':')
-        const applet = find(bajo.applets, a => (a.ns === ns || a.alias === ns))
-        if (applet) result = await bajo.runApplet(applet, path, ...args)
+        const applet = find(bajo.app.applets, a => (a.ns === ns || a.alias === ns))
+        if (applet && scope.app.bajoCli) result = await scope.app.bajoCli.runApplet(applet, path, ...args)
       } else {
         const [ns, method, ...params] = item.split(':')
         const fn = bajo.getMethod(`${ns}:${method}`)
@@ -330,7 +367,7 @@ class Bajo extends BasePlugin {
    * @async
    * @param {function} handler - Function handler. Can be an async function. Scoped to the running plugin
    * @param {(string|Object)} [options={}] - Options. If a string is provided, it serves as the glob pattern, otherwise:
-   * @param {(string|Array)} [options.glob] - Glob pattern. If provided,
+   * @param {(string|string[])} [options.glob] - Glob pattern. If provided,
    * @param {boolean} [options.useBajo=false] - If true, add ```bajo``` to the running plugins too
    * @param {string} [options.prefix=''] - Prepend glob pattern with prefix
    * @param {boolean} [options.noUnderscore=true] - If true (default), matched file with name starts with underscore is ignored
@@ -340,7 +377,7 @@ class Bajo extends BasePlugin {
   eachPlugins = async (handler, options = {}) => {
     if (typeof options === 'string') options = { glob: options }
     const result = {}
-    const pluginPkgs = cloneDeep(this.app.bajo.pluginPkgs) ?? []
+    const pluginPkgs = cloneDeep(this.app.pluginPkgs) ?? []
     const { glob, useBajo, prefix = '', noUnderscore = true, returnItems } = options
     if (useBajo) pluginPkgs.unshift('bajo')
     for (const pkgName of pluginPkgs) {
@@ -386,11 +423,12 @@ class Bajo extends BasePlugin {
   }
 
   /**
-   * Object returned by {@link BajoCore#getUnitFormat|getUnitFormat}
+   * Object returned by {@link Bajo#getUnitFormat|bajo:getUnitFormat}
    *
-   * @typedef {Object} ObjectFormatType
+   * @typedef {Object} TBajoFormatResult
    * @property {string} unitSys - Unit system
    * @property {Object} format - Format object
+   * @see Bajo#getUnitFormat
    */
 
   /**
@@ -400,7 +438,7 @@ class Bajo extends BasePlugin {
    * @param {Object} [options={}] - Options
    * @param {string} [options.lang] - Language to use. Defaults to the one you set in config
    * @param {string} [options.unitSys] - Unit system to use. Defaults to language's unit system or ```metric``` if unspecified
-   * @returns {ObjectFormatType} - Returned value
+   * @returns {TBajoFormatResult} - Returned value
    */
   getUnitFormat = (options = {}) => {
     const lang = options.lang ?? this.config.lang
@@ -413,16 +451,16 @@ class Bajo extends BasePlugin {
    * Format value by type
    *
    * @method
-   * @param {string} type - Format type. See {@link FormatType} for acceptable values
+   * @param {string} type - Format type. See {@link TBajoFormatType} for acceptable values
    * @param {any} value - Value to format
-   * @param {string} [dataType] - Value's data type. See {@link DataType} for acceptable values
+   * @param {string} [dataType] - Value's data type. See {@link TBajoDataType} for acceptable values
    * @param {Object} [options={}] - Options
    * @param {boolean} [options.withUnit=true] - Return with its unit appended
    * @param {string} [options.lang] - Format value according to this language. Defaults to the one you set in config
    * @returns {(Array|string)} Return string if ```withUnit``` is true. Otherwise is an array of ```[value, unit, separator]```
    */
   formatByType = (type, value, dataType, options = {}) => {
-    const { defaultsDeep } = this.lib.aneka
+    const { defaultsDeep } = this.app.lib.aneka
     const { format } = this.getUnitFormat(options)
     const { withUnit = true } = options
     const lang = options.lang ?? this.config.lang
@@ -440,7 +478,7 @@ class Bajo extends BasePlugin {
    *
    * @method
    * @param {any} value - Value to format
-   * @param {string} [type] - Data type to use. See {@link DataType} for acceptable values. If not provided, return the untouched value
+   * @param {string} [type] - Data type to use. See {@link TBajoDataType} for acceptable values. If not provided, return the untouched value
    * @param {Object} [options={}] - Options
    * @param {string} [options.emptyValue=''] - Empty value to use if function resulted empty. Defaults to the one from your config
    * @param {boolean} [options.withUnit=true] - Return with its unit appended
@@ -450,7 +488,7 @@ class Bajo extends BasePlugin {
    * @returns {string} Formatted value
    */
   format = (value, type, options = {}) => {
-    const { defaultsDeep } = this.lib.aneka
+    const { defaultsDeep } = this.app.lib.aneka
     const { format } = this.config.intl
     const { emptyValue = format.emptyValue } = options
     const lang = options.lang ?? this.config.lang
@@ -461,7 +499,7 @@ class Bajo extends BasePlugin {
       if (value instanceof Date) type = 'datetime'
     }
     if (['float', 'double'].includes(type) && this.app.bajoSpatial) {
-      const { latToDms, lngToDms } = this.app.bajoSpatial.lib.anekaSpatial
+      const { latToDms, lngToDms } = this.app.lib.anekaSpatial
       if (options.latitude) return latToDms(value)
       if (options.longitude) return lngToDms(value)
     }
@@ -594,7 +632,7 @@ class Bajo extends BasePlugin {
    *
    * @method
    * @param {string} pkgName - Package name to find
-   * @param {*} base - Provide base name if ```pkgName``` is a module under ```base```'s package name
+   * @param {string} base - Provide base name if ```pkgName``` is a module under ```base```'s package name
    * @returns {string} Return absolute package directory
    */
   getModuleDir = (pkgName, base) => {
@@ -622,7 +660,7 @@ class Bajo extends BasePlugin {
    */
   getPluginDataDir = (name, ensureDir = true) => {
     const plugin = this.getPlugin(name)
-    const dir = `${this.app.bajo.dir.data}/plugins/${plugin.name}`
+    const dir = `${this.app.bajo.dir.data}/plugins/${plugin.ns}`
     if (ensureDir) fs.ensureDirSync(dir)
     return dir
   }
@@ -631,7 +669,7 @@ class Bajo extends BasePlugin {
    * Resolve file path from:
    *
    * - local/absolute file
-   * - ns based path (```myPlugin:/path/to/file.txt```)
+   * - TNsPath (```myPlugin:/path/to/file.txt```)
    *
    * @method
    * @param {string} file - File path, see above for supported types
@@ -673,46 +711,38 @@ class Bajo extends BasePlugin {
         if (silent) return false
         throw this.error('pluginWithNameAliasNotLoaded%s', name)
       }
-      name = plugin.name
+      name = plugin.ns
     }
     return this.app[name]
   }
 
   /**
-   * Import file/module from any loaded plugins
+   * Import file/module from any loaded plugins.
    *
-   * Your plugin structure:
-   * ```
-   * |- src
-   * |  |- lib
-   * |  |  |- my-module.js
-   * |- index.js
-   * |- package.json
-   * ```
+   * Method proxy from {@link module:Lib.importModule}
    *
-   * Inside your app/plugin:
-   * ```javascript
-   * const { importModule } = this.app.bajo
-   * const myModule = await importModule('myPlugin:/src/lib/my-module.js')
-   * ```
    * @method
    * @async
-   * @param {string} file - File in format ```ns:<ns based file path>```
-   * @param {Object} [options={}] - Options
-   * @param {boolean} [options.asDefaultImport=true] - If ```true``` (default), return default imported module
-   * @param {boolean} [options.asHandler] - If ```true```, return as a {@link HandlerType|handler}
-   * @param {boolean} [options.noCache] - If ```true```, always import as a fresh copy
-   * @returns {(function|Object)}
+   * @see module:Lib.importModule
    */
   importModule = async (file, { asDefaultImport, asHandler, noCache } = {}) => {
     return await importModule.call(this, file, { asDefaultImport, asHandler, noCache })
   }
 
   /**
-   * Import one or more package belongs to a plugin
+   * Import one or more packages belongs to a plugin.
+   *
+   * If the last arguments passed is an object, this object serves as options object:
+   * - ```returnDefault```: should return package's default export. Defaults to ```true```
+   * - ```throwNotFound```: should throw if package is not found. Defaults to ```false```
+   * - ```noCache```: always use fresh import. Defaults to ```false```
+   * - ```asObject```: see below. Defaults to ```false```
    *
-   * Example: you want to import packages ```delay``` and ```chalk``` from ```bajo``` namespace and use it inside your app/plugin
+   * Return value:
+   * - if ```options.asObject``` is ```true``` (default ```false```), return as object with package's names as it's keys
+   * - Otherwise depends on how many parameters are provided, it should return the named package or an array of packages
    *
+   * Example: you want to import ```delay``` and ```chalk``` from ```bajo``` plugin because you want to use it in your code
    * ```javascript
    * const { importPkg } from this.app.bajo
    * const [delay, chalk] = await importPkg('bajo:delay', 'bajo:chalk')
@@ -723,14 +753,14 @@ class Bajo extends BasePlugin {
    *
    * @method
    * @async
-   * @param {...any} pkgs - One or more packages in format ```ns:packageName```
-   * @returns {(Object|Array)} Depends on how many parameters are provided, it should return the named package or an array of packages
+   * @param {...TNsPathPairs} pkgs - One or more packages in format ```{ns}:{packageName}```
+   * @returns {(Object|Array)} See above
    */
   importPkg = async (...pkgs) => {
-    const { defaultsDeep } = this.lib.aneka
+    const { defaultsDeep } = this.app.lib.aneka
     const result = {}
     const notFound = []
-    let opts = { returnDefault: true, thrownNotFound: false }
+    let opts = { returnDefault: true, throwNotFound: false }
     if (isPlainObject(last(pkgs))) {
       opts = defaultsDeep(pkgs.pop(), opts)
     }
@@ -742,7 +772,7 @@ class Bajo extends BasePlugin {
         notFound.push(pkg)
         continue
       }
-      const p = this.readJson(`${dir}/package.json`, opts.thrownNotFound)
+      const p = this.readJson(`${dir}/package.json`, opts.throwNotFound)
       const mainFileOrg = dir + '/' + (p.main ?? get(p, 'exports.default', 'index.js'))
       let mainFile = resolvePath(mainFileOrg, os.platform() === 'win32')
       if (isEmpty(path.extname(mainFile))) {
@@ -758,17 +788,17 @@ class Bajo extends BasePlugin {
       result[name] = mod
     }
     if (notFound.length > 0) throw this.error('cantFind%s', this.join(notFound))
-    if (pkgs.length === 1) return result[keys(result)[0]]
     if (opts.asObject) return result
+    if (pkgs.length === 1) return result[keys(result)[0]]
     return values(result)
   }
 
   /**
-   * Check whether directory is empty or not. More info please {@link https://github.com/gulpjs/empty-dir|check here}.
+   * Check whether a directory is empty or not. More info please {@link https://github.com/gulpjs/empty-dir|check here}.
    *
    * @method
    * @async
-   * @param {string} dir - Directory to check. Can be a ns based directory too!
+   * @param {(string|TNsPathPairs)} dir - Directory to check
    * @param {function} filterFn - Filter function to filter out files that cause false positives.
    * @returns {boolean}
    */
@@ -782,7 +812,7 @@ class Bajo extends BasePlugin {
    * Check whether log level is within log's app current level
    *
    * @method
-   * @param {string} level - Level to check. See {@link LogLevelsType} for more
+   * @param {string} level - Level to check. See {@link TLogLevels} for more
    * @returns {boolean}
    */
   isLogInRange = (level) => {
@@ -831,19 +861,28 @@ class Bajo extends BasePlugin {
     return this.isValidAppPlugin(dir, 'plugin', returnPkg)
   }
 
-  join = (array, sep) => {
-    const { isSet } = this.lib.aneka
+  /**
+   * Human friendly join array of items.
+   *
+   * @method
+   * @param {any[]} array - Array to join
+   * @param {(string|Object)} options - If provided and is a string, it will be used as separator
+   * @param {string} [options.separator=', '] - Separator to use
+   * @param {string} [options.lastSeparator=and] - Text to use as the last separator
+   * @returns {string}
+   */
+  join = (array, options) => {
+    const { isSet } = this.app.lib.aneka
     const translate = val => {
-      if (this && this.print) return this.print.write(val).toLowerCase()
-      return val
+      return this.t(val).toLowerCase()
     }
     if (array.length === 0) return translate('none')
     if (array.length === 1) return array[0]
-    if (isSet(sep) && !isPlainObject(sep)) return array.join(sep)
-    let { separator = ', ', joiner = 'and' } = sep ?? {}
-    joiner = translate(joiner)
+    if (isSet(options) && !isPlainObject(options)) return array.join(options)
+    let { separator = ', ', lastSeparator = 'and' } = options ?? {}
+    lastSeparator = translate(lastSeparator)
     const last = (array.pop() ?? '').trim()
-    return array.map(a => (a + '').trim()).join(separator) + ` ${joiner} ${last}`
+    return array.map(a => (a + '').trim()).join(separator) + ` ${lastSeparator} ${last}`
   }
 
   /**
@@ -864,22 +903,24 @@ class Bajo extends BasePlugin {
    * Parse duration to its millisecond value. Use {@link https://github.com/vercel/ms|ms} under the hood
    *
    * @method
-   * @param {(number|string)} dur - If string is given, parse this to its millisecond value. Otherwise return as is
+   * @param {(number|string)} dur - If string is given, parse this to its millisecond value. Otherwise returns as is
    * @returns {number}
+   * @see {@link https://github.com/vercel/ms|ms}
    */
   parseDur = (dur) => {
     return isNumber(dur) ? dur : ms(dur)
   }
 
   /**
-   * Parse datetime string as Javascript object. Please visit {@link https://day.js.org|dayjs} for valid formats and more infos
+   * Parse datetime string as Javascript date object. Please visit {@link https://day.js.org|dayjs} for valid formats and more infos
    *
    * @method
    * @param {string} dt - Datetime string
-   * @returns {Object} Javascript object
+   * @returns {Object} Javascript date object
+   * @see {@link https://day.js.org|dayjs}
    */
   parseDt = (dt) => {
-    const value = this.lib.dayjs(dt)
+    const value = this.app.lib.dayjs(dt)
     if (!value.isValid()) throw this.error('dtUnparsable%s', dt)
     return value.toDate()
   }
@@ -889,7 +930,7 @@ class Bajo extends BasePlugin {
    * to parse values, so please have a visit to know how it works
    *
    * If ```options.parseValue``` is ```true```, any key ends with ```Dur``` and ```Dt``` will
-   * also be parsed as millisecond and Javascript datetime accordingly
+   * also be parsed as millisecond and Javascript date time accordingly.
    *
    * @method
    * @param {(Object|string)} input - If string is given, parse it first using JSON.parse
@@ -898,14 +939,15 @@ class Bajo extends BasePlugin {
    * @param {boolean} [options.parseValue=false] - If ```true```, values will be parsed & normalized
    * @param {string} [options.lang] - If provided, use this language instead of the one in config
    * @returns {Object}
+   * @see {@link https://github.com/ladjs/dotenv-parse-variables}
    */
   parseObject = (input, options = {}) => {
     const { silent = true, parseValue = false, lang, ns } = options
-    const { isSet } = this.lib.aneka
+    const { isSet } = this.app.lib.aneka
     const translate = (item) => {
       const scope = ns ? this.app[ns] : this
       const [text, ...args] = item.split('|')
-      return scope.print.write(text, ...args, { lang })
+      return scope.t(text, ...args, { lang })
     }
     const statics = ['*']
     if (isString(input)) {
@@ -955,7 +997,7 @@ class Bajo extends BasePlugin {
   }
 
   pick = (obj, items, excludeUnset) => {
-    const { isSet } = this.lib.aneka
+    const { isSet } = this.app.lib.aneka
     const result = {}
     for (const item of items) {
       const [k, nk] = item.split(':')
@@ -984,25 +1026,25 @@ class Bajo extends BasePlugin {
    * @returns {Object}
    */
   readConfig = async (file, { ns, pattern, globOptions = {}, ignoreError, defValue = {}, opts = {} } = {}) => {
-    if (!ns) ns = this.name
+    if (!ns) ns = this.ns
     file = resolvePath(this.getPluginFile(file))
     let ext = path.extname(file)
     const fname = path.dirname(file) + '/' + path.basename(file, ext)
     ext = ext.toLowerCase()
     if (ext === '.js') {
-      const { readHandler } = find(this.app.bajo.configHandlers, { ext })
+      const { readHandler } = find(this.app.configHandlers, { ext })
       return this.parseObject(await readHandler.call(this.app[ns], file, opts))
     }
-    if (ext === '.json') return await this.readJson(file)
+    if (ext === '.json') return await this.fromJson(file, null)
     if (!['', '.*'].includes(ext)) {
-      const item = find(this.app.bajo.configHandlers, { ext })
+      const item = find(this.app.configHandlers, { ext })
       if (!item) {
         if (!ignoreError) throw this.error('cantParse%s', file, { code: 'BAJO_CONFIG_NO_PARSER' })
         return this.parseObject(defValue)
       }
       return this.parseObject(await item.readHandler.call(this.app[ns], file, opts))
     }
-    const item = pattern ?? `${fname}.{${map(map(this.app.bajo.configHandlers, 'ext'), k => k.slice(1)).join(',')}}`
+    const item = pattern ?? `${fname}.{${map(map(this.app.configHandlers, 'ext'), k => k.slice(1)).join(',')}}`
     const files = await fastGlob(item, globOptions)
     if (files.length === 0) {
       if (!ignoreError) throw this.error('noConfigFileFound', { code: 'BAJO_CONFIG_FILE_NOT_FOUND' })
@@ -1011,12 +1053,12 @@ class Bajo extends BasePlugin {
     let config = defValue
     for (const f of files) {
       const ext = path.extname(f).toLowerCase()
-      const item = find(this.app.bajo.configHandlers, { ext })
+      const item = find(this.app.configHandlers, { ext })
       if (!item) {
         if (!ignoreError) throw this.error('cantParse%s', f, { code: 'BAJO_CONFIG_NO_PARSER' })
         continue
       }
-      config = await item.readHandler.call(this.app[ns], f, opts)
+      config = await item.readHandler.call(this.app[ns], f, null, opts)
       if (!isEmpty(config)) break
     }
     return this.parseObject(config)
@@ -1032,7 +1074,7 @@ class Bajo extends BasePlugin {
    */
   readJson = (file, thrownNotFound = false) => {
     if (isPlainObject(thrownNotFound)) thrownNotFound = false
-    if (!fs.existsSync(file) && thrownNotFound) throw this.error('notFound%s%s', this.print.write('file'), file)
+    if (!fs.existsSync(file) && thrownNotFound) throw this.error('notFound%s%s', this.t('file'), file)
     let resp
     try {
       resp = fs.readFileSync(file, 'utf8')
@@ -1041,12 +1083,49 @@ class Bajo extends BasePlugin {
     return this.parseObject(JSON.parse(resp))
   }
 
+  fromJson (file, isContent) {
+    const content = isContent ? file : fs.readFileSync(file, 'utf8')
+    return JSON.parse(content)
+  }
+
+  toJson = (file, isContent, opts = 2) => {
+    const content = isContent ? file : JSON.parse(fs.readFileSync(file, 'utf8'))
+    return JSON.stringify(content, null, opts)
+  }
+
+  /**
+   * Read all config files by path
+   *
+   * @method
+   * @async
+   * @param {string} path - Base path to start looking config files
+   * @returns {Object}
+   */
+  readAllConfigs = async (path) => {
+    const { defaultsDeep } = this.app.lib.aneka
+    let cfg = {}
+    let ext = {}
+    // default config file
+    try {
+      cfg = await this.readConfig(`${path}.*`, { ignoreError: true })
+    } catch (err) {
+      if (['BAJO_CONFIG_NO_PARSER'].includes(err.code)) throw err
+    }
+    // env based config file
+    try {
+      ext = await this.readConfig(`${path}-${this.config.env}.*`, { ignoreError: true })
+    } catch (err) {
+      if (!['BAJO_CONFIG_FILE_NOT_FOUND'].includes(err.code)) throw err
+    }
+    return defaultsDeep({}, ext, cfg)
+  }
+
   /**
-   * Run named hook
+   * Run named hook/event
    *
    * @method
    * @async
-   * @param {string} hookName - ns based hook name
+   * @param {TNsPathPairs} hookName
    * @param  {...any} [args] - Argument passed to the hook function
    * @returns {Array} Array of hook execution results
    */
@@ -1085,7 +1164,7 @@ class Bajo extends BasePlugin {
    */
   saveAsDownload = async (file, item, printSaved = true) => {
     const { print, getPluginDataDir } = this.app.bajo
-    const fname = increment(`${getPluginDataDir(this.name)}/download/${trim(file, '/')}`, { fs: true })
+    const fname = increment(`${getPluginDataDir(this.ns)}/download/${trim(file, '/')}`, { fs: true })
     const dir = path.dirname(fname)
     if (!fs.existsSync(dir)) fs.ensureDirSync(dir)
     await fs.writeFile(fname, item, 'utf8')