bajo 0.0.1 → 0.1.0

package/boot/helper/get-global-module-dir.js

@@ -0,0 +1,27 @@
+import globalModulesPath from 'global-modules-path'
+import resolvePath from './resolve-path.js'
+import error from './error.js'
+import { dropRight } from 'lodash-es'
+import fs from 'fs-extra'
+
+const getGlobalModuleDir = (pkgName, silent = true) => {
+  let nodeModulesDir = process.env.BAJO_GLOBAL_MODULE_DIR
+  if (!nodeModulesDir) {
+    const npmPath = globalModulesPath.getPath('npm')
+    if (!npmPath) {
+      if (silent) return
+      throw error(`Can't locate npm global module directory`, { code: 'BAJO_CANT_LOCATE_NPM_GLOBAL_DIR' })
+    }
+    nodeModulesDir = dropRight(resolvePath(npmPath).split('/'), 1).join('/')
+    process.env.BAJO_GLOBAL_MODULE_DIR = nodeModulesDir
+  }
+  if (!pkgName) return nodeModulesDir
+  const dir = `${nodeModulesDir}/${pkgName}`
+  if (!fs.existsSync(dir)) {
+    if (silent) return
+    throw error(`Can't locate '%s' global module directory`, pkgName, { code: 'BAJO_CANT_LOCATE_MODULE_GLOBAL_DIR' })
+  }
+  return dir
+}
+
+export default getGlobalModuleDir

package/boot/helper/get-helper.js

@@ -0,0 +1,11 @@
+import { get } from 'lodash-es'
+import error from './error.js'
+
+function getHelper (name = '', thrown = true) {
+  const [plugin, method] = name.split(':')
+  const helper = get(this, `${plugin}.helper.${method}`)
+  if (helper) return helper
+  if (thrown) throw error.call(this, 'Can\'t find helper named \'%s\'', name)
+}
+
+export default getHelper

package/boot/helper/get-item-by-name.js

@@ -0,0 +1,26 @@
+import path from 'path'
+
+async function getItemByName (name) {
+  const { resolvePath, getConfig, readConfig, error } = this.bajo.helper
+  const config = getConfig()
+  const [type, ...paths] = name.split(':')
+  let result
+  switch (type) {
+    case 'config': {
+      let file = paths.join(':')
+      if (!path.isAbsolute(file)) file = resolvePath(`${config.dir.data}/config/${file}`)
+      result = await readConfig(file)
+      break
+    }
+    case 'helper': {
+      const [ns, fn] = paths.join(':').split('.')
+      if (!(ns && fn)) throw error('Unknown helper \'%s.%s\'', ns, fn, { code: 'BAJO_UNKNOWN_HELPER' })
+      result = this[ns].helper[fn]
+      break
+    }
+    default: throw error('Unsupported type \'%s\'', type, { code: 'BAJO_UNSUPPORTED_TYPE' })
+  }
+  return result
+}
+
+export default getItemByName

package/boot/helper/get-key-by-value.js

@@ -0,0 +1,5 @@
+const getKeyByValue = (object, value) => {
+  return Object.keys(object).find(key => object[key] === value)
+}
+
+export default getKeyByValue

package/boot/helper/get-module-dir.js

@@ -0,0 +1,22 @@
+import path from 'path'
+import resolvePath from './resolve-path.js'
+import { createRequire } from 'module'
+const require = createRequire(import.meta.url)
+
+const getModuleDir = (pkgName, base) => {
+  if (base === 'app') base = process.env.BAJOCWD
+  let pkgPath = pkgName + '/package.json'
+  if (base) pkgPath = `${base}/node_modules/${pkgPath}`
+  const paths = require.resolve.paths(pkgPath)
+  paths.unshift(path.join(process.env.BAJOCWD, 'node_modules', pkgName))
+  let resolved
+  try {
+    resolved = require.resolve(pkgPath, { paths })
+  } catch (err) {
+    return null
+  }
+  const dir = resolvePath(path.dirname(resolved))
+  return dir
+}
+
+export default getModuleDir

package/boot/helper/get-plugin-name.js

