dobo 2.3.1 → 2.5.0

package/index.js

@@ -480,6 +480,15 @@ async function factory (pkgName) {
       if (isEmpty(type)) throw this.error('histogramTypeMissing')
       if (!this.constructor.histogramTypes.includes(type)) throw this.error('unsupportedHistogramType%s', type)
     }
+
+    execModelHook = async (model, hookName, ...args) => {
+      const { orderBy } = this.app.lib._
+      const hooks = orderBy(model.hooks.filter(hook => hook.name === hookName), ['level'])
+      for (const hook of hooks) {
+        if (hook.noWait) hook.handler.call(model, ...args)
+        else await hook.handler.call(model, ...args)
+      }
+    }
   }
 
   return Dobo

package/lib/collect-models.js

@@ -1,5 +1,6 @@
 import path from 'path'
 import modelFactory from './factory/model.js'
+import actionFactory from './factory/action.js'
 
 /**
  * Sanitize one single property of a model
@@ -285,6 +286,7 @@ async function createSchema (item) {
 async function collectModels () {
   const { eachPlugins } = this.app.bajo
   const { orderBy, has } = this.app.lib._
+  await actionFactory.call(this)
   const DoboModel = await modelFactory.call(this)
 
   this.log.trace('collecting%s', this.t('model'))

package/lib/factory/driver.js

@@ -37,6 +37,7 @@ async function driverFactory () {
         uniqueIndex: false,
         nullableField: true
       }
+      this.maxChunkSize = 500
       this.memory = false
       this.options = options
     }
@@ -154,7 +155,7 @@ async function driverFactory () {
       return await this.dropModel(model, options)
     }
 
-    async _createRecord (model, body = {}, options = {}) {
+    async _prepBodyForCreate (model, body = {}, options = {}) {
       const { isSet, generateId } = this.app.lib.aneka
       const { isFunction } = this.app.lib._
       for (const prop of model.properties) {
@@ -185,6 +186,11 @@ async function driverFactory () {
           }
         }
       }
+    }
+
+    async _prepIdForCreate (model, body = {}, options = {}) {
+      const { isSet, generateId } = this.app.lib.aneka
+      const { isFunction } = this.app.lib._
       const prop = model.properties.find(p => p.name === 'id')
       if (!isSet(body.id) && prop.type === 'string') {
         if (this.idGenerator) {
@@ -196,17 +202,42 @@ async function driverFactory () {
         if (!body.id) body.id = ulid()
         body.id = body.id.slice(0, prop.maxLength)
       }
-      if (!this.uniqueIndexSupport) await this._checkUnique(model, body, options)
-      if (isSet(body.id)) {
+    }
+
+    async _createRecord (model, body = {}, options = {}) {
+      const { isSet } = this.app.lib.aneka
+      await this._prepBodyForCreate(model, body, options)
+      await this._prepIdForCreate(model, body, options)
+      if (!options.noUniqueCheck) {
+        if (!this.support.uniqueIndex) await this._checkUnique(model, body, options)
+      }
+      if (!options.noIdCheck && isSet(body.id)) {
         const resp = await this.getRecord(model, body.id, { noHook: true })
         if (!isEmpty(resp.data)) throw this.plugin.error('recordExists%s%s', body.id, model.name)
       }
-      const result = await this.createRecord(model, this.sanitizeBody(model, body), options)
+      const input = this.sanitizeBody(model, body)
+      const result = await this.createRecord(model, input, options)
       if (options.noResult) return
       result.data = this.sanitizeRecord(model, result.data)
       return result
     }
 
+    async _bulkCreateRecords (model, bodies = [], options = {}) {
+      const { chunk } = this.app.lib._
+      let { chunkSize = this.maxChunkSize } = options
+      if (chunkSize > this.maxChunkSize) chunkSize = this.maxChunkSize
+      for (const idx in bodies) {
+        const body = bodies[idx]
+        await this._prepBodyForCreate(model, body, options)
+        await this._prepIdForCreate(model, body, options)
+        bodies[idx] = this.sanitizeBody(model, body)
+      }
+      const items = chunk(bodies, chunkSize)
+      for (const item of items) {
+        await this.bulkCreateRecords(model, item, options)
+      }
+    }
+
     async _getRecord (model, id, options = {}) {
       const result = await this.getRecord(model, id, options)
       if (isEmpty(result.data) && options.throwNotFound) throw this.plugin.error('recordNotFound%s%s', id, model.name)
@@ -216,9 +247,11 @@ async function driverFactory () {
 
     async _updateRecord (model, id, body = {}, options = {}) {
       if (!this.support.uniqueIndex) await this._checkUnique(model, body, options)
-      const resp = await this.getRecord(model, id, { noHook: true })
-      if (!resp.data) throw this.plugin.error('recordNotFound%s%s', id, model.name)
-      options._data = resp.data
+      if (!options._data) {
+        const resp = await this.getRecord(model, id, { noHook: true })
+        if (!resp.data) throw this.plugin.error('recordNotFound%s%s', id, model.name)
+        options._data = resp.data
+      }
       const input = this.sanitizeBody(model, body, true)
       delete input.id
       const result = await this.updateRecord(model, id, input, options)
@@ -231,11 +264,14 @@ async function driverFactory () {
     async _upsertRecord (model, body = {}, options = {}) {
       if (!this.uniqueIndexSupport) await this._checkUnique(model, body, options)
       if (isSet(body.id)) {
-        const resp = await this.getRecord(model, body.id, { noHook: true })
-        if (!resp.data) throw this.plugin.error('recordNotFound%s%s', body.id, model.name)
-        options._data = resp.data
+        if (!options._data) {
+          const resp = await this.getRecord(model, body.id, { noHook: true })
+          if (!resp.data) throw this.plugin.error('recordNotFound%s%s', body.id, model.name)
+          options._data = resp.data
+        }
       }
-      const result = await this.upsertRecord(model, this.sanitizeBody(model, body), options)
+      const input = this.sanitizeBody(model, body)
+      const result = await this.upsertRecord(model, input, options)
       if (options.noResult) return
       if (result.oldData) result.oldData = this.sanitizeRecord(model, result.oldData)
       result.data = this.sanitizeRecord(model, result.data)
@@ -243,9 +279,11 @@ async function driverFactory () {
     }
 
     async _removeRecord (model, id, options = {}) {
-      const resp = await this.getRecord(model, id, { noHook: true })
-      if (!resp.data) throw this.plugin.error('recordNotFound%s%s', id, model.name)
-      options._data = resp.data
+      if (!options._data) {
+        const resp = await this.getRecord(model, id, { noHook: true })
+        if (!resp.data) throw this.plugin.error('recordNotFound%s%s', id, model.name)
+        options._data = resp.data
+      }
       const result = await this.removeRecord(model, id, options)
       if (options.noResult) return
       result.oldData = this.sanitizeRecord(model, result.oldData)
@@ -359,6 +397,10 @@ async function driverFactory () {
       throw this.plugin.error('notSupported%s%s', this.app.t('method'), 'findRecord')
     }
 
+    async bulkCreateRecords (model, bodies = [], options = {}) {
+      throw this.plugin.error('notSupported%s%s', this.app.t('method'), 'bulkCreateRecords')
+    }
+
     async countRecord (model, filter = {}, options = {}) {
       throw this.plugin.error('notSupported%s%s', this.app.t('method'), 'countRecord')
     }

package/lib/factory/model/_util.js

@@ -13,17 +13,10 @@ export async function execHook (name, ...args) {
 }
 
 export async function execModelHook (name, ...args) {
-  const { last, orderBy } = this.app.lib._
+  const { last } = this.app.lib._
+  const { execModelHook } = this.app.dobo
   const { noModelHook } = last(args)
-  const results = []
-  if (!noModelHook) {
-    const hooks = orderBy(this.hooks.filter(hook => hook.name === name), ['level'])
-    for (const hook of hooks) {
-      if (hook.noWait) hook.handler.call(this, ...args)
-      else await hook.handler.call(this, ...args)
-    }
-  }
-  return results
+  if (!noModelHook) await execModelHook(this, name, ...args)
 }
 
 export async function execDynHook (name, ...args) {
@@ -131,7 +124,7 @@ export async function copyAttachment (id, options = {}) {
     if (parts.length === 0) continue
     fieldName = setField ?? fieldName
     const file = setFile ?? parts.join('@')
-    const opts = { source: f, fieldName, file, mimeType, stats, req, silent: true }
+    const opts = { source: f, fieldName, file, mimeType, stats, req }
     const rec = await this.createAttachment(id, opts)
     if (!rec) continue
     delete rec.dir
@@ -210,7 +203,6 @@ export async function getMultiRefs (records = [], options = {}) {
         query[ref.propName] = { $in: matches }
         const rFilter = { query, limit: matches.length }
         const rOptions = { dataOnly: true, refs: [] }
-        this.app.dump(this.name, rModel.name, rFilter, records)
         const results = await rModel.findRecord(rFilter, rOptions)
         const fields = [...ref.fields]
         if (!fields.includes(prop.name)) fields.push(prop.name)

package/lib/factory/model/bulk-create-records.js

@@ -0,0 +1,36 @@
+import { getFilterAndOptions, execHook, execValidation, execModelHook, execDynHook } from './_util.js'
+
+export const onlyTypes = ['datetime', 'date', 'time', 'timestamp']
+const action = 'bulkCreateRecords'
+
+async function bulkCreateRecords (...args) {
+  if (args.length === 0) return this.action(action, ...args)
+  const [bodies = [], opts = {}] = args
+  const { cloneDeep, get } = this.app.lib._
+  const { options } = await getFilterAndOptions.call(this, null, opts, action)
+  const { truncateString, noBodySanitizer, noValidation } = options
+  const extFields = get(options, 'validation.extFields', [])
+
+  const inputs = cloneDeep(bodies)
+  if (!noBodySanitizer) {
+    for (const idx in inputs) {
+      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)
+  if (!noValidation) {
+    for (const input of inputs) {
+      await execValidation.call(this, input, options)
+    }
+  }
+  // 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)
+  return []
+}
+
+export default bulkCreateRecords

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

@@ -60,7 +60,8 @@ async function loop (params, opts, dataOnly) {
 }
 
 async function findAllRecord (...args) {
-  if (args.length === 0) return this.action(action, ...args)
+  // can't use action here, because people tends to use is without arguments
+  // if (args.length === 0) return this.action(action, ...args)
   const [params = {}, opts = {}] = args
   const { dataOnly = true } = opts
   if (this.driver.findAllRecord) {

package/lib/factory/model.js

@@ -23,6 +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 listAttachment from './model/list-attachment.js'
 import validate from './model/validate.js'
 
@@ -108,6 +109,8 @@ async function modelFactory () {
     findOneRecord = findOneRecord
     findAllRecord = findAllRecord
 
+    bulkCreateRecords = bulkCreateRecords
+
     createAggregate = createAggregate
     createHistogram = createHistogram
     countRecord = countRecord

package/package.json

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

package/wiki/CHANGES.md

@@ -1,5 +1,18 @@
 # Changes
 
+## 2026-01-30
+
+- [2.5.0] Add feature to push custom ```options._data```. If provided, this will be used instead of auto generated one.
+- [2.5.0] Remove ```silent``` in ```options``` object
+
+## 2026-01-29
+
+- [2.4.0] Add ```bulkCreateRecords()``` on model & driver
+- [2.4.0] Add ```execModelHook()```
+- [2.4.0] Bug fix on models collection
+- [2.4.0] Add ```DoboAction``` to the ```app.baseClass```
+- [2.4.0] ```findAllRecord()``` can't be called as action
+
 ## 2026-01-26
 
 - [2.3.1] Bug fix if reference model isn't loaded only yield warning