dobo 2.0.0 → 2.2.0

package/method/record/find-all.js

@@ -1,25 +0,0 @@
-async function findAll (name, filter = {}, options = {}) {
-  const { maxLimit, hardLimit } = this.config.default.filter
-  filter.page = 1
-  filter.limit = maxLimit
-  options.dataOnly = true
-  const match = filter.match
-  const all = []
-  let count = 0
-  for (;;) {
-    filter.match = match
-    const results = await this.recordFind(name, filter, options)
-    if (results.length === 0) break
-    if (count + results.length > hardLimit) {
-      const sliced = results.slice(0, hardLimit - count)
-      all.push(...sliced)
-      break
-    }
-    all.push(...results)
-    count = count + results.length
-    filter.page++
-  }
-  return all
-}
-
-export default findAll

package/method/record/find-one.js

@@ -1,56 +0,0 @@
-import resolveMethod from '../../lib/resolve-method.js'
-import singleRelRows from '../../lib/single-rel-rows.js'
-import execFeatureHook from '../../lib/exec-feature-hook.js'
-
-async function findOne (name, filter = {}, opts = {}) {
-  const { isSet } = this.lib.aneka
-  const { runHook } = this.app.bajo
-  const { get, set } = this.cache ?? {}
-  const { cloneDeep, camelCase, omit, pick } = this.lib._
-  delete opts.record
-  const options = cloneDeep(omit(opts, ['req', 'reply']))
-  options.req = opts.req
-  options.reply = opts.reply
-  options.dataOnly = options.dataOnly ?? true
-  let { fields, dataOnly, noHook, noCache, noFeatureHook, hidden, forceNoHidden } = options
-  options.count = false
-  options.dataOnly = false
-  await this.modelExists(name, true)
-  filter.limit = 1
-  filter.page = 1
-  const { handler, schema, driver } = await resolveMethod.call(this, name, 'record-find', options)
-  if (!schema.cacheable) noCache = true
-  filter.query = this.buildQuery({ filter, schema, options }) ?? {}
-  if (options.queryHandler) filter.query = await options.queryHandler.call(opts.req ? this.app[opts.req.ns] : this, filter.query, opts.req)
-  filter.match = this.buildMatch({ input: filter.match, schema, options }) ?? {}
-  if (!noHook) {
-    await runHook(`${this.name}:beforeRecordFindOne`, name, filter, options)
-    await runHook(`${this.name}.${camelCase(name)}:beforeRecordFindOne`, filter, options)
-  }
-  if (!noFeatureHook) await execFeatureHook.call(this, 'beforeFindOne', { schema, filter, options })
-  if (get && !noCache && !options.record) {
-    const cachedResult = await get({ model: name, filter, options })
-    if (cachedResult) {
-      cachedResult.cached = true
-      return dataOnly ? cachedResult.data : cachedResult
-    }
-  }
-  filter.limit = 1
-  filter.page = 1
-  let record = options.record ?? (await handler.call(this.app[driver.ns], { schema, filter, options }))
-  delete options.record
-  record.data = record.data[0]
-
-  if (isSet(options.rels)) await singleRelRows.call(this, { schema, record: record.data, options })
-  record.data = await this.pickRecord({ record: record.data, fields, schema, hidden, forceNoHidden })
-  record = pick(record, ['data'])
-  if (!noHook) {
-    await runHook(`${this.name}.${camelCase(name)}:afterRecordFindOne`, filter, options, record)
-    await runHook(`${this.name}:afterRecordFindOne`, name, filter, options, record)
-  }
-  if (set && !noCache) await set({ model: name, filter, options, record })
-  if (!noFeatureHook) await execFeatureHook.call(this, 'afterFindOne', { schema, filter, options, record })
-  return dataOnly ? record.data : record
-}
-
-export default findOne

package/method/record/find.js

