bajo 0.0.1 → 0.2.0

package/boot/exit-handler.js

@@ -0,0 +1,60 @@
+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]
+    if (!handler) return undefined
+    await handler.call(this)
+    log.debug('Exited: %s', plugin)
+  })
+  log.debug('Program shutdown')
+  process.exit(0)
+}
+
+async function exitHandler () {
+  const { log, getConfig } = this.bajo.helper
+  const config = getConfig()
+  if (!config.exitHandler) return
+
+  log.debug('Exit handlings')
+
+  process.on('SIGINT', async () => {
+    await exit.call(this, 'SIGINT')
+  })
+
+  process.on('SIGTERM', async () => {
+    await exit.call(this, 'SIGTERM')
+  })
+
+  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)
+    setTimeout(() => {
+      console.error(error)
+      process.exit(1)
+    }, 50)
+  })
+
+  process.on('unhandledRejection', (reason, promise) => {
+    const stackFile = reason.stack.split('\n')[1]
+    let file
+    const info = stackFile.match(/\((.*)\)/) // file is in (<file>)
+    if (info) file = info[1]
+    else if (stackFile.startsWith('    at ')) file = stackFile.slice(7) // file is stackFile itself
+    if (!file) return
+    const parts = file.split(':')
+    const column = parseInt(parts[parts.length - 1])
+    const line = parseInt(parts[parts.length - 2])
+    parts.pop()
+    parts.pop()
+    file = parts.join(':')
+    log.error({ file, line, column }, '%s', reason.message)
+  })
+
+  process.on('warning', warning => {
+    log.error('%s', warning.message)
+  })
+}
+
+export default exitHandler

package/boot/helper/break-ns-path.js

@@ -0,0 +1,17 @@
+import { isEmpty } from 'lodash-es'
+
+function breakNsPath (item = '') {
+  const { error, getPlugin } = this.bajo.helper
+  let [ns, ...path] = item.split(':')
+  path = path.join(':')
+  if (isEmpty(path)) {
+    path = ns
+    ns = null
+  }
+  // if (path.startsWith('.')) throw error('Path \'%s\' must be an absolute path', path)
+  if (!this[ns]) ns = (getPlugin(ns) || {}).name
+  if (!this[ns]) throw error('Unknown plugin \'%s\' or plugin isn\'t loaded yet', ns)
+  return [ns, path]
+}
+
+export default breakNsPath

package/boot/helper/build-collections.js

@@ -0,0 +1,34 @@
+import { filter, isArray, each, pullAt, camelCase } from 'lodash-es'
+
+async function buildCollections (options = {}) {
+  const { getConfig, getPluginName, fatal, runHook } = this.bajo.helper
+  let { plugin, handler, dupChecks = [], container = 'connections' } = options
+  if (!plugin) plugin = getPluginName(4)
+  const cfg = getConfig(plugin, { full: true })
+  if (!cfg[container]) return []
+  if (!isArray(cfg[container])) cfg[container] = [cfg[container]]
+  cfg[container] = cfg[container] ?? []
+  await runHook(`${plugin}:${camelCase(`before build ${container}`)}`)
+  const deleted = []
+  for (const index in cfg[container]) {
+    const item = cfg[container][index]
+    const result = await handler.call(this, { item, index, cfg })
+    if (result) cfg[container][index] = result
+    else if (result === false) deleted.push(index)
+  }
+  if (deleted.length > 0) pullAt(cfg[container], deleted)
+
+  // check for duplicity
+  each(cfg[container], c => {
+    const checker = {}
+    each(dupChecks, d => {
+      checker[d] = c[d]
+    })
+    const match = filter(cfg[container], checker)
+    if (match.length > 1) fatal('One or more %s shared the same \'%s\'', container, dupChecks.join(', '), { code: 'BAJOMQTT_CONNECTION_NOT_UNIQUE' })
+  })
+  await runHook(`${plugin}:${camelCase(`after build ${container}`)}`)
+  return cfg[container]
+}
+
+export default buildCollections

