waibu 1.2.12 → 2.0.1

package/index.js

@@ -2,7 +2,7 @@ import collectRoutePathHandlers from './lib/collect-route-path-handlers.js'
 import fastify from 'fastify'
 import appHook from './lib/app-hook.js'
 import routeHook from './lib/webapp-scope/route-hook.js'
-import logRoutes from './lib/log-routes.js'
+import printRoutes from './lib/print-routes.js'
 import { boot } from './lib/app.js'
 import sensible from '@fastify/sensible'
 import noIcon from 'fastify-no-icon'
@@ -12,15 +12,83 @@ import handleRedirect from './lib/handle-redirect.js'
 import buildLocals from './lib/build-locals.js'
 import queryString from 'query-string'
 
+/**
+ * @typedef TEscapeChars
+ * @type {Object}
+ * @memberof Waibu
+ * @property {string} <=<
+ * @property {string} >=>
+ * @property {string} "="
+ * @property {string} '='
+ */
+
+/**
+ * Plugin factory
+ *
+ * @param {string} pkgName - NPM package name
+ * @returns {class}
+ */
 async function factory (pkgName) {
   const me = this
 
-  return class Waibu extends this.lib.BajoPlugin {
+  /**
+   * Waibu Web Framework plugin for Bajo. This is the main foundation of all web apps attached to
+   * the system through a route prefix. Those web apps are then build as childrens with
+   * its own fastify's context.
+   *
+   * There are currently 3 web apps available:
+   * - {@link https://github.com/ardhi/waibu-static|waibu-static} for static content delivery
+   * - {@link https://github.com/ardhi/waibu-rest-api|waibu-rest-api} for rest api setup
+   * - and {@link https://github.com/ardhi/waibu-mpa|waibu-mpa} for normal multi-page application
+   *
+   * You should write your code as the extension of above web apps. Not to this main app.
+   * Unless, of course, if you want to write custom web apps with its own context.
+   *
+   * @class
+   */
+  class Waibu extends this.app.pluginClass.base {
+    /**
+     * @constant {string[]}
+     * @default ['onRequest', 'onResponse', 'preParsing', 'preValidation', 'preHandler', 'preSerialization', 'onSend', 'onTimeout', 'onError']
+     * @memberof Waibu
+     */
+    static hookTypes = ['onRequest', 'onResponse', 'preParsing', 'preValidation', 'preHandler',
+      'preSerialization', 'onSend', 'onTimeout', 'onError']
+
+    /**
+     * @constant {string}
+     * @memberof Waibu
+     * @default 'w'
+     */
+    static alias = 'w'
+
+    /**
+     * @constant {string[]}
+     * @default ['bajo-extra']
+     * @memberof Waibu
+     */
+    static dependencies = ['bajo-extra']
+
+    /**
+     * @constant {TEscapeChars}
+     * @memberof Waibu
+     */
+    static escapeChars = {
+      '<': '&lt;',
+      '>': '&gt;',
+      '"': '&quot;',
+      "'": '&apos;'
+    }
+
     constructor () {
       super(pkgName, me.app)
-      this.alias = 'w'
-      this.dependencies = ['bajo-extra']
+
+      /**
+       * @see {@tutorial config}
+       * @type {Object}
+       */
       this.config = {
+        home: undefined,
         server: {
           host: '127.0.0.1',
           port: 7771
@@ -46,7 +114,7 @@ async function factory (pkgName) {
           lang: 'lang'
         },
         paramsCharMap: {},
-        logRoutes: true,
+        printRoutes: true,
         pageTitleFormat: '%s : %s',
         siteInfo: {
           title: 'My Website',
@@ -77,12 +145,6 @@ async function factory (pkgName) {
           }
         }
       }
-      this.escapeChars = {
-        '<': '&lt;',
-        '>': '&gt;',
-        '"': '&quot;',
-        "'": '&apos;'
-      }
       this.qs = {
         parse: (item) => {
           return queryString.parse(item, {
@@ -94,15 +156,25 @@ async function factory (pkgName) {
         stringify: queryString.stringify,
         stringifyUrl: queryString.stringifyUrl
       }
-      this.hookTypes = ['onRequest', 'onResponse', 'preParsing', 'preValidation', 'preHandler',
-        'preSerialization', 'onSend', 'onTimeout', 'onError']
     }
 
+    /**
+     * Initialize plugin
+     *
+     * @method
+     * @async
+     */
     init = async () => {
       if (this.config.home === '/') this.config.home = false
       await collectRoutePathHandlers.call(this)
     }
 
+    /**
+     * Start plugin
+     *
+     * @method
+     * @async
+     */
     start = async () => {
       const { generateId, runHook } = this.app.bajo
       const cfg = this.getConfig()
@@ -132,21 +204,33 @@ async function factory (pkgName) {
       await handleRedirect.call(this, instance)
       await handleForward.call(this, instance)
       await appHook.call(this)
-      await routeHook.call(this, this.name)
+      await routeHook.call(this, this.ns)
       await boot.call(this)
       await instance.listen(cfg.server)
-      if (cfg.logRoutes) logRoutes.call(this)
+      if (cfg.printRoutes) printRoutes.call(this)
     }
 
+    /**
+     * Exit handler
+     *
+     * @method
+     * @async
+     */
     exit = async () => {
       this.instance.close()
     }
 
-    findRoute = (route) => {
-      const { outmatch } = this.lib
-      const { find } = this.lib._
+    /**
+     * Find route by route name
+     *
+     * @param {string} name - ns based route name
+     * @returns {Object} Route object
+     */
+    findRoute = (name) => {
+      const { outmatch } = this.app.lib
+      const { find } = this.app.lib._
       const { breakNsPath } = this.app.bajo
-      let { ns, subNs = '', path } = breakNsPath(route)
+      let { ns, subNs = '', path } = breakNsPath(name)
       const params = path.split('|')
       if (params.length > 1) path = params[0]
       return find(this.routes, r => {
@@ -158,15 +242,37 @@ async function factory (pkgName) {
       })
     }
 
+    get escapeChars () {
+      return this.constructor.escapeChars
+    }
+
+    /**
+     * Escape text
+     *
+     * @method
+     * @param {string} text
+     * @returns {string}
+     */
     escape = (text = '') => {
       if (typeof text !== 'string') return text
-      const { forOwn } = this.lib._
+      const { forOwn } = this.app.lib._
       forOwn(this.escapeChars, (v, k) => {
         text = text.replaceAll(k, v)
       })
       return text
     }
 
+    /**
+     * Fetch something from url. A wrapper of bajo-extra's fetchUrl which support
+     * bajo's ns based url.
+     *
+     * @method
+     * @async
+     * @param {string} url - Also support ns based url
+     * @param {Object} [opts={}] - node's fetch options
+     * @param {Object} [extra={}] - See {@link https://ardhi.github.io/bajo-extra|bajo-extra}
+     * @returns {Object}
+     */
     fetch = async (url, opts = {}, extra = {}) => {
       const { fetch } = this.app.bajoExtra
       extra.rawResponse = true
@@ -183,22 +289,43 @@ async function factory (pkgName) {
       return result
     }
 
+    /**
+     * Get visitor IP from fastify's request object
+     *
+     * @method
+     * @param {Object} req - request object
+     * @returns {string}
+     */
     getIp = (req) => {
-      const { isEmpty } = this.lib._
+      const { isEmpty } = this.app.lib._
       let fwd = req.headers['x-forwarded-for'] ?? ''
       if (!Array.isArray(fwd)) fwd = fwd.split(',').map(ip => ip.trim())
       return isEmpty(fwd[0]) ? req.ip : fwd[0]
     }
 
+    /**
+     * Get origin of fastify's request object
+     *
+     * @method
+     * @param {Object} req
+     * @returns {string}
+     */
     getOrigin = (req) => {
-      const { isEmpty } = this.lib._
+      const { isEmpty } = this.app.lib._
       let host = req.host
       if (isEmpty(host) || host === ':authority') host = `${this.config.server.host}:${this.config.server.port}`
       return `${req.protocol}://${host}`
     }
 
+    /**
+     * Get plugin by prefix
+     *
+     * @method
+     * @param {string} prefix
+     * @returns {Object}
+     */
     getPluginByPrefix = (prefix) => {
-      const { get, find } = this.lib._
+      const { get, find } = this.app.lib._
       const item = find(this.app.waibu.routes, r => {
         return get(r, 'config.prefix') === prefix
       })
@@ -206,19 +333,34 @@ async function factory (pkgName) {
       if (ns) return this.app[ns]
     }
 
-    getPluginPrefix = (base, webApp = 'waibuMpa') => {
-      const { get, trim } = this.lib._
-      let prefix = get(this, `app.${base}.config.waibu.prefix`, this.app[base].alias)
-      if (base === 'main') {
+    /**
+     * Get plugin's prefix by name
+     *
+     * @method
+     * @param {string} name - Plugin's name
+     * @param {string} [webApp=waibuMpa] - Web app to use
+     * @returns {string}
+     */
+    getPluginPrefix = (name, webApp = 'waibuMpa') => {
+      const { get, trim } = this.app.lib._
+      let prefix = get(this, `app.${name}.config.${webApp}.prefix`, get(this, `app.${name}.config.waibu.prefix`, this.app[name].alias))
+      if (name === 'main') {
         const cfg = this.app[webApp].config
         if (cfg.mountMainAsRoot) prefix = ''
       }
-
       return trim(prefix, '/')
     }
 
-    getRoutes = (grouped, lite) => {
-      const { groupBy, orderBy, mapValues, map, pick } = this.lib._
+    /**
+     * Get all available routes
+     *
+     * @method
+     * @param {boolean} [grouped=false] - Returns as groups of urls and methods
+     * @param {*} [lite=false] - Retuns only urls and methods
+     * @returns {Array}
+     */
+    getRoutes = (grouped = false, lite = false) => {
+      const { groupBy, orderBy, mapValues, map, pick } = this.app.lib._
       const all = this.routes
       let routes
       if (grouped) {
@@ -229,18 +371,34 @@ async function factory (pkgName) {
       return routes
     }
 
-    getUploadedFiles = async (reqId, fileUrl, returnDir) => {
+    /**
+     * Get uploaded files by request ID
+     *
+     * @method
+     * @param {string} reqId - Request ID
+     * @param {boolean} [fileUrl=false] - If ```true```, files returned as file url format (```file:///...```)
+     * @param {*} returnDir - If ```true```, also return its directory
+     * @returns {(Object|Array)} - Returns object if ```returnDir``` is ```true```, array of files otherwise
+     */
+    getUploadedFiles = async (reqId, fileUrl = false, returnDir = false) => {
       const { getPluginDataDir, resolvePath } = this.app.bajo
-      const { fastGlob } = this.lib
-      const dir = `${getPluginDataDir(this.name)}/upload/${reqId}`
+      const { fastGlob } = this.app.lib
+      const dir = `${getPluginDataDir(this.ns)}/upload/${reqId}`
       const result = await fastGlob(`${dir}/*`)
       if (!fileUrl) return returnDir ? { dir, files: result } : result
       const files = result.map(f => resolvePath(f, true))
       return returnDir ? { dir, files } : files
     }
 
+    /**
+     * Is namespace's path contains language detector token?
+     *
+     * @method
+     * @param {string} ns - Plugin name
+     * @returns {boolean}
+     */
     isIntlPath = (ns) => {
-      const { get } = this.lib._
+      const { get } = this.app.lib._
       return get(this.app[ns], 'config.intl.detectors', []).includes('path')
     }
 
@@ -248,6 +406,13 @@ async function factory (pkgName) {
       throw this.error('_notFound', { path: name })
     }
 
+    /**
+     * Parse filter found from Fastify's request based on keys set in config object
+     *
+     * @method
+     * @param {Object} req - Request object
+     * @returns {Object}
+     */
     parseFilter = (req) => {
       const result = {}
       const items = Object.keys(this.config.qsKey)
@@ -257,26 +422,45 @@ async function factory (pkgName) {
       return result
     }
 
-    routeDir = (ns, base) => {
-      const { get } = this.lib._
-      if (!base) base = ns
-      const cfg = this.app[base].config
-      const prefix = get(cfg, 'waibu.prefix', this.app[base].alias)
+    /**
+     * Get route directory by plugin's name
+     *
+     * @param {*} ns - Namespace
+     * @param {*} [baseNs] - Base namespace. If not provided, defaults to scope's ns
+     * @returns {string}
+     */
+    routeDir = (ns, baseNs) => {
+      const { get } = this.app.lib._
+      if (!baseNs) baseNs = ns
+      const cfg = this.app[baseNs].config
+      const prefix = get(cfg, 'waibu.prefix', this.app[baseNs].alias)
       const dir = prefix === '' ? '' : `/${prefix}`
-      if (!ns) return dir
       const cfgMpa = get(this, 'app.waibuMpa.config')
-      if (ns === this.app.bajo.mainNs && cfgMpa.mountMainAsRoot) return ''
-      if (ns === base) return dir
+      if (ns === this.app.mainNs && cfgMpa.mountMainAsRoot) return ''
+      if (ns === baseNs) return dir
       return dir + `/${get(this.app[ns].config, 'waibu.prefix', this.app[ns].alias)}`
     }
 
-    routePath = (name = '', options = {}) => {
+    /**
+     * Get route path by route's name:
+     * - If it is a ```mailto:``` or ```tel:``` url, it returns as is
+     * - If it is a ns based name, it will be parsed first
+     *
+     * @method
+     * @param {string} name
+     * @param {Object} [options={}] - Options object
+     * @param {string} [options.base=waibu] - Base namespace
+     * @param {boolean} [options.guessHost] - If true, guest host if host is not set
+     * @param {Object} [options.query={}] - Query string's object. If provided, it will be added to returned value
+     * @param {Object} [options.params={}] - Parameter object. If provided, it will be merged to returned value
+     * @returns {string}
+     */
+    routePath = (name, options = {}) => {
       const { getPlugin } = this.app.bajo
-      const { defaultsDeep } = this.lib.aneka
-      const { isEmpty, get, trimEnd, trimStart } = this.lib._
+      const { defaultsDeep } = this.app.lib.aneka
+      const { isEmpty, get, trimEnd, trimStart } = this.app.lib._
       const { breakNsPath } = this.app.bajo
-      const { query = {}, base = 'waibu', params = {}, guessHost } = options
-      if (isEmpty(name)) return name
+      const { query = {}, base = this.ns, params = {}, guessHost } = options
 
       const plugin = getPlugin(base)
       const cfg = plugin.config ?? {}
@@ -304,10 +488,22 @@ async function factory (pkgName) {
       return url
     }
 
+    /**
+     * Method to send mail through Masohi Messaging System. It is a thin wrapper
+     * for {@link https://github.com/ardhi/masohi-mail|masohi-mail} send method.
+     *
+     * If masohi is not loaded, nothing is delivered.
+     *
+     * @method
+     * @async
+     * @param {(string|Array)} tpl - Mail's template to use. If a string is given, the same template will be used for html & plaintext versions. Otherwise, the first template will be used for html mail, and the second one is for it's plaintext version
+     * @param {Object} [params={}] - {@link https://github.com/ardhi/masohi-mail|masohi-mail}'s params object.
+     * @returns
+     */
     sendMail = async (tpl, { to, cc, bcc, from, subject, data = {}, conn, source, options = {} }) => {
       conn = conn ?? 'masohiMail:default'
       if (!this.app.masohi || !this.app.masohiMail) return
-      const { get, isString } = this.lib._
+      const { get, isString } = this.app.lib._
       const { generateId } = this.app.bajo
       const { render } = this.app.bajoTemplate
       if (isString(tpl)) tpl = [tpl]
@@ -319,11 +515,22 @@ async function factory (pkgName) {
       const message = await render(tpl[0], locals, opts)
       if (tpl[1]) opts.messageText = await render(tpl[1], locals, opts)
       const payload = { type: 'object', data: { to, cc, bcc, from, subject, message, options: opts } }
-      await this.app.masohi.send({ payload, source: source ?? this.name, conn }) // mail sent through worker
+      await this.app.masohi.send({ payload, source: source ?? this.ns, conn }) // mail sent through worker
     }
 
+    /**
+     * Recursively unescape block of texts
+     *
+     * @method
+     * @param {string} content - Source content
+     * @param {string} start - Block's start
+     * @param {string} end - Block's end
+     * @param {string} startReplacer - Token to use as block's start replacer
+     * @param {string} endReplacer - Token to use as block's end replacer
+     * @returns {string}
+     */
     unescapeBlock = (content, start, end, startReplacer, endReplacer) => {
-      const { extractText } = this.lib.aneka
+      const { extractText } = this.app.lib.aneka
       const { result } = extractText(content, start, end)
       if (result.length === 0) return content
       const unescaped = this.unescape(result)
@@ -333,8 +540,15 @@ async function factory (pkgName) {
       return this.unescapeBlock(block, start, end, startReplacer, endReplacer)
     }
 
+    /**
+     * Unescape text using {@link TEscapeChars} rules
+     *
+     * @method
+     * @param {string} text - Text to unescape
+     * @returns {string}
+     */
     unescape = (text) => {
-      const { forOwn, invert } = this.lib._
+      const { forOwn, invert } = this.app.lib._
       const mapping = invert(this.escapeChars)
       forOwn(mapping, (v, k) => {
         text = text.replaceAll(k, v)
@@ -342,6 +556,8 @@ async function factory (pkgName) {
       return text
     }
   }
+
+  return Waibu
 }
 
 export default factory

package/lib/app-hook.js

@@ -5,8 +5,8 @@ async function appHook () {
   for (const hook of hooks) {
     me.instance.addHook(hook, async function (...args) {
       args.push(this)
-      if (['onClose', 'onReady'].includes(hook)) await runHook(`${me.name}:${hook}`, ...args)
-      else await runHook(`${me.name}:${hook}`, ...args)
+      if (['onClose', 'onReady'].includes(hook)) await runHook(`${me.ns}:${hook}`, ...args)
+      else await runHook(`${me.ns}:${hook}`, ...args)
     })
   }
 }

package/lib/app.js

@@ -2,11 +2,12 @@ import home from './home.js'
 
 export async function collect (glob = 'boot.js', baseNs) {
   const { eachPlugins, importModule } = this.app.bajo
-  const { orderBy, get } = this.lib._
-  if (!baseNs) baseNs = this.name
+  const { orderBy, get } = this.app.lib._
+  if (!baseNs) baseNs = this.ns
   const mods = []
 
-  await eachPlugins(async function ({ config, file, ns, alias }) {
+  await eachPlugins(async function ({ file }) {
+    const { ns, alias, config } = this
     const mod = await importModule(file, { asHandler: true })
     mod.prefix = get(config, 'waibu.prefix', alias)
     if (get(config, 'intl.detectors', []).includes('path')) mod.prefix = `/:lang${mod.prefix}`
@@ -26,23 +27,23 @@ export async function collect (glob = 'boot.js', baseNs) {
 export async function boot () {
   const { runHook } = this.app.bajo
   const mods = await collect.call(this)
-  await runHook(`${this.name}:beforeAppBoot`)
+  await runHook(`${this.ns}:beforeAppBoot`)
   for (const m of mods) {
     const disabled = this.app[m.ns].config.disabled
     if (Array.isArray(disabled) && disabled.length === 1 && ['*', 'all'].includes(disabled[0])) {
       this.log.warn('allRoutesConfigDisabled%s', m.ns)
       continue
     }
-    await runHook(`${this.name}.${m.ns}:beforeAppBoot`)
+    await runHook(`${this.ns}.${m.ns}:beforeAppBoot`)
     this.log.debug('bootApp%s', m.ns)
     await this.instance.register(async (ctx) => {
       const plugin = this.app[m.ns]
       plugin.instance = ctx
-      await runHook(`${plugin.name}:afterCreateContext`, ctx)
+      await runHook(`${plugin.ns}:afterCreateContext`, ctx)
       await m.handler.call(plugin, ctx, m.prefix)
     }, { prefix: m.prefix })
-    await runHook(`${this.name}.${m.ns}:afterAppBoot`)
+    await runHook(`${this.ns}.${m.ns}:afterAppBoot`)
   }
-  await runHook(`${this.name}:afterAppBoot`)
+  await runHook(`${this.ns}:afterAppBoot`)
   await home.call(this)
 }

package/lib/build-locals.js

@@ -1,8 +1,8 @@
 async function buildHomesMenu (req) {
   const { callHandler } = this.app.bajo
-  const { get, find, orderBy } = this.lib._
+  const { get, find, orderBy } = this.app.lib._
   const routes = []
-  for (const ns of this.app.bajo.pluginNames) {
+  for (const ns of this.app.getAllNs()) {
     let home = get(this, `app.${ns}.config.waibuMpa.home`)
     const homeHandler = get(this, `app.${ns}.config.waibuMpa.homeHandler`)
     if (homeHandler) home = await callHandler(this.app[ns], homeHandler)
@@ -14,15 +14,15 @@ async function buildHomesMenu (req) {
 }
 
 async function buildPagesMenu (req) {
-  const { find, orderBy, merge, isString } = this.lib._
+  const { find, orderBy, merge, isString } = this.app.lib._
   const { callHandler, runHook } = this.app.bajo
   const all = [{ icon: 'house', href: '/', level: 1 }]
-  for (const ns of this.app.bajo.pluginNames) {
+  for (const ns of this.app.getAllNs()) {
     const items = []
     let pages = this.app[ns].getConfig('waibuMpa.menuHandler', { defValue: [] })
     if (isString(pages)) pages = await callHandler(this.app[ns], pages, req)
     if (pages.length === 0) continue
-    await runHook(`${this.name}.${ns}:afterBuildPagesMenu`, pages, req)
+    await runHook(`${this.ns}.${ns}:afterBuildPagesMenu`, pages, req)
     for (const page of pages) {
       const existing = find(all, { title: page.title })
       page.level = page.level ?? 1000
@@ -51,7 +51,7 @@ async function buildPagesMenu (req) {
 }
 async function buildLocals ({ tpl, params = {}, opts = {} } = {}) {
   const { runHook } = this.app.bajo
-  const { set, merge, pick, get, isEmpty, find } = this.lib._
+  const { set, merge, pick, get, isEmpty, find } = this.app.lib._
   const { req, reply } = opts
 
   const appTitle = this.app.waibuMpa ? req.t(this.app.waibuMpa.getAppTitle(req.ns)) : ''
@@ -86,8 +86,8 @@ async function buildLocals ({ tpl, params = {}, opts = {} } = {}) {
   set(params, 'menu.homes', await buildHomesMenu.call(this, req))
   set(params, 'menu.pages', await buildPagesMenu.call(this, req))
   const merged = merge({}, params, { _meta })
-  await runHook(`${this.name}:afterBuildLocals`, merged, req)
-  if (!isEmpty(routeOpts.ns)) await runHook(`${this.name}.${routeOpts.ns}:afterBuildLocals`, merged, req)
+  await runHook(`${this.ns}:afterBuildLocals`, merged, req)
+  if (!isEmpty(routeOpts.ns)) await runHook(`${this.ns}.${routeOpts.ns}:afterBuildLocals`, merged, req)
   return merged
 }
 

package/lib/collect-route-path-handlers.js

@@ -1,10 +1,11 @@
 async function collectRoutePathHandlers () {
   const { eachPlugins } = this.app.bajo
-  const { isEmpty } = this.lib._
+  const { isEmpty } = this.app.lib._
   this.routePathHandlers = this.routePathHandlers ?? {}
   const me = this
 
-  await eachPlugins(async function ({ ns }) {
+  await eachPlugins(async function () {
+    const { ns } = this
     if (isEmpty(this.routePathHandlers) || !this.routePath) return undefined
     for (const key of this.routePathHandlers) {
       me.routePathHandlers[key] = { handler: this.routePath, ns }

package/lib/handle-download.js

@@ -2,9 +2,9 @@ import path from 'path'
 
 async function handleDownload (input, req, reply) {
   const { importPkg } = this.app.bajo
-  const { isFunction } = this.lib._
+  const { isFunction } = this.app.lib._
   const mime = await importPkg('waibu:mime')
-  const { fs } = this.lib
+  const { fs } = this.app.lib
   const file = isFunction(input) ? (await input.call(this, req)) : input
   if (!fs.existsSync(file)) throw this.error('_notFound')
   const mimeType = mime.getType(path.extname(file))

package/lib/handle-forward.js

@@ -1,7 +1,7 @@
 import replyFrom from '@fastify/reply-from'
 
 async function handleForward (ctx) {
-  const { defaultsDeep } = this.lib.aneka
+  const { defaultsDeep } = this.app.lib.aneka
   const me = this
 
   function rewriteHeaders (headers, req) {

package/lib/home.js

@@ -1,7 +1,7 @@
 async function home () {
   const { callHandler } = this.app.bajo
-  const { defaultsDeep } = this.lib.aneka
-  const { isString, pick } = this.lib._
+  const { defaultsDeep } = this.app.lib.aneka
+  const { isString, pick } = this.app.lib._
   const config = this.getConfig()
   if (config.home) {
     if (isString(config.home)) config.home = { path: config.home }

package/lib/{log-routes.js → print-routes.js}

@@ -1,5 +1,5 @@
 function printRoutes () {
-  const { findIndex, orderBy, isArray } = this.lib._
+  const { findIndex, orderBy, isArray } = this.app.lib._
   let items = []
   this.routes.forEach(r => {
     const idx = findIndex(items, { url: r.url })
@@ -10,9 +10,9 @@ function printRoutes () {
     }
   })
   items = orderBy(items, ['url'])
-  this.log.debug('loaded%s', this.print.write('routesL'))
+  this.log.trace('loaded%s', this.t('routesL'))
   items.forEach(item => {
-    this.log.debug('- %s (%s)', item.url, item.methods.join('|'))
+    this.log.trace('- %s (%s)', item.url, item.methods.join('|'))
   })
 }