dobo 2.0.1 → 2.2.0

package/lib/factory/model/_util.js

@@ -0,0 +1,402 @@
+import path from 'path'
+import nql from '@tryghost/nql'
+
+export async function execHook (name, ...args) {
+  const { runHook } = this.app.bajo
+  const { camelCase, last } = this.app.lib._
+  const { noHook } = last(args)
+  const { ns } = this.app.dobo
+  if (!noHook) {
+    await runHook(`${ns}:${name}`, this.name, ...args)
+    await runHook(`${ns}.${camelCase(this.name)}:${name}`, ...args)
+  }
+}
+
+export async function execModelHook (name, ...args) {
+  const { last } = this.app.lib._
+  const { noModelHook } = last(args)
+  const results = []
+  if (!noModelHook) {
+    const hooks = this.hooks.filter(hook => hook.name === name)
+    for (const hook of hooks) {
+      await hook.handler.call(this, ...args)
+    }
+  }
+  return results
+}
+
+export async function execValidation (body, options = {}) {
+  const { uniq } = this.app.lib._
+  const { validation = {}, extFields = [], partial, req } = options
+  const fields = uniq([...Object.keys(body), ...(options.fields ?? [])])
+  await execHook.call(this, 'beforeRecordValidation', body, options)
+  const result = await this.validate(body, validation, { fields, extFields, partial, req })
+  await execHook.call(this, 'afterRecordValidation', body, result, options)
+  return result
+}
+
+/**
+ * Break any reference to the original and get the new options
+ *
+ * @param {Object} options
+ * @returns {Object}
+ */
+export async function getFilterAndOptions (filter = {}, options = {}, action) {
+  const { cloneDeep, omit } = this.app.lib._
+  const keys = ['req', 'reply']
+  const nFilter = cloneDeep(omit(filter, keys))
+  const nOptions = cloneDeep(omit(options, keys))
+  nOptions.action = action
+  nOptions.dataOnly = false
+  nOptions.truncateString = nOptions.truncateString ?? false
+  nOptions.throwNotFound = nOptions.throwNotFound ?? true
+  for (const key of keys) {
+    nOptions[key] = options[key]
+  }
+
+  nFilter.query = buildFilterQuery.call(this, nFilter, nOptions) ?? {}
+  nFilter.match = buildFilterMatch.call(this, nFilter, nOptions) ?? {}
+  handleRegexInQuery.call(this, nFilter)
+  const { limit, page, skip, sort } = preparePagination.call(this, nFilter, nOptions)
+  nFilter.limit = limit
+  nFilter.page = page
+  nFilter.skip = skip
+  nFilter.sort = sort
+  if (nOptions.queryHandler) {
+    const scope = nOptions.req ? this.app[nOptions.req.ns] : this.plugin
+    nFilter.query = await options.queryHandler.call(scope, nFilter.query, nOptions.req)
+  }
+  return { filter: nFilter, options: nOptions }
+}
+
+export async function handleReq (id, trigger, options = {}) {
+  const { upperFirst } = this.app.lib._
+  if (options.req) {
+    if (options.req.file && trigger !== 'removed') await handleAttachmentUpload.call(this, id, trigger, options)
+    if (options.req.flash && !options.noFlash) options.req.flash('notify', options.req.t(`record${upperFirst(trigger)}`))
+  }
+}
+
+export async function mergeAttachmentInfo (rec, source, options = {}) {
+  if (!this.app.waibu) return
+  const { mimeType, stats, fullPath } = options
+  const { importPkg } = this.app.bajo
+  const { fs } = this.app.lib
+  const { pick } = this.app.lib._
+  const mime = await importPkg('waibu:mime')
+
+  if (mimeType) rec.mimeType = mime.getType(rec.file)
+  if (fullPath) rec.fullPath = source
+  if (stats) {
+    const s = fs.statSync(source)
+    rec.stats = pick(s, ['size', 'atime', 'ctime', 'mtime'])
+  }
+}
+
+export async function getAttachmentPath (id, fieldName, file, options = {}) {
+  const { getPluginDataDir } = this.app.bajo
+  const { fs } = this.app.lib
+  const dir = `${getPluginDataDir(this.app.dobo.ns)}/attachment/${this.name}/${id}`
+  if (options.dirOnly) return dir
+  const path = fieldName ? `${dir}/${fieldName}/${file}` : `${dir}/${file}`
+  if (!fs.existsSync(path)) throw this.app.dobo.error('notFound')
+  return path
+}
+
+export async function copyAttachment (id, options = {}) {
+  if (!this.app.waibu) return
+  if (!this.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)
+  const result = []
+  if (files.length === 0) return result
+  for (const f of files) {
+    let [fieldName, ...parts] = path.basename(f).split('@')
+    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 rec = await this.createAttachment(id, opts)
+    if (!rec) continue
+    delete rec.dir
+    result.push(rec)
+    if (setField || setFile) break
+  }
+  fs.removeSync(dir)
+  return result
+}
+
+export async function handleAttachmentUpload (id, trigger, options = {}) {
+  if (!this.attachment) return
+  const { getPluginDataDir } = this.app.bajo
+  const { fs } = this.app.lib
+  const { req, mimeType, stats, setFile, setField } = options
+  if (trigger === 'removed') {
+    const dir = `${getPluginDataDir(this.app.dobo.ns)}/attachment/${this.name}/${id}`
+    await fs.remove(dir)
+    return
+  }
+  return copyAttachment.call(this, id, { req, mimeType, stats, setFile, setField })
+}
+
+export async function getSingleRef (record = {}, options = {}) {
+  const { isSet } = this.app.lib.aneka
+  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) {
+        if (!((typeof options.refs === 'string' && ['*', 'all'].includes(options.refs)) || options.refs.includes(key))) continue
+        const ref = prop.ref[key]
+        if (ref.fields.length === 0) continue
+        const rModel = this.plugin.getModel(key)
+        const query = {}
+        query[ref.propName] = record[prop.name]
+        if (ref.propName === 'id') query[ref.propName] = this.sanitizeId(query[ref.propName])
+        const rFilter = { query }
+        const rOptions = { dataOnly: true, refs: [] }
+        const results = await rModel.findRecord(rFilter, rOptions)
+        const fields = [...ref.fields]
+        const data = []
+        for (const res of results) {
+          data.push(await rModel.sanitizeRecord(res, { fields }))
+        }
+        refs[key] = ['1:1'].includes(ref.type) ? data[0] : data
+      }
+    }
+  }
+  record._ref = refs
+}
+
+export async function getMultiRefs (records = [], options = {}) {
+  const { isSet } = this.app.lib.aneka
+  const { uniq, map } = 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) {
+    for (const prop of props) {
+      for (const key in prop.ref) {
+        if (!((typeof options.refs === 'string' && ['*', 'all'].includes(options.refs)) || options.refs.includes(key))) continue
+        const ref = prop.ref[key]
+        if (ref.fields.length === 0) continue
+        if (ref.type !== '1:1') continue
+        const rModel = this.plugin.getModel(key)
+        const matches = uniq(map(records, r => {
+          let v = r[prop.name]
+          if (ref.propName === 'id') v = this.sanitizeId(v)
+          return v
+        }))
+        const query = {}
+        query[ref.propName] = { $in: matches }
+        const rFilter = { query, limit: matches.length }
+        const rOptions = { dataOnly: true, refs: [] }
+        const results = await rModel.findRecord(rFilter, rOptions)
+        const fields = [...ref.fields]
+        if (!fields.includes(prop.name)) fields.push(prop.name)
+        for (const i in records) {
+          records[i]._ref = records[i]._ref ?? {}
+          const rec = records[i]
+          const res = results.find(res => (res[ref.propName] + '') === rec[prop.name] + '')
+          if (res) records[i]._ref[key] = await rModel.sanitizeRecord(res, { fields })
+          else records[i]._ref[key] = {}
+        }
+      }
+    }
+  }
+}
+
+export function buildFilterQuery (filter = {}, options = {}) {
+  const { trim, find, isString, isPlainObject } = this.app.lib._
+  let query = {}
+  if (isString(filter.query)) {
+    try {
+      filter.query = trim(filter.query)
+      filter.orgQuery = filter.query
+      if (trim(filter.query).startsWith('{')) query = JSON.parse(filter.query)
+      else if (filter.query.includes(':')) query = nql(filter.query).parse()
+      else {
+        const fields = this.sortables.filter(f => {
+          const field = find(this.properties, { name: f, type: 'string' })
+          return !!field
+        })
+        const parts = fields.map(f => {
+          if (filter.query[0] === '*') return `${f}:~$'${filter.query.replaceAll('*', '')}'`
+          if (filter.query[filter.length - 1] === '*') return `${f}:~^'${filter.query.replaceAll('*', '')}'`
+          return `${f}:~'${filter.query.replaceAll('*', '')}'`
+        })
+        if (parts.length === 1) query = nql(parts[0]).parse()
+        else if (parts.length > 1) query = nql(parts.join(',')).parse()
+      }
+    } catch (err) {
+      this.app.dobo.error('invalidQuery', { orgMessage: err.message })
+    }
+  } else if (isPlainObject(filter.query)) query = filter.query
+  return sanitizeQuery.call(this, query)
+}
+
+function sanitizeQuery (query = {}, parent) {
+  const { cloneDeep, isPlainObject, isArray, find } = this.app.lib._
+  const { isSet } = this.app.lib.aneka
+  const { dayjs } = this.app.lib
+  const obj = cloneDeep(query)
+  const keys = Object.keys(obj)
+  const sanitize = (key, val, p) => {
+    if (!isSet(val)) return val
+    const prop = find(this.properties, { name: key.startsWith('$') ? p : key })
+    if (!prop) return val
+    if (['datetime', 'date', 'time'].includes(prop.type)) {
+      const dt = dayjs(val)
+      return dt.isValid() ? dt.toDate() : val
+    } else if (['smallint', 'integer'].includes(prop.type)) return parseInt(val) || val
+    else if (['float', 'double'].includes(prop.type)) return parseFloat(val) || val
+    else if (['boolean'].includes(prop.type)) return !!val
+    return val
+  }
+  keys.forEach(k => {
+    const v = obj[k]
+    if (isPlainObject(v)) obj[k] = sanitizeQuery.call(this, v, k)
+    else if (isArray(v)) {
+      v.forEach((i, idx) => {
+        if (isPlainObject(i)) obj[k][idx] = sanitizeQuery.call(this, i, k)
+      })
+    } else obj[k] = sanitize(k, v, parent)
+  })
+  return obj
+}
+
+export function buildFilterMatch (filter = {}, options = {}) {
+  const { isPlainObject, trim, has, uniq } = this.app.lib._
+  let input = filter.match
+  if (isPlainObject(input)) return input
+  const split = (value) => {
+    let [field, val] = value.split(':').map(i => i.trim())
+    if (!val) {
+      val = field
+      field = '*'
+    }
+    return { field, value: val }
+  }
+  input = trim(input)
+  let items = {}
+  if (isPlainObject(input)) items = input
+  else if (input[0] === '{') {
+    try {
+      items = JSON.parse(input)
+    } catch (err) {}
+  } else {
+    for (const item of input.split('+').map(i => i.trim())) {
+      const part = split(item, ' ')
+      if (!items[part.field]) items[part.field] = []
+      items[part.field].push(...part.value.split(' ').filter(v => ![''].includes(v)))
+    }
+  }
+  const matcher = {}
+  for (const index of this.indexes.filter(i => i.type === 'fulltext')) {
+    for (const f of index.fields) {
+      const value = []
+      if (typeof items[f] === 'string') items[f] = [items[f]]
+      if (has(items, f)) value.push(...items[f])
+      if (!matcher[f]) matcher[f] = []
+      matcher[f] = uniq([...matcher[f], ...value])
+    }
+  }
+  if (has(items, '*')) matcher['*'] = items['*']
+  return matcher
+}
+
+export function handleRegexInQuery (filter) {
+  if (this.driver.idField.name !== 'id') {
+    const query = JSON.stringify(filter.query ?? {}, (key, value) => {
+      if (value instanceof RegExp) return ['__REGEXP__', value.source, value.flags]
+      return value
+    }).replaceAll('"id"', `"${this.driver.idField.name}"`)
+    try {
+      filter.query = JSON.parse(query, (key, value) => {
+        if (Array.isArray(value) && value[0] === '__REGEXP__') return new RegExp(value[1], value[2])
+        return value
+      })
+    } catch (err) {}
+    const match = JSON.stringify(filter.match ?? {}).replaceAll('"id"', `"${this.driver.idField.name}"`)
+    try {
+      filter.match = JSON.parse(match)
+    } catch (err) {}
+  }
+}
+
+/**
+ * Prepare records pagination:
+ * - making sure records limit is obeyed
+ * - making sure page is a positive value
+ * - if skip is given, recalculate limit to use skip instead of page number
+ * - Build sort info
+ *
+ * @method
+ * @async
+ * @param {Object} [filter={}] - Filter object
+ * @param {Object} options - Options
+ * @returns {TRecordPagination}
+ */
+export function preparePagination (filter = {}, options = {}) {
+  const { isEmpty, map, each, isPlainObject, isString, trim, keys } = this.app.lib._
+  const config = this.app.dobo.config
+
+  const buildPageSkipLimit = (filter) => {
+    let limit = parseInt(filter.limit) || config.default.filter.limit
+    if (limit === -1) limit = config.default.filter.maxLimit
+    if (limit > config.default.filter.maxLimit) limit = config.default.filter.maxLimit
+    if (limit < 1) limit = 1
+    let page = parseInt(filter.page) || 1
+    if (page < 1) page = 1
+    let skip = (page - 1) * limit
+    if (filter.skip) {
+      skip = parseInt(filter.skip) || skip
+      page = undefined
+    }
+    if (skip < 0) skip = 0
+    return { page, skip, limit }
+  }
+
+  const buildSort = (input, allowSortUnindexed) => {
+    let sort
+    if (isEmpty(input)) {
+      const columns = map(this.properties ?? [], 'name')
+      each(config.default.filter.sort, s => {
+        const [col] = s.split(':')
+        if (columns.includes(col)) {
+          input = s
+          return false
+        }
+      })
+    }
+    if (!isEmpty(input)) {
+      if (isPlainObject(input)) sort = input
+      else if (isString(input)) {
+        const item = {}
+        each(input.split('+'), text => {
+          let [col, dir] = map(trim(text).split(':'), i => trim(i))
+          dir = (dir ?? '').toUpperCase()
+          dir = dir === 'DESC' ? -1 : parseInt(dir) || 1
+          item[col] = dir / Math.abs(dir)
+        })
+        sort = item
+      }
+      const items = keys(sort)
+      each(items, i => {
+        if (!this.sortables.includes(i) && !allowSortUnindexed) throw this.app.dobo.error('sortOnUnindexedField%s%s', i, this.name)
+        // if (model.fullText.fields.includes(i)) throw this.error('Can\'t sort on full-text index: \'%s@%s\'', i, model.name)
+      })
+    }
+    return sort
+  }
+
+  const { page, skip, limit } = buildPageSkipLimit(filter)
+  let sortInput = filter.sort
+  try {
+    sortInput = JSON.parse(sortInput)
+  } catch (err) {
+  }
+  const sort = buildSort(sortInput, options.allowSortUnindexed)
+  return { limit, page, skip, sort }
+}