@@ -1,52 +0,0 @@
-import resolveMethod from '../../lib/resolve-method.js'
-import multiRelRows from '../../lib/multi-rel-rows.js'
-import execFeatureHook from '../../lib/exec-feature-hook.js'
-
-async function find (name, filter = {}, opts = {}) {
-  const { isSet } = this.lib.aneka
-  const { runHook } = this.app.bajo
-  const { get, set } = this.cache ?? {}
-  const { cloneDeep, camelCase, omit } = this.lib._
-  delete opts.records
-  const options = cloneDeep(omit(opts, ['req', 'reply']))
-  options.req = opts.req
-  options.reply = opts.reply
-  options.dataOnly = options.dataOnly ?? true
-  let { fields, dataOnly, noHook, noCache, noFeatureHook, hidden, forceNoHidden } = options
-  options.count = options.count ?? false
-  options.dataOnly = false
-  await this.modelExists(name, true)
-  const { handler, schema, driver } = await resolveMethod.call(this, name, 'record-find', options)
-  if (!schema.cacheable) noCache = true
-  filter.query = this.buildQuery({ filter, schema, options }) ?? {}
-  if (options.queryHandler) filter.query = await options.queryHandler.call(opts.req ? this.app[opts.req.ns] : this, filter.query, opts.req)
-  filter.match = this.buildMatch({ input: filter.match, schema, options }) ?? {}
-  if (!noHook) {
-    await runHook(`${this.name}:beforeRecordFind`, name, filter, options)
-    await runHook(`${this.name}.${camelCase(name)}:beforeRecordFind`, filter, options)
-  }
-  if (!noFeatureHook) await execFeatureHook.call(this, 'beforeFind', { schema, filter, options })
-  if (get && !noCache && !options.records) {
-    const cachedResult = await get({ model: name, filter, options })
-    if (cachedResult) {
-      cachedResult.cached = true
-      if (!noFeatureHook) await execFeatureHook.call(this, 'afterFind', { schema, filter, options, records: cachedResult })
-      return dataOnly ? cachedResult.data : cachedResult
-    }
-  }
-  const records = options.records ?? (await handler.call(this.app[driver.ns], { schema, filter, options }))
-  delete options.records
-  if (isSet(options.rels)) await multiRelRows.call(this, { schema, records: records.data, options })
-  for (const idx in records.data) {
-    records.data[idx] = await this.pickRecord({ record: records.data[idx], fields, schema, hidden, forceNoHidden })
-  }
-  if (!noHook) {
-    await runHook(`${this.name}.${camelCase(name)}:afterRecordFind`, filter, options, records)
-    await runHook(`${this.name}:afterRecordFind`, name, filter, options, records)
-  }
-  if (set && !noCache) await set({ model: name, filter, options, records })
-  if (!noFeatureHook) await execFeatureHook.call(this, 'afterFind', { schema, filter, options, records })
-  return dataOnly ? records.data : records
-}
-
-export default find

package/method/record/get.js

@@ -1,47 +0,0 @@
-import resolveMethod from '../../lib/resolve-method.js'
-import singleRelRows from '../../lib/single-rel-rows.js'
-import execFeatureHook from '../../lib/exec-feature-hook.js'
-
-async function get (name, id, opts = {}) {
-  const { isSet } = this.lib.aneka
-  const { runHook } = this.app.bajo
-  const { get, set } = this.cache ?? {}
-  const { cloneDeep, camelCase, omit } = this.lib._
-  delete opts.record
-  const options = cloneDeep(omit(opts, ['req', 'reply']))
-  options.req = opts.req
-  options.reply = opts.reply
-  options.dataOnly = options.dataOnly ?? true
-  let { fields, dataOnly, noHook, noCache, noFeatureHook, hidden = [], forceNoHidden } = options
-  await this.modelExists(name, true)
-  const { handler, schema, driver } = await resolveMethod.call(this, name, 'record-get', options)
-  if (!schema.cacheable) noCache = true
-  id = this.sanitizeId(id, schema)
-  options.dataOnly = false
-  if (!noHook) {
-    await runHook(`${this.name}:beforeRecordGet`, name, id, options)
-    await runHook(`${this.name}.${camelCase(name)}:beforeRecordGet`, id, options)
-  }
-  if (!noFeatureHook) await execFeatureHook.call(this, 'beforeGet', { schema, id, options })
-  if (get && !noCache && !options.record) {
-    const cachedResult = await get({ model: name, id, options })
-    if (cachedResult) {
-      cachedResult.cached = true
-      if (!noFeatureHook) await execFeatureHook.call(this, 'afterGet', { schema, id, options, record: cachedResult })
-      return dataOnly ? cachedResult.data : cachedResult
-    }
-  }
-  const record = options.record ?? (await handler.call(this.app[driver.ns], { schema, id, options }))
-  delete options.record
-  if (isSet(options.rels)) await singleRelRows.call(this, { schema, record: record.data, options })
-  record.data = await this.pickRecord({ record: record.data, fields, schema, hidden, forceNoHidden })
-  if (!noHook) {
-    await runHook(`${this.name}.${camelCase(name)}:afterRecordGet`, id, options, record)
-    await runHook(`${this.name}:afterRecordGet`, name, id, options, record)
-  }
-  if (set && !noCache) await set({ model: name, id, options, record })
-  if (!noFeatureHook) await execFeatureHook.call(this, 'afterGet', { schema, id, options, record })
-  return dataOnly ? record.data : record
-}
-
-export default get