@@ -0,0 +1,39 @@
+import { isString, isNumber, each, camelCase } from 'lodash-es'
+import callsites from 'callsites'
+import error from './error.js'
+import resolvePath from './resolve-path.js'
+
+/**
+ * Get the right Bajo name inside your app or plugins/Bajos. If parameter ```fname```
+ * is not provided, it will be set to the actual file this function is called.
+ *
+ * @memberof helper
+ * @instance
+ * @param {string} [fname] - File name (relative/absolute)
+ * @throws Will throw if Bajo name coldn't be resolved
+ * @returns {string} Bajo name
+ */
+
+function getPluginName (fname) {
+  const config = this.bajo.config
+  let file
+  if (isString(fname)) file = fname
+  else file = callsites()[isNumber(fname) ? fname : 2].getFileName()
+  if (!file) throw error('Can\'t resolve bajo named \'%s\', sorry!', fname, { code: 'BAJO_UNABLE_TO_RESOLVE_BAJO_NAME' })
+  file = resolvePath(file)
+  let match
+  each(config.plugins, b => {
+    if (file.includes('/bajo/boot/')) {
+      match = 'bajo'
+      return false
+    }
+    if (file.includes('/' + b + '/')) {
+      match = b
+      return false
+    }
+  })
+  if (match) return camelCase(match)
+  return 'bajo'
+}
+
+export default getPluginName

package/boot/helper/get-plugin.js

@@ -0,0 +1,7 @@
+async function getPlugin (name) {
+  const { error } = this.bajo.helper
+  if (!this[name]) throw error('\'%s\' is not loaded', name)
+  return this[name]
+}
+
+export default getPlugin

package/boot/helper/import-module.js

@@ -0,0 +1,25 @@
+import resolvePath from './resolve-path.js'
+import { isFunction, isPlainObject } from 'lodash-es'
+import error from './error.js'
+
+async function load (file, asDefaultImport = true) {
+  const imported = await import(resolvePath(file, true))
+  if (asDefaultImport) return imported.default
+  return imported
+}
+
+async function importModule (file, { asDefaultImport, asHandler } = {}) {
+  let mod = await load(file, asDefaultImport)
+  if (!asHandler) return mod
+  if (isFunction(mod)) mod = { level: 999, handler: mod }
+  if (!isPlainObject(mod)) throw error.call(this, 'File \'%s\' is NOT a handler module', file)
+  if (mod.forceAsync && mod.handler.constructor.name !== 'AsyncFunction') {
+    const oldHandler = mod.handler
+    mod.handler = async function (...args) {
+      oldHandler.call(this, ...args)
+    }
+  }
+  return mod
+}
+
+export default importModule

package/boot/helper/import-pkg.js

@@ -0,0 +1,67 @@
+import { isPlainObject, map, last, isEmpty, has, keys, values, trim, get } from 'lodash-es'
+import os from 'os'
+import getModuleDir from './get-module-dir.js'
+import resolvePath from './resolve-path.js'
+import readJson from './read-json.js'
+import defaultsDeep from './defaults-deep.js'
+import path from 'path'
+import fs from 'fs-extra'
+
+/**
+ * Load/import a package dynamically. You can import package one-by-one or multiple
+ * packages at once.
+ *
+ * Package 'pkg' must be in the following format: ```<original name>:<new name>:<bajo package name>```
+ * ```<new name>``` can be omitted, so the format will be: ```<name>::<bajo package name>```
+ *
+ * If you only import one package, returned value is the imported package itself
+ * If multiple packages are imported, returned value is an object with ```<new name>``` as its
+ * keys and imported packages as its values
+ *
+ * Example:
+ * ```
+ * const imported = await importPkg('ora::bajo-cli')
+ * const multiple = await importPkg('ora::bajo-cli', 'lodash:_:bajo')
+ *
+ * @param  {...string} pkg
+ * @returns
+ */
+
+const importPkg = async (...pkg) => {
+  const result = {}
+  let opts = { returnDefault: true }
+  if (isPlainObject(last(pkg))) {
+    opts = defaultsDeep(pkg.pop(), opts)
+  }
+  for (const p of pkg) {
+    const parts = map(p.split(':'), i => trim(i))
+    let [ns, orgName, name] = parts
+    if (parts.length === 1) {
+      orgName = ns
+      ns = 'bajo'
+      name = orgName
+    } else if (parts.length === 2) {
+      name = orgName
+    }
+    if (isEmpty(name)) name = orgName
+    const dir = getModuleDir(orgName, ns)
+    const pkg = readJson(`${dir}/package.json`)
+    const mainFileOrg = dir + '/' + (pkg.main ?? get(pkg, 'exports.default', 'index.js'))
+    let mainFile = resolvePath(mainFileOrg, os.platform() === 'win32')
+    if (isEmpty(path.extname(mainFile))) {
+      if (fs.existsSync(`${mainFileOrg}/index.js`)) mainFile += '/index.js'
+      else mainFile += '.js'
+    }
+    let mod = await import(mainFile)
+    if (opts.returnDefault && has(mod, 'default')) {
+      mod = mod.default
+      if (opts.returnDefault && has(mod, 'default')) mod = mod.default
+    }
+    result[name] = mod
+  }
+  if (pkg.length === 1) return result[keys(result)[0]]
+  if (opts.asObject) return result
+  return values(result)
+}
+
+export default importPkg

