dobo 2.22.1 → 2.24.0

package/lib/factory/driver.js

@@ -12,8 +12,9 @@ const defIdField = {
 
 async function driverFactory () {
   const { Tools } = this.app.baseClass
-  const { pick, cloneDeep, has, uniq, without, isEmpty, omit, isFunction } = this.app.lib._
+  const { pick, cloneDeep, has, uniq, without, isEmpty, omit, isFunction, camelCase, last } = this.app.lib._
   const { isSet } = this.app.lib.aneka
+  const { runHook } = this.app.bajo
 
   /**
    * Driver class
@@ -59,11 +60,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 +83,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 = {}) {
@@ -107,6 +112,7 @@ async function driverFactory () {
             const dt = this.useUtc ? dayjs.utc(item[prop.name]) : dayjs(item[prop.name])
             item[prop.name] = dt.toDate()
           }
+          if (prop.type === 'boolean' && isSet(item[prop.name])) item[prop.name] = Boolean(item[prop.name])
         }
       }
       return item
@@ -120,6 +126,15 @@ async function driverFactory () {
       return uniq(items)
     }
 
+    async _attachHook (name, model, ...args) {
+      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)
+      }
+    }
+
     /**
      * Check uniqueness of fields with unique index
      *
@@ -241,7 +256,11 @@ async function driverFactory () {
         if (!isEmpty(resp.data)) throw this.plugin.error('recordExists%s%s', body.id, model.name)
       }
       body = this.sanitizeBody(model, body)
+
+      await this._attachHook('beforeDriverCreateRecord', model, body, options)
       const result = await this.createRecord(model, body, options)
+      await this._attachHook('afterDriverCreateRecord', model, body, result, options)
+
       if (options.noResult) return
       result.data = this.sanitizeRecord(model, result.data)
       this._injectMeta(result, options)
@@ -257,14 +276,20 @@ async function driverFactory () {
         await this._prepIdForCreate(model, body, options)
         bodies[idx] = this.sanitizeBody(model, body)
       }
+
+      await this._attachHook('beforeDriverBulkCreateRecord', model, bodies, options)
       const items = chunk(bodies, chunkSize)
       for (const item of items) {
-        await this.bulkCreateRecords(model, item, options)
+        await this.bulkCreateRecord(model, item, options)
       }
+      await this._attachHook('afterDriverBulkCreateRecord', model, bodies, [], options)
     }
 
     async _getRecord (model, id, options = {}) {
+      await this._attachHook('beforeDriverGetRecord', model, id, options)
       const result = await this.getRecord(model, id, options)
+      await this._attachHook('afterDriverGetRecord', 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)
       this._injectMeta(result, options)
@@ -283,7 +308,11 @@ async function driverFactory () {
       }
       body = this.sanitizeBody(model, body, true)
       delete body.id
+
+      await this._attachHook('beforeDriverUpdateRecord', model, id, body, options)
       const result = await this.updateRecord(model, id, body, options)
+      await this._attachHook('afterDriverUpdateRecord', model, id, body, result, options)
+
       if (options.noResult) return
       result.oldData = this.sanitizeRecord(model, result.oldData)
       result.data = this.sanitizeRecord(model, result.data)
@@ -304,7 +333,11 @@ async function driverFactory () {
         }
       }
       body = this.sanitizeBody(model, body)
+
+      await this._attachHook('beforeDriverUpsertRecord', model, body, options)
       const result = await this.upsertRecord(model, body, options)
+      await this._attachHook('afterDriverUpsertRecord', model, body, result, options)
+
       if (options.noResult) return
       if (result.oldData) result.oldData = this.sanitizeRecord(model, result.oldData)
       result.data = this.sanitizeRecord(model, result.data)
@@ -318,7 +351,11 @@ async function driverFactory () {
         if (!resp.data) throw this.plugin.error('recordNotFound%s%s', id, model.name)
         options._data = resp.data
       }
+
+      await this._attachHook('beforeDriverRemoveRecord', model, id, options)
       const result = await this.removeRecord(model, id, options)
+      await this._attachHook('afterDriverRemoveRecord', model, id, result, options)
+
       if (options.noResult) return
       result.oldData = this.sanitizeRecord(model, result.oldData)
       this._injectMeta(result, options)
@@ -326,13 +363,29 @@ async function driverFactory () {
     }
 
     async _clearRecord (model, options = {}) {
+      await this._attachHook('beforeDriverClearRecord', model, options)
       const result = await this.clearRecord(model, options)
+      await this._attachHook('afterDriverClearRecord', model, result, options)
+
       this._injectMeta(result, options)
       return result
     }
 
     async _findRecord (model, filter = {}, options = {}) {
-      const result = await this.findRecord(model, filter, options)
+      let result
+      try {
+        await this._attachHook('beforeDriverFindRecord', model, filter, options)
+        result = await this.findRecord(model, filter, options)
+        await this._attachHook('afterDriverFindRecord', model, filter, result, options)
+      } catch (err) {
+        if (err.message !== '_emptyColumnQuery') throw err
+        result = {
+          data: [],
+          count: 0
+          // warnings: [] // TODO: should generate warnings?
+        }
+      }
+
       for (const idx in result.data) {
         result.data[idx] = this.sanitizeRecord(model, result.data[idx])
       }
@@ -341,7 +394,20 @@ async function driverFactory () {
     }
 
     async _findAllRecord (model, filter = {}, options = {}) {
-      const result = await this.findAllRecord(model, filter, options)
+      let result
+      try {
+        await this._attachHook('beforeDriverFindAllRecord', model, filter, options)
+        result = await this.findAllRecord(model, filter, options)
+        await this._attachHook('afterDriverFindAllRecord', model, filter, result, options)
+      } catch (err) {
+        if (err.message !== '_emptyColumnQuery') throw err
+        result = {
+          data: [],
+          count: 0
+          // warnings: [] // TODO: should generate warnings?
+        }
+      }
+
       for (const idx in result.data) {
         result.data[idx] = this.sanitizeRecord(model, result.data[idx])
       }
@@ -350,7 +416,17 @@ async function driverFactory () {
     }
 
     async _countRecord (model, filter = {}, options = {}) {
-      return await this.countRecord(model, filter, options)
+      let result
+      try {
+        await this._attachHook('beforeDriverCountRecord', model, filter, options)
+        result = await this.countRecord(model, filter, options)
+        await this._attachHook('afterDriverCountRecord', model, filter, result, options)
+      } catch (err) {
+        if (err.message !== '_emptyColumnQuery') throw err
+        result = { data: 0 }
+      }
+
+      return result
     }
 
     async _createAggregate (model, filter = {}, params = {}, options = {}) {
@@ -367,7 +443,16 @@ async function driverFactory () {
       if (!prop) throw this.plugin.error('unknown%s%s', this.plugin.t('field.field'), field)
       // if (!fieldPropTypes.includes(prop.type)) throw this.plugin.error('allowedPropType%s%s', field, fieldPropTypes.join(', '))
 
-      const result = await this.createAggregate(model, filter, params, options)
+      let result
+      try {
+        await this._attachHook('beforeDriverCreateAggregate', model, filter, params, options)
+        result = await this.createAggregate(model, filter, params, options)
+        await this._attachHook('afterDriverCreateAggregate', model, filter, params, result, options)
+      } catch (err) {
+        if (err.message !== '_emptyColumnQuery') throw err
+        result = { data: [] }
+      }
+
       for (const idx in result.data) {
         result.data[idx] = this.sanitizeRecord(model, result.data[idx])
       }
@@ -387,8 +472,17 @@ async function driverFactory () {
 
       prop = model.properties.find(p => p.name === field)
       if (!prop) throw this.plugin.error('unknown%s%s', this.plugin.t('field.field'), field)
-      // if (!fieldPropTypes.includes(prop.type)) throw this.plugin.error('allowedPropType%s%s', field, fieldPropTypes.join(', '))
-      const result = await this.createHistogram(model, filter, params, options)
+
+      let result
+      try {
+        await this._attachHook('beforeDriverCreateHistogram', model, filter, params, options)
+        result = await this.createHistogram(model, filter, params, options)
+        await this._attachHook('afterDriverCreateHistogram', model, filter, params, result, options)
+      } catch (err) {
+        if (err.message !== '_emptyColumnQuery') throw err
+        result = { data: [] }
+      }
+
       for (const idx in result.data) {
         result.data[idx] = this.sanitizeRecord(model, result.data[idx])
       }
@@ -402,64 +496,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,17 +13,22 @@ 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, this.name, ...args)
     await runHook(`${ns}:${name}`, this.name, ...args)
+    if (prefix === 'after') await runHook(`${ns}:afterAction`, action, this.name, ...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)
   }
 }
 
 export async function execModelHook (name, ...args) {
-  if (['beforeBuildQuery', 'beforeBuildSearch', 'afterBuildQuery', 'afterBuildSearch'].includes(name)) return
   const { last } = this.app.lib._
   const { runModelHook } = this.app.dobo
   const { noModelHook } = last(args)
@@ -62,7 +67,6 @@ export async function execValidation (body, options = {}) {
  */
 export async function getFilterAndOptions (filter = {}, options = {}, action) {
   const { cloneDeep } = this.app.lib._
-  const { runModelHook } = this.app.dobo
   const nFilter = cloneDeep(filter || {})
   const nOptions = cloneOptions.call(this, options)
   if (options.noMagic) {
@@ -81,12 +85,8 @@ export async function getFilterAndOptions (filter = {}, options = {}, action) {
   nOptions.throwNotFound = nOptions.throwNotFound ?? true
   nFilter.orgQuery = nFilter.query
   nFilter.orgSearch = nFilter.search
-  if (!nOptions.noModelHook) await runModelHook(this, 'beforeBuildQuery', nFilter.query, nOptions)
   nFilter.query = buildFilterQuery.call(this, nFilter) ?? {}
-  if (!nOptions.noModelHook) await runModelHook(this, 'afterBuildQuery', nFilter.query, nOptions)
-  if (!nOptions.noModelHook) await runModelHook(this, 'beforeBuilSearch', nFilter.search, nOptions)
   nFilter.search = buildFilterSearch.call(this, nFilter) ?? {}
-  if (!nOptions.noModelHook) await runModelHook(this, 'afterBuildSearch', nFilter.search, nOptions)
   const { limit, page, skip, sort } = preparePagination.call(this, nFilter, nOptions)
   nFilter.limit = limit
   nFilter.page = page
@@ -135,7 +135,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 +158,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 +170,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 +180,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 +231,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)