package/method/record/remove.js

@@ -1,41 +0,0 @@
-import resolveMethod from '../../lib/resolve-method.js'
-import handleAttachmentUpload from '../../lib/handle-attachment-upload.js'
-import execFeatureHook from '../../lib/exec-feature-hook.js'
-
-async function remove (name, id, opts = {}) {
-  const { runHook } = this.app.bajo
-  const { clearModel } = this.cache ?? {}
-  const { cloneDeep, camelCase, omit } = this.lib._
-  delete opts.record
-  const options = cloneDeep(omit(opts, ['req', 'reply']))
-  options.req = opts.req
-  options.reply = opts.reply
-  options.dataOnly = options.dataOnly ?? true
-  const { fields, dataOnly, noHook, noResult, noFeatureHook, hidden, forceNoHidden } = options
-  options.dataOnly = false
-  await this.modelExists(name, true)
-  const { handler, schema, driver } = await resolveMethod.call(this, name, 'record-remove', options)
-  id = this.sanitizeId(id, schema)
-  if (!noHook) {
-    await runHook(`${this.name}:beforeRecordRemove`, name, id, options)
-    await runHook(`${this.name}.${camelCase(name)}:beforeRecordRemove`, id, options)
-  }
-  if (!noFeatureHook) await execFeatureHook.call(this, 'beforeRemove', { schema, id, options })
-  const record = options.record ?? (await handler.call(this.app[driver.ns], { schema, id, options }))
-  delete options.record
-  if (options.req) {
-    if (options.req.file) await handleAttachmentUpload.call(this, { name: schema.name, id, options, action: 'remove' })
-    if (options.req.flash && !options.noFlash) options.req.flash('notify', options.req.t('recordRemoved'))
-  }
-  if (clearModel) await clearModel({ model: name, id, options, record })
-  if (noResult) return
-  record.oldData = options.record ? options.record.oldData : (await this.pickRecord({ record: record.oldData, fields, schema, hidden, forceNoHidden }))
-  if (!noHook) {
-    await runHook(`${this.name}.${camelCase(name)}:afterRecordRemove`, id, options, record)
-    await runHook(`${this.name}:afterRecordRemove`, name, id, options, record)
-  }
-  if (!noFeatureHook) await execFeatureHook.call(this, 'afterRemove', { schema, id, options, record })
-  return dataOnly ? record.oldData : record
-}
-
-export default remove

package/method/record/update.js

