dobo 2.11.4 → 2.13.0

package/.bootorder

@@ -0,0 +1 @@
+10

package/extend/bajo/intl/en-US.json

@@ -146,7 +146,7 @@
   "buildOp": "'build' operation",
   "dropOp": "'drop' operation",
   "maxLimitWarning%s%s": "Records per page (%s rows) above the allowed threshold (%s rows)",
-  "hardLimitWarning%s%s": "Max records returned (%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)",
   "field": {
     "id": "ID",

package/extend/bajo/intl/id.json

@@ -143,8 +143,8 @@
   "inMemoryDb%s%s": "'%s' adalah database in-memory, %s tidak diizinkan",
   "buildOp": "operasi 'build'",
   "dropOp": "operasi 'drop'",
-  "maxLimitWarning%s": "Data per halaman (%s baris) melampaui batas yang diijinkan (%s baris)",
-  "hardLimitWarning%s": "Maksimum data yang dihasilkan (%s baris) melampaui batas yang diijinkan (%s baris)",
+  "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)",
   "field": {
     "id": "ID",

package/index.js

@@ -148,10 +148,10 @@ async function factory (pkgName) {
         },
         default: {
           filter: {
-            limit: 25,
-            maxLimit: 200,
-            hardLimit: 10000,
-            maxPage: 50,
+            limit: 25, // num of records per page
+            maxLimit: 200, // max num of records per page
+            hardCap: 10000, // max returned records
+            maxPage: 50, // max allowed page number
             sort: ['dt:-1', 'updatedAt:-1', 'updated_at:-1', 'createdAt:-1', 'createdAt:-1', 'ts:-1', 'username', 'name']
           },
           cache: {
@@ -493,6 +493,29 @@ async function factory (pkgName) {
         else await hook.handler.call(model, ...args)
       }
     }
+
+    getDefaultValues = (options = {}) => {
+      const { get } = this.app.lib._
+      const config = this.app.dobo.config
+      const limit = get(options, 'req.site.setting.dobo.default.limit', config.default.filter.limit)
+      const maxLimit = get(options, 'req.site.setting.dobo.default.maxLimit', config.default.filter.maxLimit)
+      const hardCap = get(options, 'req.site.setting.dobo.default.hardCap', config.default.filter.hardCap)
+      const maxPage = get(options, 'req.site.setting.dobo.default.maxPage', config.default.filter.maxPage)
+      const t = options.req ? options.req.t : this.t
+      return { limit, maxLimit, hardCap, maxPage, t }
+    }
+
+    handleLastPage = (params = {}, options = {}) => {
+      const { count, limit, page } = params
+      const { hardCap } = this.getDefaultValues(options)
+      if (count > hardCap) {
+        const lastPage = Math.floor(hardCap / limit)
+        if (page > lastPage) {
+          const warnings = [this.t('hardCapWarning%s%s', count, hardCap)]
+          return { data: [], count: hardCap, warnings }
+        }
+      }
+    }
   }
 
   return Dobo

package/lib/factory/driver.js

@@ -135,8 +135,7 @@ async function driverFactory () {
           if (isSet(body[field])) query[field] = body[field]
         }
         if (isEmpty(query)) continue
-        const resp = await this.findRecord(model, { query, limit: 1 }, options)
-        const data = resp.data[0]
+        const data = await this.findOneRecord(model, { query }, options)
         if (!isEmpty(data)) {
           if (['updateRecord', 'upsertRecord'].includes(options.action)) {
             let eq = true

package/lib/factory/model/_util.js

@@ -383,20 +383,21 @@ export function replaceIdInQuerySearch (filter) {
  */
 export function preparePagination (filter = {}, options = {}) {
   const { isEmpty, map, each, isPlainObject, isString, trim, keys } = this.app.lib._
-  const config = this.app.dobo.config
+  const { getDefaultValues, config } = this.app.dobo
+  const { limit: defLimit, maxLimit: defMaxLimit, maxPage: defMaxPage } = getDefaultValues(options)
 
   const buildPageSkipLimit = (filter) => {
-    let limit = parseInt(filter.limit) || config.default.filter.limit
-    if (limit === -1) limit = config.default.filter.maxLimit
-    if (limit > config.default.filter.maxLimit) {
+    let limit = parseInt(filter.limit) || defLimit
+    if (limit === -1) limit = defMaxLimit
+    if (limit > defMaxLimit) {
       options.warnings = options.warnings ?? []
-      options.warnings.push(options.req ? options.req.t('maxLimitWarning%s%s', limit, config.default.filter.maxLimit) : this.plugin.t('maxLimitWarning%s', limit, config.default.filter.maxLimit))
-      limit = config.default.filter.maxLimit // TODO: notify as warning in response object
+      options.warnings.push(options.req ? options.req.t('maxLimitWarning%s%s', limit, defMaxLimit) : this.plugin.t('maxLimitWarning%s', limit, defMaxLimit))
+      limit = defMaxLimit // TODO: notify as warning in response object
     }
     if (limit < 1) limit = 1
     let page = parseInt(filter.page) || 1
     if (page < 1) page = 1
-    if (page > config.default.filter.maxPage) throw this.plugin.error('maxPageError%s%s', page, config.default.filter.maxPage)
+    if (page > defMaxPage) throw this.plugin.error('maxPageError%s%s', page, defMaxPage)
     let skip = (page - 1) * limit
     if (filter.skip) {
       skip = parseInt(filter.skip) || skip

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

@@ -2,14 +2,22 @@ import { getFilterAndOptions, execHook, execModelHook, execDynHook } from './_ut
 const action = 'countRecord'
 
 async function countRecord (...args) {
+  const { getDefaultValues } = this.app.dobo
   if (args.length === 0) return this.action(action, ...args)
   const [params = {}, opts = {}] = args
   const { dataOnly = true } = opts
   const { filter, options } = await getFilterAndOptions.call(this, params, opts, action)
+  const { hardCap, t } = getDefaultValues(options)
   await execHook.call(this, 'beforeCountRecord', options)
   await execModelHook.call(this, 'beforeCountRecord', filter, options)
   await execDynHook.call(this, 'beforeCountRecord', filter, options)
   const result = (await this.driver._countRecord(this, filter, options)) ?? {}
+  if (result.data > hardCap) {
+    result.warnings = result.warnings ?? []
+    result.warnings.push(t('hardCapWarning%s%s', result.data, hardCap))
+    result.orgCount = result.data
+    result.data = hardCap
+  }
   await execDynHook.call(this, 'afterCountRecord', filter, result, options)
   await execModelHook.call(this, 'afterCountRecord', filter, result, options)
   await execHook.call(this, 'afterCountRecord', filter, result, options)

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

@@ -44,10 +44,11 @@ async function native (...args) {
 
 async function loop (...args) {
   const { cloneDeep } = this.app.lib._
+  const { getDefaultValues } = this.app.dobo
   const [params = {}, opts = {}] = args
   const { dataOnly = true } = opts
   const { filter, options } = await getFilterAndOptions.call(this, params, opts, action)
-  const { maxLimit, hardLimit } = this.app.dobo.config.default.filter
+  const { maxLimit, hardCap } = getDefaultValues(options)
   const nFilter = cloneDeep(filter || {})
   const nOptions = cloneOptions.call(this, options)
   nOptions.count = false
@@ -60,9 +61,9 @@ async function loop (...args) {
   for (;;) {
     const result = await this.findRecord(nFilter, nOptions)
     if (result.data.length === 0) break
-    if (count + result.data.length > hardLimit) {
-      const sliced = result.data.slice(0, hardLimit - count)
-      warnings.push(options.req ? options.req.t('hardLimitWarning%s%s', result.data.length, hardLimit) : this.plugin.t('hardLimitWarning%s%s', result.data.length, hardLimit))
+    if (count + result.data.length > hardCap) {
+      const sliced = result.data.slice(0, hardCap - count)
+      warnings.push(options.req ? options.req.t('hardCapWarning%s%s', result.data.length, hardCap) : this.plugin.t('hardCapWarning%s%s', result.data.length, hardCap))
       data.push(...sliced)
       break
     }

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

@@ -66,12 +66,14 @@ const action = 'findRecord'
  */
 async function findRecord (...args) {
   if (args.length === 0) return this.action(action, ...args)
+  const { getDefaultValues, t } = this.app.dobo
   const [params = {}, opts = {}] = args
   const { isSet } = this.app.lib.aneka
-  const { cloneDeep } = this.app.lib._
+  const { cloneDeep, pick, omit } = this.app.lib._
   const { dataOnly = true } = opts
   const { get: getCache, set: setCache } = this.app.bajoCache ?? {}
   const { filter, options } = await getFilterAndOptions.call(this, params, opts, action)
+  const { hardCap } = getDefaultValues(options)
   if (dataOnly) options.count = false
   let { noResultSanitizer, noCache } = options
   await execHook.call(this, 'beforeFindRecord', filter, options)
@@ -89,7 +91,18 @@ async function findRecord (...args) {
       return dataOnly ? result.data : result
     }
   }
-  const result = options.record ?? (await this.driver._findRecord(this, 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.pages = options.count ? Math.ceil(result.count / filter.limit) : undefined
+
   if (!noResultSanitizer) {
     for (const idx in result.data) {
       result.data[idx] = await this.sanitizeRecord(result.data[idx], options)

package/lib/factory/model/validate.js

@@ -238,7 +238,7 @@ async function validate (body, joiModel, opts = {}) {
   try {
     return await joiModel.validateAsync(body, params)
   } catch (err) {
-    const payload = { details: err.details, statusCode: 422, code: 'DB_VALIDATION' }
+    const payload = { details: err.details, statusCode: 422, code: 'DB_VALIDATION', model: this.name }
     if (err.values) payload.values = err.values
     throw this.plugin.error('validationError', payload)
   }

package/lib/factory/model.js

@@ -109,7 +109,9 @@ async function modelFactory () {
       if (isEmpty(field)) field = 'id'
       const { getModel } = this.app.dobo
       const ref = getModel(model)
-      const rec = await ref.findOneRecord({ query }, { noHook: true, noCache: true, ...options })
+      const opts = { noHook: true, noCache: true, ...options }
+      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.11.4",
+  "version": "2.13.0",
   "description": "DBMS for Bajo Framework",
   "main": "index.js",
   "scripts": {

package/wiki/CHANGES.md

@@ -1,5 +1,12 @@
 # Changes
 
+## 2026-03-30
+
+- [2.12.0] Add ```.bootorder``` level 10
+- [2.12.0] Bug fix in ```model._simpleLookup()```
+- [2.12.0] Add model name in validation error's payload
+- [2.13.0] Add ```hardCap``` support
+
 ## 2026-03-26
 
 - [2.11.4] Exceptions thrown in ```getSingleRef()``` && ```getMultiRefs()``` will be catched and are ignored

package/wiki/CONFIG.md

@@ -16,7 +16,7 @@
 |         ```filter``` | ```object``` | | |
 |             ```limit``` | ```number``` | ```25``` | Rows returned in one page |
 |             ```maxLimit``` | ```number``` | ```200``` | Max rows returned in one page |
-|             ```hardLimit``` | ```number``` | ```10000``` | Max rows returned on dataset export |
+|             ```hardCap``` | ```number``` | ```10000``` | Max rows returned on dataset export |
 |             ```sort``` | ```array``` | | |
 |         ```idField``` | ```object``` | | |
 | ```memDb``` | ```object``` | | |