package/boot/helper/call-helper-or-handler.js

@@ -0,0 +1,15 @@
+import { isString, isFunction } from 'lodash-es'
+import getHelper from './get-helper.js'
+
+async function callHelperOrHandler (nameOrFn, ...args) {
+  let result
+  if (isString(nameOrFn)) {
+    const helper = getHelper.call(this, nameOrFn)
+    if (isFunction(helper)) result = await helper(...args)
+  } else if (isFunction(nameOrFn)) {
+    result = await nameOrFn.call(this, ...args)
+  }
+  return result
+}
+
+export default callHelperOrHandler

package/boot/helper/current-loc.js

@@ -0,0 +1,11 @@
+import path from 'path'
+import resolvePath from './resolve-path.js'
+import { fileURLToPath } from 'url'
+
+const currentLoc = (meta) => {
+  const file = resolvePath(fileURLToPath(meta.url))
+  const dir = path.dirname(file)
+  return { dir, file, __dirname: dir, __filename: file }
+}
+
+export default currentLoc

package/boot/helper/defaults-deep.js

@@ -0,0 +1,14 @@
+import { mergeWith, isArray } from 'lodash-es'
+// taken from https://github.com/nodeutils/defaults-deep/blob/master/lib/index.js
+
+const defaultsDeep = (...args) => {
+  const output = {}
+  args.reverse().forEach(function (item) {
+    mergeWith(output, item, function (objectValue, sourceValue) {
+      return isArray(sourceValue) ? sourceValue : undefined
+    })
+  })
+  return output
+}
+
+export default defaultsDeep

package/boot/helper/dump.js

@@ -0,0 +1,10 @@
+import util from 'util'
+
+const dump = (...args) => {
+  for (const arg of args) {
+    const result = util.inspect(arg, false, null, true)
+    console.log(result)
+  }
+}
+
+export default dump

package/boot/helper/each-plugins.js

@@ -0,0 +1,104 @@
+import { camelCase, isString, omit, trim } from 'lodash-es'
+import fastGlob from 'fast-glob'
+import path from 'path'
+import omittedPluginKeys from '../lib/omitted-plugin-keys.js'
+
+async function _eachPlugins (handler, { key = 'name', glob, ns, useBajo } = {}) {
+  const { getConfig } = this.bajo.helper
+  const config = getConfig()
+  const result = {}
+  const plugins = [...config.plugins]
+  if (useBajo) plugins.unshift('bajo')
+  for (const pkg of plugins) {
+    const plugin = camelCase(pkg)
+    let cfg = getConfig(plugin, { full: true })
+    const { alias, dependencies } = cfg
+    const dir = cfg.dir.pkg
+    cfg = omit(cfg, omittedPluginKeys)
+    let r
+    if (glob) {
+      const base = `${dir}/${ns}`
+      let opts = isString(glob) ? { pattern: [glob] } : glob
+      let pattern = opts.pattern ?? []
+      if (isString(pattern)) pattern = [pattern]
+      opts = omit(opts, ['pattern'])
+      for (const i in pattern) {
+        pattern[i] = `${base}/${pattern[i]}`
+      }
+      const files = await fastGlob(pattern, opts)
+      for (const f of files) {
+        const resp = await handler.call(this, { plugin, pkg, cfg, alias, file: f, dir: base, dependencies })
+        if (resp === false) break
+        else if (resp === undefined) continue
+        else {
+          result[plugin] = result[plugin] ?? {}
+          result[plugin][f] = resp
+        }
+      }
+    } else {
+      r = await handler.call(this, { plugin, pkg, cfg, dir, alias, dependencies })
+      if (r === false) break
+      else if (r === undefined) continue
+      else result[plugin] = r
+    }
+  }
+  return result
+}
+
+/**
+ * @module helper/eachPlugins
+ */
+
+/**
+ * Callback function that will be executed while walking through all Bajos
+ *
+ * @callback handlerFn
+ * @async
+ * @param {Object} argument - Provides information about current Bajo
+ * @param {string} argument.name - Bajo's name
+ * @param {string} argument.pkgName - Bajo's package name
+ * @param {Object} argument.cfg - Bajo's config object
+ * @returns {Object|boolean|undefined}
+ */
+
+/**
+ * Walk through all plugins and execute the callback handler
+ *
+ * @instance
+ * @async
+ * @param {function} handlerFn - [The callback]{@link module:helper/eachPlugins~handlerFn}
+ * @param {Object} [options] - Optional parameter
+ * @param {string} [options.key=name] - Key of Bajo's config object that will be used as the key of returned object
+ * @returns {Object} Results from callback execution through all Bajos
+ *
+ * @example
+ * const { eachPlugins } = this.bajo.helper
+ * await eachPlugins(async function ({ name }) => {
+ *   console.log(name)
+ * })
+ */
+
+async function eachPlugins (handler, options = {}) {
+  const { getConfig, getPluginName } = this.bajo.helper
+  let { key = 'name', glob, ns, extend, extendHandler, useBajo } = options
+  if (!extendHandler) extendHandler = handler
+  ns = ns ?? getPluginName(4)
+  const result = await _eachPlugins.call(this, handler, { key, glob, ns, useBajo })
+  if (extend && isString(glob)) {
+    let nsExtend = ns
+    if (isString(extend)) nsExtend += '/' + trim(extend, '/')
+    const cfg = getConfig('app', { full: true })
+    const ext = `${cfg.dir.pkg}/${nsExtend}/extend/*`
+    const exts = await fastGlob(ext, { onlyDirectories: true })
+    for (const e of exts) {
+      const plugin = path.basename(e)
+      const files = await fastGlob(`${e}/${glob}`)
+      for (const file of files) {
+        await extendHandler.call(this, { file, plugin, dir: e })
+      }
+    }
+  }
+  return result // TODO: merge with extender
+}
+
+export default eachPlugins