@@ -1,63 +0,0 @@
-import resolveMethod from '../../lib/resolve-method.js'
-import checkUnique from '../../lib/check-unique.js'
-import handleAttachmentUpload from '../../lib/handle-attachment-upload.js'
-import execValidation from '../../lib/exec-validation.js'
-import execFeatureHook from '../../lib/exec-feature-hook.js'
-import singleRelRows from '../../lib/single-rel-rows.js'
-
-async function update (name, id, input, opts = {}) {
-  const { isSet } = this.lib.aneka
-  const { runHook } = this.app.bajo
-  const { clearModel } = this.cache ?? {}
-  const { forOwn, find, cloneDeep, camelCase, omit, get } = this.lib._
-  delete opts.record
-  const options = cloneDeep(omit(opts, ['req', 'reply']))
-  options.req = opts.req
-  options.reply = opts.reply
-  options.dataOnly = options.dataOnly ?? true
-  input = cloneDeep(input)
-  const { fields, dataOnly, noHook, noValidation, noCheckUnique, noFeatureHook, noResult, noSanitize, partial = true, hidden, forceNoHidden } = options
-  options.dataOnly = true
-  options.truncateString = options.truncateString ?? true
-  await this.modelExists(name, true)
-  const { handler, schema, driver } = await resolveMethod.call(this, name, 'record-update', options)
-  id = this.sanitizeId(id, schema)
-  const extFields = get(options, 'validation.extFields', [])
-  let body = noSanitize ? input : await this.sanitizeBody({ body: input, schema, partial, strict: true, extFields })
-  delete body.id
-  if (!noHook) {
-    await runHook(`${this.name}:beforeRecordUpdate`, name, id, body, options)
-    await runHook(`${this.name}.${camelCase(name)}:beforeRecordUpdate`, id, body, options)
-  }
-  if (!noValidation) body = await execValidation.call(this, { name, body, options, partial })
-  if (!noCheckUnique) await checkUnique.call(this, { schema, body, id })
-  const nbody = {}
-  forOwn(body, (v, k) => {
-    if (v === undefined) return undefined
-    const prop = find(schema.properties, { name: k })
-    if (!prop) return undefined
-    if (options.truncateString && isSet(v) && ['string', 'text'].includes(prop.type)) v = v.slice(0, prop.maxLength)
-    nbody[k] = v
-  })
-  delete nbody.id
-  if (!noFeatureHook) await execFeatureHook.call(this, 'beforeUpdate', { schema, body: nbody, options })
-  const record = options.record ?? (await handler.call(this.app[driver.ns], { schema, id, body: nbody, options }))
-  delete options.record
-  if (isSet(options.rels)) await singleRelRows.call(this, { schema, record: record.data, options })
-  if (options.req) {
-    if (options.req.file) await handleAttachmentUpload.call(this, { name: schema.name, id, body, options, action: 'update' })
-    if (options.req.flash && !options.noFlash) options.req.flash('notify', options.req.t('recordUpdated'))
-  }
-  if (clearModel) await clearModel({ model: name, id, body: nbody, options, record })
-  if (noResult) return
-  record.oldData = await this.pickRecord({ record: record.oldData, fields, schema, hidden, forceNoHidden })
-  record.data = await this.pickRecord({ record: record.data, fields, schema, hidden, forceNoHidden })
-  if (!noHook) {
-    await runHook(`${this.name}.${camelCase(name)}:afterRecordUpdate`, id, nbody, options, record)
-    await runHook(`${this.name}:afterRecordUpdate`, name, id, nbody, options, record)
-  }
-  if (!noFeatureHook) await execFeatureHook.call(this, 'afterUpdate', { schema, body: nbody, record })
-  return dataOnly ? record.data : record
-}
-
-export default update

package/method/record/upsert.js

@@ -1,35 +0,0 @@
-async function upsert (name, input, opts = {}) {
-  const { generateId } = this.app.bajo
-  const { find } = this.lib._
-  const { cloneDeep, omit, merge } = this.lib._
-  const { query, omitOnUpdate = [], omitOnCreate = [] } = opts
-  const options = cloneDeep(omit(opts, ['req', 'reply', 'query', 'omitOnUpdate', 'omitOnCreate']))
-  options.req = opts.req
-  options.reply = opts.reply
-  options.dataOnly = options.dataOnly ?? true
-  await this.modelExists(name, true)
-  const { schema } = this.getInfo(name)
-  const idField = find(schema.properties, { name: 'id' })
-  let id
-  if (idField.type === 'string') id = input.id ?? generateId()
-  else if (idField.type === 'integer') id = input.id ?? generateId('int')
-  id = this.sanitizeId(id, schema)
-  let old
-  let body
-  const o = { dataOnly: true, noHook: true, noCache: true, hidden: options.hidden, forceNoHidden: options.forceNoHidden }
-  if (query) {
-    old = await this.recordFindOne(name, { query }, o)
-  } else {
-    o.thrownNotFound = false
-    old = await this.recordGet(name, id, o)
-  }
-  if (old) {
-    body = merge(omit(old, ['id', 'createdAt', 'updatedAt', 'removedAt']), omit(input, omitOnUpdate))
-    return await this.recordUpdate(name, old.id, body, options)
-  }
-  if (!query) input.id = id
-  body = omit(input, omitOnCreate)
-  return await this.recordCreate(name, body, options)
-}
-
-export default upsert

