dobo 2.23.0 → 2.24.0

package/extend/dobo/feature/immutable.js

@@ -11,8 +11,7 @@ async function immutable (opts = {}) {
   return {
     properties: {
       name: opts.field,
-      type: 'boolean',
-      hidden: true
+      type: 'boolean'
     },
     hooks: [{
       name: 'beforeUpdateRecord',

package/lib/factory/driver.js

@@ -12,8 +12,9 @@ const defIdField = {
 
 async function driverFactory () {
   const { Tools } = this.app.baseClass
-  const { pick, cloneDeep, has, uniq, without, isEmpty, omit, isFunction } = this.app.lib._
+  const { pick, cloneDeep, has, uniq, without, isEmpty, omit, isFunction, camelCase, last } = this.app.lib._
   const { isSet } = this.app.lib.aneka
+  const { runHook } = this.app.bajo
 
   /**
    * Driver class
@@ -111,6 +112,7 @@ async function driverFactory () {
             const dt = this.useUtc ? dayjs.utc(item[prop.name]) : dayjs(item[prop.name])
             item[prop.name] = dt.toDate()
           }
+          if (prop.type === 'boolean' && isSet(item[prop.name])) item[prop.name] = Boolean(item[prop.name])
         }
       }
       return item
@@ -124,6 +126,15 @@ async function driverFactory () {
       return uniq(items)
     }
 
+    async _attachHook (name, model, ...args) {
+      const { ns } = this.app.dobo
+      const options = last(args)
+      if (!options.noDriverHook) {
+        await runHook(`${ns}:${name}`, model, ...args)
+        await runHook(`${ns}.${camelCase(model.name)}:${name}`, model, ...args)
+      }
+    }
+
     /**
      * Check uniqueness of fields with unique index
      *
@@ -245,7 +256,11 @@ async function driverFactory () {
         if (!isEmpty(resp.data)) throw this.plugin.error('recordExists%s%s', body.id, model.name)
       }
       body = this.sanitizeBody(model, body)
+
+      await this._attachHook('beforeDriverCreateRecord', model, body, options)
       const result = await this.createRecord(model, body, options)
+      await this._attachHook('afterDriverCreateRecord', model, body, result, options)
+
       if (options.noResult) return
       result.data = this.sanitizeRecord(model, result.data)
       this._injectMeta(result, options)
@@ -261,14 +276,20 @@ async function driverFactory () {
         await this._prepIdForCreate(model, body, options)
         bodies[idx] = this.sanitizeBody(model, body)
       }
+
+      await this._attachHook('beforeDriverBulkCreateRecord', model, bodies, options)
       const items = chunk(bodies, chunkSize)
       for (const item of items) {
         await this.bulkCreateRecord(model, item, options)
       }
+      await this._attachHook('afterDriverBulkCreateRecord', model, bodies, [], options)
     }
 
     async _getRecord (model, id, options = {}) {
+      await this._attachHook('beforeDriverGetRecord', model, id, options)
       const result = await this.getRecord(model, id, options)
+      await this._attachHook('afterDriverGetRecord', model, id, result, options)
+
       if (isEmpty(result.data) && options.throwNotFound) throw this.plugin.error('recordNotFound%s%s', id, model.name)
       result.data = this.sanitizeRecord(model, result.data)
       this._injectMeta(result, options)
@@ -287,7 +308,11 @@ async function driverFactory () {
       }
       body = this.sanitizeBody(model, body, true)
       delete body.id
+
+      await this._attachHook('beforeDriverUpdateRecord', model, id, body, options)
       const result = await this.updateRecord(model, id, body, options)
+      await this._attachHook('afterDriverUpdateRecord', model, id, body, result, options)
+
       if (options.noResult) return
       result.oldData = this.sanitizeRecord(model, result.oldData)
       result.data = this.sanitizeRecord(model, result.data)
@@ -308,7 +333,11 @@ async function driverFactory () {
         }
       }
       body = this.sanitizeBody(model, body)
+
+      await this._attachHook('beforeDriverUpsertRecord', model, body, options)
       const result = await this.upsertRecord(model, body, options)
+      await this._attachHook('afterDriverUpsertRecord', model, body, result, options)
+
       if (options.noResult) return
       if (result.oldData) result.oldData = this.sanitizeRecord(model, result.oldData)
       result.data = this.sanitizeRecord(model, result.data)
@@ -322,7 +351,11 @@ async function driverFactory () {
         if (!resp.data) throw this.plugin.error('recordNotFound%s%s', id, model.name)
         options._data = resp.data
       }
+
+      await this._attachHook('beforeDriverRemoveRecord', model, id, options)
       const result = await this.removeRecord(model, id, options)
+      await this._attachHook('afterDriverRemoveRecord', model, id, result, options)
+
       if (options.noResult) return
       result.oldData = this.sanitizeRecord(model, result.oldData)
       this._injectMeta(result, options)
@@ -330,13 +363,29 @@ async function driverFactory () {
     }
 
     async _clearRecord (model, options = {}) {
+      await this._attachHook('beforeDriverClearRecord', model, options)
       const result = await this.clearRecord(model, options)
+      await this._attachHook('afterDriverClearRecord', model, result, options)
+
       this._injectMeta(result, options)
       return result
     }
 
     async _findRecord (model, filter = {}, options = {}) {
-      const result = await this.findRecord(model, filter, options)
+      let result
+      try {
+        await this._attachHook('beforeDriverFindRecord', model, filter, options)
+        result = await this.findRecord(model, filter, options)
+        await this._attachHook('afterDriverFindRecord', model, filter, result, options)
+      } catch (err) {
+        if (err.message !== '_emptyColumnQuery') throw err
+        result = {
+          data: [],
+          count: 0
+          // warnings: [] // TODO: should generate warnings?
+        }
+      }
+
       for (const idx in result.data) {
         result.data[idx] = this.sanitizeRecord(model, result.data[idx])
       }
@@ -345,7 +394,20 @@ async function driverFactory () {
     }
 
     async _findAllRecord (model, filter = {}, options = {}) {
-      const result = await this.findAllRecord(model, filter, options)
+      let result
+      try {
+        await this._attachHook('beforeDriverFindAllRecord', model, filter, options)
+        result = await this.findAllRecord(model, filter, options)
+        await this._attachHook('afterDriverFindAllRecord', model, filter, result, options)
+      } catch (err) {
+        if (err.message !== '_emptyColumnQuery') throw err
+        result = {
+          data: [],
+          count: 0
+          // warnings: [] // TODO: should generate warnings?
+        }
+      }
+
       for (const idx in result.data) {
         result.data[idx] = this.sanitizeRecord(model, result.data[idx])
       }
@@ -354,7 +416,17 @@ async function driverFactory () {
     }
 
     async _countRecord (model, filter = {}, options = {}) {
-      return await this.countRecord(model, filter, options)
+      let result
+      try {
+        await this._attachHook('beforeDriverCountRecord', model, filter, options)
+        result = await this.countRecord(model, filter, options)
+        await this._attachHook('afterDriverCountRecord', model, filter, result, options)
+      } catch (err) {
+        if (err.message !== '_emptyColumnQuery') throw err
+        result = { data: 0 }
+      }
+
+      return result
     }
 
     async _createAggregate (model, filter = {}, params = {}, options = {}) {
@@ -371,7 +443,16 @@ async function driverFactory () {
       if (!prop) throw this.plugin.error('unknown%s%s', this.plugin.t('field.field'), field)
       // if (!fieldPropTypes.includes(prop.type)) throw this.plugin.error('allowedPropType%s%s', field, fieldPropTypes.join(', '))
 
-      const result = await this.createAggregate(model, filter, params, options)
+      let result
+      try {
+        await this._attachHook('beforeDriverCreateAggregate', model, filter, params, options)
+        result = await this.createAggregate(model, filter, params, options)
+        await this._attachHook('afterDriverCreateAggregate', model, filter, params, result, options)
+      } catch (err) {
+        if (err.message !== '_emptyColumnQuery') throw err
+        result = { data: [] }
+      }
+
       for (const idx in result.data) {
         result.data[idx] = this.sanitizeRecord(model, result.data[idx])
       }
@@ -391,8 +472,17 @@ async function driverFactory () {
 
       prop = model.properties.find(p => p.name === field)
       if (!prop) throw this.plugin.error('unknown%s%s', this.plugin.t('field.field'), field)
-      // if (!fieldPropTypes.includes(prop.type)) throw this.plugin.error('allowedPropType%s%s', field, fieldPropTypes.join(', '))
-      const result = await this.createHistogram(model, filter, params, options)
+
+      let result
+      try {
+        await this._attachHook('beforeDriverCreateHistogram', model, filter, params, options)
+        result = await this.createHistogram(model, filter, params, options)
+        await this._attachHook('afterDriverCreateHistogram', model, filter, params, result, options)
+      } catch (err) {
+        if (err.message !== '_emptyColumnQuery') throw err
+        result = { data: [] }
+      }
+
       for (const idx in result.data) {
         result.data[idx] = this.sanitizeRecord(model, result.data[idx])
       }

package/lib/factory/model/_util.js

@@ -19,9 +19,9 @@ export async function execHook (name, ...args) {
   let [prefix, ...action] = kebabCase(name).split('-')
   action = camelCase(action.join(' '))
   if (!noHook) {
-    if (prefix === 'before') await runHook(`${ns}:beforeAction`, action, ...args)
+    if (prefix === 'before') await runHook(`${ns}:beforeAction`, action, this.name, ...args)
     await runHook(`${ns}:${name}`, this.name, ...args)
-    if (prefix === 'after') await runHook(`${ns}:afterAction`, action, ...args)
+    if (prefix === 'after') await runHook(`${ns}:afterAction`, action, this.name, ...args)
     if (prefix === 'before') await runHook(`${ns}.${camelCase(this.name)}:beforeAction`, action, ...args)
     await runHook(`${ns}.${camelCase(this.name)}:${name}`, ...args)
     if (prefix === 'after') await runHook(`${ns}.${camelCase(this.name)}:afterAction`, action, ...args)
@@ -29,7 +29,6 @@ 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 { runModelHook } = this.app.dobo
   const { noModelHook } = last(args)
@@ -68,7 +67,6 @@ export async function execValidation (body, options = {}) {
  */
 export async function getFilterAndOptions (filter = {}, options = {}, action) {
   const { cloneDeep } = this.app.lib._
-  const { runModelHook } = this.app.dobo
   const nFilter = cloneDeep(filter || {})
   const nOptions = cloneOptions.call(this, options)
   if (options.noMagic) {
@@ -87,12 +85,8 @@ export async function getFilterAndOptions (filter = {}, options = {}, action) {
   nOptions.throwNotFound = nOptions.throwNotFound ?? true
   nFilter.orgQuery = nFilter.query
   nFilter.orgSearch = nFilter.search
-  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)
   const { limit, page, skip, sort } = preparePagination.call(this, nFilter, nOptions)
   nFilter.limit = limit
   nFilter.page = page

package/lib/factory/model/load-fixtures.js

@@ -26,8 +26,8 @@ async function exec ({ item, spinner, options, result, items } = {}) {
 
 async function loadFixtures ({ spinner, ignoreError = true, collectItems = false, noLookup = false } = {}, options = {}) {
   const { readConfig } = this.app.bajo
-  const { resolvePath } = this.app.lib.aneka
-  const { isEmpty } = this.app.lib._
+  const { resolvePath, isSet } = this.app.lib.aneka
+  const { isEmpty, isString, isArray } = this.app.lib._
   if (this.connection.proxy) {
     this.log.warn('proxiedConnBound%s', this.name)
     return
@@ -38,13 +38,27 @@ async function loadFixtures ({ spinner, ignoreError = true, collectItems = false
   const items = await readConfig(pattern, { ns: this.plugin.ns, baseNs: 'dobo', checkOverride: true, defValue: [] })
   const opts = { ...options, noMagic: true }
   for (const item of items) {
-    for (const k in item) {
-      const v = item[k]
-      if (!noLookup && typeof v === 'string' && v.slice(0, 2) === '?:') item[k] = await this._simpleLookup(v.slice(2), opts)
-      if (v === null) item[k] = undefined
+    const lv = {}
+    for (const key in item) {
+      const val = item[key]
+      if (!noLookup) {
+        if (isString(val) && val.slice(0, 2) === '?:') {
+          item[key] = await this._simpleLookup(val.slice(2), lv, opts)
+          lv[key] = item[key]
+        } else if (isArray(val)) {
+          for (const idx in val) {
+            if (isString(val[idx]) && val[idx].slice(0, 2) === '?:') {
+              item[key][idx] = await this._simpleLookup(val[idx].slice(2), lv, opts)
+              if (isSet(item[key][idx])) item[key][idx] += ''
+              lv[`${key}.${idx}`] = item[key][idx]
+            }
+          }
+        }
+      }
+      if (val === null) item[key] = undefined
       else {
-        const prop = this.properties.find(item => item.name === k)
-        if (prop && ['string', 'text'].includes(prop.type)) item[k] += ''
+        const prop = this.properties.find(item => item.name === key)
+        if (prop && ['string', 'text'].includes(prop.type)) item[key] += ''
       }
     }
   }

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

@@ -41,7 +41,6 @@ async function sanitizeBody ({ body = {}, partial, strict, extFields = [], noDef
         continue
       }
       result[prop.name] = body[prop.name]
-      if (result[prop.name] === null) continue
       if (prop.type === 'array' && isSet(result[prop.name]) && !Array.isArray(result[prop.name])) result[prop.name] = [result[prop.name]]
       if (isSet(result[prop.name])) sanitize(prop.name, prop.type)
       else {
@@ -53,8 +52,9 @@ async function sanitizeBody ({ body = {}, partial, strict, extFields = [], noDef
           } else sanitize(prop.name, prop.type)
         }
       }
+      if (result[prop.name] === null) continue
       if (truncateString && isSet(result[prop.name]) && ['string', 'text'].includes(prop.type)) result[prop.name] = result[prop.name].slice(0, prop.maxLength)
-      if (prop.name.endsWith('Id') && prop.type === 'string' && ['smallint', 'integer'].includes(this.driver.idField.type)) result[prop.name] = result[prop.name] + ''
+      if (prop.name.endsWith('Id') && isSet(result[prop.name]) && prop.type === 'string' && ['smallint', 'integer'].includes(this.driver.idField.type)) result[prop.name] = result[prop.name] + ''
       if (result[prop.name] === undefined) omitted.push(prop.name)
     } catch (err) {
       details.push({ field: prop.name, error: err.message, value: body[prop.name], ext: { type: prop.type } })

package/lib/factory/model/transaction.js

@@ -1,6 +1,15 @@
 async function transaction (handler, ...args) {
   if (!this.driver.support.transaction) return handler.call(this, ...args)
-  return await this.driver.transaction(this, handler, ...args)
+
+  const { ns } = this.app.dobo
+  const { camelCase } = this.app.lib._
+  const { runHook } = this.app.bajo
+  const name = 'afterTransaction'
+  const result = await this.driver.transaction(this, handler, ...args)
+  const [action, ...params] = args
+  await runHook(`${ns}:${name}`, this.name, action, result, ...params)
+  await runHook(`${ns}.${camelCase(this.name)}:${name}`, action, result, ...params)
+  return result
 }
 
 export default transaction

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

@@ -66,7 +66,7 @@ async function updateRecord (...args) {
   await execModelHook.call(this, 'beforeUpdateRecord', id, input, options)
   await execDynHook.call(this, 'beforeUpdateRecord', id, input, options)
   if (!noValidation) await execValidation.call(this, input, options)
-  const result = options.record ?? (await this.driver._updateRecord(this, id, input, options)) ?? {}
+  const result = await this.driver._updateRecord(this, id, input, options)
   await handleReq.call(this, result.data.id, 'updated', options)
   await clearCache.call(this, id)
   if (noResult) return

package/lib/factory/model.js

@@ -119,7 +119,7 @@ async function modelFactory () {
       this.properties.unshift(idField)
     }
 
-    _simpleLookup = async (value, options = {}) => {
+    _simpleLookup = async (value, lookupValue, options = {}) => {
       const { get, isEmpty, isString, isPlainObject, isArray } = this.app.lib._
       let model
       let field
@@ -130,10 +130,13 @@ async function modelFactory () {
       } else if (isPlainObject(value)) ({ model, field, query } = value)
       else if (isArray(value)) [model, field, query] = value
       else return
+      for (const key in lookupValue) {
+        query = query.replaceAll(`{${key}}`, lookupValue[key])
+      }
       if (isEmpty(field)) field = 'id'
       const { getModel } = this.app.dobo
       const ref = getModel(model)
-      const opts = { noHook: true, noCache: true, ...options }
+      const opts = { ...options, noCache: true, noMagic: true }
       opts.dataOnly = true
       const rec = await ref.findOneRecord({ query }, opts)
       return get(rec, field, null)

package/package.json

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

package/wiki/CHANGES.md

@@ -1,5 +1,17 @@
 # Changes
 
+## 2026-05-16
+
+- [2.24.0] Change ```dobo:immutable``` feature, field no longer hidden
+- [2.24.0] Add ```dobo:[before|after]Driver<Action>``` hook
+- [2.24.0] Add ```dobo.<modelName>:[before|after]Driver<Action>``` hook
+- [2.24.0] Change ```model._simpleLookup()```
+- [2.24.0] Remove ```dobo:[before|after]Build[Query|Search]``` hook
+- [2.24.0] Change ```model.loadFixtures()```
+- [2.24.0] Bugfix in ```model.sanitizeBody()```
+- [2.24.0] Add ```dobo:afterTransaction``` hook
+- [2.24.0] Add ```dobo.<modelName>:afterTransaction``` hook
+
 ## 2026-05-11
 
 - [2.23.0] Add ```beforeBulkCreate``` model hook on ```dobo:unique``` feature