dobo 2.5.0 → 2.6.0

package/index.js

@@ -481,7 +481,7 @@ async function factory (pkgName) {
       if (!this.constructor.histogramTypes.includes(type)) throw this.error('unsupportedHistogramType%s', type)
     }
 
-    execModelHook = async (model, hookName, ...args) => {
+    runModelHook = async (model, hookName, ...args) => {
       const { orderBy } = this.app.lib._
       const hooks = orderBy(model.hooks.filter(hook => hook.name === hookName), ['level'])
       for (const hook of hooks) {

package/lib/collect-models.js

@@ -203,7 +203,9 @@ export async function sanitizeAll (model) {
     }
   }
   await runHook(`dobo.${camelCase(model.name)}:afterSanitizeModel`, model)
-  // sortables
+  // fields that can participate in table scan if needed
+  model.scans = []
+  // sorting only possible using these fields
   model.sortables = []
   for (const index of model.indexes) {
     model.sortables.push(...index.fields)

package/lib/factory/driver.js

@@ -34,9 +34,11 @@ async function driverFactory () {
           array: false,
           datetime: true
         },
+        search: false,
         uniqueIndex: false,
         nullableField: true
       }
+      this.useUtc = false
       this.maxChunkSize = 500
       this.memory = false
       this.options = options
@@ -81,18 +83,28 @@ async function driverFactory () {
     }
 
     sanitizeRecord (model, record = {}) {
+      const { dayjs } = this.app.lib
+      const { isString } = this.app.lib._
       const item = { ...record }
       if (has(item, this.idField.name) && this.idField.name !== 'id') {
         item.id = item[this.idField.name]
         delete item[this.idField.name]
       }
       for (const prop of model.properties) {
-        if (isSet(item[prop.name]) && !this.support.propType[prop.type]) {
-          try {
-            if (prop.type === 'datetime') item[prop.name] = new Date(item[prop.name])
-            else if (['object', 'array'].includes(prop.type)) item[prop.name] = JSON.parse(item[prop.name])
-          } catch (err) {
-            item[prop.name] = null
+        if (isSet(item[prop.name])) {
+          if (!this.support.propType[prop.type]) {
+            try {
+              if (prop.type === 'datetime') {
+                const dt = this.useUtc ? dayjs.utc(item[prop.name]) : dayjs(item[prop.name])
+                item[prop.name] = dt.toDate()
+              } else if (['object', 'array'].includes(prop.type)) item[prop.name] = JSON.parse(item[prop.name])
+            } catch (err) {
+              item[prop.name] = null
+            }
+          }
+          if (prop.type === 'datetime' && isString(item[prop.name])) {
+            const dt = this.useUtc ? dayjs.utc(item[prop.name]) : dayjs(item[prop.name])
+            item[prop.name] = dt.toDate()
           }
         }
       }

package/lib/factory/model/_util.js

@@ -13,10 +13,11 @@ export async function execHook (name, ...args) {
 }
 
 export async function execModelHook (name, ...args) {
+  if (['beforeBuildQuery', 'beforeBuildSearch', 'afterBuildQuery', 'afterBuildSearch'].includes(name)) return
   const { last } = this.app.lib._
-  const { execModelHook } = this.app.dobo
+  const { runModelHook } = this.app.dobo
   const { noModelHook } = last(args)
-  if (!noModelHook) await execModelHook(this, name, ...args)
+  if (!noModelHook) await runModelHook(this, name, ...args)
 }
 
 export async function execDynHook (name, ...args) {
@@ -51,6 +52,7 @@ export async function execValidation (body, options = {}) {
  */
 export async function getFilterAndOptions (filter = {}, options = {}, action) {
   const { cloneDeep, omit } = this.app.lib._
+  const { runModelHook } = this.app.dobo
   const keys = ['req', 'reply']
   const nFilter = cloneDeep(omit(filter, keys))
   const nOptions = cloneDeep(omit(options, keys))
@@ -62,9 +64,13 @@ export async function getFilterAndOptions (filter = {}, options = {}, action) {
     nOptions[key] = options[key]
   }
 
-  nFilter.query = buildFilterQuery.call(this, nFilter, nOptions) ?? {}
-  nFilter.match = buildFilterMatch.call(this, nFilter, nOptions) ?? {}
-  handleRegexInQuery.call(this, nFilter)
+  if (!nOptions.noModelHook) await runModelHook(this, 'beforeBuildQuery', nFilter.query, nOptions)
+  nFilter.query = buildFilterQuery.call(this, nFilter) ?? {}
+  if (!nOptions.noModelHook) await runModelHook(this, 'afterBuildQuery', nFilter.query, nOptions)
+  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
@@ -218,68 +224,85 @@ export async function getMultiRefs (records = [], options = {}) {
   }
 }
 
-export function buildFilterQuery (filter = {}, options = {}) {
+export function buildFilterQuery (filter = {}) {
   const { trim, find, isString, isPlainObject } = this.app.lib._
-  let query = {}
-  if (isString(filter.query)) {
+  let query = filter.query ?? {}
+  let q = {}
+  if (isString(query)) {
     try {
-      filter.query = trim(filter.query)
-      filter.orgQuery = filter.query
-      if (trim(filter.query).startsWith('{')) query = JSON.parse(filter.query)
-      else if (filter.query.includes(':')) query = nql(filter.query).parse()
-      else {
-        const fields = this.sortables.filter(f => {
+      query = trim(query)
+      if (query.startsWith('{')) q = JSON.parse(query) // JSON formatted query
+      else if (query.includes(':')) q = nql(query).parse() // NQL
+      else if (this.driver.support.search) {
+        filter.search = q
+        return {} //
+      } else {
+        let scans = [...this.scans]
+        if (scans.length === 0) scans = [...this.sortables]
+        const fields = scans.filter(f => {
           const field = find(this.properties, { name: f, type: 'string' })
           return !!field
         })
         const parts = fields.map(f => {
-          if (filter.query[0] === '*') return `${f}:~$'${filter.query.replaceAll('*', '')}'`
-          if (filter.query[filter.length - 1] === '*') return `${f}:~^'${filter.query.replaceAll('*', '')}'`
-          return `${f}:~'${filter.query.replaceAll('*', '')}'`
+          if (query[0] === '*') return `${f}:~$'${query.replaceAll('*', '')}'`
+          if (query[query.length - 1] === '*') return `${f}:~^'${query.replaceAll('*', '')}'`
+          return `${f}:~'${query.replaceAll('*', '')}'`
         })
-        if (parts.length === 1) query = nql(parts[0]).parse()
-        else if (parts.length > 1) query = nql(parts.join(',')).parse()
+        if (parts.length === 1) q = nql(parts[0]).parse()
+        else if (parts.length > 1) q = nql(parts.join(',')).parse()
       }
     } catch (err) {
-      this.app.dobo.error('invalidQuery', { orgMessage: err.message })
+      this.plugin.error('invalidQuery', { orgMessage: err.message })
     }
-  } else if (isPlainObject(filter.query)) query = filter.query
-  return sanitizeQuery.call(this, query)
+  } else if (isPlainObject(query)) q = query
+  return sanitizeQuery.call(this, q)
 }
 
 function sanitizeQuery (query = {}, parent) {
-  const { cloneDeep, isPlainObject, isArray, find } = this.app.lib._
+  const { isPlainObject, isArray, find, cloneDeep } = this.app.lib._
   const { isSet } = this.app.lib.aneka
   const { dayjs } = this.app.lib
   const obj = cloneDeep(query)
   const keys = Object.keys(obj)
-  const sanitize = (key, val, p) => {
-    if (!isSet(val)) return val
-    const prop = find(this.properties, { name: key.startsWith('$') ? p : key })
+
+  const sanitizeField = (prop, val) => {
     if (!prop) return val
-    if (['datetime', 'date', 'time'].includes(prop.type)) {
+    if (val instanceof RegExp) return val
+    if (['datetime'].includes(prop.type)) {
       const dt = dayjs(val)
       return dt.isValid() ? dt.toDate() : val
     } else if (['smallint', 'integer'].includes(prop.type)) return parseInt(val) || val
     else if (['float', 'double'].includes(prop.type)) return parseFloat(val) || val
     else if (['boolean'].includes(prop.type)) return !!val
+    else if (['string', 'text'].includes(prop.type)) return val + ''
     return val
   }
+
+  const sanitizeChild = (key, val, p) => {
+    if (!isSet(val)) return val
+    const prop = find(this.properties, { name: key.startsWith('$') ? p : key })
+    if (!prop) return val
+    return sanitizeField(prop, val)
+  }
+
   keys.forEach(k => {
     const v = obj[k]
+    const prop = find(this.properties, { name: k })
     if (isPlainObject(v)) obj[k] = sanitizeQuery.call(this, v, k)
     else if (isArray(v)) {
       v.forEach((i, idx) => {
         if (isPlainObject(i)) obj[k][idx] = sanitizeQuery.call(this, i, k)
+        else obj[k][idx] = sanitizeField(prop, i)
       })
-    } else obj[k] = sanitize(k, v, parent)
+    } else obj[k] = sanitizeChild(k, v, parent)
   })
   return obj
 }
 
-export function buildFilterMatch (filter = {}, options = {}) {
+export function buildFilterSearch (filter = {}) {
   const { isPlainObject, trim, has, uniq } = this.app.lib._
-  let input = filter.match
+  const search = filter.search ?? {}
+  let input = search
   if (isPlainObject(input)) return input
   const split = (value) => {
     let [field, val] = value.split(':').map(i => i.trim())
@@ -303,37 +326,37 @@ export function buildFilterMatch (filter = {}, options = {}) {
       items[part.field].push(...part.value.split(' ').filter(v => ![''].includes(v)))
     }
   }
-  const matcher = {}
+  const s = {}
   for (const index of this.indexes.filter(i => i.type === 'fulltext')) {
     for (const f of index.fields) {
       const value = []
       if (typeof items[f] === 'string') items[f] = [items[f]]
       if (has(items, f)) value.push(...items[f])
-      if (!matcher[f]) matcher[f] = []
-      matcher[f] = uniq([...matcher[f], ...value])
+      if (!s[f]) s[f] = []
+      s[f] = uniq([...s[f], ...value])
     }
   }
-  if (has(items, '*')) matcher['*'] = items['*']
-  return matcher
+  if (has(items, '*')) s['*'] = items['*']
+  return s
 }
 
-export function handleRegexInQuery (filter) {
-  if (this.driver.idField.name !== 'id') {
-    const query = JSON.stringify(filter.query ?? {}, (key, value) => {
-      if (value instanceof RegExp) return ['__REGEXP__', value.source, value.flags]
+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}"`)
+  try {
+    filter.query = JSON.parse(query, (key, value) => {
+      if (Array.isArray(value) && value[0] === '__REGEXP__') return new RegExp(value[1], value[2])
       return value
-    }).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
-      })
-    } catch (err) {}
-    const match = JSON.stringify(filter.match ?? {}).replaceAll('"id"', `"${this.driver.idField.name}"`)
-    try {
-      filter.match = JSON.parse(match)
-    } catch (err) {}
-  }
+    })
+  } catch (err) {}
+  // search
+  const search = JSON.stringify(filter.search ?? {}).replaceAll('"id"', `"${this.driver.idField.name}"`)
+  try {
+    filter.search = JSON.parse(search)
+  } catch (err) {}
 }
 
 /**

package/package.json

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

package/wiki/CHANGES.md

@@ -1,9 +1,17 @@
 # Changes
 
+## 2026-02-01
+
+- [2.6.0] Add ```model.scans``` for fields that can participate in table scans if necessary
+- [2.6.0] Add ```driver.support.search``` for driver's fulltext search support
+- [2.6.0] Add model hooks ```before/afterBuildQuery/Search```
+
 ## 2026-01-30
 
 - [2.5.0] Add feature to push custom ```options._data```. If provided, this will be used instead of auto generated one.
 - [2.5.0] Remove ```silent``` in ```options``` object
+- [2.5.1] Driver now support ```this.useUtc``` for database that store values in UTC string
+- [2.5.1] Bug fix on ```driver.sanitizeRecord()```
 
 ## 2026-01-29