package/method/sanitize/body.js

@@ -1,70 +0,0 @@
-async function sanitizeBody ({ body = {}, schema = {}, partial, strict, extFields = [] }) {
-  const { isSet } = this.lib.aneka
-  const { dayjs } = this.lib
-  const { callHandler } = this.app.bajo
-  const { has, isString, isNumber, concat, isNaN } = this.lib._
-  const result = {}
-  for (const p of concat(schema.properties, extFields)) {
-    if (partial && !has(body, p.name)) continue
-    if (['object', 'array'].includes(p.type)) {
-      if (isString(body[p.name])) {
-        try {
-          result[p.name] = JSON.parse(body[p.name])
-        } catch (err) {
-          result[p.name] = null
-        }
-      } else {
-        try {
-          result[p.name] = JSON.parse(JSON.stringify(body[p.name]))
-        } catch (err) {}
-      }
-    } else result[p.name] = body[p.name]
-    if (isSet(body[p.name])) {
-      if (p.type === 'boolean') result[p.name] = result[p.name] === null ? null : (['true', true].includes(result[p.name]))
-      if (['float', 'double'].includes(p.type)) {
-        if (isNumber(body[p.name])) result[p.name] = body[p.name]
-        else if (strict) {
-          result[p.name] = Number(body[p.name])
-        } else {
-          result[p.name] = parseFloat(body[p.name]) || null
-        }
-      }
-      if (['integer', 'smallint'].includes(p.type)) {
-        if (isNumber(body[p.name])) result[p.name] = body[p.name]
-        else if (strict) {
-          result[p.name] = Number(body[p.name])
-        } else {
-          result[p.name] = parseInt(body[p.name]) || null
-        }
-      }
-      if (p.type === 'timestamp') {
-        if (!isNumber(body[p.name])) result[p.name] = -1
-        else {
-          const dt = dayjs.unix(body[p.name])
-          result[p.name] = dt.isValid() ? dt.unix() : -1
-        }
-      } else {
-        for (const t of ['datetime', 'date|YYYY-MM-DD', 'time|HH:mm:ss']) {
-          const [type, input] = t.split('|')
-          if (p.type === type) result[p.name] = this.sanitizeDate(body[p.name], { input })
-        }
-      }
-      if (['string', 'text'].includes(p.type)) result[p.name] = body[p.name] + ''
-    } else {
-      if (isSet(p.default)) {
-        result[p.name] = p.default
-        if (isString(p.default) && p.default.startsWith('handler:')) {
-          const [, ...args] = p.default.split(':')
-          if (args.length > 0) result[p.name] = await callHandler(args.join(':'))
-        } else {
-          if (['float', 'double'].includes(p.type)) result[p.name] = parseFloat(result[p.name])
-          if (['integer', 'smallint'].includes(p.type)) result[p.name] = parseInt(result[p.name])
-          if (isNaN(result[p.name])) result[p.name] = null
-        }
-      }
-    }
-  }
-  return result
-}
-
-export default sanitizeBody

package/method/sanitize/date.js

@@ -1,14 +0,0 @@
-function sanitizeDate (value, { input, output, silent = true } = {}) {
-  const { dayjs } = this.lib
-  if (value === 0) return null
-  if (!output) output = input
-  const dt = dayjs(value, input)
-  if (!dt.isValid()) {
-    if (silent) return -1
-    throw this.error('invalidDate')
-  }
-  if (output === 'native' || !output) return dt.toDate()
-  return dt.format(output)
-}
-
-export default sanitizeDate

package/method/sanitize/id.js

@@ -1,7 +0,0 @@
-function sanitizeId (id, schema) {
-  const prop = schema.properties.find(p => p.name === 'id')
-  if (prop.type === 'integer') id = parseInt(id)
-  return id
-}
-
-export default sanitizeId

package/method/stat/aggregate.js