package/boot/helper/index.js

@@ -0,0 +1,36 @@
+/**
+ * Bajo Helper is a general-purpose container that consists of functions, objects, or arrays
+ * that are accessible across all plugins/Bajos and applications. It also serves as a proxy
+ * to some exported third-party libraries.
+ *
+ * To use it, simply deconstruct the variables you want from Bajo Helper as shown in the
+ * example below.
+ *
+ * @module helper
+ * @example
+ * module.exports = async function () {
+ *  const { fs, getConfig } = this.bajo.helper
+ *  const config = getConfig('bajoExtra')
+ *  await fs.writeFile('./bajo-extra-config.json', JSON.stringify(config), 'utf8')
+ * }
+ */
+
+/**
+ * | Attached As | Package Name | Usage |
+ * |-------------|--------------|-------|
+ * | _ | [lodash](https://lodash.com/) | ```const { _ } = this.bajo.helper``` |
+ * | callsites | [callsites](https://github.com/sindresorhus/callsites) | ```const { _ } = this.bajo.helper``` |
+ * | dateFormat | [dateformat](https://github.com/felixge/node-dateformat) | ```const { dateFormat } = this.bajo.helper``` |
+ * | fastGlob | [fast-glob](https://github.com/mrmlnc/fast-glob) | ```const { fastGlob } = this.bajo.helper``` |
+ * | flatten | [flat](https://github.com/hughsk/flat) | ```const { flatten } = this.bajo.helper``` |
+ * | freeze | [deep-freeze-strict](https://github.com/jsdf/deep-freeze) | ```const { freeze } = this.bajo.helper``` |
+ * | fs | [fs-extra](https://github.com/jprichardson/node-fs-extra) | ```const { fs } = this.bajo.helper``` |
+ * | lockfile | [proper-lockfile](https://github.com/moxystudio/node-proper-lockfile) | ```const { lockfile } = this.bajo.helper``` |
+ * | outmatch | [outmatch](https://github.com/axtgr/outmatch) | ```const { outmatch } = this.bajo.helper``` |
+ * | semver | [semver](https://github.com/npm/node-semver) | ```const { semver } = this.bajo.helper``` |
+ * | unflatten | [flat](https://github.com/hughsk/flat) | ```const { unflatten } = this.bajo.helper``` |
+ *
+ * @memberof module:helper/3rdPartyLibs
+ * @name 3rd Party Libraries
+ * @instance
+ */

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/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,89 @@
+import bora from '../lib/bora.js'
+import Sprintf from 'sprintf-js'
+import { last, isPlainObject, get } 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])) return i18n.t(msg, params[0])
+    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,21 @@
+import { isEmpty, trim } from 'lodash-es'
+import fs from 'fs-extra'
+
+function resolveTplPath (name, baseTpl, extTpl = '') {
+  const { error, getConfig } = this.bajo.helper
+  let [ns, path] = name.split(':')
+  if (isEmpty(path)) {
+    path = ns
+    ns = 'app'
+  }
+  if (path.startsWith('.')) throw error('Path \'%s\' must be an absolute path', path)
+  if (!this[ns]) throw error('Unknown plugin \'%s\' or plugin isn\'t loaded yet', ns)
+  const cfgNs = getConfig(ns, { full: true })
+  const cfgApp = getConfig('app', { full: true })
+  let file = `${cfgNs.dir}/${baseTpl}/${trim(path, '/')}${extTpl}`
+  const override = `${cfgApp.dir}/${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,18 @@
+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, resolvePath } = this.bajo.helper
+  const config = this.bajo.config
+  const plugin = getPluginName(4)
+  const fname = resolvePath(increment(`${config.dir.data}/plugins/${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/white-space.js

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