dobo 2.14.1 → 2.16.0

package/extend/bajo/intl/en-US.json

@@ -148,6 +148,7 @@
   "maxLimitWarning%s%s": "Records per page (%s rows) above the allowed threshold (%s rows)",
   "hardCapWarning%s%s": "Max records returned (%s rows) above the allowed threshold (%s rows)",
   "maxPageError%s%s": "Page number (%s) above the allowed threshold (%s)",
+  "duplicateRefKeys%s%s": "Duplicate reference keys found in '%s' (%s)",
   "field": {
     "id": "ID",
     "code": "Kode",

package/extend/bajo/intl/id.json

@@ -146,6 +146,7 @@
   "maxLimitWarning%s%s": "Data per halaman (%s baris) melampaui batas yang diijinkan (%s baris)",
   "hardCapWarning%s%s": "Maksimum data yang dihasilkan (%s baris) melampaui batas yang diijinkan (%s baris)",
   "maxPageError%s%s": "Nomor halaman (%s) melampaui batas yang diijinkan (%s)",
+  "duplicateRefKeys%s%s": "Ditemukan kunci referensi duplikat di '%s' (%s)",
   "field": {
     "id": "ID",
     "code": "Kode",

package/extend/dobo/feature/created-at.js

@@ -1,9 +1,9 @@
 async function createdAt (opts = {}) {
-  opts.fieldName = opts.fieldName ?? 'createdAt'
+  opts.field = opts.field ?? 'createdAt'
   opts.noOverwrite = opts.noOverwrite ?? false
   return {
     properties: [{
-      name: opts.fieldName,
+      name: opts.field,
       type: 'datetime',
       index: true
     }],
@@ -11,8 +11,8 @@ async function createdAt (opts = {}) {
       name: 'beforeCreateRecord',
       handler: async function (body, options) {
         const { isSet } = this.app.lib.aneka
-        if (opts.noOverwrite) body[opts.fieldName] = new Date()
-        else if (!isSet(body[opts.fieldName])) body[opts.fieldName] = new Date()
+        if (opts.noOverwrite) body[opts.field] = new Date()
+        else if (!isSet(body[opts.field])) body[opts.field] = new Date()
       }
     }]
   }

package/extend/dobo/feature/dt.js

@@ -1,8 +1,8 @@
 async function dt (opts = {}) {
-  opts.fieldName = opts.fieldName ?? 'dt'
+  opts.field = opts.field ?? 'dt'
   return {
     properties: [{
-      name: opts.fieldName ?? 'dt',
+      name: opts.field ?? 'dt',
       type: 'datetime',
       required: opts.required ?? true,
       index: opts.index ?? true

package/extend/dobo/feature/immutable.js

@@ -1,27 +1,28 @@
-async function beforeRemoveRecord (id, opts) {
+async function beforeRemoveRecord (id, opts, options) {
   const { get } = this.app.lib._
+  if (get(options, 'req.user.interSiteAdmin')) return
   const record = await this.driver.getRecord(this, id)
-  const immutable = get(record.data, opts.fieldName)
+  const immutable = get(record.data, opts.field)
   if (immutable) throw this.plugin.error('recordImmutable%s%s', id, this.name, { statusCode: 423 })
 }
 
 async function immutable (opts = {}) {
-  opts.fieldName = opts.fieldName ?? '_immutable'
+  opts.field = opts.field ?? '_immutable'
   return {
     properties: {
-      name: opts.fieldName,
+      name: opts.field,
       type: 'boolean',
       hidden: true
     },
     hooks: [{
       name: 'beforeUpdateRecord',
       handler: async function (id, body, options) {
-        await beforeRemoveRecord.call(this, id, opts)
+        await beforeRemoveRecord.call(this, id, opts, options)
       }
     }, {
       name: 'beforeRemoveRecord',
       handler: async function (id, options) {
-        await beforeRemoveRecord.call(this, id, opts)
+        await beforeRemoveRecord.call(this, id, opts, options)
       }
     }]
   }

package/extend/dobo/feature/removed-at.js

@@ -6,24 +6,24 @@ async function beforeFindRecord ({ filter = {} }, opts) {
     if (filter.query.$and) q.$and.push(...filter.query.$and)
     else q.$and.push(filter.query)
   }
-  q.$and.push(set({}, opts.fieldName, null))
+  q.$and.push(set({}, opts.field, null))
   filter.query = q
 }
 
 async function afterGetRecord ({ id, record = {} }, opts) {
   const { isEmpty } = this.app.lib._
-  if (!isEmpty(record.data[opts.fieldName])) throw this.error('recordNotFound%s%s', id, this.name, { statusCode: 404 })
+  if (!isEmpty(record.data[opts.field])) throw this.error('recordNotFound%s%s', id, this.name, { statusCode: 404 })
 }
 
 async function beforeCreateRecord ({ body = {} }, opts) {
-  delete body[opts.fieldName]
+  delete body[opts.field]
 }
 
 async function removedAt (opts = {}) {
-  opts.fieldName = opts.fieldName ?? '_removedAt'
+  opts.field = opts.field ?? '_removedAt'
   return {
     properties: {
-      name: opts.fieldName,
+      name: opts.field,
       type: 'datetime',
       index: true,
       hidden: true
@@ -52,7 +52,7 @@ async function removedAt (opts = {}) {
       name: 'beforeRemoveRecord',
       handler: async function (id, options) {
         const { set } = this.app.lib._
-        const body = set({}, opts.fieldName, new Date())
+        const body = set({}, opts.field, new Date())
         const record = await this.driver.recordUpdate(this, id, body, { noResult: false })
         options.record = { oldData: record.oldData }
       }

package/extend/dobo/feature/unique.js

@@ -2,11 +2,11 @@ import crypto from 'crypto'
 
 async function unique (opts = {}) {
   const { omit } = this.app.lib._
-  opts.fieldName = opts.fieldName ?? 'id'
+  opts.field = opts.field ?? 'id'
   opts.fields = opts.fields ?? []
   return {
     properties: [{
-      name: opts.fieldName,
+      name: opts.field,
       type: 'string',
       maxLength: 32,
       required: true,
@@ -16,12 +16,12 @@ async function unique (opts = {}) {
       name: 'beforeCreateRecord',
       level: 1000,
       handler: async function (body, options) {
-        if (opts.fields.length === 0) opts.fields = omit(this.properties.map(prop => prop.name), [opts.fieldName])
+        if (opts.fields.length === 0) opts.fields = omit(this.properties.map(prop => prop.name), [opts.field])
         const item = {}
         for (const f of opts.fields) {
           item[f] = body[f]
         }
-        body[opts.fieldName] = crypto.createHash('md5').update(JSON.stringify(item)).digest('hex')
+        body[opts.field] = crypto.createHash('md5').update(JSON.stringify(item)).digest('hex')
       }
     }]
   }

package/extend/dobo/feature/updated-at.js

@@ -1,24 +1,24 @@
 async function updatedAt (opts = {}) {
   const { isSet } = this.app.lib.aneka
-  opts.fieldName = opts.fieldName ?? 'updatedAt'
+  opts.field = opts.field ?? 'updatedAt'
   opts.noOverwrite = opts.noOverwrite ?? false
   return {
     properties: {
-      name: opts.fieldName,
+      name: opts.field,
       type: 'datetime',
       index: true
     },
     hooks: [{
       name: 'beforeCreateRecord',
       handler: async function (body, options) {
-        if (opts.noOverwrite) body[opts.fieldName] = new Date()
-        else if (!isSet(body[opts.fieldName])) body[opts.fieldName] = new Date()
+        if (opts.noOverwrite) body[opts.field] = new Date()
+        else if (!isSet(body[opts.field])) body[opts.field] = new Date()
       }
     }, {
       name: 'beforeUpdateRecord',
       handler: async function (id, body, options) {
-        if (opts.noOverwrite) body[opts.fieldName] = new Date()
-        else if (!isSet(body[opts.fieldName])) body[opts.fieldName] = new Date()
+        if (opts.noOverwrite) body[opts.field] = new Date()
+        else if (!isSet(body[opts.field])) body[opts.field] = new Date()
       }
     }]
   }

package/extend/waibuMpa/route/attachment/@model/@id/@field/@file.js

@@ -7,7 +7,7 @@ async function attachment (req, reply) {
   const { fs } = this.app.lib
   const mdl = this.app.dobo.getModel(req.params.model)
   const type = req.query.type
-  const items = (await mdl.listAttachments({ id: req.params.id, fieldName: req.params.field, file: '*', type })) ?? []
+  const items = (await mdl.listAttachments({ id: req.params.id, field: req.params.field, file: '*', type })) ?? []
   let item
   if (req.params.file === '_first') item = items[0]
   else if (req.params.file === '_last') item = last(items)

package/index.js

@@ -1,3 +1,4 @@
+import nql from '@tryghost/nql'
 import collectConnections from './lib/collect-connections.js'
 import collectDrivers from './lib/collect-drivers.js'
 import collectFeatures from './lib/collect-features.js'
@@ -81,7 +82,7 @@ const propertyType = {
   }
 }
 
-const commonPropertyTypes = ['name', 'type', 'required', 'rules', 'validator', 'ref', 'default', 'values', 'rulesMsg', 'immutable', 'feature']
+const commonPropertyTypes = ['name', 'type', 'required', 'rules', 'validator', 'ref', 'default', 'values', 'rulesMsg', 'immutable', 'feature', 'format']
 
 /**
  * Plugin factory
@@ -150,8 +151,8 @@ async function factory (pkgName) {
           filter: {
             limit: 25, // num of records per page
             maxLimit: 200, // max num of records per page
-            maxPage: 50, // max allowed page number
-            sort: ['dt:-1', 'updatedAt:-1', 'updated_at:-1', 'createdAt:-1', 'createdAt:-1', 'ts:-1', 'username', 'name']
+            maxPage: 400, // max allowed page number
+            sort: ['dt:-1', 'updatedAt:-1', 'createdAt:-1', 'ts:-1', 'username', 'name']
           },
           cache: {
             ttlDur: '10s'
@@ -496,13 +497,10 @@ async function factory (pkgName) {
     }
 
     getDefaultValues = (options = {}) => {
-      const { get } = this.app.lib._
-      const config = this.app.dobo.config
-      const limit = get(options, 'req.site.setting.dobo.default.filter.limit', config.default.filter.limit)
-      const maxLimit = get(options, 'req.site.setting.dobo.default.filter.maxLimit', config.default.filter.maxLimit)
-      const maxPage = get(options, 'req.site.setting.dobo.default.filter.maxPage', config.default.filter.maxPage)
-      const hardCap = get(options, 'req.site.setting.dobo.default.hardCap', config.default.hardCap)
-      const warnings = get(options, 'req.site.setting.dobo.default.warnings', config.default.warnings)
+      const key = 'default.filter'
+      let config = this.app.dobo.getConfig(key)
+      if (options.req) config = options.req.getSetting(`dobo:${key}`, config)
+      const { limit, maxLimit, maxPage, hardCap, warnings } = config
       const t = options.req ? options.req.t : this.t
       return { limit, maxLimit, hardCap, maxPage, warnings, t }
     }
@@ -518,6 +516,63 @@ async function factory (pkgName) {
         }
       }
     }
+
+    parseNql = (text) => {
+      const sanitized = text.split('+').map(item => {
+        const [key, ...rest] = item.split(':').map(i => i.trim())
+        let value = rest.join(':')
+        const neg = value[1] === '-' ? '-' : ''
+        if ((value[0] === '{' || value[1] === '{') && value[value.length - 1] === '}') {
+          if (value[0] === '-') value = value.slice(1)
+          const items = value.slice(1, -1).split(',')
+          value = `${neg}>=${items[0]}+${key}:${neg}<=${items[1]}`
+        }
+        return `${key}:${value}`
+      }).join('+')
+      return nql(sanitized).parse()
+    }
+
+    parseQuery = (query, silent = true) => {
+      const { isPlainObject, trim } = this.app.lib._
+      let result = {}
+      if (isPlainObject(query)) result = query
+      else {
+        query = trim(query)
+        try {
+          if (query.startsWith('{')) result = JSON.parse(query)
+          else result = this.parseNql(query)
+        } catch (err) {
+          if (silent) return {}
+          throw err
+        }
+      }
+      try {
+        const text = JSON.stringify(result)
+        if (text.includes('["__REGEXP__",')) result = this.reviveRegexInJson(text)
+      } catch (err) {}
+      return result
+    }
+
+    replaceRegexInJson = (input = {}, returnString = true) => {
+      const { isString } = this.app.lib._
+      if (isString(input)) input = JSON.parse(input) ?? {}
+      const result = JSON.stringify(input, (key, value) => {
+        if (value instanceof RegExp) return ['__REGEXP__', value.source, value.flags]
+        return value
+      })
+      if (returnString) return result
+      return JSON.parse(result)
+    }
+
+    reviveRegexInJson = (input, returnObject = true) => {
+      const { isPlainObject } = this.app.lib._
+      if (isPlainObject(input)) input = JSON.stringify(input)
+      const result = JSON.parse(input, (key, value) => {
+        if (Array.isArray(value) && value[0] === '__REGEXP__') return { $regex: new RegExp(value[1], value[2]) }
+        return value
+      })
+      return returnObject ? result : JSON.stringify(result)
+    }
   }
 
   return Dobo

package/lib/collect-models.js

@@ -10,7 +10,7 @@ import actionFactory from './factory/action.js'
  * @param {Array} [indexes] - Container array to fill up found index
  */
 async function sanitizeProp (model, prop, indexes) {
-  const { isEmpty, isString, keys, pick, isArray, isPlainObject, camelCase } = this.app.lib._
+  const { isEmpty, isString, keys, pick, isArray, isPlainObject } = this.app.lib._
   const allPropKeys = this.getAllPropertyKeys(model.connection.driver)
   const propType = this.constructor.propertyType
   if (isString(prop)) {
@@ -25,7 +25,7 @@ async function sanitizeProp (model, prop, indexes) {
   if (isArray(prop.values)) {
     prop.values = prop.values.map(item => {
       if (isPlainObject(item)) return pick(item, ['value', 'text'])
-      return { value: item, text: camelCase(item) }
+      return { value: item, text: item }
     })
   } else if (!isString(prop.values)) delete prop.values
   if (prop.index) {
@@ -39,7 +39,7 @@ async function sanitizeProp (model, prop, indexes) {
   else {
     const feature = this.getFeature(prop.type)
     if (!feature) this.fatal('unknownPropType%s%s', prop.type, model.name)
-    await applyFeature.call(this, model, feature, { name: prop.name }, indexes)
+    await applyFeature.call(this, model, feature, { field: prop.name }, indexes)
   }
 }
 
@@ -74,12 +74,13 @@ async function findAllProps (model, inputs = [], indexes = [], isExtender) {
  */
 async function applyFeature (model, feature, options, indexes, isExtender) {
   const { isArray, findIndex } = this.app.lib._
-  if (feature.name === 'dobo:unique' && options.fieldName === 'id') {
+  if (feature.name === 'dobo:unique' && options.field === 'id') {
     const idx = findIndex(model.properties, { name: 'id' })
     if (idx > -1) model.properties.pullAt(idx)
   }
   const item = await feature.handler(options)
   if (item.rules) model.rules.push(...item.rules)
+  if (item.scanables) model.scanables.push(...item.scanables)
   if (!isArray(item.properties)) item.properties = [item.properties]
   for (const prop of item.properties) {
     prop.feature = `${feature.plugin.ns}:${feature.name}`
@@ -137,24 +138,29 @@ async function findAllIndexes (model, inputs = [], indexes = []) {
 export async function sanitizeRef (model, models) {
   const { find, isString, pullAt } = this.app.lib._
   if (!models) models = this.models
+  const _refKeys = []
   for (const prop of model.properties) {
     const ignored = []
     for (const key in prop.ref ?? {}) {
+      _refKeys.push(key)
       let ref = prop.ref[key]
       if (isString(ref)) {
-        ref = { propName: ref }
+        ref = { field: ref }
       }
+      ref.field = ref.field ?? 'id'
       ref.type = ref.type ?? '1:1'
+      ref.searchField = ref.searchField ?? model.scanables[0] ?? ref.field
+      ref.labelField = ref.labelField ?? ref.searchField
       const rModel = find(models, { name: ref.model })
       if (!rModel) {
         ignored.push(key)
         this.log.warn('notFound%s%s', this.t('model'), ref.model)
         continue
       }
-      const rProp = find(rModel.properties, { name: ref.propName })
+      const rProp = find(rModel.properties, { name: ref.field })
       if (!rProp) {
         ignored.push(key)
-        this.log.warn('notFound%s%s', this.t('property'), `${ref.propName}@${ref.model}`)
+        this.log.warn('notFound%s%s', this.t('property'), `${ref.field}@${ref.model}`)
         continue
       }
       ref.fields = ref.fields ?? '*'
@@ -172,6 +178,8 @@ export async function sanitizeRef (model, models) {
       delete prop.ref[key]
     }
   }
+  const dupes = _refKeys.filter((item, index) => _refKeys.indexOf(item) !== index)
+  if (dupes.length > 0) throw this.error('duplicateRefKeys%s%s', model.name, dupes.join(', '))
 }
 
 /**
@@ -333,7 +341,7 @@ async function collectModels () {
     me.models.push(model)
   }
   for (const model of me.models) {
-    await sanitizeRef.call(this, model, me.models, true)
+    await sanitizeRef.call(this, model, me.models)
     me.log.trace('- %s', model.name)
   }
   this.log.debug('collected%s%d', this.t('model'), this.models.length)

package/lib/factory/action.js

@@ -13,9 +13,9 @@ const methods = {
   createHistogram: ['params'],
   createAttachment: ['id'],
   findAttachment: ['id'],
-  getAttachment: ['id', 'fieldName', 'file'],
+  getAttachment: ['id', 'field', 'file'],
   listAttachment: ['params'],
-  removeAttachment: ['id', 'fieldName', 'file'],
+  removeAttachment: ['id', 'field', 'file'],
   updateAttachment: ['id']
 }
 
@@ -123,8 +123,8 @@ async function actionFactory () {
       return this
     }
 
-    fieldName = value => {
-      this._fieldName = value
+    field = value => {
+      this._field = value
       return this
     }
 
@@ -147,8 +147,8 @@ async function actionFactory () {
       return await this.model[this.name](...args)
     }
 
-    dispose () {
-      super.dispose()
+    dispose = async () => {
+      await super.dispose()
       this.model = null
       this._options = null
     }

package/lib/factory/connection.js

@@ -50,8 +50,8 @@ async function connectionFactory () {
       if (client) this.client = client
     }
 
-    dispose () {
-      super.dispose()
+    dispose = async () => {
+      await super.dispose()
       this.driver = null
     }
   }

package/lib/factory/feature.js

@@ -19,8 +19,8 @@ async function featureFactory () {
       this.handler = options.handler
     }
 
-    dispose () {
-      super.dispose()
+    dispose = async () => {
+      await super.dispose()
       this.name = null
       this.handler = null
     }

package/lib/factory/model/_util.js

@@ -1,5 +1,4 @@
 import path from 'path'
-import nql from '@tryghost/nql'
 
 export const omittedOptionsKeys = ['req', 'reply', 'trx']
 
@@ -115,12 +114,12 @@ export async function mergeAttachmentInfo (rec, source, options = {}) {
   }
 }
 
-export async function getAttachmentPath (id, fieldName, file, options = {}) {
+export async function getAttachmentPath (id, field, file, options = {}) {
   const { getPluginDataDir } = this.app.bajo
   const { fs } = this.app.lib
   const dir = `${getPluginDataDir(this.app.dobo.ns)}/attachment/${this.name}/${id}`
   if (options.dirOnly) return dir
-  const path = fieldName ? `${dir}/${fieldName}/${file}` : `${dir}/${file}`
+  const path = field ? `${dir}/${field}/${file}` : `${dir}/${file}`
   if (!fs.existsSync(path)) throw this.app.dobo.error('notFound')
   return path
 }
@@ -134,11 +133,11 @@ export async function copyAttachment (id, options = {}) {
   const result = []
   if (files.length === 0) return result
   for (const f of files) {
-    let [fieldName, ...parts] = path.basename(f).split('@')
+    let [field, ...parts] = path.basename(f).split('@')
     if (parts.length === 0) continue
-    fieldName = setField ?? fieldName
+    field = setField ?? field
     const file = setFile ?? parts.join('@')
-    const opts = { source: f, fieldName, file, mimeType, stats, req }
+    const opts = { source: f, field, file, mimeType, stats, req }
     const rec = await this.createAttachment(id, opts)
     if (!rec) continue
     delete rec.dir
@@ -162,8 +161,20 @@ export async function handleAttachmentUpload (id, trigger, options = {}) {
   return copyAttachment.call(this, id, { req, mimeType, stats, setFile, setField })
 }
 
+async function _getRef ({ ref, rModel, prop, key, options, filter } = {}) {
+  if (!((typeof options.refs === 'string' && ['*', 'all'].includes(options.refs)) || options.refs.includes(key))) return
+  if (ref.fields.length === 0) return
+  const { formatValue, retainOriginalValue } = options
+  const fields = [...ref.fields]
+  if (!fields.includes(prop.name)) fields.push(prop.name)
+  const rOptions = { dataOnly: true, refs: [], formatValue, retainOriginalValue, fields }
+  const results = await rModel.findRecord(filter, rOptions)
+  return { rOptions, results }
+}
+
 export async function getSingleRef (record = {}, options = {}) {
   const { isSet } = this.app.lib.aneka
+  const { parseQuery } = this.app.dobo
   const { get } = this.app.lib._
   const props = this.properties.filter(p => isSet(p.ref) && !(options.hidden ?? []).includes(p.name))
   const refs = {}
@@ -172,21 +183,21 @@ export async function getSingleRef (record = {}, options = {}) {
     for (const prop of props) {
       for (const key in prop.ref) {
         try {
-          if (!((typeof options.refs === 'string' && ['*', 'all'].includes(options.refs)) || options.refs.includes(key))) continue
-          const ref = prop.ref[key]
-          if (ref.fields.length === 0) continue
           if (get(record, `_ref.${key}`)) continue
-          const rModel = this.app.dobo.getModel(ref.model)
-          const query = {}
-          query[ref.propName] = record[prop.name]
-          if (ref.propName === 'id') query[ref.propName] = this.sanitizeId(query[ref.propName])
-          const rFilter = { query }
-          const rOptions = { dataOnly: true, refs: [] }
-          const results = await rModel.findRecord(rFilter, rOptions)
-          const fields = [...ref.fields]
+          const ref = prop.ref[key]
+          const rModel = this.app.dobo.getModel(ref.model, true)
+          if (!rModel) return
+          let query = {}
+          query[ref.field] = record[prop.name]
+          if (ref.field === 'id') query[ref.field] = this.sanitizeId(query[ref.field])
+          if (ref.query) query = { $and: [query, parseQuery(ref.query)] }
+          const filter = { query }
+          const resp = await _getRef.call(this, { ref, rModel, prop, key, options, filter })
+          if (!resp) continue
+          const { rOptions, results } = resp
           const data = []
           for (const res of results) {
-            data.push(await rModel.sanitizeRecord(res, { fields }))
+            data.push(await rModel.sanitizeRecord(res, rOptions))
           }
           refs[key] = ['1:1'].includes(ref.type) ? data[0] : data
         } catch (err) {}
@@ -199,35 +210,34 @@ export async function getSingleRef (record = {}, options = {}) {
 export async function getMultiRefs (records = [], options = {}) {
   const { isSet } = this.app.lib.aneka
   const { uniq, without, get } = this.app.lib._
+  const { parseQuery } = this.app.dobo
   const props = this.properties.filter(p => isSet(p.ref) && !(options.hidden ?? []).includes(p.name))
   options.refs = options.refs ?? []
   if (props.length > 0) {
     for (const prop of props) {
       for (const key in prop.ref) {
         try {
-          if (!((typeof options.refs === 'string' && ['*', 'all'].includes(options.refs)) || options.refs.includes(key))) continue
-          const ref = prop.ref[key]
-          if (ref.fields.length === 0) continue
-          if (ref.type !== '1:1') continue
           if (get(records, `0._ref.${key}`)) continue
-          const rModel = this.app.dobo.getModel(ref.model)
+          const ref = prop.ref[key]
+          const rModel = this.app.dobo.getModel(ref.model, true)
+          if (!rModel) return
           let matches = []
           for (const r of records) {
             matches.push(rModel.sanitizeId(r[prop.name]))
           }
           matches = uniq(without(matches, undefined, null, NaN))
-          const query = {}
-          query[ref.propName] = { $in: matches }
-          const rFilter = { query, limit: matches.length }
-          const rOptions = { dataOnly: true, refs: [] }
-          const results = await rModel.findRecord(rFilter, rOptions)
-          const fields = [...ref.fields]
-          if (!fields.includes(prop.name)) fields.push(prop.name)
+          let query = {}
+          query[ref.field] = { $in: matches }
+          if (ref.query) query = { $and: [query, parseQuery(ref.query)] }
+          const filter = { query, limit: matches.length }
+          const resp = await _getRef.call(this, { ref, rModel, prop, key, options, filter })
+          if (!resp) continue
+          const { rOptions, results } = resp
           for (const i in records) {
             records[i]._ref = records[i]._ref ?? {}
             const rec = records[i]
-            const res = results.find(res => (res[ref.propName] + '') === rec[prop.name] + '')
-            if (res) records[i]._ref[key] = await rModel.sanitizeRecord(res, { fields })
+            const res = results.find(res => (res[ref.field] + '') === rec[prop.name] + '')
+            if (res) records[i]._ref[key] = await rModel.sanitizeRecord(res, rOptions)
             else records[i]._ref[key] = {}
           }
         } catch (err) {}
@@ -236,31 +246,16 @@ export async function getMultiRefs (records = [], options = {}) {
   }
 }
 
-export function parseNql (text) {
-  const sanitized = text.split('+').map(item => {
-    const [key, ...rest] = item.split(':').map(i => i.trim())
-    let value = rest.join(':')
-    const neg = value[1] === '-' ? '-' : ''
-    if ((value[0] === '{' || value[1] === '{') && value[value.length - 1] === '}') {
-      if (value[0] === '-') value = value.slice(1)
-      const items = value.slice(1, -1).split(',')
-      value = `${neg}>=${items[0]}+${key}:${neg}<=${items[1]}`
-    }
-    return `${key}:${value}`
-  }).join('+')
-
-  return nql(sanitized).parse()
-}
-
 export function buildFilterQuery (filter = {}) {
   const { trim, find, isString, isPlainObject } = this.app.lib._
+  const { parseNql } = this.app.dobo
   let query = filter.query ?? {}
   let q = {}
   if (isString(query)) {
     try {
       query = trim(query)
       if (query.startsWith('{')) q = JSON.parse(query) // JSON formatted query
-      else if (query.includes(':')) q = parseNql.call(this, query) // NQL
+      else if (query.includes(':')) q = parseNql(query) // NQL
       else {
         let scanables = [...this.scanables]
         if (scanables.length === 0) scanables = [...this.sortables]
@@ -273,8 +268,8 @@ export function buildFilterQuery (filter = {}) {
           if (query[query.length - 1] === '*') return `${f}:~^'${query.replaceAll('*', '')}'`
           return `${f}:~'${query.replaceAll('*', '')}'`
         })
-        if (parts.length === 1) q = nql(parts[0]).parse()
-        else if (parts.length > 1) q = nql(parts.join(',')).parse()
+        if (parts.length === 1) q = parseNql(parts[0])
+        else if (parts.length > 1) q = parseNql(parts.join(','))
       }
     } catch (err) {
       this.plugin.error('invalidQuery', { orgMessage: err.message })
@@ -366,16 +361,10 @@ export function buildFilterSearch (filter = {}) {
 }
 
 export function replaceIdInQuerySearch (filter) {
-  // query
-  const query = JSON.stringify(filter.query ?? {}, (key, value) => {
-    if (value instanceof RegExp) return ['__REGEXP__', value.source, value.flags]
-    return value
-  }).replaceAll('"id"', `"${this.driver.idField.name}"`)
+  const { replaceRegexInJson, reviveRegexInJson } = this.app.dobo
+  const query = replaceRegexInJson(filter.query).replaceAll('"id"', `"${this.driver.idField.name}"`)
   try {
-    filter.query = JSON.parse(query, (key, value) => {
-      if (Array.isArray(value) && value[0] === '__REGEXP__') return new RegExp(value[1], value[2])
-      return value
-    })
+    filter.query = reviveRegexInJson(query)
   } catch (err) {}
   // search
   const search = JSON.stringify(filter.search ?? {}).replaceAll('"id"', `"${this.driver.idField.name}"`)

package/lib/factory/model/create-attachment.js

@@ -7,17 +7,17 @@ async function createAttachment (...args) {
   const [id, opts = {}] = args
   const { fs } = this.app.lib
   const { isEmpty } = this.app.lib._
-  const { source, fieldName = 'file', file, fullPath, stats, mimeType, req } = opts
+  const { source, field = 'file', file, fullPath, stats, mimeType, req } = opts
   if (isEmpty(file)) return
   if (!source) throw this.plugin.error('isMissing%s', this.plugin.t('field.source'))
-  const baseDir = await getAttachmentPath.call(this, id, fieldName, file, { dirOnly: true })
-  let dir = `${baseDir}/${fieldName}`
-  if ((fieldName || '').endsWith('[]')) dir = `${baseDir}/${fieldName.replace('[]', '')}`
+  const baseDir = await getAttachmentPath.call(this, id, field, file, { dirOnly: true })
+  let dir = `${baseDir}/${field}`
+  if ((field || '').endsWith('[]')) dir = `${baseDir}/${field.replace('[]', '')}`
   const dest = `${dir}/${file}`.replaceAll('//', '/')
   await fs.ensureDir(dir)
   await fs.copy(source, dest)
   const rec = {
-    field: fieldName === '' ? undefined : fieldName,
+    field: field === '' ? undefined : field,
     dir,
     file
   }

package/lib/factory/model/find-attachment.js

@@ -14,12 +14,12 @@ async function findAttachment (...args) {
   const recs = []
   for (const f of files) {
     const item = f.replace(dir, '')
-    let [, fieldName, file] = item.split('/')
+    let [, field, file] = item.split('/')
     if (!file) {
-      file = fieldName
-      fieldName = null
+      file = field
+      field = null
     }
-    const rec = { fieldName, file }
+    const rec = { field, file }
     await mergeAttachmentInfo.call(this, rec, f, { mimeType, fullPath, stats })
     recs.push(rec)
   }

package/lib/factory/model/get-attachment.js

@@ -3,11 +3,11 @@ const action = 'getAttachment'
 async function getAttachment (...args) {
   if (!this.attachment) return
   if (args.length === 0) return this.action(action, ...args)
-  let [id, fieldName, file, opts = {}] = args
+  let [id, field, file, opts = {}] = args
   const { find } = this.app.lib._
   const all = await this.findAttachment(id, opts)
-  if (fieldName === 'null') fieldName = null
-  const data = find(all, { fieldName, file })
+  if (field === 'null') field = null
+  const data = find(all, { field, file })
   if (!data) throw this.error('notFound', { statusCode: 404 })
   return data
 }

package/lib/factory/model/list-attachment.js

@@ -10,10 +10,10 @@ async function listAttachment (...args) {
   const mime = await importPkg('waibu:mime')
   const { fastGlob } = this.app.lib
 
-  const { id = '*', fieldName = '*', file = '*', type } = params
+  const { id = '*', field = '*', file = '*', type } = params
   const { uriEncoded = true } = opts
   const root = `${getPluginDataDir('dobo')}/attachment`
-  let pattern = `${root}/${this.name}/${id}/${fieldName}/${file}`
+  let pattern = `${root}/${this.name}/${id}/${field}/${file}`
   if (type === 'image') pattern += '.{jpg,jpeg,gif,png,webp,avif,svg}'
   else if (type === 'video') pattern += '.{mp4,m4v,webm,mov,qt,mkv,ogg,ogv}'
   else if (type) pattern += `.${type}`
@@ -26,12 +26,12 @@ async function listAttachment (...args) {
       fileName: path.basename(fullPath),
       fullPath,
       mimeType,
-      params: { model: this.name, id, fieldName, file }
+      params: { model: this.name, id, field, file }
     }
     if (this.app.waibuMpa) {
       const { routePath } = this.app.waibu
-      const [, _model, _id, _fieldName, _file] = fullPath.split('/')
-      row.url = routePath(`dobo:/attachment/${kebabCase(_model)}/${_id}/${_fieldName}/${_file}`)
+      const [, _model, _id, _field, _file] = fullPath.split('/')
+      row.url = routePath(`dobo:/attachment/${kebabCase(_model)}/${_id}/${_field}/${_file}`)
     }
     return row
   })

package/lib/factory/model/remove-attachment.js

@@ -4,9 +4,9 @@ const action = 'removeAttachment'
 async function removeAttachment (...args) {
   if (!this.attachment) return
   if (args.length === 0) return this.action(action, ...args)
-  const [id, fieldName, file, opts = {}] = args
+  const [id, field, file, opts = {}] = args
   const { fs } = this.app.lib
-  const path = await getAttachmentPath.call(this, id, fieldName, file)
+  const path = await getAttachmentPath.call(this, id, field, file)
   const { req } = opts
   await fs.remove(path)
   if (!opts.noFlash && req && req.flash) req.flash('notify', req.t('attachmentRemoved'))

package/lib/factory/model/sanitize-record.js

@@ -11,8 +11,9 @@
  */
 async function sanitizeRecord (record = {}, opts = {}) {
   const { fields = [], hidden = [], forceNoHidden } = opts
-  const { isEmpty, map, without, isArray } = this.app.lib._
+  const { isEmpty, map, without, isArray, isFunction, isString, get, cloneDeep } = this.app.lib._
   const { fillObject } = this.app.lib.aneka
+  const { callHandler, format } = this.app.bajo
   let allHidden = without([...this.hidden, ...hidden], 'id')
   if (forceNoHidden === true) allHidden = []
   else if (isArray(forceNoHidden)) allHidden = without(allHidden, ...forceNoHidden)
@@ -22,6 +23,24 @@ async function sanitizeRecord (record = {}, opts = {}) {
   newFields = without(newFields, ...allHidden)
   const body = fillObject(record, newFields, null)
   const newRecord = await this.sanitizeBody({ body, noDefault: true })
+  if (opts.formatValue) {
+    if (opts.retainOriginalValue) newRecord._orig = cloneDeep(newRecord)
+    for (const key in newRecord) {
+      const prop = this.getProperty(key)
+      if (!prop) continue
+      if (prop.format) {
+        if (isFunction(prop.format)) newRecord[key] = await prop.format.call(this, newRecord[key], newRecord, opts)
+        else if (isString(prop.format)) newRecord[key] = await callHandler(this.plugin, this, newRecord[key], newRecord, opts)
+      } else {
+        const options = {
+          lang: get(opts, 'req.lang'),
+          latitude: ['lat', 'latitude'].includes(key),
+          longitude: ['lon', 'lng', 'longitude'].includes(key)
+        }
+        newRecord[key] = format(newRecord[key], prop.type, options)
+      }
+    }
+  }
   if (record._ref) newRecord._ref = record._ref
   return newRecord
 }

package/lib/factory/model.js

@@ -160,8 +160,8 @@ async function modelFactory () {
     getField = (name) => this.getProperty(name)
     hasField = (name) => this.hasProperty(name)
 
-    dispose () {
-      super.dispose()
+    dispose = async () => {
+      await super.dispose()
       this.connection = null
       this.driver = null
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dobo",
-  "version": "2.14.1",
+  "version": "2.16.0",
   "description": "DBMS for Bajo Framework",
   "main": "index.js",
   "scripts": {

package/wiki/CHANGES.md

@@ -1,5 +1,32 @@
 # Changes
 
+## 2026-04-11
+
+- [2.16.0] Add ```format``` as new model's property key
+- [2.16.0] Rewrite ```getDefaultValues()``` to base on ```req.getSetting()```
+- [2.16.0] All inter site admins are now exempts from ```immutable``` row
+- [2.16.0] Bug fix in ```collect-models.js```
+- [2.16.0] Bug fix in ```getSingleRef()``` and ```getMultiRefs()```
+- [2.16.0] Add feature to return formatted row(s) with ```options.formatValue```
+- [2.16.0] If row is formatted, add feature to save original row in ```_orig``` with ```options.retainOriginalValue```
+
+## 2026-04-07
+
+- [2.15.0] Add ```parseNql()```
+- [2.15.0] Add ```parseQuery()```
+- [2.15.0] Add ```replaceRegexInJson()```
+- [2.15.0] Add ```reviveRegexInJson()```
+- [2.15.0] Change all ```opts.fieldName``` to ```opts.field``` in features
+- [2.15.0] Add ```ref.searchField``` in model reference
+- [2.15.0] Add ```ref.labelField``` in model reference
+- [2.15.0] Add ```ref.valueField``` in model reference
+- [2.15.0] change ```ref.propName``` to ```ref.field``` in model reference
+
+## 2026-04-02
+
+- [2.14.1] Bug fix in ```hardCap```
+- [2.14.1] ```warnings``` now can be turned off through ```config``` or site settings
+
 ## 2026-04-01
 
 - [2.14.0] Add ```between``` as custom query, since it doesn't exists in NQL