dobo 2.22.0 → 2.23.0

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

@@ -141,7 +141,7 @@
   "invalidIdType%s%s": "Invalid ID type for '%s'. Please only use one of these: %s",
   "noDefaultConnection": "No default connection found. All models will use the built-in memory database instead",
   "recordImmutable%s%s": "Record with ID: '%s' & model: '%s' is immutable and can't be modified or deleted",
-  "notSupported%s%s%s": "%s|upperFirst '%s' is not supported by driver '%s'",
+  "notSupportedDriver%s%s%s": "%s|upperFirst '%s' is not supported by driver '%s'",
   "inMemoryDb%s%s": "'%s' is an in-memory database, %s is not allowed",
   "buildOp": "'build' operation",
   "dropOp": "'drop' operation",

package/extend/bajo/intl/id.json

@@ -140,6 +140,7 @@
   "invalidIdType%s%s": "Invalid ID type for '%s'. Please only use one of these: %s",
   "noDefaultConnection": "No default connection found. All models will use the built-in memory database instead",
   "recordImmutable%s%s": "Data dengan ID: '%s' & model: '%s' adalah immutable dan tidak bisa diubah atau dihapus",
+  "notSupportedDriver%s%s%s": "%s|upperFirst '%s' tidak didukung oleh driver '%s'",
   "inMemoryDb%s%s": "'%s' adalah database in-memory, %s tidak diizinkan",
   "buildOp": "operasi 'build'",
   "dropOp": "operasi 'drop'",

package/extend/dobo/driver/memory.js