package/lib/factory/model/build.js

@@ -0,0 +1,15 @@
+import { getFilterAndOptions, execHook, execModelHook } from './_util.js'
+const action = 'build'
+
+async function build (opts = {}) {
+  const { dataOnly = true } = opts
+  const { options } = await getFilterAndOptions.call(this, null, opts, action)
+  await execHook.call(this, 'beforeBuildModel', options)
+  await execModelHook.call(this, 'beforeBuildModel', options)
+  const result = (await this.driver._buildModel(this, options)) ?? {}
+  await execModelHook.call(this, 'afterBuildModel', result, options)
+  await execHook.call(this, 'afterBuildModel', result, options)
+  return dataOnly ? result.data : result
+}
+
+export default build

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

@@ -0,0 +1,17 @@
+import { getFilterAndOptions, execHook, execModelHook } from './_util.js'
+const action = 'clearRecord'
+
+async function clearRecord (...args) {
+  if (args.length === 0) return this.action(action, ...args)
+  const [opts = {}] = args
+  const { dataOnly = true } = opts
+  const { options } = await getFilterAndOptions.call(this, null, opts, action)
+  await execHook.call(this, 'beforeClearRecord', options)
+  await execModelHook.call(this, 'beforeClearRecord', options)
+  const result = (await this.driver._clearRecord(this, options)) ?? {}
+  await execModelHook.call(this, 'afterClearRecord', result, options)
+  await execHook.call(this, 'afterClearRecord', result, options)
+  return dataOnly ? result.data : result
+}
+
+export default clearRecord

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