@@ -1,23 +0,0 @@
-import resolveMethod from '../../lib/resolve-method.js'
-
-async function aggregate (name, filter = {}, options = {}) {
-  const { runHook } = this.app.bajo
-  const { dataOnly = true, noHook, aggregate } = options
-  options.dataOnly = false
-  await this.modelExists(name, true)
-  const { handler, schema, driver } = await resolveMethod.call(this, name, 'stat-aggregate', options)
-  if (!noHook) {
-    await runHook(`${this.name}:beforeStatAggregate`, name, aggregate, filter, options)
-    await runHook(`${this.name}.${name}:beforeStatAggregate`, aggregate, filter, options)
-  }
-  filter.query = this.buildQuery({ filter, schema, options }) ?? {}
-  filter.match = this.buildMatch({ input: filter.match, schema, options }) ?? {}
-  const rec = await handler.call(this.app[driver.ns], { schema, filter, options })
-  if (!noHook) {
-    await runHook(`${this.name}.${name}:afterStatAggregate`, aggregate, filter, options, rec)
-    await runHook(`${this.name}:afterStatAggregate`, name, aggregate, filter, options, rec)
-  }
-  return dataOnly ? rec.data : rec
-}
-
-export default aggregate

package/method/stat/histogram.js

@@ -1,26 +0,0 @@
-import resolveMethod from '../../lib/resolve-method.js'
-
-const types = ['daily', 'monthly', 'yearly']
-
-async function histogram (name, filter = {}, options = {}) {
-  const { runHook, join } = this.app.bajo
-  const { dataOnly = true, noHook, type } = options
-  options.dataOnly = false
-  if (!types.includes(type)) throw this.error('histogramTypeMusBe%s', join(types))
-  await this.modelExists(name, true)
-  const { handler, schema, driver } = await resolveMethod.call(this, name, 'stat-histogram', options)
-  filter.query = this.buildQuery({ filter, schema, options }) ?? {}
-  filter.match = this.buildMatch({ input: filter.match, schema, options }) ?? {}
-  if (!noHook) {
-    await runHook(`${this.name}:beforeStatHistogram`, name, type, filter, options)
-    await runHook(`${this.name}.${name}:beforeStatHistogram`, type, filter, options)
-  }
-  const rec = await handler.call(this.app[driver.ns], { schema, type, filter, options })
-  if (!noHook) {
-    await runHook(`${this.name}.${name}:afterStatHistogram`, type, filter, options, rec)
-    await runHook(`${this.name}:afterStatHistogram`, name, type, filter, options, rec)
-  }
-  return dataOnly ? rec.data : rec
-}
-
-export default histogram

package/method/validate.js