@@ -11,7 +11,6 @@ async function memoryDriverFactory () {
       this.idGenerator = 'ulid'
       this.saving = true
       this.memory = true
-      this.autoSave = []
       this.storage = {}
       this.support = {
         propType: {
@@ -21,19 +20,6 @@ async function memoryDriverFactory () {
       }
     }
 
-    async _loadFromFile (model, dir) {
-      const { fs } = this.app.lib
-      this.autoSave.push(model.name)
-      const file = `${dir}/${model.name}.json`
-      if (!fs.existsSync(file)) return
-      try {
-        const data = fs.readFileSync(file, 'utf8')
-        this.storage[model.name] = JSON.parse(data)
-      } catch (err) {
-        this.fatal('cantLoad%s%s', model.name, err.message)
-      }
-    }
-
     async sanitizeConnection (conn) {
       await super.sanitizeConnection(conn)
       conn.memory = true
@@ -41,27 +27,42 @@ async function memoryDriverFactory () {
 
     async connect (connection, noRebuild) {
       const conn = this.plugin.getConnection('memory')
-      const models = this.plugin.getModelsByConnection(conn.name)
       const { getPluginDataDir } = this.app.bajo
       const { fs } = this.app.lib
-      const pdir = `${getPluginDataDir(this.plugin.ns)}/memDb/data` // persistence dir
-      fs.ensureDirSync(pdir)
-      conn.autoSave = conn.autoSave ?? []
+      const dir = `${getPluginDataDir(this.plugin.ns)}/memDb/data` // persistence dir
+      fs.ensureDirSync(dir)
+      conn.persistences = conn.persistences ?? []
+
+      const models = this.plugin.getModelsByConnection(conn.name).map(model => {
+        if (conn.persistences.includes(model.name)) model.options.persistence = true
+        return model
+      })
+
       for (const model of models) {
         this.storage[model.name] = this.storage[model.name] ?? [] // init empty model
-        if (conn.autoSave.includes(model.name)) await this._loadFromFile(model, pdir)
-        await model.loadFixtures()
+        if (model.options.persistence) {
+          const file = `${dir}/${model.name}.json`
+          let data = []
+          if (fs.existsSync(file)) {
+            try {
+              data = JSON.parse(fs.readFileSync(file, 'utf8'))
+            } catch (err) {}
+          }
+          if (data.length === 0) await model.loadFixtures({ ignoreError: false })
+          else this.storage[model.name] = data
+        } else await model.loadFixtures({ ignoreError: false })
       }
-      if (conn.autoSave.length === 0) return
       setInterval(() => {
         if (!this.saving) return
         this.saving = true
-        for (const item of conn.autoSave) {
-          const data = this.storage[item]
-          fs.writeFileSync(`${pdir}/${item}.json`, JSON.stringify(data), 'utf8')
+        for (const model of models) {
+          if (!model.options.persistence) continue
+          try {
+            fs.writeFileSync(`${dir}/${model.name}.json`, JSON.stringify(this.storage[model.name], null, 2), 'utf8')
+          } catch (err) {}
         }
         this.saving = false
-      }, this.plugin.config.memDb.autoSaveDur)
+      }, this.plugin.config.memDb.persistenceDur)
     }
 
     async _getOldRecord (model, id, options = {}) {

package/extend/dobo/feature/created-at.js

@@ -1,3 +1,9 @@
+async function handler (body, options, opts) {
+  const { isSet } = this.app.lib.aneka
+  if (opts.noOverwrite) body[opts.field] = new Date()
+  else if (!isSet(body[opts.field])) body[opts.field] = new Date()
+}
+
 async function createdAt (opts = {}) {
   opts.field = opts.field ?? 'createdAt'
   opts.noOverwrite = opts.noOverwrite ?? false
@@ -10,9 +16,14 @@ async function createdAt (opts = {}) {
     hooks: [{
       name: 'beforeCreateRecord',
       handler: async function (body, options) {
-        const { isSet } = this.app.lib.aneka
-        if (opts.noOverwrite) body[opts.field] = new Date()
-        else if (!isSet(body[opts.field])) body[opts.field] = new Date()
+        await handler.call(this, body, options, opts)
+      }
+    }, {
+      name: 'beforeBulkCreateRecord',
+      handler: async function (bodies, options) {
+        for (const body of bodies) {
+          await handler.call(this, body, options, opts)
+        }
       }
     }]
   }

package/extend/dobo/feature/image.js

@@ -1,5 +1,15 @@
 import path from 'path'
 
+async function handler (val, rec, opts) {
+  const atts = await this.listAttachment({ id: rec.id })
+  if (atts.length === 0) return
+  let items = atts.filter(att => att.mimeType.startsWith('image/'))
+  if (opts.asLink && this.app.waibu) items = items.map(f => `<a href="${f.url}">${opts.baseName ? path.basename(f.file) : f.file}</a>`)
+  else if (opts.baseName) items = items.map(f => path.basename(f.file))
+  if (opts.single) return items[0]
+  return opts.returnAsArray ? items : items.join(', ')
+}
+
 async function image (opts = {}) {
   opts.field = opts.field ?? 'image'
   opts.baseName = opts.baseName ?? true
@@ -10,13 +20,10 @@ async function image (opts = {}) {
       type: 'string',
       virtual: true,
       getValue: async function (val, rec) {
-        const atts = await this.listAttachment({ id: rec.id })
-        if (atts.length === 0) return
-        let items = atts.filter(att => att.mimeType.startsWith('image/'))
-        if (opts.withLink && this.app.waibu) items = items.map(f => `<a href="${f.url}">${opts.baseName ? path.basename(f.file) : f.file}</a>`)
-        else if (opts.baseName) items = items.map(f => path.basename(f.file))
-        if (opts.single) return items[0]
-        return items
+        return await handler.call(this, val, rec, { ...opts, asLink: false })
+      },
+      format: async function (val, rec) {
+        return await handler.call(this, val, rec, { ...opts, asLink: true })
       }
     }
   }

package/extend/dobo/feature/removed-at.js

@@ -43,6 +43,13 @@ async function removedAt (opts = {}) {
       handler: async function (body, options) {
         await beforeCreateRecord.call(this, { body }, opts)
       }
+    }, {
+      name: 'beforeBulkCreateRecord',
+      handler: async function (bodies, options) {
+        for (const body of bodies) {
+          await beforeCreateRecord.call(this, { body }, opts)
+        }
+      }
     }, {
       name: 'beforeUpdateRecord',
       handler: async function (id, body, options) {

package/extend/dobo/feature/unique.js

@@ -1,7 +1,16 @@
 import crypto from 'crypto'
 
-async function unique (opts = {}) {
+async function handler (body, options, opts) {
   const { omit } = this.app.lib._
+  if (opts.fields.length === 0) opts.fields = omit(this.properties.map(prop => prop.name), [opts.field])
+  const item = {}
+  for (const f of opts.fields) {
+    item[f] = body[f]
+  }
+  body[opts.field] = crypto.createHash('md5').update(JSON.stringify(item)).digest('hex')
+}
+
+async function unique (opts = {}) {
   opts.field = opts.field ?? 'id'
   opts.fields = opts.fields ?? []
   return {
@@ -16,12 +25,15 @@ async function unique (opts = {}) {
       name: 'beforeCreateRecord',
       level: 1000,
       handler: async function (body, options) {
-        if (opts.fields.length === 0) opts.fields = omit(this.properties.map(prop => prop.name), [opts.field])
-        const item = {}
-        for (const f of opts.fields) {
-          item[f] = body[f]
+        await handler.call(this, body, options, opts)
+      }
+    }, {
+      name: 'beforeBulkCreateRecord',
+      level: 1000,
+      handler: async function (bodies, options) {
+        for (const body of bodies) {
+          await handler.call(this, body, options, opts)
         }
-        body[opts.field] = crypto.createHash('md5').update(JSON.stringify(item)).digest('hex')
       }
     }]
   }

package/extend/dobo/feature/updated-at.js

@@ -1,5 +1,10 @@
-async function updatedAt (opts = {}) {
+async function createHandler (body, options, opts) {
   const { isSet } = this.app.lib.aneka
+  if (opts.noOverwrite) body[opts.field] = new Date()
+  else if (!isSet(body[opts.field])) body[opts.field] = new Date()
+}
+
+async function updatedAt (opts = {}) {
   opts.field = opts.field ?? 'updatedAt'
   opts.noOverwrite = opts.noOverwrite ?? false
   return {
@@ -11,14 +16,19 @@ async function updatedAt (opts = {}) {
     hooks: [{
       name: 'beforeCreateRecord',
       handler: async function (body, options) {
-        if (opts.noOverwrite) body[opts.field] = new Date()
-        else if (!isSet(body[opts.field])) body[opts.field] = new Date()
+        await createHandler.call(this, body, options, opts)
+      }
+    }, {
+      name: 'beforeBulkCreateRecord',
+      handler: async function (bodies, options) {
+        for (const body of bodies) {
+          await createHandler.call(this, body, options, opts)
+        }
       }
     }, {
       name: 'beforeUpdateRecord',
       handler: async function (id, body, options) {
-        if (opts.noOverwrite) body[opts.field] = new Date()
-        else if (!isSet(body[opts.field])) body[opts.field] = new Date()
+        await createHandler.call(this, body, options, opts)
       }
     }]
   }

package/index.js

@@ -164,7 +164,7 @@ async function factory (pkgName) {
           }
         },
         memDb: {
-          autoSaveDur: '1s'
+          persistenceDur: '1s'
         },
         applet: {
           confirmation: false

package/lib/collect-connections.js

@@ -31,21 +31,13 @@ async function collectConnections () {
   const { buildCollections } = this.app.bajo
   const { pullAt } = this.app.lib._
   const { filterIndex } = this.app.lib.aneka
-  const DoboConnection = await connectionFactory.call(this)
+  await connectionFactory.call(this)
 
   async function handler ({ item }) {
     const { has } = this.app.lib._
     if (!has(item, 'driver')) this.fatal('unknownDbDriver%s')
-    let driver
-    try {
-      driver = this.getDriver(item.driver, true)
-      if (!driver) throw new Error()
-    } catch (err) {
-      this.fatal('unknownDbDriver%s', item.driver)
-    }
-    await driver.sanitizeConnection(item)
-    const conn = new DoboConnection(this, item)
-    conn.driver = driver
+    const conn = new this.app.baseClass.DoboConnection(this, item)
+    await conn.initDriver(item.driver)
     return conn
   }
   const memIndexes = filterIndex(this.config.connections, current => current.driver === 'dobo:memory' || current.name === 'memory')

package/lib/collect-drivers.js

@@ -13,7 +13,7 @@ async function collectDrivers () {
   const { eachPlugins, runHook } = this.app.bajo
   const { importModule } = this.app.bajo
   const { camelCase, isFunction } = this.app.lib._
-  const DoboDriver = await driverFactory.call(this)
+  await driverFactory.call(this)
 
   this.log.trace('collecting%s', this.t('driver'))
   const me = this
@@ -24,7 +24,7 @@ async function collectDrivers () {
     if (!isFunction(factory)) this.fatal('invalidDriverClassFactory%s%s', this.ns, name)
     const Cls = await factory.call(this)
     const instance = new Cls(this, name)
-    if (!(instance instanceof DoboDriver)) this.fatal('invalidDriverClass%s%s', this.ns, name)
+    if (!(instance instanceof this.app.baseClass.DoboDriver)) this.fatal('invalidDriverClass%s%s', this.ns, name)
     me.drivers.push(instance)
     me.log.trace('- %s:%s', this.ns, name)
   }, { glob: 'driver/*.js', prefix: this.ns })

package/lib/collect-features.js

@@ -20,7 +20,7 @@ import featureFactory from './factory/feature.js'
  */
 async function collectFeature () {
   const { eachPlugins } = this.app.bajo
-  const DoboFeature = await featureFactory.call(this)
+  await featureFactory.call(this)
 
   this.log.trace('collecting%s', this.t('feature'))
   const me = this
@@ -31,7 +31,7 @@ async function collectFeature () {
     const name = camelCase(path.basename(file, '.js'))
     const handler = await importModule(file)
     if (!isFunction(handler)) this.fatal('invalidFeatureHandler%s%s', this.ns, name)
-    me.features.push(new DoboFeature(this, { name, handler }))
+    me.features.push(new this.app.baseClass.DoboFeature(this, { name, handler }))
     me.log.trace('- %s:%s', this.ns, name)
   }, { glob: 'feature/*.js', prefix: this.ns })
   this.log.debug('collected%s%d', this.t('feature'), this.features.length)

package/lib/collect-models.js

@@ -247,8 +247,6 @@ export async function sanitizeAll (model) {
 async function createSchema (item) {
   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
   const feats = item.features ?? []
   const props = item.properties ?? []
   const indexes = item.indexes ?? []
@@ -258,21 +256,23 @@ async function createSchema (item) {
   item.hidden = item.hidden ?? []
   item.rules = item.rules ?? []
   item.buildLevel = item.buildLevel ?? 999
-  const conn = item.connection ?? 'default'
-  item.connection = null
   item.hooks = item.hooks ?? []
   item.disabled = item.disabled ?? []
   item.scanables = item.scanables ?? []
   if (item.disabled === 'all') item.disabled = ['find', 'get', 'create', 'update', 'remove']
   else if (item.disabled === 'readonly') item.disabled = ['create', 'update', 'remove']
-  // Is there any overwritten connection?
-  const newConn = find(this.connections, c => c.options.models.includes(item.name))
-  if (newConn) item.connection = newConn
-  else {
-    item.connection = this.getConnection(conn, true)
-    if (!item.connection && conn === 'default') item.connection = this.getConnection('memory')
+  const conn = item.connection ?? 'default'
+  if (!(conn instanceof this.app.baseClass.DoboConnection)) {
+    item.connection = null
+    // Is there any overwritten connection?
+    const newConn = find(this.connections, c => c.options.models.includes(item.name))
+    if (newConn) item.connection = newConn
+    else {
+      item.connection = this.getConnection(conn, true)
+      if (!item.connection && conn === 'default') item.connection = this.getConnection('memory')
+    }
+    if (!item.connection) this.fatal('unknownConn%s%s', conn, item.name)
   }
-  if (!item.connection) this.fatal('unknownConn%s%s', conn, item.name)
   // 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 }
@@ -305,9 +305,9 @@ async function createSchema (item) {
  */
 async function collectModels () {
   const { eachPlugins } = this.app.bajo
-  const { orderBy, has } = this.app.lib._
+  const { orderBy, has, isFunction, omit } = this.app.lib._
   await actionFactory.call(this)
-  const DoboModel = await modelFactory.call(this)
+  await modelFactory.call(this)
 
   this.log.trace('collecting%s', this.t('model'))
   const me = this
@@ -325,8 +325,13 @@ async function collectModels () {
     item.name = item.name ?? defName
     me.log.trace('- %s', item.name)
     item.collName = item.collName ?? item.name
-    item.file = file
+    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 })
@@ -337,11 +342,13 @@ async function collectModels () {
     const idProp = schema.properties.find(p => p.name === 'id')
     if (!this.constructor.idTypes.includes(idProp.type)) this.fatal('invalidIdType%s%s', schema.name, this.constructor.idTypes.join(', '))
     if (idProp.type === 'string' && !has(idProp, 'maxLength')) idProp.maxLength = 50
-    const model = new DoboModel(plugin, schema)
+    const model = new this.app.baseClass.DoboModel(plugin, omit(schema, ['beforeCreate', 'afterCreate']))
+    schema.model = model
     me.models.push(model)
   }
   // last sanitizing & checking
-  for (const model of me.models) {
+  for (const schema of schemas) {
+    const model = schema.model
     await sanitizeRef.call(this, model, me.models)
     for (const item of model.indexes) {
       for (const field of item.fields) {
@@ -353,7 +360,9 @@ 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)
   }
+  schemas = []
   this.log.debug('collected%s%d', this.t('model'), this.models.length)
 }
 

package/lib/factory/action.js

@@ -155,7 +155,6 @@ async function actionFactory () {
   }
 
   this.app.baseClass.DoboAction = DoboAction
-  return DoboAction
 }
 
 export default actionFactory

package/lib/factory/connection.js

@@ -28,15 +28,37 @@ async function connectionFactory () {
        * @type {string}
        */
       this.name = options.name
+      this.options = {
+        models: []
+      }
 
       /**
        * Options object from connection defined on ```dobo.config.connections```
        *
        * @type {Object}
        */
-      this.options = omit(options, ['name', 'driver'])
-      this.options.connName = options.name
-      this.options.models = this.options.models ?? []
+      if (options instanceof this.app.baseClass.DoboNullDriver) {
+        this.driver = options
+        this.options.connName = 'nulldriver'
+      } else {
+        this.options = omit(options, ['name', 'driver'])
+        this.options.connName = options.name
+        this.options.models = this.options.models ?? []
+      }
+    }
+
+    /**
+     * Init driver. Called automatically during connections collection
+     *
+     * @param {strin} name - Driver name
+     * @async
+     */
+    async initDriver (name) {
+      if (name instanceof this.app.baseClass.DoboDriver) this.driver = name
+      else {
+        this.driver = this.plugin.getDriver(name)
+        await this.driver.sanitizeConnection(this.options)
+      }
     }
 
     /**
@@ -48,6 +70,7 @@ async function connectionFactory () {
     async connect (noRebuild) {
       const client = await this.driver.connect(this, noRebuild)
       if (client) this.client = client
+      this.connected = true
     }
 
     dispose = async () => {
@@ -57,7 +80,6 @@ async function connectionFactory () {
   }
 
   this.app.baseClass.DoboConnection = DoboConnection
-  return DoboConnection
 }
 
 export default connectionFactory

package/lib/factory/driver.js

@@ -59,11 +59,13 @@ async function driverFactory () {
     sanitizeBody (model, body = {}, partial) {
       const { keys, pick } = this.app.lib._
       const item = cloneDeep(body)
+      let newId = false
       if (has(item, 'id') && this.idField.name !== 'id') {
         item[this.idField.name] = item.id
-        delete item.id
+        newId = true
       }
       for (const prop of model.properties) {
+        if (item[prop.name] === 'null') item[prop.name] = null
         if (!isSet(item[prop.name]) && !this.support.nullableField) {
           switch (prop.type) {
             case 'datetime': item[prop.name] = new Date(0); break
@@ -80,7 +82,9 @@ async function driverFactory () {
           else if (['object', 'array'].includes(prop.type)) item[prop.name] = JSON.stringify(item[prop.name])
         }
       }
-      return partial ? pick(item, keys(body)) : item
+      const result = partial ? pick(item, keys(body)) : item
+      if (newId) delete result.id
+      return result
     }
 
     sanitizeRecord (model, record = {}) {
@@ -259,7 +263,7 @@ async function driverFactory () {
       }
       const items = chunk(bodies, chunkSize)
       for (const item of items) {
-        await this.bulkCreateRecords(model, item, options)
+        await this.bulkCreateRecord(model, item, options)
       }
     }
 
@@ -402,64 +406,75 @@ async function driverFactory () {
     }
 
     async modelExists (model, options = {}) {
-      throw this.plugin.error('notSupported%s%s', this.app.t('method'), 'modelExists')
+      throw this.plugin.error('notSupportedDriver%s%s%s', this.app.t('method'), 'modelExists', this.name)
     }
 
     async buildModel (model, options = {}) {
-      throw this.plugin.error('notSupported%s%s', this.app.t('method'), 'buildModel')
+      throw this.plugin.error('notSupportedDriver%s%s%s', this.app.t('method'), 'buildModel', this.name)
     }
 
     async dropModel (model, options = {}) {
-      throw this.plugin.error('notSupported%s%s', this.app.t('method'), 'dropModel')
+      throw this.plugin.error('notSupportedDriver%s%s%s', this.app.t('method'), 'dropModel', this.name)
     }
 
     async createRecord (model, body = {}, options = {}) {
-      throw this.plugin.error('notSupported%s%s', this.app.t('method'), 'createRecord')
+      throw this.plugin.error('notSupportedDriver%s%s%s', this.app.t('method'), 'createRecord', this.name)
     }
 
     async getRecord (model, id, options = {}) {
-      throw this.plugin.error('notSupported%s%s', this.app.t('method'), 'getRecord')
+      throw this.plugin.error('notSupportedDriver%s%s%s', this.app.t('method'), 'getRecord', this.name)
     }
 
     async updateRecord (model, id, body = {}, options = {}) {
-      throw this.plugin.error('notSupported%s%s', this.app.t('method'), 'updateRecord')
+      throw this.plugin.error('notSupportedDriver%s%s%s', this.app.t('method'), 'updateRecord', this.name)
     }
 
     async removeRecord (model, id, options = {}) {
-      throw this.plugin.error('notSupported%s%s', this.app.t('method'), 'removeRecord')
+      throw this.plugin.error('notSupportedDriver%s%s%s', this.app.t('method'), 'removeRecord', this.name)
     }
 
     async clearRecord (model, options = {}) {
-      throw this.plugin.error('notSupported%s%s', this.app.t('method'), 'clearRecord')
+      throw this.plugin.error('notSupportedDriver%s%s%s', this.app.t('method'), 'clearRecord', this.name)
     }
 
     async findRecord (model, filter = {}, options = {}) {
-      throw this.plugin.error('notSupported%s%s', this.app.t('method'), 'findRecord')
+      throw this.plugin.error('notSupportedDriver%s%s%s', this.app.t('method'), 'findRecord', this.name)
     }
 
-    async bulkCreateRecords (model, bodies = [], options = {}) {
-      throw this.plugin.error('notSupported%s%s', this.app.t('method'), 'bulkCreateRecords')
+    async bulkCreateRecord (model, bodies = [], options = {}) {
+      throw this.plugin.error('notSupportedDriver%s%s%s', this.app.t('method'), 'bulkCreateRecord', this.name)
     }
 
     async countRecord (model, filter = {}, options = {}) {
-      throw this.plugin.error('notSupported%s%s', this.app.t('method'), 'countRecord')
+      throw this.plugin.error('notSupportedDriver%s%s%s', this.app.t('method'), 'countRecord', this.name)
     }
 
     async createAggregate (model, filter = {}, params = {}, options = {}) {
-      throw this.plugin.error('notSupported%s%s', this.app.t('method'), 'createAggregate')
+      throw this.plugin.error('notSupportedDriver%s%s%s', this.app.t('method'), 'createAggregate', this.name)
     }
 
     async createHistogram (model, filter = {}, params = {}, options = {}) {
-      throw this.plugin.error('notSupported%s%s', this.app.t('method'), 'createHistogram')
+      throw this.plugin.error('notSupportedDriver%s%s%s', this.app.t('method'), 'createHistogram', this.name)
     }
 
     async transaction (model, handler, ...args) {
-      throw this.plugin.error('notSupported%s%s', this.app.t('method'), 'transaction')
+      throw this.plugin.error('notSupportedDriver%s%s%s', this.app.t('method'), 'transaction', this.name)
+    }
+
+    async dispose () {
+      await super.dispose()
+    }
+  }
+
+  class DoboNullDriver extends DoboDriver {
+    constructor (plugin, name = 'null', options = {}) {
+      super(plugin, name, options)
+      this.memory = true
     }
   }
 
   this.app.baseClass.DoboDriver = DoboDriver
-  return DoboDriver
+  this.app.baseClass.DoboNullDriver = DoboNullDriver
 }
 
 export default driverFactory

package/lib/factory/feature.js

@@ -27,7 +27,6 @@ async function featureFactory () {
   }
 
   this.app.baseClass.DoboFeature = DoboFeature
-  return DoboFeature
 }
 
 export default featureFactory

package/lib/factory/model/_util.js

@@ -13,12 +13,18 @@ export function cloneOptions (options = {}) {
 
 export async function execHook (name, ...args) {
   const { runHook } = this.app.bajo
-  const { camelCase, last } = this.app.lib._
+  const { camelCase, last, kebabCase } = this.app.lib._
   const { noHook } = last(args)
   const { ns } = this.app.dobo
+  let [prefix, ...action] = kebabCase(name).split('-')
+  action = camelCase(action.join(' '))
   if (!noHook) {
+    if (prefix === 'before') await runHook(`${ns}:beforeAction`, action, ...args)
     await runHook(`${ns}:${name}`, this.name, ...args)
+    if (prefix === 'after') await runHook(`${ns}:afterAction`, action, ...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)
   }
 }
 
@@ -135,7 +141,7 @@ export async function getAttachmentPath (id, field, file, options = {}) {
 
 export async function copyAttachment (id, options = {}) {
   if (!this.app.waibu) return
-  if (!this.attachment) return
+  if (!this.options.attachment) return
   const { fs } = this.app.lib
   const { req, setField, setFile, mimeType, stats } = options
   const { dir, files } = await this.app.waibu.getUploadedFiles(req.id, false, true)
@@ -158,7 +164,7 @@ export async function copyAttachment (id, options = {}) {
 }
 
 export async function handleAttachmentUpload (id, trigger, options = {}) {
-  if (!this.attachment) return
+  if (!this.options.attachment) return
   const { getPluginDataDir } = this.app.bajo
   const { fs } = this.app.lib
   const { req, mimeType, stats, setFile, setField } = options
@@ -170,53 +176,7 @@ export async function handleAttachmentUpload (id, trigger, options = {}) {
   return copyAttachment.call(this, id, { req, mimeType, stats, setFile, setField })
 }
 
-async function _getRef ({ ref, rModel, prop, key, options, filter } = {}) {
-  if (!((typeof options.refs === 'string' && ['*', 'all'].includes(options.refs)) || options.refs.includes(key))) return
-  if (ref.fields.length === 0) return
-  const { fmt } = options
-  const fields = [...ref.fields]
-  if (!fields.includes(prop.name)) fields.push(prop.name)
-  const rOptions = { dataOnly: true, refs: [], fmt, fields }
-  const results = await rModel.findRecord(filter, rOptions)
-  return { rOptions, results }
-}
-
-export async function getSingleRef (record = {}, options = {}) {
-  const { isSet } = this.app.lib.aneka
-  const { parseQuery } = this.app.dobo
-  const { get } = this.app.lib._
-  const props = this.properties.filter(p => isSet(p.ref) && !(options.hidden ?? []).includes(p.name))
-  const refs = {}
-  options.refs = options.refs ?? []
-  if (props.length > 0) {
-    for (const prop of props) {
-      for (const key in prop.ref) {
-        try {
-          if (get(record, `_ref.${key}`)) continue
-          const ref = prop.ref[key]
-          const rModel = this.app.dobo.getModel(ref.model, true)
-          if (!rModel) return
-          let query = {}
-          query[ref.field] = record[prop.name]
-          if (ref.field === 'id') query[ref.field] = this.sanitizeId(query[ref.field])
-          if (ref.query) query = { $and: [query, parseQuery(ref.query, rModel)] }
-          const filter = { query }
-          const resp = await _getRef.call(this, { ref, rModel, prop, key, options, filter })
-          if (!resp) continue
-          const { rOptions, results } = resp
-          const data = []
-          for (const res of results) {
-            data.push(await rModel.sanitizeRecord(res, rOptions))
-          }
-          refs[key] = ['1:1'].includes(ref.type) ? data[0] : data
-        } catch (err) {}
-      }
-    }
-  }
-  record._ref = refs
-}
-
-export async function getMultiRefs (records = [], options = {}) {
+export async function getRefs (records = [], options = {}) {
   const { isSet } = this.app.lib.aneka
   const { uniq, without, get } = this.app.lib._
   const { parseQuery } = this.app.dobo
@@ -226,30 +186,46 @@ export async function getMultiRefs (records = [], options = {}) {
     for (const prop of props) {
       for (const key in prop.ref) {
         try {
-          if (get(records, `0._ref.${key}`)) continue
+          if (records.length === 0) return
+          const isValues = Array.isArray(records[0][prop.name])
+          if (get(records, `0._ref.${key}`)) return
           const ref = prop.ref[key]
           const rModel = this.app.dobo.getModel(ref.model, true)
           if (!rModel) return
           let matches = []
-          for (const r of records) {
-            matches.push(prop.name === 'id' ? rModel.sanitizeId(r[prop.name]) : r[prop.name])
+          for (const rec of records) {
+            const items = isValues ? [...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 + '')
           let query = {}
           query[ref.field] = { $in: matches }
+
+          const siteIdProp = this.properties.find(item => item.name === 'siteId')
+          const siteIdRProp = rModel.properties.find(item => item.name === 'siteId')
+          if (siteIdProp && siteIdRProp) query.siteId = records[0].siteId
+
           if (ref.query) query = { $and: [query, parseQuery(ref.query, rModel)] }
           const filter = { query, limit: matches.length }
-          const resp = await _getRef.call(this, { ref, rModel, prop, key, options, filter })
-          if (!resp) continue
-          const { rOptions, results } = resp
+          if (!((typeof options.refs === 'string' && ['*', 'all'].includes(options.refs)) || options.refs.includes(key))) return
+          if (ref.fields.length === 0) return
+          const { fmt, req } = options
+          const fields = [...ref.fields]
+          if (!fields.includes(prop.name)) fields.push(prop.name)
+          const rOptions = { dataOnly: true, refs: [], fmt, req, fields }
+          const results = await rModel.findRecord(filter, rOptions)
           for (const i in records) {
             records[i]._ref = records[i]._ref ?? {}
             const rec = records[i]
-            const res = results.find(res => (res[ref.field] + '') === rec[prop.name] + '')
-            if (res) records[i]._ref[key] = await rModel.sanitizeRecord(res, rOptions)
-            else records[i]._ref[key] = {}
+            let items = isValues ? [...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 ? [] : {}
+            else records[i]._ref[key] = isValues ? res : res[0]
           }
-        } catch (err) {}
+        } catch (err) {
+          if (this.app.bajo.config.log.level === 'trace') console.error(err)
+        }
       }
     }
   }
@@ -261,7 +237,7 @@ export function buildFilterQuery (filter = {}) {
   return sanitizeQuery.call(this, query)
 }
 
-function sanitizeQuery (query = {}, parent) {
+export function sanitizeQuery (query = {}, parent) {
   const { isPlainObject, isArray, find, cloneDeep } = this.app.lib._
   const { isSet } = this.app.lib.aneka
   const { dayjs } = this.app.lib

package/lib/factory/model/{bulk-create-records.js → bulk-create-record.js}

@@ -1,9 +1,9 @@
 import { getFilterAndOptions, execHook, execValidation, execModelHook, execDynHook } from './_util.js'
 
 export const onlyTypes = ['datetime', 'date', 'time', 'timestamp']
-const action = 'bulkCreateRecords'
+const action = 'bulkCreateRecord'
 
-async function bulkCreateRecords (...args) {
+async function bulkCreateRecord (...args) {
   if (args.length === 0) return this.action(action, ...args)
   const [bodies = [], opts = {}] = args
   const { cloneDeep, get } = this.app.lib._
@@ -17,9 +17,9 @@ async function bulkCreateRecords (...args) {
       inputs[idx] = await this.sanitizeBody({ body: inputs[idx], extFields, strict: true, truncateString, onlyTypes })
     }
   }
-  await execHook.call(this, 'beforeBulkCreateRecords', inputs, options)
-  await execModelHook.call(this, 'beforeBulkCreateRecords', inputs, options)
-  await execDynHook.call(this, 'beforeBulkCreateRecords', inputs, options)
+  await execHook.call(this, 'beforeBulkCreateRecord', inputs, options)
+  await execModelHook.call(this, 'beforeBulkCreateRecord', inputs, options)
+  await execDynHook.call(this, 'beforeBulkCreateRecord', inputs, options)
   if (!noValidation) {
     for (const input of inputs) {
       await execValidation.call(this, input, options)
@@ -27,10 +27,10 @@ async function bulkCreateRecords (...args) {
   }
   // TODO: bulk don't return anything currently, it should return at least a stat
   await this.driver._bulkCreateRecords(this, inputs, options)
-  await execDynHook.call(this, 'afterBulkCreateRecords', inputs, options)
-  await execModelHook.call(this, 'afterBulkCreateRecords', inputs, options)
-  await execHook.call(this, 'afterBulkCreateRecords', inputs, options)
+  await execDynHook.call(this, 'afterBulkCreateRecord', inputs, options)
+  await execModelHook.call(this, 'afterBulkCreateRecord', inputs, options)
+  await execHook.call(this, 'afterBulkCreateRecord', inputs, options)
   return []
 }
 
-export default bulkCreateRecords
+export default bulkCreateRecord

package/lib/factory/model/create-attachment.js

@@ -4,7 +4,7 @@ const action = 'createAttachment'
 async function createAttachment (...args) {
   const { createThumbnail } = this.app.bajoExtra
   const { thumbSizes: size } = this.app.dobo.config.default.attachment
-  if (!this.attachment) return
+  if (!this.options.attachment) return
   if (args.length === 0) return this.action(action, ...args)
   const [id, opts = {}] = args
   const { fs } = this.app.lib

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

@@ -1,4 +1,4 @@
-import { getFilterAndOptions, execHook, execValidation, execModelHook, execDynHook, getSingleRef, handleReq } from './_util.js'
+import { getFilterAndOptions, execHook, execValidation, execModelHook, execDynHook, getRefs, handleReq } from './_util.js'
 
 export const onlyTypes = ['datetime', 'date', 'time', 'timestamp', 'array', 'object']
 const action = 'createRecord'
@@ -25,7 +25,7 @@ async function createRecord (...args) {
   result = result ?? {}
   const { warnings } = getDefaultValues(options)
   if (!warnings) delete result.warnings
-  if (isSet(options.refs)) await getSingleRef.call(this, result.data, options)
+  if (isSet(options.refs)) await getRefs.call(this, [result.data], options)
   if (!noResultSanitizer) result.data = await this.sanitizeRecord(result.data, options)
   await execDynHook.call(this, 'afterCreateRecord', input, result, options)
   await execModelHook.call(this, 'afterCreateRecord', input, result, options)

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

@@ -1,4 +1,4 @@
-import { getMultiRefs, execHook, execModelHook, execDynHook, getFilterAndOptions, cloneOptions } from './_util.js'
+import { getRefs, execHook, execModelHook, execDynHook, getFilterAndOptions, cloneOptions, sanitizeQuery } from './_util.js'
 const action = 'findAllRecord'
 
 async function native (...args) {
@@ -13,9 +13,10 @@ async function native (...args) {
   const { hardCap, warnings } = getDefaultValues(options)
   if (dataOnly) options.count = false
   const { noResultSanitizer } = options
-  await execHook.call(this, 'beforeFindRecord', filter, options)
-  await execModelHook.call(this, 'beforeFindRecord', filter, options)
-  await execDynHook.call(this, 'beforeFindRecord', filter, options)
+  await execHook.call(this, 'beforeFindAllRecord', filter, options)
+  await execModelHook.call(this, 'beforeFindAllRecord', filter, options)
+  await execDynHook.call(this, 'beforeFindAllRecord', filter, options)
+  filter.query = sanitizeQuery.call(this, filter.query)
   const cFilter = cloneDeep(filter)
   if (get) {
     const resp = await get({ model: this, action, filter: cFilter, options })
@@ -37,15 +38,15 @@ async function native (...args) {
   result.pages = options.count ? Math.ceil(result.count / filter.limit) : undefined
   if (!warnings) delete result.warnings
 
-  if (isSet(options.refs)) await getMultiRefs.call(this, result.data, options)
+  if (isSet(options.refs)) await getRefs.call(this, result.data, options)
   if (!noResultSanitizer) {
     for (const idx in result.data) {
       result.data[idx] = await this.sanitizeRecord(result.data[idx], 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)
+  await execDynHook.call(this, 'afterFindAllRecord', filter, result, options)
+  await execModelHook.call(this, 'afterFindAllRecord', filter, result, options)
+  await execHook.call(this, 'afterFindAllRecord', filter, result, options)
   if (set) await set({ model: this, action, filter: cFilter, options, result })
   return dataOnly ? result.data : result
 }

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

@@ -2,7 +2,7 @@ import { mergeAttachmentInfo } from './_util.js'
 const action = 'findAttachment'
 
 async function findAttachment (...args) {
-  if (!this.attachment) return
+  if (!this.options.attachment) return
   if (args.length === 0) return this.action(action, ...args)
   const [id, opts = {}] = args
   const { fastGlob, fs } = this.app.lib

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

@@ -1,4 +1,4 @@
-import { getFilterAndOptions, execHook, execModelHook, execDynHook, getMultiRefs } from './_util.js'
+import { getFilterAndOptions, execHook, execModelHook, execDynHook, getRefs, sanitizeQuery } from './_util.js'
 const action = 'findRecord'
 
 /**
@@ -80,6 +80,7 @@ async function findRecord (...args) {
   await execHook.call(this, 'beforeFindRecord', filter, options)
   await execModelHook.call(this, 'beforeFindRecord', filter, options)
   await execDynHook.call(this, 'beforeFindRecord', filter, options)
+  filter.query = sanitizeQuery.call(this, filter.query)
   const cFilter = cloneDeep(filter)
   if (get) {
     const resp = await get({ model: this, action, filter: cFilter, options })
@@ -101,7 +102,7 @@ async function findRecord (...args) {
   }
   result.pages = options.count ? Math.ceil(result.count / filter.limit) : undefined
   if (!warnings) delete result.warnings
-  if (isSet(options.refs)) await getMultiRefs.call(this, result.data, options)
+  if (isSet(options.refs)) await getRefs.call(this, result.data, options)
   if (!noResultSanitizer) {
     for (const idx in result.data) {
       result.data[idx] = await this.sanitizeRecord(result.data[idx], options)

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

@@ -1,7 +1,7 @@
 const action = 'getAttachment'
 
 async function getAttachment (...args) {
-  if (!this.attachment) return
+  if (!this.options.attachment) return
   if (args.length === 0) return this.action(action, ...args)
   let [id, field, file, opts = {}] = args
   const { find } = this.app.lib._

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

@@ -1,4 +1,4 @@
-import { getFilterAndOptions, execHook, execModelHook, execDynHook, getSingleRef } from './_util.js'
+import { getFilterAndOptions, execHook, execModelHook, execDynHook, getRefs } from './_util.js'
 const action = 'getRecord'
 
 /**
@@ -68,7 +68,7 @@ async function getRecord (...args) {
   const { warnings } = getDefaultValues(options)
   if (!warnings) delete result.warnings
   if (isEmpty(result.data) && !options.throwNotFound) return dataOnly ? undefined : { data: undefined }
-  if (isSet(options.refs)) await getSingleRef.call(this, result.data, options)
+  if (isSet(options.refs)) await getRefs.call(this, [result.data], options)
   if (!noResultSanitizer) result.data = await this.sanitizeRecord(result.data, options)
   await execDynHook.call(this, 'afterGetRecord', id, result, options)
   await execModelHook.call(this, 'afterGetRecord', id, result, options)

package/lib/factory/model/list-attachment.js

@@ -2,7 +2,7 @@ import path from 'path'
 const action = 'listAttachment'
 
 async function listAttachment (...args) {
-  if (!this.attachment) return
+  if (!this.options.attachment) return
   if (args.length === 0) return this.action(action, ...args)
   const [params = {}, opts = {}] = args
   const { map, kebabCase } = this.app.lib._

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

@@ -33,8 +33,8 @@ async function loadFixtures ({ spinner, ignoreError = true, collectItems = false
     return
   }
   const result = { success: 0, failed: 0 }
-  const base = path.basename(this.file, path.extname(this.file))
-  const pattern = resolvePath(`${path.dirname(this.file)}/../fixture/${base}.*`)
+  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 opts = { ...options, noMagic: true }
   for (const item of items) {

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

@@ -3,7 +3,7 @@ import path from 'path'
 const action = 'removeAttachment'
 
 async function removeAttachment (...args) {
-  if (!this.attachment) return
+  if (!this.options.attachment) return
   if (args.length === 0) return this.action(action, ...args)
   const [id, field, file, opts = {}] = args
   const { fs, fastGlob } = this.app.lib

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

@@ -1,4 +1,4 @@
-import { getFilterAndOptions, execHook, execModelHook, execDynHook, getSingleRef, handleReq, clearCache } from './_util.js'
+import { getFilterAndOptions, execHook, execModelHook, execDynHook, getRefs, handleReq, clearCache } from './_util.js'
 const action = 'removeRecord'
 
 /**
@@ -51,7 +51,7 @@ async function removeRecord (...args) {
   const { warnings } = getDefaultValues(options)
   if (!warnings) delete result.warnings
   if (!noResultSanitizer) result.oldData = await this.sanitizeRecord(result.oldData, options)
-  if (isSet(options.refs)) await getSingleRef.call(this, result.data, options)
+  if (isSet(options.refs)) await getRefs.call(this, [result.data], options)
   await execDynHook.call(this, 'afterRemoveRecord', id, result, options)
   await execModelHook.call(this, 'afterRemoveRecord', id, result, options)
   await execHook.call(this, 'afterRemoveRecord', id, result, options)

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

@@ -33,12 +33,17 @@ async function sanitizeBody ({ body = {}, partial, strict, extFields = [], noDef
 
   const omitted = []
   const details = []
-  for (const prop of [...this.properties, ...extFields]) {
+  const properties = [...this.properties, ...extFields]
+  for (const prop of properties) {
     try {
-      if (partial && !has(body, prop.name)) continue
+      if (partial && !has(body, prop.name)) {
+        if (prop.type === 'array') result[prop.name] = null
+        continue
+      }
       result[prop.name] = body[prop.name]
-      if (body[prop.name] === null) continue
-      if (isSet(body[prop.name])) sanitize(prop.name, prop.type)
+      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 {
         if (isSet(prop.default) && !noDefault) {
           result[prop.name] = prop.default
@@ -50,7 +55,7 @@ async function sanitizeBody ({ body = {}, partial, strict, extFields = [], noDef
       }
       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 (body[prop.name] === undefined) omitted.push(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/sanitize-record.js

@@ -24,7 +24,7 @@ async function sanitizeRecord (record = {}, opts = {}) {
   if (!newFields.includes('id')) newFields.unshift('id')
   newFields = without(newFields, ...allHidden)
   const body = fillObject(record, newFields, null)
-  const newRecord = await this.sanitizeBody({ body, noDefault: true })
+  const newRecord = await this.sanitizeBody({ body, partial: true, noDefault: true })
   if (record._ref) newRecord._ref = cloneDeep(record._ref)
   for (const key in newRecord) {
     const prop = this.getProperty(key)
@@ -35,6 +35,7 @@ async function sanitizeRecord (record = {}, opts = {}) {
   }
   if (opts.fmt) {
     newRecord._fmt = cloneDeep(newRecord)
+    delete newRecord._fmt._ref
     for (const key in newRecord) {
       const prop = this.getProperty(key)
       if (!prop) continue

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

@@ -1,4 +1,4 @@
-import { getFilterAndOptions, execHook, execValidation, execModelHook, execDynHook, getSingleRef, handleReq, clearCache } from './_util.js'
+import { getFilterAndOptions, execHook, execValidation, execModelHook, execDynHook, getRefs, handleReq, clearCache } from './_util.js'
 import { onlyTypes } from './create-record.js'
 const action = 'updateRecord'
 
@@ -72,7 +72,7 @@ async function updateRecord (...args) {
   if (noResult) return
   const { warnings } = getDefaultValues(options)
   if (!warnings) delete result.warnings
-  if (isSet(options.refs)) await getSingleRef.call(this, result.data, options)
+  if (isSet(options.refs)) await getRefs.call(this, [result.data], options)
   if (!noResultSanitizer) {
     result.data = await this.sanitizeRecord(result.data, options)
     result.oldData = await this.sanitizeRecord(result.oldData, options)

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

@@ -1,4 +1,4 @@
-import { getFilterAndOptions, execHook, execModelHook, execDynHook, execValidation, getSingleRef, handleReq, clearCache } from './_util.js'
+import { getFilterAndOptions, execHook, execModelHook, execDynHook, execValidation, getRefs, handleReq, clearCache } from './_util.js'
 const action = 'upsertRecord'
 
 async function native (body = {}, opts = {}) {
@@ -21,7 +21,7 @@ async function native (body = {}, opts = {}) {
   if (noResult) return
   const { warnings } = getDefaultValues(options)
   if (!warnings) delete result.warnings
-  if (isSet(options.refs)) await getSingleRef.call(this, result.data, options)
+  if (isSet(options.refs)) await getRefs.call(this, [result.data], options)
   if (!noResultSanitizer) result.data = await this.sanitizeRecord(result.data, options)
   await execDynHook.call(this, 'afterUpsertRecord', input, result, options)
   await execModelHook.call(this, 'afterUpsertRecord', input, result, options)

package/lib/factory/model.js

@@ -23,7 +23,7 @@ import sanitizeBody from './model/sanitize-body.js'
 import sanitizeRecord from './model/sanitize-record.js'
 import sanitizeId from './model/sanitize-id.js'
 import upsertRecord from './model/upsert-record.js'
-import bulkCreateRecords from './model/bulk-create-records.js'
+import bulkCreateRecord from './model/bulk-create-record.js'
 import listAttachment from './model/list-attachment.js'
 import transaction from './model/transaction.js'
 import validate from './model/validate.js'
@@ -109,6 +109,16 @@ async function modelFactory () {
       return !!this.getProperty(name)
     }
 
+    syncIdField = (idField) => {
+      const { cloneDeep, findIndex } = this.app.lib._
+      if (!this.driver) return
+      if (!idField) idField = cloneDeep(this.driver.idField)
+      const idx = findIndex(this.properties, { name: 'id' })
+      if (idx === -1) return
+      this.properties.splice(idx, 1)
+      this.properties.unshift(idField)
+    }
+
     _simpleLookup = async (value, options = {}) => {
       const { get, isEmpty, isString, isPlainObject, isArray } = this.app.lib._
       let model
@@ -144,7 +154,7 @@ async function modelFactory () {
     findAllRecord = findAllRecord
 
     transaction = transaction
-    bulkCreateRecords = bulkCreateRecords
+    bulkCreateRecord = bulkCreateRecord
 
     createAggregate = createAggregate
     createHistogram = createHistogram
@@ -170,6 +180,7 @@ async function modelFactory () {
     findRecords = findRecord
     findAllRecords = findAllRecord
     listAttachments = listAttachment
+    bulkCreateRecords = bulkCreateRecord
 
     getField = (name) => this.getProperty(name)
     hasField = (name) => this.hasProperty(name)
@@ -182,7 +193,6 @@ async function modelFactory () {
   }
 
   this.app.baseClass.DoboModel = DoboModel
-  return DoboModel
 }
 
 export default modelFactory

package/package.json

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

package/wiki/CHANGES.md

@@ -1,5 +1,27 @@
 # Changes
 
+## 2026-05-11
+
+- [2.23.0] Add ```beforeBulkCreate``` model hook on ```dobo:unique``` feature
+- [2.23.0] Add ```beforeBulkCreate``` model hook on ```dobo:updatedAt``` feature
+- [2.23.0] Add ```beforeBulkCreate``` model hook on ```dobo:unique``` feature
+- [2.23.0] Add ```connection.initDriver()```
+- [2.23.0] Move ```model.file``` in model definition to ```model.options.file```
+- [2.23.0] Move ```model.attachment``` in model definition to ```model.options.attachment```
+- [2.23.0] Add ```model.buildStart()``` and ```model.buildEnd()``` in model definition
+- [2.23.0] Add ```null``` driver
+- [2.23.0] Add ```model.syncIdField()```
+- [2.23.0] Rename method to ```model.bulkCreateRecord``` instead ```bulkCreateRecords```. The later name now serve only as alias
+- [2.23.0] Remove ```getSingleRef()``` and ```getMultiRefs()```, use ```getRefs()``` instead
+- [2.23.0] Add reference support for ```array``` column type
+- [2.23.0] Bug fix in ```model.findAllRecord()```, now use correctly hook names
+- [2.23.0] Bug fix in ```model.sanitizeBody()```
+- [2.23.0] Bug fix in ```model.sanitizeRecord()```
+
+## 2026-05-03
+
+- [2.22.1] Bug fix in ```dobo:image``` feature
+
 ## 2026-05-02
 
 - [2.22.0] Add auto thumbnail creation when image attachment is uploaded
@@ -83,7 +105,7 @@
 - [2.16.0] Rewrite ```getDefaultValues()``` to base on ```req.getSetting()```
 - [2.16.0] All inter site admins are now exempts from ```immutable``` row
 - [2.16.0] Bug fix in ```collect-models.js```
-- [2.16.0] Bug fix in ```getSingleRef()``` and ```getMultiRefs()```
+- [2.16.0] Bug fix in ```getRefs()``` and ```getRefs()```
 - [2.16.0] Add feature to return formatted row(s) with ```options.formatValue```
 - [2.16.0] If row is formatted, add feature to save original row in ```_orig``` with ```options.retainOriginalValue```
 
@@ -117,7 +139,7 @@
 
 ## 2026-03-26
 
-- [2.11.4] Exceptions thrown in ```getSingleRef()``` && ```getMultiRefs()``` will be catched and are ignored
+- [2.11.4] Exceptions thrown in ```getRefs()``` && ```getRefs()``` will be catched and are ignored
 
 ## 2026-03-25
 
@@ -222,7 +244,7 @@
 
 ## 2026-01-29
 
-- [2.4.0] Add ```bulkCreateRecords()``` on model & driver
+- [2.4.0] Add ```bulkCreateRecord()``` on model & driver
 - [2.4.0] Add ```execModelHook()```
 - [2.4.0] Bug fix in models collection
 - [2.4.0] Add ```DoboAction``` to the ```app.baseClass```