@@ -0,0 +1,17 @@
+import { getFilterAndOptions, execHook, execModelHook } from './_util.js'
+const action = 'countRecord'
+
+async function countRecord (...args) {
+  if (args.length === 0) return this.action(action, ...args)
+  const [params = {}, opts = {}] = args
+  const { dataOnly = true } = opts
+  const { filter, options } = await getFilterAndOptions.call(this, params, opts, action)
+  await execHook.call(this, 'beforeCountRecord', options)
+  await execModelHook.call(this, 'beforeCountRecord', filter, options)
+  const result = (await this.driver._countRecord(this, filter, options)) ?? {}
+  await execModelHook.call(this, 'afterCountRecord', filter, result, options)
+  await execHook.call(this, 'afterCountRecord', filter, result, options)
+  return dataOnly ? result.data : result
+}
+
+export default countRecord

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

@@ -0,0 +1,17 @@
+import { getFilterAndOptions, execHook, execModelHook } from './_util.js'
+const action = 'createAggregate'
+
+async function createAggregate (...args) {
+  if (args.length === 0) return this.action(action, ...args)
+  const [_filter = {}, params = {}, opts = {}] = args
+  const { dataOnly = true } = opts
+  const { filter, options } = await getFilterAndOptions.call(this, _filter, opts, action)
+  await execHook.call(this, 'beforeCreateAggregate', filter, params, options)
+  await execModelHook.call(this, 'beforeCreateAggregate', filter, params, options)
+  const result = (await this.driver._createAggregate(this, filter, params, options)) ?? {}
+  await execModelHook.call(this, 'afterCreateAggregate', filter, params, result, options)
+  await execHook.call(this, 'afterCreateAggregate', filter, params, result, options)
+  return dataOnly ? result.data : result
+}
+
+export default createAggregate

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