package/boot/helper/envs.js

@@ -0,0 +1,14 @@
+/**
+ * Supported environment
+ *
+ * @memberof module:helper
+ * @type Object
+ * @instance
+ */
+
+const envs = {
+  dev: 'development',
+  prod: 'production'
+}
+
+export default envs

package/boot/helper/error.js

@@ -0,0 +1,67 @@
+import { last, isPlainObject, each, isArray, get } from 'lodash-es'
+import print from './print.js'
+import getPluginName from './get-plugin-name.js'
+
+/**
+ * It's a shortcut to create an instance of Error with message and optional parameter
+ * in a single line
+ *
+ * @memberof helper
+ * @type Object
+ * @instance
+ * @param {string} msg - String that will be used as error message
+ * @param {options} [options] - Optional parameter
+ * @param {string} [options.code] - Error code
+ * @returns {error} Instance of Error
+ */
+
+Error.stackTraceLimit = 15
+
+function formatErrorDetails (value, ns) {
+  each(value, (v, i) => {
+    if (!v.context) {
+      v.error = print._format.call(this, ns, v.error, {})
+      return undefined
+    }
+    v.context.message = v.message
+    if (v.type === 'any.only') v.context.ref = print._format.call(this, ns, `field.${get(v, 'context.valids.0.key')}`, {})
+    value[i] = {
+      field: get(v, 'context.key'),
+      error: print._format.call(this, ns, `validation.${v.type}`, v.context, {})
+    }
+  })
+}
+
+function error (msg = 'Internal server error', ...args) {
+  let payload = last(args)
+  let ns
+  if (isPlainObject(payload)) {
+    payload = args.pop()
+    ns = payload.ns
+  }
+  if (!ns) ns = getPluginName.call(this, 3)
+  const orgMsg = msg
+  const message = print._format.call(this, ns, msg, ...args)
+  let err
+  if (isPlainObject(payload) && payload.class) err = payload.class(message)
+  else err = Error(message)
+  const stacks = err.stack.split('\n')
+  stacks.splice(1, 1) // this file
+  if (stacks[1].includes('/helper/fatal.js')) stacks.splice(1, 1) // if it goes to fatal.js
+  stacks.splice(1, 1) // for buildHelper.js
+  err.stack = stacks.join('\n')
+  if (isPlainObject(payload)) {
+    delete payload.class
+    delete payload.ns
+    for (const key in payload) {
+      const value = payload[key]
+      if (key === 'details' && isArray(value) && orgMsg === 'Validation Error') {
+        formatErrorDetails.call(this, value, ns)
+      }
+      err[key] = value
+    }
+  }
+  return err
+}
+
+export default error

