dobo 2.24.0 → 2.26.0

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

@@ -151,6 +151,7 @@
   "duplicateRefKeys%s%s": "Duplicate reference keys found in '%s' (%s)",
   "sanitizeBodyError": "Error sanitizing body",
   "virtualFieldIn%s%s%s": "Virtual field '%s' can't be used in '%s' on %s",
+  "noFunctionAllowed%s%s": "Use name handler instead of function in '%s.%s'",
   "field": {
     "id": "ID",
     "code": "Kode",
@@ -225,6 +226,9 @@
       "required": "Required",
       "only": "Must match with %(ref)s"
     },
+    "array": {
+      "base": "Required"
+    },
     "string": {
       "alphanum": "Must only contain alpha-numeric characters",
       "base": "Must be a string",

package/extend/bajo/intl/id.json

@@ -150,6 +150,7 @@
   "duplicateRefKeys%s%s": "Ditemukan kunci referensi duplikat di '%s' (%s)",
   "sanitizeBodyError": "Kesalahan saat sanitasi body",
   "virtualFieldIn%s%s%s": "Kolom virtual '%s' tidak bisa digunakan di '%s' pada %s",
+  "noFunctionAllowed%s%s": "Gunakan nama handler, bukan fungsi di '%s.%s'",
   "field": {
     "id": "ID",
     "code": "Kode",
@@ -224,6 +225,9 @@
       "required": "Harus diisi/dipilih",
       "only": "Harus sesuai dengan %(ref)s"
     },
+    "array": {
+      "base": "Required"
+    },
     "string": {
       "alphanum": "Harus berupa alfa numerik karakter saja",
       "base": "Harus berupa string",

package/extend/dobo/feature/immutable.js

@@ -1,6 +1,6 @@
 async function beforeRemoveRecord (id, opts, options) {
   const { get } = this.app.lib._
-  if (get(options, 'req.user.interSiteAdmin')) return
+  if (get(options, 'req.user.isXSiteAdmin')) return
   const record = await this.driver.getRecord(this, id)
   const immutable = get(record.data, opts.field)
   if (immutable) throw this.plugin.error('recordImmutable%s%s', id, this.name, { statusCode: 423 })

package/index.js

@@ -73,11 +73,11 @@ const propertyType = {
     rules: []
   },
   object: {
-    validator: null,
+    validator: 'object',
     rules: []
   },
   array: {
-    validator: null,
+    validator: 'array',
     rules: []
   }
 }

package/lib/collect-models.js

@@ -290,7 +290,6 @@ async function createSchema (item) {
   }
   item.hooks = orderBy(item.hooks, ['name', 'level'])
   delete item.features
-  delete item.base
   await sanitizeAll.call(this, item)
   return item
 }
@@ -304,8 +303,8 @@ async function createSchema (item) {
  * @see Dobo#init
  */
 async function collectModels () {
-  const { eachPlugins } = this.app.bajo
-  const { orderBy, has, isFunction, omit } = this.app.lib._
+  const { eachPlugins, callHandler } = this.app.bajo
+  const { orderBy, has, omit } = this.app.lib._
   await actionFactory.call(this)
   await modelFactory.call(this)
 
@@ -313,28 +312,31 @@ async function collectModels () {
   const me = this
   let schemas = []
   await eachPlugins(async function ({ file }) {
-    const { readConfig } = this.app.bajo
+    const { readConfig, callHandler } = this.app.bajo
     const { pascalCase } = this.app.lib.aneka
-    const { isPlainObject, isEmpty } = this.app.lib._
+    const { isPlainObject, isEmpty, isArray } = this.app.lib._
 
-    const base = path.basename(file, path.extname(file))
-    const defName = pascalCase(`${this.alias} ${base}`)
-    const item = await readConfig(file, { ns: this.ns, baseNs: me.ns, merge: true })
-    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.options = item.options ?? {}
-    item.options.attachment = item.options.attachment ?? true
-    item.options.persistence = item.options.persistence ?? true
-    item.options.file = file
-    item.options.base = item.options.base ?? path.basename(file, path.extname(file))
-    item.ns = this.ns
-    if (isFunction(item.buildStart)) await item.buildStart.call(me, item)
-    const schema = await createSchema.call(me, item)
-    schemas.push(schema)
-  }, { glob: 'model/*.*', prefix: this.ns })
+    let items = await readConfig(file, { ns: this.ns, baseNs: me.ns, merge: true })
+    if (isEmpty(items)) return undefined
+    if (isPlainObject(items)) {
+      items.baseName = items.baseName ?? path.basename(file, path.extname(file))
+      items.name = items.name ?? pascalCase(`${this.alias} ${items.baseName}`)
+    }
+    if (!isArray(items)) items = [items]
+    for (const item of items) {
+      if (!item.baseName) me.fatal('missing%s%s', 'baseName', file)
+      item.name = item.name ?? pascalCase(`${this.alias} ${item.baseName}`)
+      me.log.trace('- %s', item.name)
+      item.collName = item.collName ?? item.name
+      item.options = item.options ?? {}
+      item.options.attachment = item.options.attachment ?? true
+      item.options.persistence = item.options.persistence ?? true
+      item.ns = this.ns
+      if (item.buildStart) await callHandler(this, item.buildStart, item)
+      const schema = await createSchema.call(me, item)
+      schemas.push(schema)
+    }
+  }, { glob: ['model/*.*', 'model.*'], prefix: this.ns })
   schemas = orderBy(schemas, ['buildLevel', 'name'])
   for (const schema of schemas) {
     const plugin = this.app[schema.ns]
@@ -360,7 +362,7 @@ async function collectModels () {
       const prop = model.properties.find(p => p.name === field)
       if (!prop || (prop && prop.virtual)) throw this.error('virtualFieldIn%s%s%s', field, 'scanable', model.name)
     }
-    if (isFunction(schema.buildEnd)) await schema.buildEnd.call(me, model)
+    if (schema.buildEnd) await callHandler(this.app[schema.ns], schema.buildEnd, model)
   }
   schemas = []
   this.log.debug('collected%s%d', this.t('model'), this.models.length)

package/lib/factory/driver.js

@@ -130,8 +130,8 @@ async function driverFactory () {
       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)
+        await runHook(`${ns}.driver:${name}`, model, ...args)
+        await runHook(`${ns}.driver.${camelCase(model.name)}:${name}`, model, ...args)
       }
     }
 