@@ -0,0 +1,29 @@
+import { mergeAttachmentInfo, getAttachmentPath } from './_util.js'
+const action = 'createAttachment'
+
+async function createAttachment (...args) {
+  if (!this.attachment) return
+  if (args.length === 0) return this.action(action, ...args)
+  const [id, opts = {}] = args
+  const { fs } = this.app.lib
+  const { isEmpty } = this.app.lib._
+  const { source, fieldName = 'file', file, fullPath, stats, mimeType, req } = opts
+  if (isEmpty(file)) return
+  if (!source) throw this.plugin.error('isMissing%s', this.plugin.t('field.source'))
+  const baseDir = await getAttachmentPath.call(this, id, fieldName, file, { dirOnly: true })
+  let dir = `${baseDir}/${fieldName}`
+  if ((fieldName || '').endsWith('[]')) dir = `${baseDir}/${fieldName.replace('[]', '')}`
+  const dest = `${dir}/${file}`.replaceAll('//', '/')
+  await fs.ensureDir(dir)
+  await fs.copy(source, dest)
+  const rec = {
+    field: fieldName === '' ? undefined : fieldName,
+    dir,
+    file
+  }
+  await mergeAttachmentInfo.call(this, rec, dest, { mimeType, fullPath, stats })
+  if (!opts.noFlash && req && req.flash) req.flash('notify', req.t('attachmentUploaded'))
+  return rec
+}
+
+export default createAttachment

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

