dobo 2.18.1 → 2.19.0

package/index.js

@@ -501,9 +501,12 @@ async function factory (pkgName) {
     }
 
     getDefaultValues = (options = {}) => {
+      const { defaultsDeep } = this.app.lib.aneka
       const key = 'default.filter'
-      let config = this.app.dobo.getConfig(key)
-      if (options.req) config = options.req.getSetting(`dobo:${key}`, config)
+      let config = this.getConfig(key)
+      config.hardCap = this.config.default.hardCap
+      config.warnings = this.config.default.warnings
+      if (options.req) config = defaultsDeep({}, options.req.getSetting('dobo:default'), config)
       const { limit, maxLimit, maxPage, hardCap, warnings } = config
       const t = options.req ? options.req.t : this.t
       return { limit, maxLimit, hardCap, maxPage, warnings, t }
@@ -536,23 +539,47 @@ async function factory (pkgName) {
       return nql(sanitized).parse()
     }
 
-    parseQuery = (query, silent = true) => {
-      const { isPlainObject, trim } = this.app.lib._
+    parseAny = (query, model) => {
+      const { isEmpty } = this.app.lib._
+      let q = {}
+      if (!model) throw this.error('invalidQuery')
+      let scanables = [...model.scanables]
+      if (scanables.length === 0) scanables = [...model.sortables]
+      const fields = scanables.filter(f => {
+        const field = find(model.properties, { name: f, type: 'string' })
+        return !!field
+      })
+      const parts = fields.map(f => {
+        if (query[0] === '*') return `${f}:~$'${query.replaceAll('*', '')}'`
+        if (query[query.length - 1] === '*') return `${f}:~^'${query.replaceAll('*', '')}'`
+        return `${f}:~'${query.replaceAll('*', '')}'`
+      })
+      if (parts.length === 1) q = this.parseNql(parts[0])
+      else if (parts.length > 1) q = this.parseNql(parts.join(','))
+      if (isEmpty(q)) throw this.error('invalidQuery')
+      return q
+    }
+
+    parseQuery = (query, model, silent = true) => {
+      const { isEmpty, isPlainObject, trim } = this.app.lib._
       let result = {}
       if (isPlainObject(query)) result = query
       else {
         query = trim(query)
+        if (isEmpty(query)) return result
         try {
           if (query.startsWith('{')) result = JSON.parse(query)
-          else result = this.parseNql(query)
+          else if (query.includes(':')) result = this.parseNql(query)
+          else result = this.parseAny(query, model)
         } catch (err) {
           if (silent) return {}
           throw err
         }
       }
+      let strQ = this.replaceRegexInJson(result)
+      if (model && model.driver.idField.name !== 'id') strQ = strQ.replaceAll('"id"', `"${model.driver.idField.name}"`)
       try {
-        const text = JSON.stringify(result)
-        if (text.includes('["__REGEXP__",')) result = this.reviveRegexInJson(text)
+        result = this.reviveRegexInJson(strQ)
       } catch (err) {}
       return result
     }
@@ -572,7 +599,7 @@ async function factory (pkgName) {
       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]) }
+        if (Array.isArray(value) && value[0] === '__REGEXP__') return new RegExp(value[1], value[2])
         return value
       })
       return returnObject ? result : JSON.stringify(result)

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 } = this.app.lib._
+  const { isEmpty, isString, keys, pick, isArray, isPlainObject, omit } = this.app.lib._
   const allPropKeys = this.getAllPropertyKeys(model.connection.driver)
   const propType = this.constructor.propertyType
   if (isString(prop)) {
@@ -39,7 +39,9 @@ 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, { field: prop.name }, indexes)
+    const opts = omit(prop, ['name', 'type'])
+    opts.field = prop.name
+    await applyFeature.call(this, model, feature, opts, indexes)
   }
 }
 

package/lib/factory/model/_util.js

@@ -77,7 +77,6 @@ export async function getFilterAndOptions (filter = {}, options = {}, action) {
   if (!nOptions.noModelHook) await runModelHook(this, 'beforeBuilSearch', nFilter.search, nOptions)
   nFilter.search = buildFilterSearch.call(this, nFilter) ?? {}
   if (!nOptions.noModelHook) await runModelHook(this, 'afterBuildSearch', nFilter.search, nOptions)
-  if (this.driver.idField.name !== 'id') replaceIdInQuerySearch.call(this, nFilter)
   const { limit, page, skip, sort } = preparePagination.call(this, nFilter, nOptions)
   nFilter.limit = limit
   nFilter.page = page
@@ -190,7 +189,7 @@ export async function getSingleRef (record = {}, options = {}) {
           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)] }
+          if (ref.query) query = { $and: [query, parseQuery(ref.query, rModel)] }
           const filter = { query }
           const resp = await _getRef.call(this, { ref, rModel, prop, key, options, filter })
           if (!resp) continue
