waibu 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Ardhi Lukianto
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,23 @@
+# wakatobi
+
+Plugin name: **wakatobi**, alias: **wktb**
+
+![GitHub package.json version](https://img.shields.io/github/package-json/v/ardhi/wakatobi) ![NPM Version](https://img.shields.io/npm/v/wakatobi)
+
+> <br />**Attention**: I do NOT accept any pull request at the moment, thanks!<br /><br />
+
+[Bajo](https://github.com/ardhi/bajo)'s Web Framework. Entirely based on [Fastify](https://github.com/fastify/fastify) and its ecosystem.
+
+## Installation
+
+Goto your ```<bajo-base-dir>``` and type:
+
+```bash
+$ npm install wakatobi
+```
+
+Now open your ```<bajo-data-dir>/config/.plugins``` and put ```wakatobi``` in it
+
+## License
+
+[MIT](LICENSE)

package/bajo/config.json

@@ -0,0 +1,47 @@
+{
+  "alias": "wktb",
+  "server": {
+    "host": "localhost",
+    "port": 7777
+  },
+  "factory": {
+    "trustProxy": true
+  },
+  "qsKey": {
+    "bbox": "bbox",
+    "bboxLatField": "bboxLatField",
+    "bboxLngField": "bboxLngField",
+    "query": "query",
+    "match": "match",
+    "skip": "skip",
+    "page": "page",
+    "limit": "limit",
+    "sort": "sort",
+    "fields": "fields",
+    "lang": "lang"
+  },
+  "paramsCharMap": {},
+  "dbColl": {
+    "dataOnly": false,
+    "count": false,
+    "patchEnabled": false
+  },
+  "logRoutes": false,
+  "siteInfo": {
+    "title": "My Website",
+    "orgName": "My Organization"
+  },
+  "multipart": {
+    "attachFieldsToBody": true,
+    "limits": {
+      "parts": 100,
+      "fileSize": 10485760
+    }
+  },
+  "noIcon": true,
+  "underPressure": false,
+  "forwardOpts": {
+    "disableRequestLogging": true
+  },
+  "dependencies": ["bajo-logger"]
+}

package/bajo/exit.js

@@ -0,0 +1,3 @@
+export default async function () {
+  this.instance.close()
+}

package/bajo/hook/bajoI18N@before-init.js

@@ -0,0 +1,6 @@
+async function bajoI18nBeforeInit () {
+  const config = this.app.bajoI18N.config
+  if (!config.fallbackNS.includes(this.name)) config.fallbackNS.push(this.name)
+}
+
+export default bajoI18nBeforeInit

package/bajo/hook/on-close.js

@@ -0,0 +1,5 @@
+async function onClose () {
+  this.log.info('Server is closed')
+}
+
+export default onClose

package/bajo/hook/on-ready.js

@@ -0,0 +1,5 @@
+async function onReady () {
+  this.log.info('Server is ready!')
+}
+
+export default onReady

package/bajo/hook/on-request.js

@@ -0,0 +1,20 @@
+const onRequest = {
+  level: 5,
+  handler: async function onRequest (ctx, req, reply) {
+    req.site = this.config.siteInfo
+    let msg = '< %s:%s from IP %s'
+    if (req.headers['content-length']) msg += ', content length: %s'
+    this.log.info(msg, req.method, req.url, this.getIp(req), req.headers['content-length'])
+    if (Object.keys(this.config.paramsCharMap).length === 0) return
+    for (const key in req.params) {
+      let val = req.params[key]
+      if (typeof val !== 'string') continue
+      for (const char in this.config.paramsCharMap) {
+        val = val.replaceAll(char, this.config.paramsCharMap[char])
+      }
+      req.params[key] = val
+    }
+  }
+}
+
+export default onRequest

package/bajo/hook/on-response.js

@@ -0,0 +1,12 @@
+const onResponse = {
+  level: 5,
+  handler: async function onResponse (ctx, req, reply) {
+    let method = 'info'
+    if (reply.statusCode >= 300 && reply.statusCode < 400) method = 'warn'
+    else if (reply.statusCode >= 400) method = 'error'
+    this.log[method]('> %s:%s with a %d-status took %dms', req.method, req.url, reply.statusCode,
+      (reply.elapsedTime ?? 0).toFixed(3))
+  }
+}
+
+export default onResponse

package/bajo/hook/on-route.js

@@ -0,0 +1,8 @@
+const onRoute = {
+  level: 5,
+  handler: async function (ctx, opts) {
+    this.routes.push(opts)
+  }
+}
+
+export default onRoute

package/bajo/init.js

@@ -0,0 +1,5 @@
+async function init () {
+  if (this.config.home === '/') this.config.home = false
+}
+
+export default init

package/bajo/method/get-ip.js

@@ -0,0 +1,7 @@
+function getIp (req) {
+  let fwd = req.headers['x-forwarded-for'] ?? ''
+  if (!Array.isArray(fwd)) fwd = fwd.split(',').map(ip => ip.trim())
+  return fwd[0] ?? req.ip
+}
+
+export default getIp

package/bajo/method/get-params.js

@@ -0,0 +1,18 @@
+function getParams (req, ...items) {
+  const { map, trim, get } = this.app.bajo.lib._
+  let fields
+  req.query = req.query ?? {}
+  req.params = req.params ?? {}
+  if (req.query.fields) fields = map((req.query.fields ?? '').split(','), i => trim(i))
+  const params = {
+    fields,
+    count: get(this, 'config.dbColl.count', false),
+    body: req.body
+  }
+  items.forEach(i => {
+    params[i] = req.params[i]
+  })
+  return params
+}
+
+export default getParams

package/bajo/method/get-routes.js

@@ -0,0 +1,13 @@
+function getRoutes (grouped, lite) {
+  const { groupBy, orderBy, mapValues, map, pick } = this.app.bajo.lib._
+  const all = this.routes
+  let routes
+  if (grouped) {
+    const group = groupBy(orderBy(all, ['url', 'method']), 'url')
+    routes = lite ? mapValues(group, (v, k) => map(v, 'method')) : group
+  } else if (lite) routes = map(all, a => pick(a, ['url', 'method']))
+  else routes = all
+  return routes
+}
+
+export default getRoutes

package/bajo/method/get-uploaded-files.js

@@ -0,0 +1,11 @@
+async function getUploadedFiles (reqId, fileUrl, returnDir) {
+  const { getPluginDataDir, resolvePath } = this.app.bajo
+  const { fastGlob } = this.app.bajo.lib
+  const dir = `${getPluginDataDir(this.name)}/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
+}
+
+export default getUploadedFiles

package/bajo/method/hook-types.js

@@ -0,0 +1,4 @@
+const hookTypes = ['onRequest', 'onResponse', 'preParsing', 'preValidation', 'preHandler',
+  'preSerialization', 'onSend', 'onTimeout', 'onError']
+
+export default hookTypes

package/bajo/method/merge-route-hooks.js

@@ -0,0 +1,19 @@
+import hookTypes from './hook-types.js'
+
+async function mergeRouteHooks (def, withHandler = true) {
+  const { last, isFunction } = this.app.bajo.lib._
+  const hooks = [...hookTypes]
+  const me = this
+  if (withHandler) hooks.push('handler')
+  for (const h of hooks) {
+    const oldH = def[h]
+    if (!oldH) continue
+    def[h] = async function (...args) {
+      // TODO: hooks can be array of functions
+      if (isFunction(last(args))) args.pop()
+      return await oldH.call(me, this, ...args)
+    }
+  }
+}
+
+export default mergeRouteHooks

package/bajo/method/method-map.js

@@ -0,0 +1,9 @@
+const methodMap = {
+  create: 'POST',
+  find: 'GET',
+  get: 'GET',
+  update: 'PUT',
+  remove: 'DELETE'
+}
+
+export default methodMap

package/bajo/method/not-found.js

@@ -0,0 +1,5 @@
+function notFound (name, options) {
+  throw this.error('notfound', { path: name })
+}
+
+export default notFound

package/bajo/method/parse-filter.js

@@ -0,0 +1,10 @@
+function parseFilter (req) {
+  const result = {}
+  const items = Object.keys(this.config.qsKey)
+  for (const item of items) {
+    result[item] = req.query[this.config.qsKey[item]]
+  }
+  return result
+}
+
+export default parseFilter

package/bajo/method/record/create.js

@@ -0,0 +1,13 @@
+import prepCrud from '../../../lib/prep-crud.js'
+
+async function create ({ coll, req, reply, body, options = {} }) {
+  this.app.bajo.getPlugin('dobo') // ensure dobo is loaded
+  const { recordCreate, attachmentFind } = this.app.dobo
+  const { name, input, opts } = prepCrud.call(this, { coll, req, body, options, args: ['coll'] })
+  const ret = await recordCreate(name, input, opts)
+  const { attachment, stats, mimeType } = req.query
+  if (attachment) ret.data._attachment = await attachmentFind(name, ret.data.id, { stats, mimeType })
+  return ret
+}
+
+export default create

package/bajo/method/record/find-one.js

@@ -0,0 +1,19 @@
+import prepCrud from '../../../lib/prep-crud.js'
+
+async function find ({ coll, req, reply, options = {} }) {
+  this.app.bajo.getPlugin('dobo') // ensure dobo is loaded
+  const { recordFindOne, attachmentFind } = this.app.dobo
+  const { name, opts } = prepCrud.call(this, { coll, req, options, args: ['coll'] })
+  opts.bboxLatField = req.query[this.config.qsKey.bboxLatField]
+  opts.bboxLngField = req.query[this.config.qsKey.bboxLngField]
+  const filter = this.parseFilter(req)
+  const ret = await recordFindOne(name, filter, opts)
+  ret.filter = filter
+  const { attachment, stats, mimeType } = req.query
+  if (attachment) {
+    ret.data._attachment = await attachmentFind(name, ret.data.id, { stats, mimeType })
+  }
+  return ret
+}
+
+export default find

package/bajo/method/record/find.js

@@ -0,0 +1,20 @@
+import prepCrud from '../../../lib/prep-crud.js'
+
+async function find ({ coll, req, reply, options = {} }) {
+  this.app.bajo.getPlugin('dobo') // ensure dobo is loaded
+  const { recordFind, attachmentFind } = this.app.dobo
+  const { name, opts } = prepCrud.call(this, { coll, req, options, args: ['coll'] })
+  opts.bboxLatField = req.query[this.config.qsKey.bboxLatField]
+  opts.bboxLngField = req.query[this.config.qsKey.bboxLngField]
+  const filter = this.parseFilter(req)
+  const ret = await recordFind(name, filter, opts)
+  const { attachment, stats, mimeType } = req.query
+  if (attachment) {
+    for (const d of ret.data) {
+      d._attachment = await attachmentFind(name, d.id, { stats, mimeType })
+    }
+  }
+  return ret
+}
+
+export default find

package/bajo/method/record/get.js

@@ -0,0 +1,14 @@
+import prepCrud from '../../../lib/prep-crud.js'
+
+async function get ({ coll, req, reply, id, options = {} }) {
+  this.app.bajo.getPlugin('dobo') // ensure dobo is loaded
+  const { recordGet, attachmentFind } = this.app.dobo
+  const { name, recId, opts } = prepCrud.call(this, { coll, req, id, options, args: ['coll', 'id'] })
+  opts.filter = this.parseFilter(req)
+  const ret = await recordGet(name, recId, opts)
+  const { attachment, stats, mimeType } = req.query
+  if (attachment) ret.data._attachment = await attachmentFind(name, id, { stats, mimeType })
+  return ret
+}
+
+export default get

package/bajo/method/record/remove.js

@@ -0,0 +1,10 @@
+import prepCrud from '../../../lib/prep-crud.js'
+
+async function remove ({ coll, req, reply, id, options = {} }) {
+  this.app.bajo.getPlugin('dobo') // ensure dobo is loaded
+  const { recordRemove } = this.app.dobo
+  const { name, recId, opts } = prepCrud.call(this, { coll, req, id, options, args: ['coll', 'id'] })
+  return await recordRemove(name, recId, opts)
+}
+
+export default remove

package/bajo/method/record/update.js

@@ -0,0 +1,13 @@
+import prepCrud from '../../../lib/prep-crud.js'
+
+async function update ({ coll, req, reply, id, body, options = {} }) {
+  this.app.bajo.getPlugin('dobo') // ensure dobo is loaded
+  const { recordUpdate, attachmentFind } = this.app.dobo
+  const { name, input, opts, recId } = prepCrud.call(this, { coll, req, body, id, options, args: ['coll', 'id'] })
+  const ret = await recordUpdate(name, recId, input, opts)
+  const { attachment, stats, mimeType } = req.query
+  if (attachment) ret.data._attachment = await attachmentFind(name, id, { stats, mimeType })
+  return ret
+}
+
+export default update

package/bajo/method/route-dir.js

@@ -0,0 +1,10 @@
+function routeDir (ns, base) {
+  if (!base) base = ns
+  const cfg = this.app[base].config
+  const dir = cfg.prefix === '' ? '' : `/${cfg.prefix || this.app[base].alias}`
+  if (!ns) return dir
+  if (ns === base || (ns === this.app.bajo.mainNs && cfg.mountAppAsRoot)) return dir
+  return dir + '/' + this.app[ns].alias
+}
+
+export default routeDir

package/bajo/method/route-path.js

@@ -0,0 +1,25 @@
+import qs from 'querystring'
+
+function routePath (name, { query = {}, base = 'wakatobiMpa', params = {} } = {}) {
+  // TODO: what if wakatobiMpa isn't loaded?
+  const { defaultsDeep } = this.app.bajo
+  const { isEmpty, get } = this.app.bajo.lib._
+  const { breakNsPath } = this.app.bajo
+  const cfg = this.app[base].config ?? {}
+  let ns
+  let fullPath
+  if (name.startsWith('/')) fullPath = name
+  else [ns, fullPath] = breakNsPath(name)
+  let [path, queryString] = fullPath.split('?')
+  path = path.split('/').map(p => {
+    return p[0] === ':' && params[p.slice(1)] ? params[p.slice(1)] : p
+  }).join('/')
+  let url = path
+  const langDetector = get(cfg, 'i18n.detectors', [])
+  if (ns) url = langDetector.includes('path') ? `/${params.lang ?? ''}${this.routeDir(ns)}${path}` : `${this.routeDir(ns)}${path}`
+  queryString = defaultsDeep(query, qs.parse(queryString))
+  if (!isEmpty(queryString)) url += '?' + qs.stringify(queryString)
+  return url
+}
+
+export default routePath

package/bajo/method/stat/aggregate.js

@@ -0,0 +1,13 @@
+import prepCrud from '../../../lib/prep-crud.js'
+
+async function aggregate ({ coll, req, reply, options = {} }) {
+  this.app.bajo.getPlugin('dobo') // ensure dobo is loaded
+  const { statAggregate } = this.app.dobo
+  const { name, opts } = prepCrud.call(this, { coll, req, options, args: ['coll'] })
+  for (const item of ['group', 'aggregate']) {
+    opts[item] = options[item] ?? req.params[item] ?? req.query[item]
+  }
+  return await statAggregate(name, this.parseFilter(req), opts)
+}
+
+export default aggregate

package/bajo/method/stat/histogram.js

@@ -0,0 +1,13 @@
+import prepCrud from '../../../lib/prep-crud.js'
+
+async function histogram ({ coll, req, reply, options = {} }) {
+  this.app.bajo.getPlugin('dobo') // ensure dobo is loaded
+  const { statHistogram } = this.app.dobo
+  const { name, opts } = prepCrud.call(this, { coll, req, options, args: ['coll'] })
+  for (const item of ['type', 'group', 'aggregate']) {
+    opts[item] = options[item] ?? req.params[item] ?? req.query[item]
+  }
+  return await statHistogram(name, this.parseFilter(req), opts)
+}
+
+export default histogram

package/bajo/start.js

@@ -0,0 +1,41 @@
+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 { boot } from '../lib/app.js'
+import sensible from '@fastify/sensible'
+import noIcon from 'fastify-no-icon'
+import underPressure from '@fastify/under-pressure'
+import handleForward from '../lib/handle-forward.js'
+import handleRedirect from '../lib/handle-redirect.js'
+
+async function start () {
+  const { generateId, runHook } = this.app.bajo
+  const cfg = this.getConfig()
+  cfg.factory.logger = this.app.bajoLogger.instance.child(
+    {},
+    { msgPrefix: '[wakatobi] ' }
+  )
+  cfg.factory.genReqId = req => generateId()
+  cfg.factory.disableRequestLogging = true
+
+  const instance = fastify(cfg.factory)
+  instance.decorateRequest('lang', null)
+  instance.decorateRequest('langDetector', null)
+  instance.decorateRequest('site', null)
+  this.instance = instance
+  this.routes = this.routes || []
+  await runHook('wakatobi:afterCreateContext', instance)
+  await instance.register(sensible)
+  if (cfg.underPressure) await instance.register(underPressure)
+  if (cfg.noIcon) await instance.register(noIcon)
+  await handleRedirect.call(this, instance)
+  await handleForward.call(this, instance)
+  await appHook.call(this)
+  await routeHook.call(this, this.name)
+  await boot.call(this)
+  await instance.listen(cfg.server)
+  if (cfg.logRoutes) logRoutes.call(this)
+}
+
+export default start

package/bajoI18N/resource/id.json

@@ -0,0 +1,46 @@
+{
+  "[%s] Server is closed": "[%s] Penyelia telah tertutup",
+  "[%s] Server is ready!": "[%s] Penyelia telah siap!",
+  "Route '%s (%s)' not found": "Rute '%s (%s)' tidak ditemukan",
+  "Bad Request": "",
+  "Unauthorized": "Tidak Terautentikasi",
+  "Payment Required": "Pembayaran Disyaratkan",
+  "Forbidden": "Dilarang",
+  "Not Found": "Tidak Ditemukan",
+  "Method Not Allowed": "Metode Tidak Diperkenankan",
+  "Not Acceptable": "Tidak Bisa Diterima",
+  "Proxy Authentication Required": "",
+  "Request Timeout": "",
+  "Conflict": "",
+  "Gone": "",
+  "Length Required": "",
+  "Precondition Failed": "",
+  "Payload Too Large": "",
+  "URI Too Long": "",
+  "Unsupported Media Type": "",
+  "Range Not Satisfiable": "",
+  "Expectation Failed": "",
+  "Im A Teapot": "",
+  "Misdirected Request": "",
+  "Unprocessable Entity": "",
+  "Locked": "",
+  "Failed Dependency": "",
+  "Too Early": "",
+  "Upgrade Required": "",
+  "Precondition Required": "",
+  "Too Many Requests": "",
+  "Request Header Fields Too Large": "",
+  "Unavailable For Legal Reasons": "",
+  "Internal Server Error": "",
+  "Not Implemented": "",
+  "Bad Gateway": "",
+  "Service Unavailable": "",
+  "Gateway Timeout": "",
+  "HTTP Version Not Supported": "",
+  "Variant Also Negotiates": "",
+  "Insufficient Storage": "",
+  "Loop Detected": "",
+  "Bandwidth Limit Exceeded": "",
+  "Not Extended": "",
+  "Network Authentication Require": ""
+}

package/lib/app-hook.js

@@ -0,0 +1,16 @@
+async function appHook () {
+  const { runHook } = this.app.bajo
+  const hooks = ['onReady', 'onClose', 'preClose', 'onRoute', 'onRegister']
+  const me = this
+  for (const hook of hooks) {
+    me.instance.addHook(hook, async function (...args) {
+      if (['onClose', 'onReady'].includes(hook)) await runHook(`${me.name}:${hook}`, ...args)
+      else {
+        const ctx = this // encapsulated fastify scope
+        await runHook(`${me.name}:${hook}`, ctx, ...args)
+      }
+    })
+  }
+}
+
+export default appHook

package/lib/app.js

@@ -0,0 +1,35 @@
+import home from './home.js'
+
+export async function collect (glob = 'boot.js', baseNs) {
+  const { eachPlugins, importModule } = this.app.bajo
+  const { orderBy } = this.app.bajo.lib._
+  if (!baseNs) baseNs = this.name
+  const mods = []
+  await eachPlugins(async function ({ config, file, ns, alias }) {
+    const mod = await importModule(file, { asHandler: true })
+    mod.prefix = config.prefix ?? alias
+    mod.ns = ns
+    mods.push(mod)
+  }, { glob, baseNs })
+  const prefixes = {}
+  mods.forEach(m => {
+    if (!prefixes[m.prefix]) prefixes[m.prefix] = []
+    prefixes[m.prefix].push(m.plugin)
+    if (prefixes[m.prefix].length > 1) this.fatal('Plugin prefix \'%s\' conflic between \'%s\' and \'%s\'', m.prefix, prefixes[m.prefix][0], prefixes[m.prefix][1])
+  })
+  return orderBy(mods, ['level'])
+}
+
+export async function boot () {
+  const { runHook } = this.app.bajo
+  const mods = await collect.call(this)
+  await runHook(`${this.name}:beforeAppBoot`)
+  for (const m of mods) {
+    await runHook(`${this.name}.${m.ns}:beforeAppBoot`)
+    this.log.debug('Boot app: %s', m.ns)
+    await m.handler.call(this.app[m.ns])
+    await runHook(`${this.name}.${m.ns}:afterAppBoot`)
+  }
+  await runHook(`${this.name}:afterAppBoot`)
+  await home.call(this)
+}

package/lib/handle-forward.js

@@ -0,0 +1,26 @@
+import replyFrom from '@fastify/reply-from'
+
+async function handleForward (ctx) {
+  const { defaultsDeep } = this.app.bajo
+  const me = this
+
+  function rewriteHeaders (headers, req) {
+    return {
+      ...headers,
+      'X-Fwd-To': true
+    }
+  }
+
+  const base = `http://${this.config.server.host}:${this.config.server.port}`
+  const options = defaultsDeep({ base }, this.config.forwardOpts)
+  await ctx.register(replyFrom, options)
+
+  await ctx.decorateReply('forwardTo', async function (url, options = {}) {
+    if (url.startsWith('http')) return await me.redirectTo(url)
+    return this.from(me.routePath(url, options), {
+      rewriteHeaders
+    })
+  })
+}
+
+export default handleForward

package/lib/handle-redirect.js

@@ -0,0 +1,11 @@
+import path from 'path'
+
+async function handleRedirect (ctx, options) {
+  const me = this
+  ctx.decorateReply('redirectTo', async function (url, options = {}) {
+    if (url.startsWith('http') || path.isAbsolute(url)) return this.redirect(url)
+    return this.redirect(me.routePath(url, options))
+  })
+}
+
+export default handleRedirect

package/lib/handle-xml-body.js

@@ -0,0 +1,54 @@
+// based on: https://github.com/NaturalIntelligence/fastify-xml-body-parser/blob/master/index.js
+
+async function xmlBodyParser (ctx, opts = {}) {
+  if (!this.app.bajoExtra) {
+    this.log.warn('Can\'t parse XML body unless package \'%s\' is loaded first', 'bajo-extra')
+    return
+  }
+  const { importPkg } = this.app.bajo
+  const fxp = await importPkg('bajoExtra:fast-xml-parser')
+
+  function contentParser (req, payload, done) {
+    const xmlParser = new fxp.XMLParser(opts)
+    const parsingOpts = opts
+    let body = ''
+    payload.on('error', errorListener)
+    payload.on('data', dataListener)
+    payload.on('end', endListener)
+
+    function errorListener (err) {
+      done(err)
+    }
+    function endListener () {
+      if (parsingOpts.validate) {
+        const result = fxp.XMLValidator.validate(body, parsingOpts)
+        if (result.err) {
+          const invalidFormat = new Error('Invalid Format: ' + result.err.msg)
+          invalidFormat.statusCode = 400
+          payload.removeListener('error', errorListener)
+          payload.removeListener('data', dataListener)
+          payload.removeListener('end', endListener)
+          done(invalidFormat)
+        } else {
+          handleParseXml(body)
+        }
+      } else {
+        handleParseXml(body)
+      }
+    }
+    function dataListener (data) {
+      body = body + data
+    }
+    function handleParseXml (body) {
+      try {
+        done(null, xmlParser.parse(body))
+      } catch (err) {
+        done(err)
+      }
+    }
+  }
+
+  ctx.addContentTypeParser(opts.contentTypes, contentParser)
+}
+
+export default xmlBodyParser

package/lib/home.js

@@ -0,0 +1,15 @@
+async function home () {
+  const { defaultsDeep } = this.app.bajo
+  const { isString, pick } = this.app.bajo.lib._
+  const config = this.getConfig()
+  if (config.home) {
+    if (isString(config.home)) config.home = { path: config.home }
+    await this.instance.get('/', async function (req, reply) {
+      if (!config.home.forward) return await reply.redirectTo(config.home.path)
+      const opts = defaultsDeep(pick(req, ['params', 'query']), pick(config.home, ['params', 'query']))
+      return await reply.forwardTo(config.home.path, opts)
+    })
+  }
+}
+
+export default home

package/lib/log-routes.js

@@ -0,0 +1,19 @@
+function printRoutes () {
+  const { findIndex, orderBy, isArray } = this.app.bajo.lib._
+  let items = []
+  this.routes.forEach(r => {
+    const idx = findIndex(items, { url: r.url })
+    if (idx < 0) items.push({ url: r.url, methods: isArray(r.method) ? r.method : [r.method] })
+    else {
+      if (isArray(r.method)) items[idx].methods.push(...r.method)
+      else items[idx].methods.push(r.method)
+    }
+  })
+  items = orderBy(items, ['url'])
+  this.log.debug('Loaded routes')
+  items.forEach(item => {
+    this.log.debug('- %s (%s)', item.url, item.methods.join('|'))
+  })
+}
+
+export default printRoutes

package/lib/prep-crud.js

@@ -0,0 +1,17 @@
+function prepCrud ({ coll, body, id, req, options, args }) {
+  const { pascalCase } = this.app.bajo
+  const { cloneDeep, get } = this.app.bajo.lib._
+  const opts = cloneDeep(options)
+  const params = this.getParams(req, ...args)
+  for (const k of ['count', 'fields']) {
+    opts[k] = opts[k] ?? params[k]
+  }
+  opts.dataOnly = get(this, 'config.dbColl.dataOnly', false)
+  opts.req = req
+  const recId = id ?? params.id ?? req.query.id
+  const name = pascalCase(coll ?? params.coll)
+  const input = body ?? params.body
+  return { name, recId, input, opts }
+}
+
+export default prepCrud

package/lib/webapp-scope/attach-i18n.js

@@ -0,0 +1,63 @@
+function detect (detector = [], req, reply) {
+  const { get, map, trim, orderBy } = this.app.bajo.lib._
+  const supported = get(this, 'app.bajoI18N.config.supportedLngs', [this.app.bajo.config.lang])
+  const defLang = get(this, 'app.bajoI18N.config.lang', this.app.bajo.config.lang)
+  let lang = null
+  // by route path
+  if (detector.includes('path')) {
+    lang = req.params.lang
+    if (lang && supported.includes(lang)) {
+      req.lang = lang
+      req.langDetector = 'path'
+      return
+    }
+    const length = req.url.split('/').length
+    let url = req.url.replace(`/${lang}`, `/${defLang}`)
+    if (length > 2) url = req.url.replace(`/${lang}/`, `/${defLang}/`)
+    reply.redirectTo(url)
+    return
+  }
+  // by query string
+  lang = null
+  if (detector.includes('qs')) {
+    lang = req.query[this.app.wakatobi.config.qsKey.lang]
+    if (lang && supported.includes(lang)) {
+      req.lang = lang
+      req.langDetector = 'qs'
+      return
+    }
+  }
+  // by header
+  if (detector.includes('header')) {
+    lang = null
+    const accepteds = orderBy(map((req.headers['accept-language'] || '').split(','), a => {
+      const [name, qty] = trim(a || '').split(';').map(i => trim(i))
+      return { name, qty: parseFloat((qty || '').split('=')[1]) || 1 }
+    }), ['qty'], ['desc'])
+    for (const a of accepteds) {
+      if (supported.includes(a.name)) {
+        lang = a.name
+        break
+      }
+    }
+    if (lang) {
+      req.lang = lang
+      req.langDetector = 'header'
+      return
+    }
+  }
+  req.lang = lang ?? defLang
+}
+
+async function attachI18N (detector = [], req, reply) {
+  if (!this.app.bajoI18N) return
+  const { get } = this.app.bajo.lib._
+  detect.call(this, detector, req, reply)
+  const i18n = this.app.bajoI18N.instance.cloneInstance()
+  const defNs = get(req, 'routeOptions.config.ns', 'wakatobi')
+  i18n.setDefaultNamespace(defNs)
+  await i18n.changeLanguage(req.lang)
+  req.i18n = i18n
+}
+
+export default attachI18N

package/lib/webapp-scope/error-handler.js

@@ -0,0 +1,22 @@
+async function errorHandler (ctx, extHandler) {
+  const me = this
+  ctx.setErrorHandler(async function (err, req, reply) {
+    if (err.redirect) {
+      reply.redirect(err.redirect)
+      return
+    }
+    if (err.print) {
+      reply.send(err.print)
+      return
+    }
+    if (me.app.bajo.config.log.level === 'trace' && !['notfound', 'redirect'].includes(err.message)) console.error(err)
+    if (extHandler) return await extHandler.call(me, ctx, err, req, reply)
+    if (err.message === 'notfound' || err.statusCode === 404) {
+      reply.code(err.statusCode)
+      return
+    }
+    reply.code(err.statusCode ?? 500)
+  })
+}
+
+export default errorHandler

package/lib/webapp-scope/handle-compress.js

@@ -0,0 +1,8 @@
+import compress from '@fastify/compress'
+
+async function handleCompress (ctx, options = {}) {
+  if (!options) return
+  await ctx.register(compress, options)
+}
+
+export default handleCompress

package/lib/webapp-scope/handle-cors.js

@@ -0,0 +1,8 @@
+import cors from '@fastify/cors'
+
+async function handleCors (ctx, options = {}) {
+  if (!options) return
+  await ctx.register(cors, options)
+}
+
+export default handleCors

package/lib/webapp-scope/handle-helmet.js

@@ -0,0 +1,8 @@
+import helmet from '@fastify/helmet'
+
+async function handleHelmet (ctx, options = {}) {
+  if (!options) return
+  await ctx.register(helmet, options)
+}
+
+export default handleHelmet

package/lib/webapp-scope/handle-multipart-body.js

@@ -0,0 +1,72 @@
+import multipart from '@fastify/multipart'
+import { promisify } from 'util'
+import { pipeline } from 'stream'
+import path from 'path'
+const pump = promisify(pipeline)
+
+async function onFileHandler () {
+  const { getPluginDataDir } = this.app.bajo
+  const { fs } = this.app.bajo.lib
+  const dir = `${getPluginDataDir(this.name)}/upload`
+  return async function (part) {
+    // 'this' is the fastify context here
+    const filePath = `${dir}/${this.id}/${part.fieldname}@${part.filename}`
+    await fs.ensureDir(path.dirname(filePath))
+    await pump(part.file, fs.createWriteStream(filePath))
+  }
+}
+
+async function handleMultipartBody (ctx, options = {}) {
+  const { defaultsDeep, importPkg, isSet } = this.app.bajo
+  const { isArray, map, trim, isPlainObject, isEmpty } = this.app.bajo.lib._
+  const parseVar = await importPkg('dotenv-parse-variables')
+  const opts = defaultsDeep(options, this.config.multipart)
+  const onFile = await onFileHandler.call(this)
+  opts.onFile = onFile
+  await ctx.register(multipart, opts)
+
+  function normalizeValue (value) {
+    if (!isSet(value)) return
+    if (value === 'null') value = null
+    else if (value === 'undefined') value = undefined
+    else {
+      const val = trim(value)
+      if (['{', '['].includes(val[0])) {
+        try {
+          const parsed = JSON.parse(val)
+          if (isPlainObject(parsed) || isArray(parsed)) value = parsed
+        } catch (err) {
+          value = val
+        }
+      } else value = parseVar({ item: value }).item
+    }
+    return value
+  }
+
+  ctx.addHook('preValidation', async function (req, reply) {
+    if (req.isMultipart() && opts.attachFieldsToBody === true) {
+      const body = Object.fromEntries(
+        Object.keys(req.body || {}).map((key) => {
+          let item = req.body[key]
+          let value
+          if (key.endsWith('[]') && !isArray(item)) item = [item]
+          if (isArray(item)) {
+            value = map(item, i => normalizeValue(i.value))
+          } else {
+            value = normalizeValue(item.value)
+          }
+          key = key.replace('[]', '')
+          return [key, value]
+        })
+      )
+      const newBody = {}
+      for (const k in body) {
+        if (isEmpty(k)) continue
+        newBody[k] = body[k]
+      }
+      req.body = newBody
+    }
+  })
+}
+
+export default handleMultipartBody

package/lib/webapp-scope/handle-rate-limit.js

@@ -0,0 +1,9 @@
+import rateLimit from '@fastify/rate-limit'
+
+async function handleRateLimit (ctx, options = {}) {
+  const { cloneDeep } = this.app.bajo.lib._
+  if (!options) return
+  await ctx.register(rateLimit, cloneDeep(options))
+}
+
+export default handleRateLimit

package/lib/webapp-scope/is-route-disabled.js

@@ -0,0 +1,28 @@
+function santizeMethods (methods = '*') {
+  if (['*', 'all'].includes(methods)) methods = ['GET', 'POST', 'PUT', 'PATCH', 'DELETE']
+  else methods = methods.split(',').map(s => s.trim())
+  return methods
+}
+
+async function isRouteDisabled (url, method, matchers = []) {
+  const { outmatch } = this.app.bajo
+  const { intersection, cloneDeep } = this.app.bajo.lib._
+  const items = []
+  for (const m of cloneDeep(matchers)) {
+    m.path = this.app.wakatobi.routePath(m.path)
+    m.methods = santizeMethods(m.methods)
+    items.push(m)
+  }
+  const matcher = items.find(i => {
+    const isMatch = outmatch(i.path)
+    return isMatch(url)
+  })
+  if (!matcher) return false
+  if (Array.isArray(method)) {
+    const result = intersection(method, matcher.methods)
+    return result.length > 0
+  }
+  return matcher.methods.includes(method)
+}
+
+export default isRouteDisabled

package/lib/webapp-scope/rerouted-path.js

@@ -0,0 +1,12 @@
+async function reroutedPath (path, mapper = {}) {
+  const { routePath } = this.app.wakatobi
+  let result
+  for (let k in mapper) {
+    const v = routePath(mapper[k])
+    k = routePath(k)
+    if (k === path) result = v
+  }
+  return result
+}
+
+export default reroutedPath

package/lib/webapp-scope/route-hook.js

@@ -0,0 +1,13 @@
+async function routeHook (ns) {
+  const ctx = this.app[ns].instance
+  const { runHook } = this.app.bajo
+  const { hookTypes } = this.app.wakatobi
+  for (const hook of hookTypes) {
+    ctx.addHook(hook, async function (...args) {
+      const context = this // encapsulated fastify scope
+      await runHook(`${ns}:${hook}`, context, ...args)
+    })
+  }
+}
+
+export default routeHook

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "waibu",
+  "version": "1.0.0",
+  "description": "Web Framework for Bajo",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "type": "module",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ardhi/waibu.git"
+  },
+  "keywords": [
+    "web",
+    "webserver",
+    "bajo",
+    "framework",
+    "fastify",
+    "modular"
+  ],
+  "author": "Ardhi Lukianto <ardhi@lukianto.com>",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/ardhi/waibu/issues"
+  },
+  "homepage": "https://github.com/ardhi/waibu#readme",
+  "dependencies": {
+    "@fastify/accepts": "^4.3.0",
+    "@fastify/compress": "^7.0.3",
+    "@fastify/cookie": "^9.3.1",
+    "@fastify/cors": "^9.0.1",
+    "@fastify/flash": "^5.2.0",
+    "@fastify/formbody": "^7.4.0",
+    "@fastify/helmet": "^11.1.1",
+    "@fastify/multipart": "^8.3.0",
+    "@fastify/rate-limit": "^9.1.0",
+    "@fastify/reply-from": "^9.8.0",
+    "@fastify/sensible": "^5.6.0",
+    "@fastify/session": "^10.9.0",
+    "@fastify/static": "github:ardhi/fastify-static#v7.x",
+    "@fastify/under-pressure": "^8.5.1",
+    "fastify": "^4.28.1",
+    "fastify-no-icon": "^6.0.0"
+  }
+}