@@ -0,0 +1,17 @@
+import { getFilterAndOptions, execHook, execModelHook } from './_util.js'
+const action = 'createHistogram'
+
+async function createHistogram (...args) {
+  if (args.length === 0) return this.action(action, ...args)
+  const [_filter = {}, params = {}, opts = {}] = args
+  const { dataOnly = true } = opts
+  const { filter, options } = await getFilterAndOptions.call(this, _filter, opts, action)
+  await execHook.call(this, 'beforeCreateHistogram', filter, params, options)
+  await execModelHook.call(this, 'beforeCreateHistogram', filter, params, options)
+  const result = (await this.driver._createHistogram(this, filter, params, options)) ?? {}
+  await execModelHook.call(this, 'afterCreateHistogram', filter, params, result, options)
+  await execHook.call(this, 'afterCreateHistogram', filter, params, result, options)
+  return dataOnly ? result.data : result
+}
+
+export default createHistogram

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

@@ -0,0 +1,35 @@
+import { getFilterAndOptions, execHook, execValidation, execModelHook, getSingleRef, handleReq } from './_util.js'
+
+export const onlyTypes = ['datetime', 'date', 'time', 'timestamp']
+const action = 'createRecord'
+
+async function createRecord (...args) {
+  if (args.length === 0) return this.action(action, ...args)
+  const [body = {}, opts = {}] = args
+  const { isSet } = this.app.lib.aneka
+  const { runHook } = this.app.bajo
+  const { cloneDeep, get } = this.app.lib._
+  const { dataOnly = true } = opts
+  const { options } = await getFilterAndOptions.call(this, null, opts, action)
+  const { truncateString, noResult, noBodySanitizer, noResultSanitizer, noValidation } = options
+  const extFields = get(options, 'validation.extFields', [])
+  const input = noBodySanitizer ? cloneDeep(body) : await this.sanitizeBody({ body, extFields, strict: true, truncateString, onlyTypes })
+  await execHook.call(this, 'beforeCreateRecord', input, options)
+  await execModelHook.call(this, 'beforeCreateRecord', input, options)
+  if (!noValidation) await execValidation.call(this, input, options)
+  let result = options.record ?? (await this.driver._createRecord(this, input, options)) ?? {}
+  if (noResult) {
+    await runHook('cache:clear', this, 'create', body)
+    return
+  }
+  result = result ?? {}
+  if (!noResultSanitizer) result.data = await this.sanitizeRecord(result.data, options)
+  if (isSet(options.refs)) await getSingleRef.call(this, { record: result.data, options })
+  await handleReq.call(this, result.data.id, 'created', options)
+  await execModelHook.call(this, 'afterCreateRecord', input, result, options)
+  await execHook.call(this, 'afterCreateRecord', input, result, options)
+  await runHook('cache:clear', this, 'create', body, result)
+  return dataOnly ? result.data : result
+}
+
+export default createRecord