@@ -228,7 +227,7 @@ export async function getMultiRefs (records = [], options = {}) {
           matches = uniq(without(matches, undefined, null, NaN))
           let query = {}
           query[ref.field] = { $in: matches }
-          if (ref.query) query = { $and: [query, parseQuery(ref.query)] }
+          if (ref.query) query = { $and: [query, parseQuery(ref.query, rModel)] }
           const filter = { query, limit: matches.length }
           const resp = await _getRef.call(this, { ref, rModel, prop, key, options, filter })
           if (!resp) continue
@@ -247,35 +246,9 @@ export async function getMultiRefs (records = [], options = {}) {
 }
 
 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(query) // NQL
-      else {
-        let scanables = [...this.scanables]
-        if (scanables.length === 0) scanables = [...this.sortables]
-        const fields = scanables.filter(f => {
-          const field = find(this.properties, { name: f, type: 'string' })
-          return !!field
-        })
-        const parts = fields.map(f => {
-          if (query[0] === '*') return `${f}:~$'${query.replaceAll('*', '')}'`
-          if (query[query.length - 1] === '*') return `${f}:~^'${query.replaceAll('*', '')}'`
-          return `${f}:~'${query.replaceAll('*', '')}'`
-        })
-        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 })
-    }
-  } else if (isPlainObject(query)) q = query
-  return sanitizeQuery.call(this, q)
+  const { parseQuery } = this.app.dobo
+  const query = parseQuery(filter.query ?? {}, this, false)
+  return sanitizeQuery.call(this, query)
 }
 
 function sanitizeQuery (query = {}, parent) {
@@ -346,7 +319,7 @@ export function buildFilterSearch (filter = {}) {
       items[part.field].push(...part.value.split(' ').filter(v => ![''].includes(v)))
     }
   }
-  const s = {}
+  let s = {}
   for (const index of this.indexes.filter(i => i.type === 'fulltext')) {
     for (const f of index.fields) {
       const value = []
@@ -357,22 +330,15 @@ export function buildFilterSearch (filter = {}) {
     }
   }
   if (has(items, '*')) s['*'] = items['*']
+  if (this.driver.idField.name !== 'id') {
+    const search = JSON.stringify(s).replaceAll('"id"', `"${this.driver.idField.name}"`)
+    try {
+      s = JSON.parse(search)
+    } catch (err) {}
+  }
   return s
 }
 
-export function replaceIdInQuerySearch (filter) {
-  const { replaceRegexInJson, reviveRegexInJson } = this.app.dobo
-  const query = replaceRegexInJson(filter.query).replaceAll('"id"', `"${this.driver.idField.name}"`)
-  try {
-    filter.query = reviveRegexInJson(query)
-  } catch (err) {}
-  // search
-  const search = JSON.stringify(filter.search ?? {}).replaceAll('"id"', `"${this.driver.idField.name}"`)
-  try {
-    filter.search = JSON.parse(search)
-  } catch (err) {}
-}
-
 /**
  * Prepare records pagination:
  * - making sure records limit is obeyed

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

@@ -46,10 +46,10 @@ async function sanitizeRecord (record = {}, opts = {}) {
         })
         value = (values.find(v => v.value === value) ?? {}).text ?? value
       }
-      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 {
+      if (prop.format === false) newRecord[key] = value + ''
+      else 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),
@@ -57,8 +57,6 @@ async function sanitizeRecord (record = {}, opts = {}) {
         }
         newRecord[key] = format(value, prop.type, options)
       }
-      // exception
-      if (['year'].includes(key)) newRecord[key] = (get(newRecord, `_orig.${key}`, newRecord[key]) + '')
     }
   }
   if (record._ref) newRecord._ref = record._ref

package/package.json

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

package/wiki/CHANGES.md

@@ -1,5 +1,19 @@
 # Changes
 
+## 2026-04-19
+
+- [2.19.0] Add ```queryAny()``` for query using model's scanables fields
+- [2.19.0] Bug fix in ```reviveRegexInJson()```
+- [2.19.0] Bug fix in query sanitizing especially for regex existance
+- [2.19.0] Remove ```replaceIdInQuerySearch()``` in ```_util.js``` as it isn't needed anymore
+
+## 2026-04-18
+
+- [2.18.2] Bug fix in ```config``` object
+- [2.18.2] Bug fix in ```getDefaultValues```
+- [2.18.2] Bug fix in ```sanitizeProp()``` in ```collect-models.js```
+- [2.18.2] Bug fix in ```sanitizeRecord()``` for prop with ```format``` set to ```false```
+
 ## 2026-04-17
 
 - [2.18.1] Bug fix in ```model.createAttachment()```