@@ -257,9 +257,9 @@ async function driverFactory () {
       }
       body = this.sanitizeBody(model, body)
 
-      await this._attachHook('beforeDriverCreateRecord', model, body, options)
+      await this._attachHook('beforeCreateRecord', model, body, options)
       const result = await this.createRecord(model, body, options)
-      await this._attachHook('afterDriverCreateRecord', model, body, result, options)
+      await this._attachHook('afterCreateRecord', model, body, result, options)
 
       if (options.noResult) return
       result.data = this.sanitizeRecord(model, result.data)
@@ -277,18 +277,18 @@ async function driverFactory () {
         bodies[idx] = this.sanitizeBody(model, body)
       }
 
-      await this._attachHook('beforeDriverBulkCreateRecord', model, bodies, options)
+      await this._attachHook('beforeBulkCreateRecord', 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)
+      await this._attachHook('afterBulkCreateRecord', model, bodies, [], options)
     }
 
     async _getRecord (model, id, options = {}) {
-      await this._attachHook('beforeDriverGetRecord', model, id, options)
+      await this._attachHook('beforeGetRecord', model, id, options)
       const result = await this.getRecord(model, id, options)
-      await this._attachHook('afterDriverGetRecord', model, id, result, options)
+      await this._attachHook('afterGetRecord', 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)
@@ -309,9 +309,9 @@ async function driverFactory () {
       body = this.sanitizeBody(model, body, true)
       delete body.id
 
-      await this._attachHook('beforeDriverUpdateRecord', model, id, body, options)
+      await this._attachHook('beforeUpdateRecord', model, id, body, options)
       const result = await this.updateRecord(model, id, body, options)
-      await this._attachHook('afterDriverUpdateRecord', model, id, body, result, options)
+      await this._attachHook('afterUpdateRecord', model, id, body, result, options)
 
       if (options.noResult) return
       result.oldData = this.sanitizeRecord(model, result.oldData)
@@ -334,9 +334,9 @@ async function driverFactory () {
       }
       body = this.sanitizeBody(model, body)
 
-      await this._attachHook('beforeDriverUpsertRecord', model, body, options)
+      await this._attachHook('beforeUpsertRecord', model, body, options)
       const result = await this.upsertRecord(model, body, options)
-      await this._attachHook('afterDriverUpsertRecord', model, body, result, options)
+      await this._attachHook('afterUpsertRecord', model, body, result, options)
 
       if (options.noResult) return
       if (result.oldData) result.oldData = this.sanitizeRecord(model, result.oldData)
@@ -352,9 +352,9 @@ async function driverFactory () {
         options._data = resp.data
       }
 
-      await this._attachHook('beforeDriverRemoveRecord', model, id, options)
+      await this._attachHook('beforeRemoveRecord', model, id, options)
       const result = await this.removeRecord(model, id, options)
-      await this._attachHook('afterDriverRemoveRecord', model, id, result, options)
+      await this._attachHook('afterRemoveRecord', model, id, result, options)
 
       if (options.noResult) return
       result.oldData = this.sanitizeRecord(model, result.oldData)
@@ -363,9 +363,9 @@ async function driverFactory () {
     }
 
     async _clearRecord (model, options = {}) {
-      await this._attachHook('beforeDriverClearRecord', model, options)
+      await this._attachHook('beforeClearRecord', model, options)
       const result = await this.clearRecord(model, options)
-      await this._attachHook('afterDriverClearRecord', model, result, options)
+      await this._attachHook('afterClearRecord', model, result, options)
 
       this._injectMeta(result, options)
       return result
@@ -374,9 +374,9 @@ async function driverFactory () {
     async _findRecord (model, filter = {}, options = {}) {
       let result
       try {
-        await this._attachHook('beforeDriverFindRecord', model, filter, options)
+        await this._attachHook('beforeFindRecord', model, filter, options)
         result = await this.findRecord(model, filter, options)
-        await this._attachHook('afterDriverFindRecord', model, filter, result, options)
+        await this._attachHook('afterFindRecord', model, filter, result, options)
       } catch (err) {
         if (err.message !== '_emptyColumnQuery') throw err
         result = {
@@ -396,9 +396,9 @@ async function driverFactory () {
     async _findAllRecord (model, filter = {}, options = {}) {
       let result
       try {
-        await this._attachHook('beforeDriverFindAllRecord', model, filter, options)
+        await this._attachHook('beforeFindAllRecord', model, filter, options)
         result = await this.findAllRecord(model, filter, options)
-        await this._attachHook('afterDriverFindAllRecord', model, filter, result, options)
+        await this._attachHook('afterFindAllRecord', model, filter, result, options)
       } catch (err) {
         if (err.message !== '_emptyColumnQuery') throw err
         result = {
@@ -418,9 +418,9 @@ async function driverFactory () {
     async _countRecord (model, filter = {}, options = {}) {
       let result
       try {
-        await this._attachHook('beforeDriverCountRecord', model, filter, options)
+        await this._attachHook('beforeCountRecord', model, filter, options)
         result = await this.countRecord(model, filter, options)
-        await this._attachHook('afterDriverCountRecord', model, filter, result, options)
+        await this._attachHook('afterCountRecord', model, filter, result, options)
       } catch (err) {
         if (err.message !== '_emptyColumnQuery') throw err
         result = { data: 0 }
@@ -445,9 +445,9 @@ async function driverFactory () {
 
       let result
       try {
-        await this._attachHook('beforeDriverCreateAggregate', model, filter, params, options)
+        await this._attachHook('beforeCreateAggregate', model, filter, params, options)
         result = await this.createAggregate(model, filter, params, options)
-        await this._attachHook('afterDriverCreateAggregate', model, filter, params, result, options)
+        await this._attachHook('afterCreateAggregate', model, filter, params, result, options)
       } catch (err) {
         if (err.message !== '_emptyColumnQuery') throw err
         result = { data: [] }
@@ -475,9 +475,9 @@ async function driverFactory () {
 
       let result
       try {
-        await this._attachHook('beforeDriverCreateHistogram', model, filter, params, options)
+        await this._attachHook('beforeCreateHistogram', model, filter, params, options)
         result = await this.createHistogram(model, filter, params, options)
-        await this._attachHook('afterDriverCreateHistogram', model, filter, params, result, options)
+        await this._attachHook('afterCreateHistogram', model, filter, params, result, options)
       } catch (err) {
         if (err.message !== '_emptyColumnQuery') throw err
         result = { data: [] }

package/lib/factory/model/_util.js

@@ -188,7 +188,7 @@ export async function getRefs (records = [], options = {}) {
           if (!rModel) return
           let matches = []
           for (const rec of records) {
-            const items = isValues ? [...rec[prop.name]] : [rec[prop.name]]
+            const items = isValues ? [...(rec[prop.name] ?? [])] : (rec[prop.name] ? [rec[prop.name]] : [])
             matches.push(...items.map(item => prop.name === 'id' ? rModel.sanitizeId(item) : item))
           }
           matches = uniq(without(matches, undefined, null, NaN)).map(i => i + '')
@@ -211,7 +211,7 @@ export async function getRefs (records = [], options = {}) {
           for (const i in records) {
             records[i]._ref = records[i]._ref ?? {}
             const rec = records[i]
-            let items = isValues ? [...rec[prop.name]] : [rec[prop.name]]
+            let items = isValues ? [...(rec[prop.name] ?? [])] : (rec[prop.name] ? [rec[prop.name]] : [])
             items = items.map(item => item + '')
             const res = results.filter(r => items.includes(r[ref.field] + ''))
             if (res.length === 0) records[i]._ref[key] = isValues ? [] : {}

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

@@ -26,21 +26,21 @@ 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, isSet } = this.app.lib.aneka
-  const { isEmpty, isString, isArray } = this.app.lib._
+  const { isSet } = this.app.lib.aneka
+  const { isEmpty, isString, isArray, pullAt } = this.app.lib._
   if (this.connection.proxy) {
     this.log.warn('proxiedConnBound%s', this.name)
     return
   }
   const result = { success: 0, failed: 0 }
-  const base = path.basename(this.options.file, path.extname(this.options.file))
-  const pattern = resolvePath(`${path.dirname(this.options.file)}/../fixture/${base}.*`)
-  const items = await readConfig(pattern, { ns: this.plugin.ns, baseNs: 'dobo', checkOverride: true, defValue: [] })
+  const items = await readConfig(`${this.plugin.ns}:/extend/dobo/fixture/${this.baseName}.*`, { ns: this.plugin.ns, baseNs: 'dobo', checkOverride: true, defValue: [] })
   const opts = { ...options, noMagic: true }
   for (const item of items) {
     const lv = {}
+    const deleted = {}
     for (const key in item) {
       const val = item[key]
+      deleted[key] = deleted[key] ?? []
       if (!noLookup) {
         if (isString(val) && val.slice(0, 2) === '?:') {
           item[key] = await this._simpleLookup(val.slice(2), lv, opts)
@@ -50,11 +50,14 @@ async function loadFixtures ({ spinner, ignoreError = true, collectItems = false
             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] += ''
+              else deleted[key].push(idx)
               lv[`${key}.${idx}`] = item[key][idx]
             }
           }
+          if (deleted[key].length > 0) pullAt(item[key], deleted[key])
         }
       }
+      delete deleted[key]
       if (val === null) item[key] = undefined
       else {
         const prop = this.properties.find(item => item.name === key)

package/lib/factory/model/validate.js

@@ -1,6 +1,6 @@
 import joi from 'joi'
 
-const excludedTypes = ['object', 'array']
+const excludedTypes = ['object']
 const excludedNames = []
 
 /**
@@ -142,7 +142,9 @@ async function buildFromDbModel (opts = {}) {
         const resp = await callHandler(prop.values)
         items = resp.map(item => item.value)
       }
-      obj = obj.valid(...items)
+      if (prop.type === 'array') {
+        obj = obj.items(joi.string().valid(...items))
+      } else obj = obj.valid(...items)
     }
     if (prop.rulesMsg) {
       const msgs = {}
@@ -185,6 +187,9 @@ async function buildFromDbModel (opts = {}) {
       case 'boolean':
         item = await applyFieldRules(p, joi.boolean())
         break
+      case 'array':
+        item = await applyFieldRules(p, joi.array())
+        break
     }
     if (item) {
       if (item.$_root && !p.required) obj[p.name] = item.allow(null, '')

package/lib/factory/model.js

@@ -96,11 +96,16 @@ async function modelFactory () {
       return namesOnly ? items.map(item => item.name) : items
     }
 
-    getVirtualProperties = ({ namesOnly }) => {
+    getVirtualProperties = (namesOnly) => {
       const items = this.properties.filter(prop => prop.virtual)
       return namesOnly ? items.map(item => item.name) : items
     }
 
+    getNonVirtualProperties = (namesOnly) => {
+      const items = this.properties.filter(prop => !prop.virtual)
+      return namesOnly ? items.map(item => item.name) : items
+    }
+
     getIndexes = () => {
       return this.indexes
     }

package/package.json

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

package/wiki/CHANGES.md

@@ -1,5 +1,19 @@
 # Changes
 
+## 2026-05-26
+
+- [2.26.0] Add loading multiple model schema as in one ```model.js``` file
+- [2.26.0] Remove caching feature of model schema
+- [2.26.0] Change driver hook name with this syntax: ```dobo.driver:<action>```
+
+## 2026-05-22
+
+- [2.25.0] Add ```array``` & ```object``` validator handling
+- [2.25.0] Change ```interSite``` definition to ```xSite```
+- [2.25.0] Add ```model.getNonVirtualProperties()```
+- [2.25.0] Bug fix in ```model.loadFixtures()```
+- [2.25.0] Handle ```array``` validation schema
+
 ## 2026-05-16
 
 - [2.24.0] Change ```dobo:immutable``` feature, field no longer hidden