package/lib/factory/model/drop.js

@@ -0,0 +1,15 @@
+import { getFilterAndOptions, execHook, execModelHook } from './_util.js'
+const action = 'drop'
+
+async function drop (opts = {}) {
+  const { dataOnly = true } = opts
+  const { options } = await getFilterAndOptions.call(this, null, opts, action)
+  await execHook.call(this, 'beforeDropModel', options)
+  await execModelHook.call(this, 'beforeDropModel', options)
+  const result = (await this.driver._dropModel(this, options)) ?? {}
+  await execModelHook.call(this, 'afterDropModel', result, options)
+  await execHook.call(this, 'afterModelDrop', result, options)
+  return dataOnly ? result.data : result
+}
+
+export default drop

package/lib/factory/model/exists.js

@@ -0,0 +1,21 @@
+import { getFilterAndOptions, execHook, execModelHook } from './_util.js'
+const action = 'modelExists'
+
+/**
+ * Method to check if the underlaying table/collection exists already
+ *
+ * @param {Object} [options]
+ * @returns {Object}
+ */
+async function isExists (opts = {}) {
+  const { dataOnly = true } = opts
+  const { options } = await getFilterAndOptions.call(this, null, opts, action)
+  await execHook.call(this, 'beforeModelExists', options)
+  await execModelHook.call(this, 'beforeModelExists', options)
+  const result = (await this.driver._modelExists(this, options)) ?? {}
+  await execModelHook.call(this, 'afterModelExists', result, options)
+  await execHook.call(this, 'afterModelExists', result, options)
+  return dataOnly ? result.data : result
+}
+
+export default isExists

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