@@ -1,157 +0,0 @@
-import joi from 'joi'
-
-const excludedTypes = ['object', 'array']
-const excludedNames = []
-
-const validator = {
-  string: ['alphanum', 'base64', 'case', 'creditCard', 'dataUri', 'domain', 'email', 'guid',
-    'uuid', 'hex', 'hostname', 'insensitive', 'ip', 'isoDate', 'isoDuration', 'length', 'lowercase',
-    'max', 'min', 'normalize', 'pattern', 'regex', 'replace', 'token', 'trim', 'truncate',
-    'uppercase', 'uri'],
-  number: ['great', 'less', 'max', 'min', 'multiple', 'negative', 'port', 'positive',
-    'sign', 'unsafe'],
-  boolean: ['falsy', 'sensitive', 'truthy'],
-  date: ['greater', 'iso', 'less', 'max', 'min'],
-  timestamp: ['timestamp']
-}
-
-function buildFromDbSchema (schema, { fields = [], rule = {}, extFields = [] } = {}) {
-  // if (schema.validation) return schema.validation
-  const {
-    isPlainObject, get, each, isEmpty, isString, forOwn, keys,
-    find, isArray, has, cloneDeep, concat, without
-  } = this.lib._
-  const obj = {}
-  const me = this
-  const refs = []
-
-  function getRuleKv (kvRule) {
-    let key
-    let value
-    let columns
-    if (isPlainObject(kvRule)) {
-      key = kvRule.rule
-      value = kvRule.params
-      columns = kvRule.fields
-    } else if (isString(kvRule)) {
-      [key, value, columns] = kvRule.split(':')
-    }
-    return { key, value, columns }
-  }
-
-  function applyFieldRules (prop, obj) {
-    const minMax = { min: false, max: false }
-    const rules = get(rule, prop.name, prop.rules ?? [])
-    if (!isArray(rules)) return rules
-    each(rules, r => {
-      const types = validator[me.propType[prop.type].validator]
-      const { key, value } = getRuleKv(r)
-      if (keys(minMax).includes(key)) minMax[key] = true
-      if (key === 'ref') {
-        refs.push(prop.name)
-        obj = joi.ref(value)
-        return undefined
-      }
-      if (!key || !types.includes(key)) return undefined
-      obj = obj[key](value)
-    })
-    if (refs.includes(prop.name)) return obj
-    if (['string', 'text'].includes(prop.type)) {
-      forOwn(minMax, (v, k) => {
-        if (v) return undefined
-        if (has(prop, `${k}Length`)) obj = obj[k](prop[`${k}Length`])
-      })
-    }
-    if (isArray(prop.values)) obj = obj.valid(...prop.values)
-    if (!['id'].includes(prop.name) && prop.required) obj = obj.required()
-    return obj
-  }
-
-  const props = concat(cloneDeep(schema.properties), extFields)
-
-  for (const p of props) {
-    if (excludedTypes.includes(p.type) || excludedNames.includes(p.name)) continue
-    if (fields.length > 0 && !fields.includes(p.name)) continue
-    let item
-    switch (p.type) {
-      case 'text':
-      case 'string': {
-        item = applyFieldRules(p, joi.string())
-        break
-      }
-      case 'smallint':
-      case 'integer':
-        item = applyFieldRules(p, joi.number().integer())
-        break
-      case 'float':
-      case 'double':
-        if (p.precision) item = applyFieldRules(p, joi.number().precision(p.precision))
-        else item = applyFieldRules(p, joi.number())
-        break
-      case 'time':
-      case 'date':
-      case 'datetime':
-        item = applyFieldRules(p, joi.date())
-        break
-      case 'timestamp':
-        item = applyFieldRules(p, joi.number().integer())
-        break
-      case 'boolean':
-        item = applyFieldRules(p, joi.boolean())
-        break
-    }
-    if (item) {
-      if (item.$_root) obj[p.name] = item.allow(null)
-      else obj[p.name] = item
-    }
-  }
-  if (isEmpty(obj)) return false
-  each(get(schema, 'globalRules', []), r => {
-    each(without(keys(obj), ...refs), k => {
-      const prop = find(props, { name: k })
-      if (!prop) return undefined
-      const types = validator[me.propType[prop.type].validator]
-      const { key, value, columns = [] } = getRuleKv(r)
-      if (!types.includes(key)) return undefined
-      if (columns.length === 0 || columns.includes(k)) obj[k] = obj[k][key](value)
-    })
-  })
-  const result = joi.object(obj)
-  if (fields.length === 0) return result
-  each(['with', 'xor', 'without'], k => {
-    const item = get(schema, `extRule.${k}`)
-    if (item) result[k](...item)
-  })
-  return result
-}
-
-async function validate (value, joiSchema, { ns, fields, extFields, params } = {}) {
-  const { defaultsDeep, isSet } = this.lib.aneka
-  const { isString, forOwn, find } = this.lib._
-
-  ns = ns ?? [this.name]
-  params = defaultsDeep(params, this.config.validationParams)
-  const { rule = {} } = params
-  delete params.rule
-  if (isString(joiSchema)) {
-    const { schema } = this.getInfo(joiSchema)
-    forOwn(value, (v, k) => {
-      if (!isSet(v)) return undefined
-      const p = find(schema.properties, { name: k })
-      if (!p) return undefined
-      for (const t of ['date|YYYY-MM-DD', 'time|HH:mm:ss']) {
-        const [type, input] = t.split('|')
-        if (p.type === type) value[k] = this.sanitizeDate(value[k], { input, output: 'native' })
-      }
-    })
-    joiSchema = buildFromDbSchema.call(this, schema, { fields, rule, extFields })
-  }
-  if (!joiSchema) return value
-  try {
-    return await joiSchema.validateAsync(value, params)
-  } catch (err) {
-    throw this.error('validationError', { details: err.details, values: err.values, ns, statusCode: 422, code: 'DB_VALIDATION' })
-  }
-}
-
-export default validate