dobo 2.19.1 → 2.20.1

package/lib/collect-models.js

@@ -52,12 +52,12 @@ async function sanitizeProp (model, prop, indexes) {
  * @param {Array} [inputs] - Array of properties
  * @param {Array} [indexes] - Container array to fill up found index
  */
-async function findAllProps (model, inputs = [], indexes = [], isExtender) {
+async function findAllProps (model, inputs = [], indexes = []) {
   const { isPlainObject, cloneDeep } = this.app.lib._
   const isIdProp = inputs.find(p => {
     return isPlainObject(p) ? p.name === 'id' : p.startsWith('id,')
   })
-  if (!isExtender && !isIdProp) {
+  if (!isIdProp) {
     const idField = cloneDeep(model.connection.driver.idField)
     idField.name = 'id'
     inputs.unshift(idField)
@@ -74,7 +74,7 @@ async function findAllProps (model, inputs = [], indexes = [], isExtender) {
  * @param {Object} options - Options to the feature
  * @returns {Array} New properties found in feature
  */
-async function applyFeature (model, feature, options, indexes, isExtender) {
+async function applyFeature (model, feature, options, indexes) {
   const { isArray, findIndex } = this.app.lib._
   if (feature.name === 'dobo:unique' && options.field === 'id') {
     const idx = findIndex(model.properties, { name: 'id' })
@@ -103,14 +103,14 @@ async function applyFeature (model, feature, options, indexes, isExtender) {
  * @param {Object} model - Model
  * @param {Array} [inputs] - Array of properties
  */
-async function findAllFeats (model, inputs = [], indexes = [], isExtender) {
+async function findAllFeats (model, inputs = [], indexes = []) {
   const { isString, omit } = this.app.lib._
   for (let feat of inputs) {
     if (isString(feat)) feat = { name: feat }
     const featName = feat.name.indexOf(':') === -1 ? `dobo:${feat.name}` : feat.name
     const feature = this.app.dobo.getFeature(featName)
     if (!feature) this.fatal('invalidFeature%s%s', model.name, featName)
-    await applyFeature.call(this, model, feature, omit(feat, 'name'), indexes, isExtender)
+    await applyFeature.call(this, model, feature, omit(feat, 'name'), indexes)
   }
 }
 
@@ -235,9 +235,7 @@ export async function sanitizeAll (model) {
  * @returns {Object} Sanitized model
  */
 async function createSchema (item) {
-  const { readConfig } = this.app.bajo
-  const { fastGlob } = this.app.lib
-  const { find, isPlainObject, orderBy, get, cloneDeep } = this.app.lib._
+  const { find, orderBy, get } = this.app.lib._
   const { mergeObjectsByKey, defaultsDeep, parseObject } = this.app.lib.aneka
   if (item.file && !item.base) item.base = path.basename(item.file, path.extname(item.file))
   item.attachment = item.attachment ?? true
@@ -265,29 +263,18 @@ async function createSchema (item) {
     if (!item.connection && conn === 'default') item.connection = this.getConnection('memory')
   }
   if (!item.connection) this.fatal('unknownConn%s%s', conn, item.name)
-  const defCache = cloneDeep(get(this, 'app.bajoCache.config.default', this.config.default.cache))
-  item.cache = item.cache ?? item.connection.options.cache ?? defCache
-  if (item.cache === true) item.cache = get(item, 'connection.options.cache', defCache)
-  else if (item.cache === false) item.cache = { ttlDur: 0 }
-  item.cache = parseObject(defaultsDeep(get(this, `app.bajoCache.config.dobo.${item.name}`), item.cache))
+  // cache settings
+  const defCache = defaultsDeep({}, item.connection.options.cache, get(this, 'app.bajoCache.config.default', this.config.default.cache))
+  if (item.cache === false) item.cache = { ttlDur: 0 }
+  else if (item.cache === true) item.cache = defCache
+  else item.cache = defaultsDeep({}, item.cache, defCache)
+  item.cache = parseObject(item.cache)
+  if (item.connection.name === 'memory') item.cache.ttlDur = 0
+
+  // let's run
   await findAllProps.call(this, item, props, indexes)
   await findAllFeats.call(this, item, feats, indexes)
   await findAllIndexes.call(this, item, indexes)
-  // item extender
-  if (item.base) {
-    for (const ns of this.app.getAllNs()) {
-      const plugin = this.app[ns]
-      const glob = `${plugin.dir.pkg}/extend/dobo/extend/${item.ns}/model/${item.base}.*`
-      const files = await fastGlob(glob)
-      for (const file of files) {
-        const extender = await readConfig(file, { ns: plugin.ns, ignoreError: true })
-        if (!isPlainObject(extender)) this.plugin.fatal('invalidModelExtender%s%s', ns, item.name)
-        await findAllProps.call(this, item, extender.properties ?? [], indexes, true)
-        await findAllFeats.call(this, item, extender.features ?? [], indexes, true)
-        await findAllIndexes.call(this, item, extender.indexes ?? [], indexes, true)
-      }
-    }
-  }
   for (const key of ['properties', 'indexes']) {
     item[key] = mergeObjectsByKey(item[key], 'name')
   }
@@ -322,10 +309,11 @@ async function collectModels () {
 
     const base = path.basename(file, path.extname(file))
     const defName = pascalCase(`${this.alias} ${base}`)
-    const item = await readConfig(file, { ns: this.ns, ignoreError: true })
+    const item = await readConfig(file, { ns: this.ns, baseNs: me.ns })
     if (isEmpty(item)) return undefined
     if (!isPlainObject(item)) me.fatal('invalidModel%s', defName)
     item.name = item.name ?? defName
+    me.log.trace('- %s', item.name)
     item.collName = item.collName ?? item.name
     item.file = file
     item.ns = this.ns
@@ -344,7 +332,6 @@ async function collectModels () {
   }
   for (const model of me.models) {
     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

@@ -430,3 +430,12 @@ export function preparePagination (filter = {}, options = {}) {
   const sort = buildSort(sortInput, options.allowSortUnindexed)
   return { limit, page, skip, sort }
 }
+
+export async function clearCache (id) {
+  const { clear } = this.app.bajoCache
+  if (!clear) return
+  await clear({ key: `dobo|${this.name}|getRecord|${id}` })
+  await clear({ key: `dobo|${this.name}|findRecord` })
+  await clear({ key: `dobo|${this.name}|findAllRecord` })
+  await clear({ key: `dobo|${this.name}|findOneRecord` })
+}

package/lib/factory/model/find-all-record.js

@@ -4,45 +4,50 @@ const action = 'findAllRecord'
 async function native (...args) {
   const { isSet } = this.app.lib.aneka
   const { getDefaultValues, t } = this.app.dobo
-  const { pick, omit } = this.app.lib._
+  const { pick, omit, cloneDeep } = this.app.lib._
   const [params = {}, opts = {}] = args
+  const { get, set } = this.app.bajoCache ?? {}
   opts.dataOnly = opts.dataOnly ?? true
   const { dataOnly } = opts
   const { filter, options } = await getFilterAndOptions.call(this, params, opts, action)
   const { hardCap, warnings } = getDefaultValues(options)
   if (dataOnly) options.count = false
   const { noResultSanitizer } = options
-  try {
-    await execHook.call(this, 'beforeFindRecord', filter, options)
-    await execModelHook.call(this, 'beforeFindRecord', filter, options)
-    await execDynHook.call(this, 'beforeFindRecord', filter, options)
-    let result = options.record ?? (await this.driver._findAllRecord(this, filter, options)) ?? {}
-    result.limit = filter.limit
-    result.filter = pick(filter, ['query', 'match', 'sort'])
-    result.warnings = result.warnings ?? []
-    if (!options.count) result = omit(result, ['count', 'pages'])
-    else if (options.count && result.count > hardCap) {
-      result.warnings.push(t('hardCapWarning%s%s', result.count, hardCap))
-      result.count = hardCap
-      result.hardCapped = true
+  await execHook.call(this, 'beforeFindRecord', filter, options)
+  await execModelHook.call(this, 'beforeFindRecord', filter, options)
+  await execDynHook.call(this, 'beforeFindRecord', filter, options)
+  const cFilter = cloneDeep(filter)
+  if (get) {
+    const resp = await get({ model: this, action, filter: cFilter, options })
+    if (resp) {
+      resp.cached = true
+      return dataOnly ? resp.data : resp
     }
-    result.pages = options.count ? Math.ceil(result.count / filter.limit) : undefined
-    if (!warnings) delete result.warnings
+  }
+  let result = options.record ?? (await this.driver._findAllRecord(this, filter, options)) ?? {}
+  result.limit = filter.limit
+  result.filter = pick(filter, ['query', 'match', 'sort'])
+  result.warnings = result.warnings ?? []
+  if (!options.count) result = omit(result, ['count', 'pages'])
+  else if (options.count && result.count > hardCap) {
+    result.warnings.push(t('hardCapWarning%s%s', result.count, hardCap))
+    result.count = hardCap
+    result.hardCapped = true
+  }
+  result.pages = options.count ? Math.ceil(result.count / filter.limit) : undefined
+  if (!warnings) delete result.warnings
 
-    if (!noResultSanitizer) {
-      for (const idx in result.data) {
-        result.data[idx] = await this.sanitizeRecord(result.data[idx], options)
-      }
+  if (!noResultSanitizer) {
+    for (const idx in result.data) {
+      result.data[idx] = await this.sanitizeRecord(result.data[idx], options)
     }
-    if (isSet(options.refs)) await getMultiRefs.call(this, result.data, options)
-    await execDynHook.call(this, 'afterFindRecord', filter, result, options)
-    await execModelHook.call(this, 'afterFindRecord', filter, result, options)
-    await execHook.call(this, 'afterFindRecord', filter, result, options)
-    return dataOnly ? result.data : result
-  } catch (err) {
-    if (err.code === 'cachedResult') return err.data
-    throw err
   }
+  if (isSet(options.refs)) await getMultiRefs.call(this, result.data, options)
+  await execDynHook.call(this, 'afterFindRecord', filter, result, options)
+  await execModelHook.call(this, 'afterFindRecord', filter, result, options)
+  await execHook.call(this, 'afterFindRecord', filter, result, options)
+  if (set) await set({ model: this, action, filter: cFilter, options, result })
+  return dataOnly ? result.data : result
 }
 
 async function loop (...args) {

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

@@ -69,45 +69,50 @@ async function findRecord (...args) {
   const { getDefaultValues, t } = this.app.dobo
   const [params = {}, opts = {}] = args
   const { isSet } = this.app.lib.aneka
-  const { pick, omit } = this.app.lib._
+  const { pick, omit, cloneDeep } = this.app.lib._
+  const { get, set } = this.app.bajoCache ?? {}
   opts.dataOnly = opts.dataOnly ?? true
   const { dataOnly } = opts
   const { filter, options } = await getFilterAndOptions.call(this, params, opts, action)
   const { hardCap, warnings } = getDefaultValues(options)
   if (dataOnly) options.count = false
   const { noResultSanitizer } = options
-  try {
-    await execHook.call(this, 'beforeFindRecord', filter, options)
-    await execModelHook.call(this, 'beforeFindRecord', filter, options)
-    await execDynHook.call(this, 'beforeFindRecord', filter, options)
-    let result = options.record ?? (await this.driver._findRecord(this, filter, options)) ?? {}
-    result.page = filter.page
-    result.limit = filter.limit
-    result.filter = pick(filter, ['query', 'match', 'sort'])
-    result.warnings = result.warnings ?? []
-    if (!options.count) result = omit(result, ['count', 'pages'])
-    else if (options.count && result.count > hardCap) {
-      result.warnings.push(t('hardCapWarning%s%s', result.count, hardCap))
-      result.count = hardCap
-      result.hardCapped = true
+  await execHook.call(this, 'beforeFindRecord', filter, options)
+  await execModelHook.call(this, 'beforeFindRecord', filter, options)
+  await execDynHook.call(this, 'beforeFindRecord', filter, options)
+  const cFilter = cloneDeep(filter)
+  if (get) {
+    const resp = await get({ model: this, action, filter: cFilter, options })
+    if (resp) {
+      resp.cached = true
+      return dataOnly ? resp.data : resp
     }
-    result.pages = options.count ? Math.ceil(result.count / filter.limit) : undefined
-    if (!warnings) delete result.warnings
+  }
+  let result = options.record ?? (await this.driver._findRecord(this, filter, options)) ?? {}
+  result.page = filter.page
+  result.limit = filter.limit
+  result.filter = pick(filter, ['query', 'search', 'sort'])
+  result.warnings = result.warnings ?? []
+  if (!options.count) result = omit(result, ['count', 'pages'])
+  else if (options.count && result.count > hardCap) {
+    result.warnings.push(t('hardCapWarning%s%s', result.count, hardCap))
+    result.count = hardCap
+    result.hardCapped = true
+  }
+  result.pages = options.count ? Math.ceil(result.count / filter.limit) : undefined
+  if (!warnings) delete result.warnings
 
-    if (!noResultSanitizer) {
-      for (const idx in result.data) {
-        result.data[idx] = await this.sanitizeRecord(result.data[idx], options)
-      }
+  if (!noResultSanitizer) {
+    for (const idx in result.data) {
+      result.data[idx] = await this.sanitizeRecord(result.data[idx], options)
     }
-    if (isSet(options.refs)) await getMultiRefs.call(this, result.data, options)
-    await execDynHook.call(this, 'afterFindRecord', filter, result, options)
-    await execModelHook.call(this, 'afterFindRecord', filter, result, options)
-    await execHook.call(this, 'afterFindRecord', filter, result, options)
-    return dataOnly ? result.data : result
-  } catch (err) {
-    if (err.code === 'cachedResult') return err.data
-    throw err
   }
+  if (isSet(options.refs)) await getMultiRefs.call(this, result.data, options)
+  await execDynHook.call(this, 'afterFindRecord', filter, result, options)
+  await execModelHook.call(this, 'afterFindRecord', filter, result, options)
+  await execHook.call(this, 'afterFindRecord', filter, result, options)
+  if (set) await set({ model: this, action, filter: cFilter, options, result })
+  return dataOnly ? result.data : result
 }
 
 export default findRecord

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

@@ -48,29 +48,33 @@ async function getRecord (...args) {
   const { getDefaultValues } = this.app.dobo
   const { isEmpty } = this.app.lib._
   const { isSet } = this.app.lib.aneka
+  const { get, set } = this.app.bajoCache ?? {}
   opts.dataOnly = opts.dataOnly ?? true
   const { dataOnly } = opts
   const { options } = await getFilterAndOptions.call(this, null, opts, action)
   const { noResultSanitizer } = options
   id = this.sanitizeId(id)
-  try {
-    await execHook.call(this, 'beforeGetRecord', id, options)
-    await execModelHook.call(this, 'beforeGetRecord', id, options)
-    await execDynHook.call(this, 'beforeGetRecord', id, options)
-    const result = options.record ?? (await this.driver._getRecord(this, id, options)) ?? {}
-    const { warnings } = getDefaultValues(options)
-    if (!warnings) delete result.warnings
-    if (isEmpty(result.data) && !options.throwNotFound) return dataOnly ? undefined : { data: undefined }
-    if (!noResultSanitizer) result.data = await this.sanitizeRecord(result.data, options)
-    if (isSet(options.refs)) await getSingleRef.call(this, result.data, options)
-    await execDynHook.call(this, 'afterGetRecord', id, result, options)
-    await execModelHook.call(this, 'afterGetRecord', id, result, options)
-    await execHook.call(this, 'afterGetRecord', id, result, options)
-    return dataOnly ? result.data : result
-  } catch (err) {
-    if (err.code === 'cachedResult') return err.data
-    throw err
+  await execHook.call(this, 'beforeGetRecord', id, options)
+  await execModelHook.call(this, 'beforeGetRecord', id, options)
+  await execDynHook.call(this, 'beforeGetRecord', id, options)
+  if (get) {
+    const resp = await get({ model: this, action, id, options })
+    if (resp) {
+      resp.cached = true
+      return dataOnly ? resp.data : resp
+    }
   }
+  const result = options.record ?? (await this.driver._getRecord(this, id, options)) ?? {}
+  const { warnings } = getDefaultValues(options)
+  if (!warnings) delete result.warnings
+  if (isEmpty(result.data) && !options.throwNotFound) return dataOnly ? undefined : { data: undefined }
+  if (!noResultSanitizer) result.data = await this.sanitizeRecord(result.data, options)
+  if (isSet(options.refs)) await getSingleRef.call(this, result.data, options)
+  await execDynHook.call(this, 'afterGetRecord', id, result, options)
+  await execModelHook.call(this, 'afterGetRecord', id, result, options)
+  await execHook.call(this, 'afterGetRecord', id, result, options)
+  if (set) await set({ model: this, action, id, options, result })
+  return dataOnly ? result.data : result
 }
 
 export default getRecord

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

@@ -1,4 +1,4 @@
-import { getFilterAndOptions, execHook, execModelHook, execDynHook, getSingleRef, handleReq } from './_util.js'
+import { getFilterAndOptions, execHook, execModelHook, execDynHook, getSingleRef, handleReq, clearCache } from './_util.js'
 const action = 'removeRecord'
 
 /**
@@ -45,6 +45,7 @@ async function removeRecord (...args) {
   await execModelHook.call(this, 'beforeRemoveRecord', id, options)
   await execDynHook.call(this, 'beforeRemoveRecord', id, options)
   const result = options.record ?? (await this.driver._removeRecord(this, id, options)) ?? {}
+  await clearCache.call(this, id)
   if (noResult) return
   const { warnings } = getDefaultValues(options)
   if (!warnings) delete result.warnings

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

@@ -1,4 +1,4 @@
-import { getFilterAndOptions, execHook, execValidation, execModelHook, execDynHook, getSingleRef, handleReq } from './_util.js'
+import { getFilterAndOptions, execHook, execValidation, execModelHook, execDynHook, getSingleRef, handleReq, clearCache } from './_util.js'
 import { onlyTypes } from './create-record.js'
 const action = 'updateRecord'
 
@@ -67,6 +67,7 @@ async function updateRecord (...args) {
   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)) ?? {}
+  await clearCache.call(this, id)
   if (noResult) return
   const { warnings } = getDefaultValues(options)
   if (!warnings) delete result.warnings

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

@@ -1,4 +1,4 @@
-import { getFilterAndOptions, execHook, execModelHook, execDynHook, execValidation, getSingleRef, handleReq } from './_util.js'
+import { getFilterAndOptions, execHook, execModelHook, execDynHook, execValidation, getSingleRef, handleReq, clearCache } from './_util.js'
 const action = 'upsertRecord'
 
 async function native (body = {}, opts = {}) {
@@ -16,6 +16,7 @@ async function native (body = {}, opts = {}) {
   await execModelHook.call(this, 'beforeUpsertRecord', input, options)
   await execDynHook.call(this, 'beforeUpsertRecord', input, options)
   const result = options.record ?? (await this.driver._upsertRecord(this, input, options)) ?? {}
+  await clearCache.call(this, body.id)
   if (noResult) return
   const { warnings } = getDefaultValues(options)
   if (!warnings) delete result.warnings
@@ -39,7 +40,7 @@ async function manual (body = {}, options = {}) {
     } catch (err) {
     }
   }
-  const id = get(old, 'dara.id')
+  const id = get(old, 'data.id')
   if (id) return await this.updateRecord(old.data.id, omit(body, ['id']), options)
   return await this.createRecord(body, options)
 }

package/package.json

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

package/wiki/CHANGES.md

@@ -1,10 +1,15 @@
 # Changes
 
+## 2026-04-23
+
+- [2.20.1] Bug fix in ```collect-models.js```, now with deep merge in advance
+
 ## 2026-04-21
 
-- [2.5.1] Bug fix in ```collect-models.js```, now values are sanitized with ```parseObject()```
-- [2.5.1] Bug fix in ```options.dataOnly``` on all model methods
-- [2.5.1] Add ```options.noMagic```
+- [2.19.1] Bug fix in ```collect-models.js```, now values are sanitized with ```parseObject()```
+- [2.19.1] Bug fix in ```options.dataOnly``` on all model methods
+- [2.19.1] Add ```options.noMagic```
+- [2.20.0] Revert back to NOT using hooks for caching
 
 ## 2026-04-19