package/boot/helper/fatal.js

@@ -0,0 +1,12 @@
+import error from './error.js'
+import getPluginName from './get-plugin-name.js'
+
+function fatal (...args) {
+  const ns = getPluginName.call(this, 3)
+  args.push({ ns })
+  const err = error(...args)
+  console.error(err)
+  process.exit(1)
+}
+
+export default fatal

package/boot/helper/generate-id.js

@@ -0,0 +1,20 @@
+import { cloneDeep, isPlainObject } from 'lodash-es'
+import { customAlphabet } from 'nanoid'
+
+const generateId = (options = {}) => {
+  let { pattern, length = 21, returnInstance } = options
+  let opts = {}
+  if (isPlainObject(pattern)) {
+    opts = cloneDeep(pattern)
+    returnInstance = opts.returnInstance
+    length = opts.length
+    pattern = opts.pattern
+  }
+  pattern = pattern ?? 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789'
+  if (opts.lowerCase) pattern = pattern.toLowerCase()
+  else if (opts.upperCase) pattern = pattern.toUpperCase()
+  const nid = customAlphabet(pattern, length)
+  return returnInstance ? nid : nid()
+}
+
+export default generateId

package/boot/helper/get-config.js

@@ -0,0 +1,19 @@
+import { isEmpty, isPlainObject, cloneDeep, omit, find } from 'lodash-es'
+import omittedPluginKeys from '../lib/omitted-plugin-keys.js'
+
+function getConfig (name, options = {}) {
+  const { full, clone } = options
+  if (name === 'bajo' || isEmpty(name)) return this.bajo.config
+  if (this[name] && isPlainObject(this[name].config) && this[name].config.name === name) {
+    const cfg = clone ? cloneDeep(this[name].config) : this[name].config
+    return full ? cfg : omit(cfg, omittedPluginKeys)
+  }
+  const ref = find(this.bajo.pluginRefs ?? [], { alias: name })
+  if (ref) {
+    const cfg = clone ? cloneDeep(this[ref.plugin].config) : this[ref.plugin].config
+    return full ? cfg : omit(cfg, omittedPluginKeys)
+  }
+  return {}
+}
+
+export default getConfig

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,12 @@
+import { get } from 'lodash-es'
+import error from './error.js'
+import breakNsPath from './break-ns-path.js'
+
+function getHelper (name = '', thrown = true) {
+  const [plugin, method] = breakNsPath(name)
+  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-data-dir.js

@@ -0,0 +1,12 @@
+import fs from 'fs-extra'
+
+function getPluginDataDir (name, ensureDir = true) {
+  const { getPlugin, getConfig } = this.bajo.helper
+  const plugin = getPlugin(name)
+  const cfg = getConfig()
+  const dir = `${cfg.dir.data}/plugins/${plugin.config.name}`
+  if (ensureDir) fs.ensureDirSync(dir)
+  return dir
+}
+
+export default getPluginDataDir

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,14 @@
+import { find } from 'lodash-es'
+
+function getPlugin (name) {
+  const { error } = this.bajo.helper
+  if (!this[name]) {
+    // alias?
+    const ref = find(this.bajo.pluginRefs ?? [], { alias: name })
+    if (!ref) throw error('\'%s\' is not loaded', name)
+    name = ref.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