@@ -0,0 +1,71 @@
+import { getMultiRefs, execHook, execModelHook, getFilterAndOptions } from './_util.js'
+const action = 'findAllRecord'
+
+async function native (filter, options, dataOnly) {
+  const { isSet } = this.app.lib.aneka
+  const { get, set } = this.plugin.cache ?? {}
+  if (dataOnly) options.count = false
+  let { noResultSanitizer, noCache } = options
+  if (!this.cacheable) noCache = true
+  await execHook.call(this, 'beforeFindAllRecord', filter, options)
+  await execModelHook.call(this, 'beforeFindAllRecord', filter, options)
+  if (get && !noCache && !options.record) {
+    const cachedResult = await get({ model: this.name, filter, options })
+    if (cachedResult) {
+      cachedResult.cached = true
+      await execModelHook.call(this, 'afterFindAllRecord', filter, cachedResult, options)
+      return dataOnly ? cachedResult.data : cachedResult
+    }
+  }
+  const result = options.record ?? (await this.driver._findAllRecord(this, filter, options)) ?? {}
+  if (!noResultSanitizer) {
+    for (const idx in result.data) {
+      result.data[idx] = await this.sanitizeRecord(result.data[idx], options)
+    }
+  }
+  if (isSet(options.refs)) await getMultiRefs.call(this, { records: result.data, options })
+  await execModelHook.call(this, 'afterFindAllRecord', filter, result, options)
+  await execHook.call(this, 'afterFindAllRecord', filter, result, options)
+  if (set && !noCache) await set({ model: this.name, filter, options, result })
+  return dataOnly ? result.data : result
+}
+
+async function loop (params, opts, dataOnly) {
+  const { cloneDeep } = this.app.lib._
+  const { filter, options } = await getFilterAndOptions.call(this, params, opts, action)
+  const { maxLimit, hardLimit } = this.app.dobo.config.default.filter
+  const nFilter = cloneDeep(filter)
+  const nOptions = cloneDeep(options)
+  nOptions.count = false
+  nOptions.dataOnly = false
+  nFilter.limit = maxLimit
+  nFilter.page = 1
+  let count = 0
+  const data = []
+  for (;;) {
+    const result = await this.findRecord(nFilter, nOptions)
+    if (result.data.length === 0) break
+    if (count + result.data.length > hardLimit) {
+      const sliced = result.data.slice(0, hardLimit - count)
+      data.push(...sliced)
+      break
+    }
+    data.push(...result.data)
+    count = count + result.data.length
+    nFilter.page++
+  }
+  return dataOnly ? data : { data, count }
+}
+
+async function findAllRecord (...args) {
+  if (args.length === 0) return this.action(action, ...args)
+  const [params = {}, opts = {}] = args
+  const { dataOnly = true } = opts
+  if (this.driver.findAllRecord) {
+    const { filter, options } = await getFilterAndOptions.call(this, params, opts, action)
+    return await native.call(this, filter, options, dataOnly)
+  }
+  return await loop.call(this, params, opts, dataOnly)
+}
+
+export default findAllRecord