bajo 0.3.10 → 1.0.2

package/README.md

@@ -1,57 +1,158 @@
-# Bajo Framework
+# bajo
 
-## Installation
+![GitHub package.json version](https://img.shields.io/github/package-json/v/ardhi/bajo) ![NPM Version](https://img.shields.io/npm/v/bajo)
+
+> <br />**Attention**: I do NOT accept any pull request at the moment, thanks!<br /><br />
+
+## Overview
 
-> Note: you must have a proper install of ```node```, ```npm``` and/or ```yarn``` before
+Before we go any further, below are some terminologies I use throughout these documentations:
+
+- ```<bajo-base-dir>```: project directory is where you write all your codes
+- ```<bajo-data-dir>```: data directory, defaults to ```<bajo-base-dir>/data``` if not specifically stated
+- ```<bajo-tmp-dir>```: temp directory, defaults to OS temporary directory
+- ```<package>```: plugin package name as normally showed on npm listing
+- ```<plugin>```: plugin name, which is camel cased version of package name
+
+## Installation
 
 Open your terminal and type:
 
-```
-npm install bajo
-# or
-yarn add bajo
+```bash
+$ npm install bajo
 ```
 
 ## Fire up!
 
-Goto your project directory, create the ```index.js``` file and put this in it:
+Create a new empty directory, this will be your project directory or your ```<bajo-base-dir>```. Now goto your newly created directory, and type:
+
+```bash
+$ npm init
+```
+
+You'll be asked to name your project etc. **IMPORTANT**: don't forget to mark your project as ES6 project by setting ```type``` key in your ```package.json``` to ```module```.
+
+After completing those steps, move on the the next one: crating bajo bootstrap.
+
+Inside your ```<bajo-base-dir>```, create the ```index.js``` file and put these lines below:
 
 ```js
-const bajo = require('bajo')
-bajo.boot()
-  .then(scope => {
-  })
-  .catch(err => {
-    console.trace(err)
-  })
+import bajo from 'bajo'
+await bajo.default()
 ```
 
-Bajo application **ALWAYS** need a data directory to put configuration files, etc. This
-cloud be located inside or outside your project directory.
+A bajo app **ALWAYS** needs a data directory to put configuration files, etc. This
+could be located inside or outside your ```<bajo-base-dir>```.
 
-Lets assume you're going to put your data directory inside your project directory. So please
+Lets assume you're going to put your data directory inside your ```<bajo-base-dir>```. So please
 create a new directory called ```data``` first. After that, just type in your terminal:
 
-```
-node index.js --dir-data=data
+```bash
+$ node index.js --dir-data=data
 ```
 
-Or you could use ```dotenv``` by creating ```.env``` file in the same directory as ```index.js```, and put this inside:
+Or you could utilize ```dotenv``` by creating ```.env``` file in the same directory as ```index.js```, and put this inside:
 
 ```
-DIR_DATA = .\data
+DIR_DATA = ./data
 ```
 
 Now you can omit calling node with arguments, you just need to type:
 
+```bash
+$ node index.js
+```
+
+## Configuration
+
+### General rules
+
+- All configuration files must be placed in ```<bajo-data-dir>/config/``` subfolder
+- Config files should be named after its plugin name
+- File format should be in ```.json``` or ```.js``` format
+- If  ```.js``` file is used, it should be in ES6 format and should export either plain javascript object or a function (sync or async both supported)
+- If it returns a function, this function will be called within its plugin scope and should return a plain js object
+- Other formats (```.yml```, ```.yaml``` and ```.toml```) can also be used by installing [bajoConfig](https://github.com/ardhi/bajo-config) plugin
+- Order of precedence: ```.js``` > ```.json``` > ```.yml``` > ```.yaml``` > ```.toml```
+
+### Main configuration File
+
+It should be named ```bajo.json``` with following keys:
+
+| Key | Type | Required | Default | Description |
+| --- | ---- | -------- | ------- | ----------- |
+| ```env``` | ```string``` | no | ```dev``` | App environment: ```dev``` or ```prod``` |
+| ```log``` | ```object``` | no || Logger setting |
+| &nbsp;&nbsp;```dateFormat``` | ```string``` | no | ```YYYY-MM-DDTHH:MM:ss.SSS[Z]```| Date format accoding to [dayjs](https://github.com/iamkun/dayjs) |
+| &nbsp;&nbsp;```tool``` | ```boolean``` | no | ```false``` | Set to ```true``` if you want to show log even in [tool mode](#tool-mode) |
+| &nbsp;&nbsp;```level``` | ```string``` | no || Set one of these: ```trace```, ```debug```, ```info```, ```warn```, ```error```, ```fatal``` and ```silent```. If it isn't set, it will auto selected based on environment |
+| ```lang``` | ```string``` | no || Language to use. If not set, it will be auto detected |
+| ```exitHandler``` | ```boolean``` | no | ```true``` | Set to ```false``` if you want your app **NOT** to exit gracefully |
+
+### Installed Plugins
+
+Plugins are what make Bajo Framework so great and flexible: they extends app features!
+
+To use plugins:
+
+1. Install with ```npm install <package>```
+2. Optionally create ```<bajo-data-dir>/config/<plugin>.json``` to customize plugin settings
+3. Open/create ```<bajo-data-dir>/config/.plugins``` and put ```<package>``` in it, line by line
+
+Example below will load ```bajoConfig```, ```bajoLogger``` and ```bajoMqtt```:
+
 ```
-node index.js
+bajo-config
+bajo-logger
+bajo-mqtt
 ```
 
-## Documentation
+If you later decide to NOT load one or more plugins from your app, you just need to remove those from ```.plugins``` file and restart your app.
+
+> **Warning**: please do not confuse between ```<package>``` and ```<plugin>```. Plugin package is the name of JS package listed on npm, while plugin name is the name of a plugin - a camel cased version of plugin package
+
+### Configuration Overrides
+
+You can override ANY settings on ANY configuration files with dotenv variables and program's argument switches easily.
+
+Order of importance: dotenv variable > args switches > config files
+
+#### dotenv
+
+- Create/open ```<bajo-base-dir>/.env```
+- Use ```__``` (double underscores) as the replacement of the dot in object
+- ```DIR__DATA```: Set ```<bajo-data-dir>``` data directory
+- ```DIR__TMP```: Set ```<bajo-tmp-dir>``` temp directory
+- For every key in ```bajo.json```, use its snake cased, upper cased version, e.g:
+  - ```env``` => ```ENV```
+  - ```log.dateFormat``` => ```LOG__DATE_FORMAT```
+  - ```exitHandler``` => ```EXIT_HANDLER```
+- To override plugins config, prepend every key in plugin config with snake cased, upper cased version of the plugin name followed by a dot, e.g:
+  - ```key``` in ```myPlugin``` => ```MY_PLUGIN.KEY```
+  - ```key.subKey.subSubKey``` in ```myPlugin``` => ```MY_PLUGIN.KEY__SUB_KEY__SUB_SUB_KEY```
+
+#### Program argument switches
+- Execute with switches, e.g: ```node index.js --xxx=one --yyy=two```
+- Every switches must be prefixed with ```--```
+- Use ```-``` as the replacement of the dot in object
+- ```--dir-data```: Set ```<bajo-data-dir>``` data directory
+- ```--dir-tmp```: Set ```<bajo-tmp-dir>``` temp directory
+- For every key in ```bajo.json```, add prefix ```--``` e.g:
+  - ```env``` => ```--env=prod```
+  - ```log.dateFormat``` => ```--log-dateFormat=xxx```
+  - ```exitHandler``` => ```--exitHandler```
+- To override plugins config, prepend every key in plugin config with the plugin name  followed by a ```:```, e.g:
+  - ```key``` in ```myPlugin``` => ```--myPlugin:key```
+  - ```key.subKey.subSubKey``` in ```myPlugin``` => ```--myPlugin:key-subKey-subSubKey```
+
+## More Documentations
 
-[API](https://ardhi.github.io/bajo)
+- [Tutorial](docs/tutorial.md)
+- [User Guide](docs/user-guide.md)
+- [Plugin Development](docs/plugin-dev.md)
+- [API](docs/api.md)
+- [Ecosystem](docs/ecosystem.md)
 
 ## License
 
-[MIT](LICENSE) License
+[MIT](LICENSE)

package/bajoI18N/resource/id.json

@@ -0,0 +1,31 @@
+{
+  "[%s] '%s' signal received": "[%s] Diterima signal '%s'",
+  "[%s] Exited: %s": "[%s] Keluar: %s",
+  "[%s] Program shutdown": "[%s] Program berakhir",
+  "[%s] Exit handlings": "[%s] Pengaturan keluar",
+  "[%s] Boot process completed in %s": "[%s] Proses boot komplit dalam waktu %s",
+  "[%s] Run tool": "[%s] Jalankan perkakas",
+  "[%s] Loaded plugins: %s": "[%s] Plugin termuat: %s",
+  "[%s] Unloaded 'single' plugins: %s": "[%s] 'Single' plugin tak termuat: %s",
+  "[%s] No %s found": "[%s] Tidak ditemukan %s",
+  "[%s] Init plugin...": "[%s] Init plugin...",
+  "[%s] Start plugin...": "[%s] Jalankan plugin...",
+  "[%s] Collecting %s": "[%s] Mengumpulkan %s",
+  "[%s] %s collected: %d": "[%s] Total %s terkumpul: %d",
+  "- All -": "- Semua -",
+  "Tool mode activated": "Mode perkakas diaktifkan",
+  "App is running in tool mode...": "Aplikasi berjalan dalam mode perkakas",
+  "No tool loaded. Aborted!": "Tidak ada perkakas yang termuat. Batalkan!",
+  "Please select:": "Silahkan pilih:",
+  "Tool '%s' not found. Aborted!": "perkakas '%s' tidak ditemukan. Batalkan!",
+  "Please select a method:": "Silahkan pilih metode:",
+  "Unknown method '%s'": "Metode '%s' tidak dikenal",
+  "and": "dan",
+  "or": "atau",
+  "Yes": "Ya",
+  "No": "Tidak",
+  "[%s] Exited": "[%s] Telah keluar",
+  "[%s] App shutdown": "[%s] Aplikasi dimatikan",
+  "[%s] Collect %s": "",
+  "[%s] %s support is disabled": ""
+}

package/boot/class/app.js

@@ -0,0 +1,69 @@
+import util from 'util'
+import { last } from 'lodash-es'
+import BajoCore from './bajo-core.js'
+import resolvePath from './bajo-core/method/resolve-path.js'
+import parseArgsArgv from '../lib/parse-args-argv.js'
+import parseEnv from '../lib/parse-env.js'
+import buildPlugins from './bajo-core/helper/build-plugins.js'
+import { buildBaseConfig, buildExtConfig } from './bajo-core/helper/build-config.js'
+import collectConfigHandlers from './bajo-core/helper/collect-config-handlers.js'
+import attachMethod from './bajo-core/helper/attach-method.js'
+import bootOrder from './bajo-core/helper/boot-order.js'
+import bootPlugins from './bajo-core/helper/boot-plugins.js'
+import exitHandler from './bajo-core/helper/exit-handler.js'
+import runAsApplet from './bajo-core/helper/run-as-applet.js'
+
+class App {
+  constructor (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
+    this.cwd = cwd
+  }
+
+  addPlugin (plugin) {
+    if (this[plugin.name]) throw new Error(`Plugin '${plugin.name}' added already`)
+    this[plugin.name] = plugin
+    plugin.initPrint()
+  }
+
+  dump (...args) {
+    const terminate = last(args) === true
+    if (terminate) args.pop()
+    for (const arg of args) {
+      const result = util.inspect(arg, false, null, true)
+      console.log(result)
+    }
+    if (terminate) process.kill(process.pid, 'SIGINT')
+  }
+
+  async boot () {
+    // argv/args
+    const { args, argv } = await parseArgsArgv.call(this.app) ?? {}
+    this.argv = argv
+    this.args = args
+    this.env = parseEnv() ?? {}
+
+    const bajo = new BajoCore(this)
+    await buildBaseConfig.call(bajo)
+    await buildPlugins.call(bajo)
+    await collectConfigHandlers.call(bajo)
+    await buildExtConfig.call(bajo)
+    await attachMethod.call(bajo)
+    await bootOrder.call(bajo)
+    await bootPlugins.call(bajo)
+    await exitHandler.call(bajo)
+    // boot complete
+    await bajo.runHook('bajo:bootComplete')
+    const elapsed = new Date() - bajo.runAt
+    bajo.log.info('Boot process completed in %s', bajo.secToHms(elapsed, true))
+    if (bajo.applet) await runAsApplet.call(bajo)
+  }
+}
+
+export default App

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

@@ -0,0 +1,30 @@
+import createMethod from '../../../lib/create-method.js'
+import deepFreeze from 'deep-freeze-strict'
+import currentLoc from '../../../lib/current-loc.js'
+import fs from 'fs-extra'
+import fastGlob from 'fast-glob'
+import { sprintf } from 'sprintf-js'
+import outmatch from 'outmatch'
+
+export default async function () {
+  await createMethod.call(this, `${currentLoc(import.meta).dir}/../method`)
+  this.freeze = (o, shallow) => {
+    if (shallow) Object.freeze(o)
+    else deepFreeze(o)
+  }
+  this.setImmediate = function () {
+    return new Promise((resolve) => {
+      setImmediate(() => resolve())
+    })
+  }
+  // commonly used libraries
+  this.lib._ = await import('lodash-es')
+  this.lib.fs = fs
+  this.lib.fastGlob = fastGlob
+  this.lib.sprintf = sprintf
+  this.lib.outmatch = outmatch
+  // last cleanup
+  if (!fs.existsSync(this.dir.data)) {
+    this.log.warn('Data directory \'%s\' doesn\'t exists!', this.dir.data)
+  }
+}

package/boot/{boot-order.js → class/bajo-core/helper/boot-order.js}

@@ -1,22 +1,20 @@
 import { reduce, map, isNaN, trim, forOwn, orderBy } from 'lodash-es'
 import fs from 'fs-extra'
-import getModuleDir from './helper/get-module-dir.js'
+import getModuleDir from '../method/get-module-dir.js'
 
 async function bootOrder () {
-  const { log, envs, error } = this.bajo.helper
-  log.debug('Setup boot order')
-  const config = this.bajo.config
-  const order = reduce(config.plugins, (o, k, i) => {
+  this.log.debug('Setup boot order')
+  const order = reduce(this.pluginPkgs, (o, k, i) => {
     const key = map(k.split(':'), m => trim(m))
     if (key[1] && !isNaN(Number(key[1]))) o[key[0]] = Number(key[1])
     else o[key[0]] = 10000 + i
     return o
   }, {})
   const norder = {}
-  for (let n of config.plugins) {
+  for (let n of this.pluginPkgs) {
     n = map(n.split(':'), m => trim(m))[0]
-    const dir = n === 'app' ? (config.dir.base + '/app') : getModuleDir(n)
-    if (n !== 'app' && !fs.existsSync(`${dir}/bajo`)) throw error('Package \'%s\' not found or isn\'t a valid Bajo package', n)
+    const dir = n === this.mainNs ? (`${this.dir.base}/${this.mainNs}`) : getModuleDir(n)
+    if (n !== this.mainNs && !fs.existsSync(`${dir}/bajo`)) throw this.error('Package \'%s\' not found or isn\'t a valid Bajo package', n)
     norder[n] = NaN
     try {
       norder[n] = Number(trim(await fs.readFile(`${dir}/bajo/.bootorder`, 'utf8')))
@@ -27,8 +25,10 @@ async function bootOrder () {
     const item = { k, v: isNaN(norder[k]) ? v : norder[k] }
     result.push(item)
   })
-  config.plugins = map(orderBy(result, ['v']), 'k')
-  log.info('Run in \'%s\' environment', envs[config.env])
+  this.pluginPkgs = map(orderBy(result, ['v']), 'k')
+  this.log.info('Run in \'%s\' environment', this.envs[this.config.env])
+  // misc
+  this.freeze(this.config)
 }
 
 export default bootOrder

package/boot/class/bajo-core/helper/boot-plugins.js

@@ -0,0 +1,19 @@
+import buildConfig from '../../bajo-plugin/helper/build-config.js'
+import checkDependency from '../../bajo-plugin/helper/check-dependency.js'
+import checkClash from '../../bajo-plugin/helper/check-clash.js'
+import attachMethod from '../../bajo-plugin/helper/attach-method.js'
+import collectHooks from '../../bajo-plugin/helper/collect-hooks.js'
+import run from '../../bajo-plugin/helper/run.js'
+import collectExitHandlers from '../../bajo-plugin/helper/collect-exit-handlers.js'
+
+async function bootPlugins () {
+  await buildConfig.call(this.app)
+  await checkClash.call(this.app)
+  await checkDependency.call(this.app)
+  await attachMethod.call(this.app)
+  await collectHooks.call(this.app)
+  await collectExitHandlers.call(this.app)
+  await run.call(this.app)
+}
+
+export default bootPlugins

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

@@ -0,0 +1,61 @@
+import readAllConfigs from '../../../lib/read-all-configs.js'
+import defaultsDeep from '../method/defaults-deep.js'
+import getKeyByValue from '../method/get-key-by-value.js'
+import resolvePath from '../method/resolve-path.js'
+import currentLoc from '../../../lib/current-loc.js'
+import envs from '../method/envs.js'
+import join from '../method/join.js'
+import omitDeep from 'omit-deep'
+import os from 'os'
+import fs from 'fs-extra'
+
+import { map, pick, values, keys, set, get } from 'lodash-es'
+
+const omitted = ['spawn', 'cwd', 'name', 'alias', 'applet', 'a', 'plugins']
+
+const defConfig = {
+  log: {
+    dateFormat: 'YYYY-MM-DDTHH:MM:ss.SSS[Z]',
+    applet: false,
+    traceHook: false
+  },
+  lang: Intl.DateTimeFormat().resolvedOptions().lang ?? 'en-US',
+  exitHandler: true
+}
+
+export async function buildBaseConfig () {
+  this.applet = this.app.argv._.applet
+  this.config = defaultsDeep({}, this.app.env._, this.app.argv._)
+  this.alias = this.name
+  set(this, 'dir.base', this.app.cwd)
+  const path = currentLoc(import.meta).dir + '/../../../..'
+  set(this, 'dir.pkg', resolvePath(path))
+  if (!get(this, 'dir.data')) set(this, 'dir.data', `${this.dir.base}/data`)
+  this.dir.data = resolvePath(this.dir.data)
+  if (!this.dir.tmp) {
+    this.dir.tmp = `${resolvePath(os.tmpdir())}/${this.name}`
+    fs.ensureDirSync(this.dir.tmp)
+  }
+  this.app.addPlugin(this)
+}
+
+export async function buildExtConfig () {
+  // config merging
+  let resp = await readAllConfigs.call(this.app, `${this.dir.data}/config/${this.name}`)
+  resp = omitDeep(pick(resp, ['log', 'exitHandler', 'env']), omitted)
+  this.config = defaultsDeep({}, resp, this.config, defConfig)
+  this.config.env = (this.config.env ?? 'dev').toLowerCase()
+  if (values(envs).includes(this.config.env)) this.config.env = getKeyByValue(envs, this.config.env)
+  if (!keys(envs).includes(this.config.env)) throw new Error(`Unknown environment '${this.config.env}'. Supported: ${join(keys(envs))}`)
+  process.env.NODE_ENV = envs[this.config.env]
+  if (!this.config.log.level) this.config.log.level = this.config.env === 'dev' ? 'debug' : 'info'
+  if (this.config.silent) this.config.log.level = 'silent'
+  if (this.applet) {
+    if (!this.pluginPkgs.includes('bajo-cli')) throw new Error('Applet needs to have \'bajo-cli\' loaded first')
+    if (!this.config.log.applet) this.config.log.level = 'silent'
+    this.config.exitHandler = false
+  }
+  const exts = map(this.configHandlers, 'ext')
+  this.log.init()
+  this.log.debug('Config handlers: %s', join(exts))
+}

package/boot/class/bajo-core/helper/build-plugins.js

@@ -0,0 +1,26 @@
+import { isString, filter, map, trim, without, uniq, camelCase, isEmpty } from 'lodash-es'
+import fs from 'fs-extra'
+import getModuleDir from '../method/get-module-dir.js'
+import BajoPlugin from '../../bajo-plugin.js'
+
+async function buildPlugins () {
+  let pluginPkgs = this.config.plugins ?? []
+  if (isString(pluginPkgs)) pluginPkgs = [pluginPkgs]
+  const pluginsFile = `${this.dir.data}/config/.plugins`
+  if (fs.existsSync(pluginsFile)) {
+    pluginPkgs = pluginPkgs.concat(filter(map(trim(fs.readFileSync(pluginsFile, 'utf8')).split('\n'), p => trim(p)), b => !isEmpty(b)))
+  }
+  this.pluginPkgs = without(uniq(pluginPkgs), this.mainNs)
+  this.pluginPkgs.push(this.mainNs)
+  for (const pkg of this.pluginPkgs) {
+    const ns = camelCase(pkg)
+    const dir = ns === this.mainNs ? (`${this.dir.base}/${this.mainNs}`) : getModuleDir.call(this, pkg)
+    if (ns !== this.mainNs && !fs.existsSync(`${dir}/${this.name}`)) throw new Error(`Package '${pkg}' isn't a valid Bajo package`)
+    const plugin = new BajoPlugin(pkg, this.app)
+    this.pluginNames.push(plugin.name)
+    this.app.addPlugin(plugin)
+  }
+  delete this.config.plugins
+}
+
+export default buildPlugins

package/boot/class/bajo-core/helper/collect-config-handlers.js

@@ -0,0 +1,21 @@
+import getModuleDir from '../method/get-module-dir.js'
+import importModule from '../method/import-module.js'
+import { isFunction, isPlainObject, camelCase } from 'lodash-es'
+
+async function collectConfigHandlers () {
+  for (const pkg of this.pluginPkgs) {
+    let dir
+    try {
+      dir = getModuleDir.call(this, pkg)
+    } catch (err) {}
+    if (!dir) continue
+    const file = `${dir}/bajo/config-handlers.js`
+    let mod = await importModule.call(this, file)
+    if (!mod) continue
+    if (isFunction(mod)) mod = await mod.call(this.app[camelCase(pkg)])
+    if (isPlainObject(mod)) mod = [mod]
+    this.configHandlers = this.configHandlers.concat(mod)
+  }
+}
+
+export default collectConfigHandlers

package/boot/{exit-handler.js → class/bajo-core/helper/exit-handler.js}

@@ -1,24 +1,20 @@
 async function exit (signal) {
-  const { eachPlugins, log } = this.bajo.helper
-  log.warn('\'%s\' signal received', signal)
-  await eachPlugins(async function ({ plugin }) {
-    const handler = this.bajo.exitHandler[plugin]
+  const { eachPlugins } = this
+  this.log.warn('\'%s\' signal received', signal)
+  await eachPlugins(async function ({ ns }) {
+    const handler = this.exitHandler
     if (!handler) return undefined
     try {
       await handler.call(this)
     } catch (err) {}
-    log.debug('Exited: %s', plugin)
+    this.log.debug('Exited')
   })
-  log.debug('Program shutdown')
+  this.log.debug('App shutdown')
   process.exit(0)
 }
 
 async function exitHandler () {
-  const { log, getConfig } = this.bajo.helper
-  const config = getConfig()
-  if (!config.exitHandler) return
-
-  log.debug('Exit handlings')
+  if (!this.config.exitHandler) return
 
   process.on('SIGINT', async () => {
     await exit.call(this, 'SIGINT')
@@ -29,9 +25,7 @@ async function exitHandler () {
   })
 
   process.on('uncaughtException', (error, origin) => {
-    const { getConfig } = this.bajo.helper
-    const config = getConfig()
-    if (config.log.report.includes('sys:uncaughtException')) log.fatal({ origin }, '%s', error.message)
+    if (this.config.log.report.includes('sys:uncaughtException')) this.log.fatal({ origin }, '%s', error.message)
     setTimeout(() => {
       console.error(error)
       process.exit(1)
@@ -51,11 +45,11 @@ async function exitHandler () {
     parts.pop()
     parts.pop()
     file = parts.join(':')
-    log.error({ file, line, column }, '%s', reason.message)
+    this.log.error({ file, line, column }, '%s', reason.message)
   })
 
   process.on('warning', warning => {
-    log.error('%s', warning.message)
+    this.log.error('%s', warning.message)
   })
 }
 

package/boot/class/bajo-core/helper/run-as-applet.js

@@ -0,0 +1,26 @@
+async function runAsApplet () {
+  const { isString, map, find } = this.lib._
+  await this.eachPlugins(async function ({ file, ns, alias }) {
+    this.app.bajo.applets.push({ ns, file, alias })
+  }, { glob: 'applet.js', prefix: 'bajoCli' })
+
+  this.log.debug('Applet mode activated')
+  this.print.info('App is running as applet...')
+  if (this.applets.length === 0) this.print.fatal('No applets loaded. Aborted!')
+  let name = this.applet
+  if (!isString(this.applet)) {
+    const select = await this.importPkg('bajoCli:@inquirer/select')
+    name = await select({
+      message: this.print.write('Please select:'),
+      choices: map(this.applets, t => ({ value: t.ns }))
+    })
+  }
+  const [ns, path] = name.split(':')
+  const applet = find(this.applets, a => (a.ns === ns || a.alias === ns))
+  if (!applet) this.print.fatal('Applet \'%s\' not found. Aborted!', name)
+  await this.runHook(`${this.app[applet.ns]}:beforeAppletRun`)
+  await this.app.bajoCli.runApplet(applet, path, ...this.app.args)
+  await this.runHook(`${this.app[applet.ns]}:afterAppletRun`)
+}
+
+export default runAsApplet

package/boot/class/bajo-core/method/arrange-array.js

@@ -0,0 +1,18 @@
+import { filter, trim } from 'lodash-es'
+
+function arrangeArray (inputs, trimItem = true) {
+  const first = []
+  const last = []
+
+  const items = filter(inputs, item => {
+    if (trimItem) item = trim(item)
+    if (item[0] === '^') first.push(item.slice(1))
+    else if (item[0] === '$') last.push(item.slice(1))
+    return !['^', '$'].includes(item[0])
+  })
+  items.unshift(...first)
+  items.push(...last)
+  return items
+}
+
+export default arrangeArray

package/boot/class/bajo-core/method/break-ns-path-from-file.js

@@ -0,0 +1,24 @@
+import _path from 'path'
+import { map, camelCase } from 'lodash-es'
+
+function breakNsPathFromFile ({ file, dir, baseNs, suffix = '', getType } = {}) {
+  let item = file.replace(dir + suffix, '')
+  let type
+  if (getType) {
+    const items = item.split('/')
+    type = items.shift()
+    item = items.join('/')
+  }
+  item = item.slice(0, item.length - _path.extname(item).length)
+  let [name, path] = item.split('@')
+  if (!path) {
+    path = name
+    name = baseNs
+  }
+  path = camelCase(path)
+  const names = map(name.split('.'), n => camelCase(n))
+  const [ns, subNs] = names
+  return { ns, subNs, path, fullNs: names.join('.'), type }
+}
+
+export default breakNsPathFromFile

package/boot/class/bajo-core/method/break-ns-path.js

@@ -0,0 +1,29 @@
+import { isEmpty } from 'lodash-es'
+import querystring from 'querystring'
+
+function breakNsPath (item = '', defaultNs = 'bajo', checkNs = true) {
+  let [ns, ...path] = item.split(':')
+  let subNs
+  let subSubNs
+  path = path.join(':')
+  if (path.startsWith('//')) return { ns: undefined, path: item } // for: http:// etc
+  if (isEmpty(path)) {
+    path = ns
+    ns = defaultNs
+  }
+  [ns, subNs, subSubNs] = ns.split('.')
+  if (checkNs) {
+    if (!this.app[ns]) {
+      const plugin = this.getPlugin(ns)
+      if (plugin) ns = plugin.name
+    }
+    if (!this.app[ns]) throw this.error('Unknown plugin \'%s\' or plugin isn\'t loaded yet')
+  }
+  const fullPath = path
+  let qs
+  [path, qs] = path.split('?')
+  qs = querystring.parse(qs) ?? {}
+  return { ns, path, subNs, subSubNs, qs, fullPath }
+}
+
+export default breakNsPath