dobo 2.15.0 → 2.17.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/immutable.js

@@ -1,5 +1,6 @@
-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.field)
   if (immutable) throw this.plugin.error('recordImmutable%s%s', id, this.name, { statusCode: 423 })
@@ -16,12 +17,12 @@ async function immutable (opts = {}) {
     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/index.js

@@ -82,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
@@ -390,17 +390,21 @@ async function factory (pkgName) {
       return parseInt(value) || null
     }
 
-    sanitizeObject = (value) => {
+    sanitizeObject = (value, { strict = false } = {}) => {
       const { isString } = this.app.lib._
       let result = null
       if (isString(value)) {
         try {
           result = JSON.parse(value)
-        } catch (err) {}
+        } catch (err) {
+          if (strict) throw err
+        }
       } else {
         try {
           result = JSON.parse(JSON.stringify(value))
-        } catch (err) {}
+        } catch (err) {
+          if (strict) throw err
+        }
       }
       return result
     }
@@ -497,13 +501,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 }
     }

package/lib/collect-models.js

@@ -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)
   }
 }
 
@@ -80,6 +80,7 @@ async function applyFeature (model, feature, options, indexes, isExtender) {
   }
   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,16 +138,18 @@ 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 = { field: ref }
       }
       ref.field = ref.field ?? 'id'
       ref.type = ref.type ?? '1:1'
-      ref.searchField = ref.searchField ?? model.scanables[0] ?? 'id'
+      ref.searchField = ref.searchField ?? model.scanables[0] ?? ref.field
       ref.labelField = ref.labelField ?? ref.searchField
       const rModel = find(models, { name: ref.model })
       if (!rModel) {
@@ -175,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(', '))
 }
 
 /**
@@ -336,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/model/_util.js

@@ -161,10 +161,21 @@ 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 { get } = this.app.lib._
   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 = {}
   options.refs = options.refs ?? []
@@ -172,23 +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 ref = prop.ref[key]
           const rModel = this.app.dobo.getModel(ref.model, true)
-          if (!rModel) continue
+          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 rFilter = { query }
-          const rOptions = { dataOnly: true, refs: [] }
-          const results = await rModel.findRecord(rFilter, rOptions)
-          const fields = [...ref.fields]
+          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) {}
@@ -208,13 +217,10 @@ export async function getMultiRefs (records = [], 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 (ref.type !== '1:1') continue
           if (get(records, `0._ref.${key}`)) continue
+          const ref = prop.ref[key]
           const rModel = this.app.dobo.getModel(ref.model, true)
-          if (!rModel) continue
+          if (!rModel) return
           let matches = []
           for (const r of records) {
             matches.push(rModel.sanitizeId(r[prop.name]))
@@ -223,16 +229,15 @@ export async function getMultiRefs (records = [], options = {}) {
           let query = {}
           query[ref.field] = { $in: matches }
           if (ref.query) query = { $and: [query, parseQuery(ref.query)] }
-          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)
+          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.field] + '') === rec[prop.name] + '')
-            if (res) records[i]._ref[key] = await rModel.sanitizeRecord(res, { fields })
+            if (res) records[i]._ref[key] = await rModel.sanitizeRecord(res, rOptions)
             else records[i]._ref[key] = {}
           }
         } catch (err) {}

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

@@ -21,7 +21,7 @@ async function sanitizeBody ({ body = {}, partial, strict, extFields = [], noDef
 
   const sanitize = (name, type) => {
     if (onlyTypes.length > 0 && !onlyTypes.includes(type)) return
-    if (['object', 'array'].includes(type)) result[name] = sanitizeObject(result[name])
+    if (['object', 'array'].includes(type)) result[name] = sanitizeObject(result[name], { strict })
     else if (type === 'boolean') result[name] = sanitizeBoolean(result[name])
     else if (['float', 'double'].includes(type)) result[name] = sanitizeFloat(result[name], { strict })
     else if (['integer', 'smallint'].includes(type)) result[name] = sanitizeInt(result[name], { strict })

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,25 @@ 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
+      const value = ['object', 'array'].includes(prop.type) ? cloneDeep(newRecord[key]) : newRecord[key]
+      if (prop.format) {
+        if (isFunction(prop.format)) newRecord[key] = await prop.format.call(this, value, newRecord, opts)
+        else if (isString(prop.format)) newRecord[key] = await callHandler(this.plugin, this, value, newRecord, opts)
+      } else {
+        const options = {
+          lang: get(opts, 'req.lang'),
+          latitude: ['lat', 'latitude'].includes(key),
+          longitude: ['lon', 'lng', 'longitude'].includes(key)
+        }
+        newRecord[key] = format(value, prop.type, options)
+      }
+    }
+  }
   if (record._ref) newRecord._ref = record._ref
   return newRecord
 }

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

@@ -57,6 +57,7 @@ async function updateRecord (...args) {
   const { truncateString, noResult, noBodySanitizer, noResultSanitizer, noValidation, partial } = options
   const extFields = get(options, 'validation.extFields', [])
   id = this.sanitizeId(id)
+
   let input = noBodySanitizer ? cloneDeep(body) : await this.sanitizeBody({ body, extFields, strict: true, truncateString, partial, onlyTypes })
   const immutables = this.properties.filter(prop => prop.immutable)
   if (immutables.length > 0) input = omit(input, immutables)

package/package.json

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

package/wiki/CHANGES.md

@@ -1,5 +1,19 @@
 # Changes
 
+## 2026-04-13
+
+- [2.17.0] Add ```{ strict }``` as parameter to ```sanitizeObject()```
+
+## 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()```