dobo 2.3.0 → 2.4.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
@@ -126,7 +127,7 @@ async function findAllIndexes (model, inputs = []) {
  * @param {Object} model - Model
  * @param {Array} [models] - All model match agaist. Defaults to ```dobo.models```
  */
-export async function sanitizeRef (model, models, fatal) {
+export async function sanitizeRef (model, models) {
   const { find, isString, pullAt } = this.app.lib._
   if (!models) models = this.models
   for (const prop of model.properties) {
@@ -139,13 +140,15 @@ export async function sanitizeRef (model, models, fatal) {
       ref.type = ref.type ?? '1:1'
       const rModel = find(models, { name: ref.model })
       if (!rModel) {
-        if (fatal) this.fatal('unknownModelForRef%s%s%s', ref.model, model.name, prop.name)
-        else ignored.push(ref.model)
+        ignored.push(key)
+        this.log.warn('notFound%s%s', this.t('model'), ref.model)
+        continue
       }
       const rProp = find(rModel.properties, { name: ref.propName })
       if (!rProp) {
-        if (fatal) this.fatal('unknownPropForRef%s%s%s%s', ref.model, ref.propName, model.name, prop.name)
-        else ignored.push(ref.model)
+        ignored.push(key)
+        this.log.warn('notFound%s%s', this.t('property'), `${ref.propName}@${ref.model}`)
+        continue
       }
       ref.fields = ref.fields ?? '*'
       if (['*', 'all'].includes(ref.fields)) ref.fields = rModel.properties.map(p => p.name)
@@ -283,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)
@@ -235,7 +266,8 @@ async function driverFactory () {
         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)
@@ -359,6 +391,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) {
@@ -189,7 +182,7 @@ export async function getSingleRef (record = {}, options = {}) {
 
 export async function getMultiRefs (records = [], options = {}) {
   const { isSet } = this.app.lib.aneka
-  const { uniq, map, get } = this.app.lib._
+  const { uniq, without, get } = this.app.lib._
   const props = this.properties.filter(p => isSet(p.ref) && !(options.hidden ?? []).includes(p.name))
   options.refs = options.refs ?? []
   if (props.length > 0) {
@@ -201,11 +194,11 @@ export async function getMultiRefs (records = [], options = {}) {
         if (ref.type !== '1:1') continue
         if (get(records, `0._ref.${key}`)) continue
         const rModel = this.app.dobo.getModel(ref.model)
-        const matches = uniq(map(records, r => {
-          let v = r[prop.name]
-          if (ref.propName === 'id') v = this.sanitizeId(v)
-          return v
-        }))
+        let matches = []
+        for (const r of records) {
+          matches.push(rModel.sanitizeId(r[prop.name]))
+        }
+        matches = uniq(without(matches, undefined, null, NaN))
         const query = {}
         query[ref.propName] = { $in: matches }
         const rFilter = { query, limit: matches.length }

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.0",
+  "version": "2.4.0",
   "description": "DBMS for Bajo Framework",
   "main": "index.js",
   "scripts": {

package/wiki/CHANGES.md

@@ -1,5 +1,18 @@
 # Changes
 
+## 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
+- [2.3.1] Bug fix on fetching multi references
+
 ## 2026-01-24
 
 - [2.3.0] Add ```dynHooks``` to model's options